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