1 /*
2 * Copyright (c) 2023 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15 #ifndef LOG_TAG
16 #define LOG_TAG "FastAudioCapturerSourceInner"
17 #endif
18
19 #include <string>
20 #include <cinttypes>
21 #ifdef FEATURE_POWER_MANAGER
22 #include "power_mgr_client.h"
23 #include "running_lock.h"
24 #include "audio_running_lock_manager.h"
25 #endif
26
27 #include "audio_errors.h"
28 #include "audio_hdi_log.h"
29 #include "audio_utils.h"
30
31 #include "v4_0/iaudio_manager.h"
32 #include "fast_audio_capturer_source.h"
33
34 using namespace std;
35
36 namespace OHOS {
37 namespace AudioStandard {
38 class FastAudioCapturerSourceInner : public FastAudioCapturerSource {
39 public:
40 int32_t Init(const IAudioSourceAttr &attr) override;
41 bool IsInited(void) override;
42 void DeInit(void) override;
43
44 int32_t Start(void) override;
45 int32_t Stop(void) override;
46 int32_t Flush(void) override;
47 int32_t Reset(void) override;
48 int32_t Pause(void) override;
49 int32_t Resume(void) override;
50 int32_t CaptureFrame(char *frame, uint64_t requestBytes, uint64_t &replyBytes) override;
51 int32_t SetVolume(float left, float right) override;
52 int32_t GetVolume(float &left, float &right) override;
53 int32_t SetMute(bool isMute) override;
54 int32_t GetMute(bool &isMute) override;
55
56 int32_t SetAudioScene(AudioScene audioScene, DeviceType activeDevice) override;
57
58 int32_t SetInputRoute(DeviceType inputDevice, AudioPortPin &inputPortPin);
59
60 int32_t SetInputRoute(DeviceType inputDevice) override;
61
62 std::string GetAudioParameter(const AudioParamKey key, const std::string &condition) override;
63 uint64_t GetTransactionId() override;
64 int32_t GetPresentationPosition(uint64_t& frames, int64_t& timeSec, int64_t& timeNanoSec) override;
65 void RegisterWakeupCloseCallback(IAudioSourceCallback *callback) override;
66 void RegisterAudioCapturerSourceCallback(std::unique_ptr<ICapturerStateCallback> callback) override;
67 void RegisterParameterCallback(IAudioSourceCallback *callback) override;
68
69 int32_t GetMmapBufferInfo(int &fd, uint32_t &totalSizeInframe, uint32_t &spanSizeInframe,
70 uint32_t &byteSizePerFrame) override;
71 int32_t GetMmapHandlePosition(uint64_t &frames, int64_t &timeSec, int64_t &timeNanoSec) override;
72 float GetMaxAmplitude() override;
73
74 int32_t UpdateAppsUid(const int32_t appsUid[PA_MAX_OUTPUTS_PER_SOURCE],
75 const size_t size) final;
76 int32_t UpdateAppsUid(const std::vector<int32_t> &appsUid) final;
77
78 FastAudioCapturerSourceInner();
79 ~FastAudioCapturerSourceInner() override;
80 private:
81 static constexpr int32_t INVALID_FD = -1;
82 static constexpr int32_t HALF_FACTOR = 2;
83 static constexpr uint32_t MAX_AUDIO_ADAPTER_NUM = 5;
84 static constexpr float MAX_VOLUME_LEVEL = 15.0f;
85 static constexpr int64_t SECOND_TO_NANOSECOND = 1000000000;
86 static constexpr uint32_t PCM_8_BIT = 8;
87 static constexpr uint32_t PCM_16_BIT = 16;
88 static constexpr uint32_t PCM_24_BIT = 24;
89 static constexpr uint32_t PCM_32_BIT = 32;
90 static constexpr uint32_t AUDIO_CHANNELCOUNT = 2;
91 static constexpr uint32_t AUDIO_SAMPLE_RATE_48K = 48000;
92 static constexpr uint32_t INT_32_MAX = 0x7fffffff;
93 int32_t routeHandle_ = -1;
94
95 IAudioSourceAttr attr_ = {};
96 bool capturerInited_ = false;
97 bool started_ = false;
98 bool paused_ = false;
99
100 uint32_t captureId_ = 0;
101 uint32_t openMic_ = 0;
102 std::string adapterNameCase_ = "";
103 struct IAudioManager *audioManager_ = nullptr;
104 struct IAudioAdapter *audioAdapter_ = nullptr;
105 struct IAudioCapture *audioCapture_ = nullptr;
106 struct AudioAdapterDescriptor adapterDesc_ = {};
107 struct AudioPort audioPort = {};
108
109 size_t bufferSize_ = 0;
110 uint32_t bufferTotalFrameSize_ = 0;
111
112 int bufferFd_ = INVALID_FD;
113 uint32_t eachReadFrameSize_ = 0;
114 AudioScene currentAudioScene_ = AUDIO_SCENE_DEFAULT;
115 std::unique_ptr<ICapturerStateCallback> audioCapturerSourceCallback_ = nullptr;
116 #ifdef FEATURE_POWER_MANAGER
117 std::shared_ptr<AudioRunningLockManager<PowerMgr::RunningLock>> runningLockManager_;
118 #endif
119 private:
120 void InitAttrsCapture(struct AudioSampleAttributes &attrs);
121 int32_t SwitchAdapterCapture(struct AudioAdapterDescriptor *descs, uint32_t size,
122 const std::string &adapterNameCase, enum AudioPortDirection portFlag, struct AudioPort &capturePort);
123 int32_t CreateCapture(const struct AudioPort &capturePort);
124 int32_t PrepareMmapBuffer();
125 int32_t InitAudioManager();
126 uint32_t PcmFormatToBits(HdiAdapterFormat format);
127 AudioFormat ConvertToHdiFormat(HdiAdapterFormat format);
128 int32_t CheckPositionTime();
129 };
130 #ifdef FEATURE_POWER_MANAGER
131 constexpr int32_t RUNNINGLOCK_LOCK_TIMEOUTMS_LASTING = -1;
132 #endif
FastAudioCapturerSourceInner()133 FastAudioCapturerSourceInner::FastAudioCapturerSourceInner() : attr_({}), capturerInited_(false), started_(false),
134 paused_(false), openMic_(0), audioManager_(nullptr), audioAdapter_(nullptr), audioCapture_(nullptr)
135 {}
136
~FastAudioCapturerSourceInner()137 FastAudioCapturerSourceInner::~FastAudioCapturerSourceInner()
138 {
139 AUDIO_DEBUG_LOG("~FastAudioCapturerSourceInner");
140 }
141
GetInstance()142 FastAudioCapturerSource *FastAudioCapturerSource::GetInstance()
143 {
144 static FastAudioCapturerSourceInner audioCapturer;
145 return &audioCapturer;
146 }
147
GetVoipInstance()148 FastAudioCapturerSource *FastAudioCapturerSource::GetVoipInstance()
149 {
150 static FastAudioCapturerSourceInner audioCapturer;
151 return &audioCapturer;
152 }
153
IsInited(void)154 bool FastAudioCapturerSourceInner::IsInited(void)
155 {
156 return capturerInited_;
157 }
158
DeInit()159 void FastAudioCapturerSourceInner::DeInit()
160 {
161 AUDIO_INFO_LOG("Deinit, flag %{public}d", attr_.audioStreamFlag);
162 if (started_) {
163 Stop();
164 started_ = false;
165 }
166 capturerInited_ = false;
167
168 if (audioAdapter_ != nullptr) {
169 audioAdapter_->DestroyCapture(audioAdapter_, captureId_);
170 }
171 audioCapture_ = nullptr;
172
173 if (audioManager_ != nullptr) {
174 audioManager_->UnloadAdapter(audioManager_, adapterDesc_.adapterName);
175 }
176 audioAdapter_ = nullptr;
177 audioManager_ = nullptr;
178
179 if (audioCapturerSourceCallback_ != nullptr) {
180 audioCapturerSourceCallback_->OnCapturerState(false);
181 }
182 }
183
InitAttrsCapture(struct AudioSampleAttributes & attrs)184 void FastAudioCapturerSourceInner::InitAttrsCapture(struct AudioSampleAttributes &attrs)
185 {
186 /* Initialization of audio parameters for playback */
187 attrs.format = AUDIO_FORMAT_TYPE_PCM_16_BIT;
188 attrs.channelCount = AUDIO_CHANNELCOUNT;
189 attrs.interleaved = true;
190 attrs.streamId = static_cast<int32_t>(GenerateUniqueID(AUDIO_HDI_CAPTURE_ID_BASE, HDI_CAPTURE_OFFSET_FAST));
191 attrs.period = 0;
192 attrs.frameSize = PCM_16_BIT * attrs.channelCount / PCM_8_BIT;
193 attrs.isBigEndian = false;
194 attrs.isSignedData = true;
195 attrs.startThreshold = 0;
196 attrs.stopThreshold = INT_32_MAX;
197 /* 16 * 1024 */
198 attrs.silenceThreshold = 0;
199 }
200
SwitchAdapterCapture(struct AudioAdapterDescriptor * descs,uint32_t size,const std::string & adapterNameCase,enum AudioPortDirection portFlag,struct AudioPort & capturePort)201 int32_t FastAudioCapturerSourceInner::SwitchAdapterCapture(struct AudioAdapterDescriptor *descs, uint32_t size,
202 const std::string &adapterNameCase, enum AudioPortDirection portFlag, struct AudioPort &capturePort)
203 {
204 CHECK_AND_RETURN_RET(descs != nullptr, ERROR);
205
206 for (uint32_t index = 0; index < size; index++) {
207 struct AudioAdapterDescriptor *desc = &descs[index];
208 if (desc == nullptr || desc->adapterName == nullptr) {
209 continue;
210 }
211 CHECK_AND_CONTINUE_LOG(adapterNameCase.compare(desc->adapterName) == 0,
212 "not equal: %{public}s <-> %{public}s", adapterNameCase.c_str(), desc->adapterName);
213 AUDIO_DEBUG_LOG("adapter name: %{public}s <-> %{public}s", adapterNameCase.c_str(), desc->adapterName);
214 for (uint32_t port = 0; port < desc->portsLen; port++) {
215 // Only find out the port of out in the sound card
216 if (desc->ports[port].dir == portFlag) {
217 capturePort = desc->ports[port];
218 return index;
219 }
220 }
221 }
222 AUDIO_ERR_LOG("SwitchAdapterCapture Fail");
223
224 return ERR_INVALID_INDEX;
225 }
226
InitAudioManager()227 int32_t FastAudioCapturerSourceInner::InitAudioManager()
228 {
229 AUDIO_INFO_LOG("FastAudioCapturerSourceInner: Initialize audio proxy manager");
230
231 audioManager_ = IAudioManagerGet(false);
232 if (audioManager_ == nullptr) {
233 return ERR_INVALID_HANDLE;
234 }
235
236 return 0;
237 }
238
239
ConvertToHdiFormat(HdiAdapterFormat format)240 AudioFormat FastAudioCapturerSourceInner::ConvertToHdiFormat(HdiAdapterFormat format)
241 {
242 AudioFormat hdiFormat;
243 switch (format) {
244 case SAMPLE_U8:
245 hdiFormat = AUDIO_FORMAT_TYPE_PCM_8_BIT;
246 break;
247 case SAMPLE_S16:
248 hdiFormat = AUDIO_FORMAT_TYPE_PCM_16_BIT;
249 break;
250 case SAMPLE_S24:
251 hdiFormat = AUDIO_FORMAT_TYPE_PCM_24_BIT;
252 break;
253 case SAMPLE_S32:
254 hdiFormat = AUDIO_FORMAT_TYPE_PCM_32_BIT;
255 break;
256 default:
257 hdiFormat = AUDIO_FORMAT_TYPE_PCM_16_BIT;
258 break;
259 }
260
261 return hdiFormat;
262 }
263
ConvertToHDIAudioInputType(const int32_t currSourceType)264 static enum AudioInputType ConvertToHDIAudioInputType(const int32_t currSourceType)
265 {
266 enum AudioInputType hdiAudioInputType;
267 switch (currSourceType) {
268 case SOURCE_TYPE_INVALID:
269 hdiAudioInputType = AUDIO_INPUT_DEFAULT_TYPE;
270 break;
271 case SOURCE_TYPE_MIC:
272 case SOURCE_TYPE_PLAYBACK_CAPTURE:
273 case SOURCE_TYPE_ULTRASONIC:
274 case SOURCE_TYPE_UNPROCESSED:
275 hdiAudioInputType = AUDIO_INPUT_MIC_TYPE;
276 break;
277 case SOURCE_TYPE_WAKEUP:
278 hdiAudioInputType = AUDIO_INPUT_SPEECH_WAKEUP_TYPE;
279 break;
280 case SOURCE_TYPE_VOICE_COMMUNICATION:
281 hdiAudioInputType = AUDIO_INPUT_VOICE_COMMUNICATION_TYPE;
282 break;
283 case SOURCE_TYPE_VOICE_RECOGNITION:
284 hdiAudioInputType = AUDIO_INPUT_VOICE_RECOGNITION_TYPE;
285 break;
286 case SOURCE_TYPE_VOICE_CALL:
287 hdiAudioInputType = AUDIO_INPUT_VOICE_CALL_TYPE;
288 break;
289 case SOURCE_TYPE_CAMCORDER:
290 hdiAudioInputType = AUDIO_INPUT_CAMCORDER_TYPE;
291 break;
292 default:
293 hdiAudioInputType = AUDIO_INPUT_MIC_TYPE;
294 break;
295 }
296 return hdiAudioInputType;
297 }
298
CreateCapture(const struct AudioPort & capturePort)299 int32_t FastAudioCapturerSourceInner::CreateCapture(const struct AudioPort &capturePort)
300 {
301 int32_t ret;
302 struct AudioSampleAttributes param;
303 // User needs to set
304 InitAttrsCapture(param);
305 param.sourceType = static_cast<int32_t>(ConvertToHDIAudioInputType(attr_.sourceType));
306 param.type = attr_.audioStreamFlag == AUDIO_FLAG_VOIP_FAST ? AUDIO_MMAP_VOIP : AUDIO_MMAP_NOIRQ; // enable mmap!
307 param.sampleRate = attr_.sampleRate;
308 param.format = ConvertToHdiFormat(attr_.format);
309 param.isBigEndian = attr_.isBigEndian;
310 param.channelCount = attr_.channel;
311 if (param.channelCount == MONO) {
312 param.channelLayout = CH_LAYOUT_MONO;
313 } else if (param.channelCount == STEREO) {
314 param.channelLayout = CH_LAYOUT_STEREO;
315 }
316 param.silenceThreshold = attr_.bufferSize;
317 param.frameSize = param.format * param.channelCount;
318 param.startThreshold = 0;
319 AUDIO_INFO_LOG("Type: %{public}d, sampleRate: %{public}u, channel: %{public}d, format: %{public}d, "
320 "device:%{public}d", param.type, param.sampleRate, param.channelCount, param.format, attr_.deviceType);
321 struct AudioDeviceDescriptor deviceDesc;
322 deviceDesc.portId = capturePort.portId;
323 char desc[] = "";
324 deviceDesc.desc = desc;
325
326 switch (static_cast<DeviceType>(attr_.deviceType)) {
327 case DEVICE_TYPE_MIC:
328 deviceDesc.pins = PIN_IN_MIC;
329 break;
330 case DEVICE_TYPE_WIRED_HEADSET:
331 deviceDesc.pins = PIN_IN_HS_MIC;
332 break;
333 case DEVICE_TYPE_USB_HEADSET:
334 deviceDesc.pins = PIN_IN_USB_EXT;
335 break;
336 case DEVICE_TYPE_BLUETOOTH_SCO:
337 deviceDesc.pins = PIN_IN_BLUETOOTH_SCO_HEADSET;
338 break;
339 default:
340 AUDIO_WARNING_LOG("Unsupported device type:%{public}d, use default mic instead", attr_.deviceType);
341 deviceDesc.pins = PIN_IN_MIC;
342 break;
343 }
344 AUDIO_INFO_LOG("Capturer device type: %{public}d", attr_.deviceType);
345
346 ret = audioAdapter_->CreateCapture(audioAdapter_, &deviceDesc, ¶m, &audioCapture_, &captureId_);
347 CHECK_AND_RETURN_RET_LOG(audioCapture_ != nullptr && ret >= 0,
348 ERR_NOT_STARTED, "Create capture failed");
349
350 return 0;
351 }
352
PcmFormatToBits(HdiAdapterFormat format)353 uint32_t FastAudioCapturerSourceInner::PcmFormatToBits(HdiAdapterFormat format)
354 {
355 switch (format) {
356 case SAMPLE_U8:
357 return PCM_8_BIT;
358 case SAMPLE_S16LE:
359 return PCM_16_BIT;
360 case SAMPLE_S24LE:
361 return PCM_24_BIT;
362 case SAMPLE_S32LE:
363 return PCM_32_BIT;
364 case SAMPLE_F32LE:
365 return PCM_32_BIT;
366 default:
367 return PCM_24_BIT;
368 }
369 }
370
GetMmapBufferInfo(int & fd,uint32_t & totalSizeInframe,uint32_t & spanSizeInframe,uint32_t & byteSizePerFrame)371 int32_t FastAudioCapturerSourceInner::GetMmapBufferInfo(int &fd, uint32_t &totalSizeInframe, uint32_t &spanSizeInframe,
372 uint32_t &byteSizePerFrame)
373 {
374 CHECK_AND_RETURN_RET_LOG(bufferFd_ != INVALID_FD, ERR_INVALID_HANDLE, "buffer fd has been released!");
375 fd = bufferFd_;
376 totalSizeInframe = bufferTotalFrameSize_;
377 spanSizeInframe = eachReadFrameSize_;
378 byteSizePerFrame = PcmFormatToBits(attr_.format) * attr_.channel / PCM_8_BIT;
379 return SUCCESS;
380 }
381
GetMmapHandlePosition(uint64_t & frames,int64_t & timeSec,int64_t & timeNanoSec)382 int32_t FastAudioCapturerSourceInner::GetMmapHandlePosition(uint64_t &frames, int64_t &timeSec, int64_t &timeNanoSec)
383 {
384 CHECK_AND_RETURN_RET_LOG(audioCapture_ != nullptr, ERR_INVALID_HANDLE, "Audio render is null!");
385
386 struct AudioTimeStamp timestamp = {};
387 int32_t ret = audioCapture_->GetMmapPosition(audioCapture_, &frames, ×tamp);
388 CHECK_AND_RETURN_RET_LOG(ret == 0, ERR_OPERATION_FAILED, "Hdi GetMmapPosition filed, ret:%{public}d!", ret);
389
390 int64_t maxSec = 9223372036; // (9223372036 + 1) * 10^9 > INT64_MAX, seconds should not bigger than it.
391 CHECK_AND_RETURN_RET_LOG(timestamp.tvSec >= 0 && timestamp.tvSec <= maxSec && timestamp.tvNSec >= 0 &&
392 timestamp.tvNSec <= SECOND_TO_NANOSECOND, ERR_OPERATION_FAILED,
393 "Hdi GetMmapPosition get invaild second:%{public}" PRId64 " or nanosecond:%{public}" PRId64 " !",
394 timestamp.tvSec, timestamp.tvNSec);
395 timeSec = timestamp.tvSec;
396 timeNanoSec = timestamp.tvNSec;
397
398 return SUCCESS;
399 }
400
PrepareMmapBuffer()401 int32_t FastAudioCapturerSourceInner::PrepareMmapBuffer()
402 {
403 uint32_t totalBufferInMs = 40; // 5 * (6 + 2 * (1)) = 40ms, the buffer size, not latency.
404 uint32_t frameSizeInByte = PcmFormatToBits(attr_.format) * attr_.channel / PCM_8_BIT;
405 uint32_t reqBufferFrameSize = totalBufferInMs * (attr_.sampleRate / 1000);
406
407 struct AudioMmapBufferDescriptor desc = {0};
408 int32_t ret = audioCapture_->ReqMmapBuffer(audioCapture_, reqBufferFrameSize, &desc);
409 CHECK_AND_RETURN_RET_LOG(ret == 0, ERR_OPERATION_FAILED, "ReqMmapBuffer failed, ret:%{public}d", ret);
410 AUDIO_INFO_LOG("AudioMmapBufferDescriptor memoryAddress[%{private}p] memoryFd[%{public}d] totalBufferFrames"
411 "[%{public}d] transferFrameSize[%{public}d] isShareable[%{public}d] offset[%{public}d]", desc.memoryAddress,
412 desc.memoryFd, desc.totalBufferFrames, desc.transferFrameSize, desc.isShareable, desc.offset);
413
414 bufferFd_ = desc.memoryFd; // fcntl(fd, 1030,3) after dup?
415 int32_t periodFrameMaxSize = 1920000; // 192khz * 10s
416 CHECK_AND_RETURN_RET_LOG(desc.totalBufferFrames >= 0 && desc.transferFrameSize >= 0 &&
417 desc.transferFrameSize <= periodFrameMaxSize, ERR_OPERATION_FAILED,
418 "ReqMmapBuffer invalid values: totalBufferFrames[%{public}d] transferFrameSize[%{public}d]",
419 desc.totalBufferFrames, desc.transferFrameSize);
420 bufferTotalFrameSize_ = static_cast<uint32_t>(desc.totalBufferFrames); // 1440 ~ 3840
421 eachReadFrameSize_ = static_cast<uint32_t>(desc.transferFrameSize); // 240
422
423 CHECK_AND_RETURN_RET_LOG(frameSizeInByte <= ULLONG_MAX / bufferTotalFrameSize_,
424 ERR_OPERATION_FAILED, "BufferSize will overflow!");
425 bufferSize_ = bufferTotalFrameSize_ * frameSizeInByte;
426
427 return SUCCESS;
428 }
429
Init(const IAudioSourceAttr & attr)430 int32_t FastAudioCapturerSourceInner::Init(const IAudioSourceAttr &attr)
431 {
432 AUDIO_INFO_LOG("Init, flag %{public}d", attr.audioStreamFlag);
433 CHECK_AND_RETURN_RET_LOG(InitAudioManager() == 0, ERR_INVALID_HANDLE, "Init audio manager Fail");
434 attr_ = attr;
435 int32_t ret;
436 int32_t index;
437 uint32_t size = MAX_AUDIO_ADAPTER_NUM;
438 AudioAdapterDescriptor descs[MAX_AUDIO_ADAPTER_NUM];
439 if (audioManager_ == nullptr) {
440 AUDIO_ERR_LOG("The audioManager is null");
441 return ERROR;
442 }
443 ret = audioManager_->GetAllAdapters(audioManager_, (struct AudioAdapterDescriptor *)&descs, &size);
444 CHECK_AND_RETURN_RET_LOG(size <= MAX_AUDIO_ADAPTER_NUM && size != 0 && ret == 0, ERR_NOT_STARTED,
445 "Get adapters Fail");
446 // Get qualified sound card and port
447 adapterNameCase_ = attr_.adapterName;
448 openMic_ = attr_.openMicSpeaker;
449 index = SwitchAdapterCapture((struct AudioAdapterDescriptor *)&descs, size, adapterNameCase_, PORT_IN, audioPort);
450 CHECK_AND_RETURN_RET_LOG(index >= 0, ERR_NOT_STARTED, "Switch Adapter Capture Fail");
451 adapterDesc_ = descs[index];
452 int32_t loadAdapter = audioManager_->LoadAdapter(audioManager_, &adapterDesc_, &audioAdapter_);
453 CHECK_AND_RETURN_RET_LOG(loadAdapter == 0, ERR_NOT_STARTED, "Load Adapter Fail");
454
455 CHECK_AND_RETURN_RET_LOG(audioAdapter_ != nullptr, ERR_NOT_STARTED, "Load audio device failed");
456
457 // Inittialization port information, can fill through mode and other parameters
458 int32_t initAllPorts = audioAdapter_->InitAllPorts(audioAdapter_);
459 CHECK_AND_RETURN_RET_LOG(initAllPorts == 0, ERR_DEVICE_INIT, "InitAllPorts failed");
460 bool tmp = CreateCapture(audioPort) == SUCCESS && PrepareMmapBuffer() == SUCCESS;
461 CHECK_AND_RETURN_RET_LOG(tmp, ERR_NOT_STARTED, "Create capture failed");
462 ret = SetInputRoute(static_cast<DeviceType>(attr_.deviceType));
463 if (ret < 0) {
464 AUDIO_WARNING_LOG("update route FAILED: %{public}d", ret);
465 }
466 capturerInited_ = true;
467
468 return SUCCESS;
469 }
470
CaptureFrame(char * frame,uint64_t requestBytes,uint64_t & replyBytes)471 int32_t FastAudioCapturerSourceInner::CaptureFrame(char *frame, uint64_t requestBytes, uint64_t &replyBytes)
472 {
473 AUDIO_ERR_LOG("CaptureFrame in fast mode is not supported!");
474 return ERR_DEVICE_NOT_SUPPORTED;
475 }
476
CheckPositionTime()477 int32_t FastAudioCapturerSourceInner::CheckPositionTime()
478 {
479 int32_t tryCount = 50; // max try count
480 uint64_t frames = 0;
481 int64_t timeSec = 0;
482 int64_t timeNanoSec = 0;
483 int64_t maxHandleCost = 10000000; // 10000000ns -> 10ms
484 int64_t waitTime = 2000000; // 2000000ns -> 2ms
485 while (tryCount-- > 0) {
486 ClockTime::RelativeSleep(waitTime); // us
487 int32_t ret = GetMmapHandlePosition(frames, timeSec, timeNanoSec);
488 int64_t curTime = ClockTime::GetCurNano();
489 int64_t curSec = curTime / AUDIO_NS_PER_SECOND;
490 int64_t curNanoSec = curTime - curSec * AUDIO_NS_PER_SECOND;
491 if (ret != SUCCESS || curSec != timeSec || curNanoSec - timeNanoSec > maxHandleCost) {
492 AUDIO_WARNING_LOG("CheckPositionTime[%{public}d]:ret %{public}d", tryCount, ret);
493 continue;
494 } else {
495 AUDIO_INFO_LOG("CheckPositionTime end, position and time is ok.");
496 return SUCCESS;
497 }
498 }
499 return ERROR;
500 }
501
Start(void)502 int32_t FastAudioCapturerSourceInner::Start(void)
503 {
504 AUDIO_INFO_LOG("Start.");
505 #ifdef FEATURE_POWER_MANAGER
506 std::shared_ptr<PowerMgr::RunningLock> keepRunningLock;
507 if (runningLockManager_ == nullptr) {
508 WatchTimeout guard("PowerMgr::PowerMgrClient::GetInstance().CreateRunningLock:Start");
509 keepRunningLock = PowerMgr::PowerMgrClient::GetInstance().CreateRunningLock("AudioFastCapturer",
510 PowerMgr::RunningLockType::RUNNINGLOCK_BACKGROUND_AUDIO);
511 guard.CheckCurrTimeout();
512 if (keepRunningLock) {
513 runningLockManager_ = std::make_shared<AudioRunningLockManager<PowerMgr::RunningLock>> (keepRunningLock);
514 }
515 }
516 if (runningLockManager_ != nullptr) {
517 AUDIO_INFO_LOG("keepRunningLock lock result: %{public}d",
518 runningLockManager_->Lock(RUNNINGLOCK_LOCK_TIMEOUTMS_LASTING)); // -1 for lasting.
519 } else {
520 AUDIO_WARNING_LOG("keepRunningLock is null, capture can not work well!");
521 }
522 #endif
523
524 if (!started_) {
525 if (audioCapturerSourceCallback_ != nullptr) {
526 audioCapturerSourceCallback_->OnCapturerState(true);
527 }
528
529 CHECK_AND_RETURN_RET_LOG(audioCapture_ != nullptr, ERR_ILLEGAL_STATE, "audioCapturer_ is nullptr");
530 int32_t ret = audioCapture_->Start(audioCapture_);
531 if (ret < 0) {
532 if (audioCapturerSourceCallback_ != nullptr) {
533 audioCapturerSourceCallback_->OnCapturerState(false);
534 }
535 return ERR_NOT_STARTED;
536 }
537 int32_t err = CheckPositionTime();
538 if (err != SUCCESS) {
539 if (audioCapturerSourceCallback_ != nullptr) {
540 audioCapturerSourceCallback_->OnCapturerState(false);
541 }
542 AUDIO_ERR_LOG("CheckPositionTime failed!");
543 return ERR_NOT_STARTED;
544 }
545 started_ = true;
546 }
547
548 return SUCCESS;
549 }
550
SetVolume(float left,float right)551 int32_t FastAudioCapturerSourceInner::SetVolume(float left, float right)
552 {
553 return ERR_DEVICE_NOT_SUPPORTED;
554 }
555
GetVolume(float & left,float & right)556 int32_t FastAudioCapturerSourceInner::GetVolume(float &left, float &right)
557 {
558 return ERR_DEVICE_NOT_SUPPORTED;
559 }
560
SetMute(bool isMute)561 int32_t FastAudioCapturerSourceInner::SetMute(bool isMute)
562 {
563 AUDIO_ERR_LOG("SetMute in fast mode is not supported!");
564 return ERR_DEVICE_NOT_SUPPORTED;
565 }
566
GetMute(bool & isMute)567 int32_t FastAudioCapturerSourceInner::GetMute(bool &isMute)
568 {
569 AUDIO_ERR_LOG("SetMute in fast mode is not supported!");
570 return ERR_DEVICE_NOT_SUPPORTED;
571 }
572
SetInputPortPin(DeviceType inputDevice,AudioRouteNode & source)573 static int32_t SetInputPortPin(DeviceType inputDevice, AudioRouteNode &source)
574 {
575 int32_t ret = SUCCESS;
576 AUDIO_ERR_LOG("Input device type %{public}d", inputDevice);
577 switch (inputDevice) {
578 case DEVICE_TYPE_MIC:
579 case DEVICE_TYPE_EARPIECE:
580 case DEVICE_TYPE_SPEAKER:
581 source.ext.device.type = PIN_IN_MIC;
582 source.ext.device.desc = const_cast<char*>("pin_in_mic");
583 break;
584 case DEVICE_TYPE_WIRED_HEADSET:
585 source.ext.device.type = PIN_IN_HS_MIC;
586 source.ext.device.desc = const_cast<char*>("pin_in_hs_mic");
587 break;
588 case DEVICE_TYPE_BLUETOOTH_SCO:
589 source.ext.device.type = PIN_IN_BLUETOOTH_SCO_HEADSET;
590 source.ext.device.desc = const_cast<char *>("pin_in_bluetooth_sco_headset");
591 break;
592 case DEVICE_TYPE_USB_HEADSET:
593 source.ext.device.type = PIN_IN_USB_EXT;
594 source.ext.device.desc = (char *)"pin_in_usb_ext";
595 break;
596 default:
597 ret = ERR_NOT_SUPPORTED;
598 break;
599 }
600
601 return ret;
602 }
603
SetInputRoute(DeviceType inputDevice)604 int32_t FastAudioCapturerSourceInner::SetInputRoute(DeviceType inputDevice)
605 {
606 AudioPortPin inputPortPin = PIN_IN_MIC;
607 return SetInputRoute(inputDevice, inputPortPin);
608 }
609
SetInputRoute(DeviceType inputDevice,AudioPortPin & inputPortPin)610 int32_t FastAudioCapturerSourceInner::SetInputRoute(DeviceType inputDevice, AudioPortPin &inputPortPin)
611 {
612 AudioRouteNode source = {};
613 AudioRouteNode sink = {};
614 int32_t ret = SetInputPortPin(inputDevice, source);
615 if (ret != SUCCESS) {
616 return ret;
617 }
618 inputPortPin = source.ext.device.type;
619 AUDIO_INFO_LOG("Input PIN is: 0x%{public}X", inputPortPin);
620 source.portId = static_cast<int32_t>(audioPort.portId);
621 source.role = AUDIO_PORT_SOURCE_ROLE;
622 source.type = AUDIO_PORT_DEVICE_TYPE;
623 source.ext.device.moduleId = 0;
624 source.ext.device.desc = const_cast<char*>("");
625
626 sink.portId = 0;
627 sink.role = AUDIO_PORT_SINK_ROLE;
628 sink.type = AUDIO_PORT_MIX_TYPE;
629 sink.ext.mix.moduleId = 0;
630 sink.ext.mix.streamId = static_cast<int32_t>(
631 GenerateUniqueID(AUDIO_HDI_CAPTURE_ID_BASE, HDI_CAPTURE_OFFSET_FAST));
632 sink.ext.device.desc = const_cast<char*>("");
633 sink.ext.mix.source = static_cast<int32_t>(ConvertToHDIAudioInputType(attr_.sourceType));
634
635 AudioRoute route = {
636 .sources = &source,
637 .sourcesLen = 1,
638 .sinks = &sink,
639 .sinksLen = 1,
640 };
641
642 CHECK_AND_RETURN_RET_LOG(audioAdapter_ != nullptr, ERR_OPERATION_FAILED,
643 "AudioAdapter object is null.");
644
645 ret = audioAdapter_->UpdateAudioRoute(audioAdapter_, &route, &routeHandle_);
646 return (ret == SUCCESS) ? SUCCESS : ERR_OPERATION_FAILED;
647 }
648
GetAudioCategory(AudioScene audioScene)649 static AudioCategory GetAudioCategory(AudioScene audioScene)
650 {
651 AudioCategory audioCategory;
652 switch (audioScene) {
653 case AUDIO_SCENE_PHONE_CALL:
654 audioCategory = AUDIO_IN_CALL;
655 break;
656 case AUDIO_SCENE_PHONE_CHAT:
657 audioCategory = AUDIO_IN_COMMUNICATION;
658 break;
659 case AUDIO_SCENE_RINGING:
660 case AUDIO_SCENE_VOICE_RINGING:
661 audioCategory = AUDIO_IN_RINGTONE;
662 break;
663 case AUDIO_SCENE_DEFAULT:
664 audioCategory = AUDIO_IN_MEDIA;
665 break;
666 default:
667 audioCategory = AUDIO_IN_MEDIA;
668 break;
669 }
670 AUDIO_DEBUG_LOG("Audio category returned is: %{public}d", audioCategory);
671
672 return audioCategory;
673 }
674
SetAudioScene(AudioScene audioScene,DeviceType activeDevice)675 int32_t FastAudioCapturerSourceInner::SetAudioScene(AudioScene audioScene, DeviceType activeDevice)
676 {
677 AUDIO_INFO_LOG("SetAudioScene scene: %{public}d, device: %{public}d",
678 audioScene, activeDevice);
679 CHECK_AND_RETURN_RET_LOG(activeDevice == DEVICE_TYPE_BLUETOOTH_SCO, ERR_NOT_SUPPORTED,
680 "Type %{public}d is not supported", activeDevice);
681 CHECK_AND_RETURN_RET_LOG(audioScene >= AUDIO_SCENE_DEFAULT && audioScene < AUDIO_SCENE_MAX,
682 ERR_INVALID_PARAM, "invalid audioScene");
683 CHECK_AND_RETURN_RET_LOG(audioCapture_ != nullptr, ERR_INVALID_HANDLE,
684 "SetAudioScene failed audioCapture_ handle is null!");
685 AudioPortPin audioSceneInPort = PIN_IN_BLUETOOTH_SCO_HEADSET;
686
687 int32_t ret = SUCCESS;
688 if (audioScene != currentAudioScene_) {
689 struct AudioSceneDescriptor scene;
690 scene.scene.id = GetAudioCategory(audioScene);
691 scene.desc.pins = audioSceneInPort;
692 scene.desc.desc = (char *)"pin_in_bluetooth_sco_headset";
693
694 ret = audioCapture_->SelectScene(audioCapture_, &scene);
695 CHECK_AND_RETURN_RET_LOG(ret >= 0, ERR_OPERATION_FAILED,
696 "Select scene FAILED: %{public}d", ret);
697 currentAudioScene_ = audioScene;
698 }
699
700 ret = SetInputRoute(activeDevice, audioSceneInPort);
701 if (ret < 0) {
702 AUDIO_WARNING_LOG("Update route FAILED: %{public}d", ret);
703 }
704
705 AUDIO_DEBUG_LOG("Select audio scene SUCCESS: %{public}d", audioScene);
706 return SUCCESS;
707 }
708
GetAudioParameter(const AudioParamKey key,const std::string & condition)709 std::string FastAudioCapturerSourceInner::GetAudioParameter(const AudioParamKey key,
710 const std::string &condition)
711 {
712 AUDIO_INFO_LOG("GetAudioParameter, key: %{public}d, condition: %{public}s",
713 key, condition.c_str());
714 AudioExtParamKey hdiKey = AudioExtParamKey(key);
715 char value[PARAM_VALUE_LENTH];
716 CHECK_AND_RETURN_RET_LOG(audioAdapter_ != nullptr, "",
717 "GetAudioParameter failed, audioAdapter_ is null");
718 int32_t ret = audioAdapter_->GetExtraParams(audioAdapter_, hdiKey, condition.c_str(),
719 value, PARAM_VALUE_LENTH);
720 CHECK_AND_RETURN_RET_LOG(ret == SUCCESS, "",
721 "FRSource GetAudioParameter failed, error code:%{public}d", ret);
722 return value;
723 }
724
GetTransactionId()725 uint64_t FastAudioCapturerSourceInner::GetTransactionId()
726 {
727 return reinterpret_cast<uint64_t>(audioCapture_);
728 }
729
GetPresentationPosition(uint64_t & frames,int64_t & timeSec,int64_t & timeNanoSec)730 int32_t FastAudioCapturerSourceInner::GetPresentationPosition(uint64_t& frames, int64_t& timeSec, int64_t& timeNanoSec)
731 {
732 return ERR_DEVICE_NOT_SUPPORTED;
733 }
734
RegisterWakeupCloseCallback(IAudioSourceCallback * callback)735 void FastAudioCapturerSourceInner::RegisterWakeupCloseCallback(IAudioSourceCallback *callback)
736 {
737 AUDIO_ERR_LOG("RegisterWakeupCloseCallback FAILED");
738 }
739
RegisterAudioCapturerSourceCallback(std::unique_ptr<ICapturerStateCallback> callback)740 void FastAudioCapturerSourceInner::RegisterAudioCapturerSourceCallback(std::unique_ptr<ICapturerStateCallback> callback)
741 {
742 AUDIO_INFO_LOG("Register AudioCapturerSource Callback");
743 audioCapturerSourceCallback_ = std::move(callback);
744 }
745
RegisterParameterCallback(IAudioSourceCallback * callback)746 void FastAudioCapturerSourceInner::RegisterParameterCallback(IAudioSourceCallback *callback)
747 {
748 AUDIO_ERR_LOG("RegisterParameterCallback in fast mode is not supported!");
749 }
750
Stop(void)751 int32_t FastAudioCapturerSourceInner::Stop(void)
752 {
753 AUDIO_INFO_LOG("Enter");
754 #ifdef FEATURE_POWER_MANAGER
755 if (runningLockManager_ != nullptr) {
756 AUDIO_INFO_LOG("keepRunningLock unLock");
757 runningLockManager_->UnLock();
758 } else {
759 AUDIO_WARNING_LOG("keepRunningLock is null, capture can not work well!");
760 }
761 #endif
762
763 if (started_ && audioCapture_ != nullptr) {
764 int32_t ret = audioCapture_->Stop(audioCapture_);
765 if (audioCapturerSourceCallback_ != nullptr) {
766 audioCapturerSourceCallback_->OnCapturerState(false);
767 }
768 CHECK_AND_RETURN_RET_LOG(ret >= 0, ERR_OPERATION_FAILED, "Stop capture Failed");
769 }
770 started_ = false;
771
772 return SUCCESS;
773 }
774
Pause(void)775 int32_t FastAudioCapturerSourceInner::Pause(void)
776 {
777 if (started_ && audioCapture_ != nullptr) {
778 int32_t ret = audioCapture_->Pause(audioCapture_);
779 if (audioCapturerSourceCallback_ != nullptr) {
780 audioCapturerSourceCallback_->OnCapturerState(false);
781 }
782 CHECK_AND_RETURN_RET_LOG(ret == 0, ERR_OPERATION_FAILED, "pause capture Failed");
783 }
784 paused_ = true;
785
786 return SUCCESS;
787 }
788
Resume(void)789 int32_t FastAudioCapturerSourceInner::Resume(void)
790 {
791 if (paused_ && audioCapture_ != nullptr) {
792 int32_t ret = audioCapture_->Resume(audioCapture_);
793 if (audioCapturerSourceCallback_ != nullptr) {
794 audioCapturerSourceCallback_->OnCapturerState(true);
795 }
796 CHECK_AND_RETURN_RET_LOG(ret == 0, ERR_OPERATION_FAILED, "resume capture Failed");
797 }
798 paused_ = false;
799
800 return SUCCESS;
801 }
802
Reset(void)803 int32_t FastAudioCapturerSourceInner::Reset(void)
804 {
805 if (started_ && audioCapture_ != nullptr) {
806 audioCapture_->Flush(audioCapture_);
807 }
808
809 return SUCCESS;
810 }
811
Flush(void)812 int32_t FastAudioCapturerSourceInner::Flush(void)
813 {
814 if (started_ && audioCapture_ != nullptr) {
815 audioCapture_->Flush(audioCapture_);
816 }
817
818 return SUCCESS;
819 }
820
GetMaxAmplitude()821 float FastAudioCapturerSourceInner::GetMaxAmplitude()
822 {
823 AUDIO_WARNING_LOG("getMaxAmplitude in fast audio cap not support");
824 return 0;
825 }
826
UpdateAppsUid(const int32_t appsUid[PA_MAX_OUTPUTS_PER_SOURCE],const size_t size)827 int32_t FastAudioCapturerSourceInner::UpdateAppsUid(const int32_t appsUid[PA_MAX_OUTPUTS_PER_SOURCE],
828 const size_t size)
829 {
830 #ifdef FEATURE_POWER_MANAGER
831 if (!runningLockManager_) {
832 return ERROR;
833 }
834
835 return runningLockManager_->UpdateAppsUid(appsUid, appsUid + size);
836 #endif
837
838 return SUCCESS;
839 }
840
UpdateAppsUid(const std::vector<int32_t> & appsUid)841 int32_t FastAudioCapturerSourceInner::UpdateAppsUid(const std::vector<int32_t> &appsUid)
842 {
843 #ifdef FEATURE_POWER_MANAGER
844 if (!runningLockManager_) {
845 return ERROR;
846 }
847
848 runningLockManager_->UpdateAppsUid(appsUid.cbegin(), appsUid.cend());
849 runningLockManager_->UpdateAppsUidToPowerMgr();
850 #endif
851
852 return SUCCESS;
853 }
854 } // namespace AudioStandard
855 } // namesapce OHOS
856