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 hdiAudioInputType = AUDIO_INPUT_MIC_TYPE;
275 break;
276 case SOURCE_TYPE_WAKEUP:
277 hdiAudioInputType = AUDIO_INPUT_SPEECH_WAKEUP_TYPE;
278 break;
279 case SOURCE_TYPE_VOICE_COMMUNICATION:
280 hdiAudioInputType = AUDIO_INPUT_VOICE_COMMUNICATION_TYPE;
281 break;
282 case SOURCE_TYPE_VOICE_RECOGNITION:
283 hdiAudioInputType = AUDIO_INPUT_VOICE_RECOGNITION_TYPE;
284 break;
285 case SOURCE_TYPE_VOICE_CALL:
286 hdiAudioInputType = AUDIO_INPUT_VOICE_CALL_TYPE;
287 break;
288 case SOURCE_TYPE_CAMCORDER:
289 hdiAudioInputType = AUDIO_INPUT_CAMCORDER_TYPE;
290 break;
291 default:
292 hdiAudioInputType = AUDIO_INPUT_MIC_TYPE;
293 break;
294 }
295 return hdiAudioInputType;
296 }
297
CreateCapture(const struct AudioPort & capturePort)298 int32_t FastAudioCapturerSourceInner::CreateCapture(const struct AudioPort &capturePort)
299 {
300 int32_t ret;
301 struct AudioSampleAttributes param;
302 // User needs to set
303 InitAttrsCapture(param);
304 param.sourceType = static_cast<int32_t>(ConvertToHDIAudioInputType(attr_.sourceType));
305 param.type = attr_.audioStreamFlag == AUDIO_FLAG_VOIP_FAST ? AUDIO_MMAP_VOIP : AUDIO_MMAP_NOIRQ; // enable mmap!
306 param.sampleRate = attr_.sampleRate;
307 param.format = ConvertToHdiFormat(attr_.format);
308 param.isBigEndian = attr_.isBigEndian;
309 param.channelCount = attr_.channel;
310 if (param.channelCount == MONO) {
311 param.channelLayout = CH_LAYOUT_MONO;
312 } else if (param.channelCount == STEREO) {
313 param.channelLayout = CH_LAYOUT_STEREO;
314 }
315 param.silenceThreshold = attr_.bufferSize;
316 param.frameSize = param.format * param.channelCount;
317 param.startThreshold = 0;
318 AUDIO_INFO_LOG("Type: %{public}d, sampleRate: %{public}u, channel: %{public}d, format: %{public}d, "
319 "device:%{public}d", param.type, param.sampleRate, param.channelCount, param.format, attr_.deviceType);
320 struct AudioDeviceDescriptor deviceDesc;
321 deviceDesc.portId = capturePort.portId;
322 char desc[] = "";
323 deviceDesc.desc = desc;
324
325 switch (static_cast<DeviceType>(attr_.deviceType)) {
326 case DEVICE_TYPE_MIC:
327 deviceDesc.pins = PIN_IN_MIC;
328 break;
329 case DEVICE_TYPE_WIRED_HEADSET:
330 deviceDesc.pins = PIN_IN_HS_MIC;
331 break;
332 case DEVICE_TYPE_USB_HEADSET:
333 deviceDesc.pins = PIN_IN_USB_EXT;
334 break;
335 case DEVICE_TYPE_BLUETOOTH_SCO:
336 deviceDesc.pins = PIN_IN_BLUETOOTH_SCO_HEADSET;
337 break;
338 default:
339 AUDIO_WARNING_LOG("Unsupported device type:%{public}d, use default mic instead", attr_.deviceType);
340 deviceDesc.pins = PIN_IN_MIC;
341 break;
342 }
343 AUDIO_INFO_LOG("Capturer device type: %{public}d", attr_.deviceType);
344
345 ret = audioAdapter_->CreateCapture(audioAdapter_, &deviceDesc, ¶m, &audioCapture_, &captureId_);
346 CHECK_AND_RETURN_RET_LOG(audioCapture_ != nullptr && ret >= 0,
347 ERR_NOT_STARTED, "Create capture failed");
348
349 return 0;
350 }
351
PcmFormatToBits(HdiAdapterFormat format)352 uint32_t FastAudioCapturerSourceInner::PcmFormatToBits(HdiAdapterFormat format)
353 {
354 switch (format) {
355 case SAMPLE_U8:
356 return PCM_8_BIT;
357 case SAMPLE_S16LE:
358 return PCM_16_BIT;
359 case SAMPLE_S24LE:
360 return PCM_24_BIT;
361 case SAMPLE_S32LE:
362 return PCM_32_BIT;
363 case SAMPLE_F32LE:
364 return PCM_32_BIT;
365 default:
366 return PCM_24_BIT;
367 }
368 }
369
GetMmapBufferInfo(int & fd,uint32_t & totalSizeInframe,uint32_t & spanSizeInframe,uint32_t & byteSizePerFrame)370 int32_t FastAudioCapturerSourceInner::GetMmapBufferInfo(int &fd, uint32_t &totalSizeInframe, uint32_t &spanSizeInframe,
371 uint32_t &byteSizePerFrame)
372 {
373 CHECK_AND_RETURN_RET_LOG(bufferFd_ != INVALID_FD, ERR_INVALID_HANDLE, "buffer fd has been released!");
374 fd = bufferFd_;
375 totalSizeInframe = bufferTotalFrameSize_;
376 spanSizeInframe = eachReadFrameSize_;
377 byteSizePerFrame = PcmFormatToBits(attr_.format) * attr_.channel / PCM_8_BIT;
378 return SUCCESS;
379 }
380
GetMmapHandlePosition(uint64_t & frames,int64_t & timeSec,int64_t & timeNanoSec)381 int32_t FastAudioCapturerSourceInner::GetMmapHandlePosition(uint64_t &frames, int64_t &timeSec, int64_t &timeNanoSec)
382 {
383 CHECK_AND_RETURN_RET_LOG(audioCapture_ != nullptr, ERR_INVALID_HANDLE, "Audio render is null!");
384
385 struct AudioTimeStamp timestamp = {};
386 int32_t ret = audioCapture_->GetMmapPosition(audioCapture_, &frames, ×tamp);
387 CHECK_AND_RETURN_RET_LOG(ret == 0, ERR_OPERATION_FAILED, "Hdi GetMmapPosition filed, ret:%{public}d!", ret);
388
389 int64_t maxSec = 9223372036; // (9223372036 + 1) * 10^9 > INT64_MAX, seconds should not bigger than it.
390 CHECK_AND_RETURN_RET_LOG(timestamp.tvSec >= 0 && timestamp.tvSec <= maxSec && timestamp.tvNSec >= 0 &&
391 timestamp.tvNSec <= SECOND_TO_NANOSECOND, ERR_OPERATION_FAILED,
392 "Hdi GetMmapPosition get invaild second:%{public}" PRId64 " or nanosecond:%{public}" PRId64 " !",
393 timestamp.tvSec, timestamp.tvNSec);
394 timeSec = timestamp.tvSec;
395 timeNanoSec = timestamp.tvNSec;
396
397 return SUCCESS;
398 }
399
PrepareMmapBuffer()400 int32_t FastAudioCapturerSourceInner::PrepareMmapBuffer()
401 {
402 uint32_t totalBufferInMs = 40; // 5 * (6 + 2 * (1)) = 40ms, the buffer size, not latency.
403 uint32_t frameSizeInByte = PcmFormatToBits(attr_.format) * attr_.channel / PCM_8_BIT;
404 uint32_t reqBufferFrameSize = totalBufferInMs * (attr_.sampleRate / 1000);
405
406 struct AudioMmapBufferDescriptor desc = {0};
407 int32_t ret = audioCapture_->ReqMmapBuffer(audioCapture_, reqBufferFrameSize, &desc);
408 CHECK_AND_RETURN_RET_LOG(ret == 0, ERR_OPERATION_FAILED, "ReqMmapBuffer failed, ret:%{public}d", ret);
409 AUDIO_INFO_LOG("AudioMmapBufferDescriptor memoryAddress[%{private}p] memoryFd[%{public}d] totalBufferFrames"
410 "[%{public}d] transferFrameSize[%{public}d] isShareable[%{public}d] offset[%{public}d]", desc.memoryAddress,
411 desc.memoryFd, desc.totalBufferFrames, desc.transferFrameSize, desc.isShareable, desc.offset);
412
413 bufferFd_ = desc.memoryFd; // fcntl(fd, 1030,3) after dup?
414 int32_t periodFrameMaxSize = 1920000; // 192khz * 10s
415 CHECK_AND_RETURN_RET_LOG(desc.totalBufferFrames >= 0 && desc.transferFrameSize >= 0 &&
416 desc.transferFrameSize <= periodFrameMaxSize, ERR_OPERATION_FAILED,
417 "ReqMmapBuffer invalid values: totalBufferFrames[%{public}d] transferFrameSize[%{public}d]",
418 desc.totalBufferFrames, desc.transferFrameSize);
419 bufferTotalFrameSize_ = static_cast<uint32_t>(desc.totalBufferFrames); // 1440 ~ 3840
420 eachReadFrameSize_ = static_cast<uint32_t>(desc.transferFrameSize); // 240
421
422 CHECK_AND_RETURN_RET_LOG(frameSizeInByte <= ULLONG_MAX / bufferTotalFrameSize_,
423 ERR_OPERATION_FAILED, "BufferSize will overflow!");
424 bufferSize_ = bufferTotalFrameSize_ * frameSizeInByte;
425
426 return SUCCESS;
427 }
428
Init(const IAudioSourceAttr & attr)429 int32_t FastAudioCapturerSourceInner::Init(const IAudioSourceAttr &attr)
430 {
431 AUDIO_INFO_LOG("Init, flag %{public}d", attr.audioStreamFlag);
432 CHECK_AND_RETURN_RET_LOG(InitAudioManager() == 0, ERR_INVALID_HANDLE, "Init audio manager Fail");
433 attr_ = attr;
434 int32_t ret;
435 int32_t index;
436 uint32_t size = MAX_AUDIO_ADAPTER_NUM;
437 AudioAdapterDescriptor descs[MAX_AUDIO_ADAPTER_NUM];
438 if (audioManager_ == nullptr) {
439 AUDIO_ERR_LOG("The audioManager is null");
440 return ERROR;
441 }
442 ret = audioManager_->GetAllAdapters(audioManager_, (struct AudioAdapterDescriptor *)&descs, &size);
443 CHECK_AND_RETURN_RET_LOG(size <= MAX_AUDIO_ADAPTER_NUM && size != 0 && ret == 0, ERR_NOT_STARTED,
444 "Get adapters Fail");
445 // Get qualified sound card and port
446 adapterNameCase_ = attr_.adapterName;
447 openMic_ = attr_.openMicSpeaker;
448 index = SwitchAdapterCapture((struct AudioAdapterDescriptor *)&descs, size, adapterNameCase_, PORT_IN, audioPort);
449 CHECK_AND_RETURN_RET_LOG(index >= 0, ERR_NOT_STARTED, "Switch Adapter Capture Fail");
450 adapterDesc_ = descs[index];
451 int32_t loadAdapter = audioManager_->LoadAdapter(audioManager_, &adapterDesc_, &audioAdapter_);
452 CHECK_AND_RETURN_RET_LOG(loadAdapter == 0, ERR_NOT_STARTED, "Load Adapter Fail");
453
454 CHECK_AND_RETURN_RET_LOG(audioAdapter_ != nullptr, ERR_NOT_STARTED, "Load audio device failed");
455
456 // Inittialization port information, can fill through mode and other parameters
457 int32_t initAllPorts = audioAdapter_->InitAllPorts(audioAdapter_);
458 CHECK_AND_RETURN_RET_LOG(initAllPorts == 0, ERR_DEVICE_INIT, "InitAllPorts failed");
459 bool tmp = CreateCapture(audioPort) == SUCCESS && PrepareMmapBuffer() == SUCCESS;
460 CHECK_AND_RETURN_RET_LOG(tmp, ERR_NOT_STARTED, "Create capture failed");
461 ret = SetInputRoute(static_cast<DeviceType>(attr_.deviceType));
462 if (ret < 0) {
463 AUDIO_WARNING_LOG("update route FAILED: %{public}d", ret);
464 }
465 capturerInited_ = true;
466
467 return SUCCESS;
468 }
469
CaptureFrame(char * frame,uint64_t requestBytes,uint64_t & replyBytes)470 int32_t FastAudioCapturerSourceInner::CaptureFrame(char *frame, uint64_t requestBytes, uint64_t &replyBytes)
471 {
472 AUDIO_ERR_LOG("CaptureFrame in fast mode is not supported!");
473 return ERR_DEVICE_NOT_SUPPORTED;
474 }
475
CheckPositionTime()476 int32_t FastAudioCapturerSourceInner::CheckPositionTime()
477 {
478 int32_t tryCount = 50; // max try count
479 uint64_t frames = 0;
480 int64_t timeSec = 0;
481 int64_t timeNanoSec = 0;
482 int64_t maxHandleCost = 10000000; // 10000000ns -> 10ms
483 int64_t waitTime = 2000000; // 2000000ns -> 2ms
484 while (tryCount-- > 0) {
485 ClockTime::RelativeSleep(waitTime); // us
486 int32_t ret = GetMmapHandlePosition(frames, timeSec, timeNanoSec);
487 int64_t curTime = ClockTime::GetCurNano();
488 int64_t curSec = curTime / AUDIO_NS_PER_SECOND;
489 int64_t curNanoSec = curTime - curSec * AUDIO_NS_PER_SECOND;
490 if (ret != SUCCESS || curSec != timeSec || curNanoSec - timeNanoSec > maxHandleCost) {
491 AUDIO_WARNING_LOG("CheckPositionTime[%{public}d]:ret %{public}d", tryCount, ret);
492 continue;
493 } else {
494 AUDIO_INFO_LOG("CheckPositionTime end, position and time is ok.");
495 return SUCCESS;
496 }
497 }
498 return ERROR;
499 }
500
Start(void)501 int32_t FastAudioCapturerSourceInner::Start(void)
502 {
503 AUDIO_INFO_LOG("Start.");
504 #ifdef FEATURE_POWER_MANAGER
505 std::shared_ptr<PowerMgr::RunningLock> keepRunningLock;
506 if (runningLockManager_ == nullptr) {
507 keepRunningLock = PowerMgr::PowerMgrClient::GetInstance().CreateRunningLock("AudioFastCapturer",
508 PowerMgr::RunningLockType::RUNNINGLOCK_BACKGROUND_AUDIO);
509 if (keepRunningLock) {
510 runningLockManager_ = std::make_shared<AudioRunningLockManager<PowerMgr::RunningLock>> (keepRunningLock);
511 }
512 }
513 if (runningLockManager_ != nullptr) {
514 AUDIO_INFO_LOG("keepRunningLock lock result: %{public}d",
515 runningLockManager_->Lock(RUNNINGLOCK_LOCK_TIMEOUTMS_LASTING)); // -1 for lasting.
516 } else {
517 AUDIO_WARNING_LOG("keepRunningLock is null, capture can not work well!");
518 }
519 #endif
520
521 if (!started_) {
522 if (audioCapturerSourceCallback_ != nullptr) {
523 audioCapturerSourceCallback_->OnCapturerState(true);
524 }
525
526 CHECK_AND_RETURN_RET_LOG(audioCapture_ != nullptr, ERR_ILLEGAL_STATE, "audioCapturer_ is nullptr");
527 int32_t ret = audioCapture_->Start(audioCapture_);
528 if (ret < 0) {
529 if (audioCapturerSourceCallback_ != nullptr) {
530 audioCapturerSourceCallback_->OnCapturerState(false);
531 }
532 return ERR_NOT_STARTED;
533 }
534 int32_t err = CheckPositionTime();
535 if (err != SUCCESS) {
536 if (audioCapturerSourceCallback_ != nullptr) {
537 audioCapturerSourceCallback_->OnCapturerState(false);
538 }
539 AUDIO_ERR_LOG("CheckPositionTime failed!");
540 return ERR_NOT_STARTED;
541 }
542 started_ = true;
543 }
544
545 return SUCCESS;
546 }
547
SetVolume(float left,float right)548 int32_t FastAudioCapturerSourceInner::SetVolume(float left, float right)
549 {
550 return ERR_DEVICE_NOT_SUPPORTED;
551 }
552
GetVolume(float & left,float & right)553 int32_t FastAudioCapturerSourceInner::GetVolume(float &left, float &right)
554 {
555 return ERR_DEVICE_NOT_SUPPORTED;
556 }
557
SetMute(bool isMute)558 int32_t FastAudioCapturerSourceInner::SetMute(bool isMute)
559 {
560 AUDIO_ERR_LOG("SetMute in fast mode is not supported!");
561 return ERR_DEVICE_NOT_SUPPORTED;
562 }
563
GetMute(bool & isMute)564 int32_t FastAudioCapturerSourceInner::GetMute(bool &isMute)
565 {
566 AUDIO_ERR_LOG("SetMute in fast mode is not supported!");
567 return ERR_DEVICE_NOT_SUPPORTED;
568 }
569
SetInputPortPin(DeviceType inputDevice,AudioRouteNode & source)570 static int32_t SetInputPortPin(DeviceType inputDevice, AudioRouteNode &source)
571 {
572 int32_t ret = SUCCESS;
573 AUDIO_ERR_LOG("Input device type %{public}d", inputDevice);
574 switch (inputDevice) {
575 case DEVICE_TYPE_MIC:
576 case DEVICE_TYPE_EARPIECE:
577 case DEVICE_TYPE_SPEAKER:
578 source.ext.device.type = PIN_IN_MIC;
579 source.ext.device.desc = const_cast<char*>("pin_in_mic");
580 break;
581 case DEVICE_TYPE_WIRED_HEADSET:
582 source.ext.device.type = PIN_IN_HS_MIC;
583 source.ext.device.desc = const_cast<char*>("pin_in_hs_mic");
584 break;
585 case DEVICE_TYPE_BLUETOOTH_SCO:
586 source.ext.device.type = PIN_IN_BLUETOOTH_SCO_HEADSET;
587 source.ext.device.desc = const_cast<char *>("pin_in_bluetooth_sco_headset");
588 break;
589 case DEVICE_TYPE_USB_HEADSET:
590 source.ext.device.type = PIN_IN_USB_EXT;
591 source.ext.device.desc = (char *)"pin_in_usb_ext";
592 break;
593 default:
594 ret = ERR_NOT_SUPPORTED;
595 break;
596 }
597
598 return ret;
599 }
600
SetInputRoute(DeviceType inputDevice)601 int32_t FastAudioCapturerSourceInner::SetInputRoute(DeviceType inputDevice)
602 {
603 AudioPortPin inputPortPin = PIN_IN_MIC;
604 return SetInputRoute(inputDevice, inputPortPin);
605 }
606
SetInputRoute(DeviceType inputDevice,AudioPortPin & inputPortPin)607 int32_t FastAudioCapturerSourceInner::SetInputRoute(DeviceType inputDevice, AudioPortPin &inputPortPin)
608 {
609 AudioRouteNode source = {};
610 AudioRouteNode sink = {};
611 int32_t ret = SetInputPortPin(inputDevice, source);
612 if (ret != SUCCESS) {
613 return ret;
614 }
615 inputPortPin = source.ext.device.type;
616 AUDIO_INFO_LOG("Input PIN is: 0x%{public}X", inputPortPin);
617 source.portId = static_cast<int32_t>(audioPort.portId);
618 source.role = AUDIO_PORT_SOURCE_ROLE;
619 source.type = AUDIO_PORT_DEVICE_TYPE;
620 source.ext.device.moduleId = 0;
621 source.ext.device.desc = const_cast<char*>("");
622
623 sink.portId = 0;
624 sink.role = AUDIO_PORT_SINK_ROLE;
625 sink.type = AUDIO_PORT_MIX_TYPE;
626 sink.ext.mix.moduleId = 0;
627 sink.ext.mix.streamId = static_cast<int32_t>(
628 GenerateUniqueID(AUDIO_HDI_CAPTURE_ID_BASE, HDI_CAPTURE_OFFSET_FAST));
629 sink.ext.device.desc = const_cast<char*>("");
630 sink.ext.mix.source = static_cast<int32_t>(ConvertToHDIAudioInputType(attr_.sourceType));
631
632 AudioRoute route = {
633 .sources = &source,
634 .sourcesLen = 1,
635 .sinks = &sink,
636 .sinksLen = 1,
637 };
638
639 CHECK_AND_RETURN_RET_LOG(audioAdapter_ != nullptr, ERR_OPERATION_FAILED,
640 "AudioAdapter object is null.");
641
642 ret = audioAdapter_->UpdateAudioRoute(audioAdapter_, &route, &routeHandle_);
643 return (ret == SUCCESS) ? SUCCESS : ERR_OPERATION_FAILED;
644 }
645
GetAudioCategory(AudioScene audioScene)646 static AudioCategory GetAudioCategory(AudioScene audioScene)
647 {
648 AudioCategory audioCategory;
649 switch (audioScene) {
650 case AUDIO_SCENE_PHONE_CALL:
651 audioCategory = AUDIO_IN_CALL;
652 break;
653 case AUDIO_SCENE_PHONE_CHAT:
654 audioCategory = AUDIO_IN_COMMUNICATION;
655 break;
656 case AUDIO_SCENE_RINGING:
657 case AUDIO_SCENE_VOICE_RINGING:
658 audioCategory = AUDIO_IN_RINGTONE;
659 break;
660 case AUDIO_SCENE_DEFAULT:
661 audioCategory = AUDIO_IN_MEDIA;
662 break;
663 default:
664 audioCategory = AUDIO_IN_MEDIA;
665 break;
666 }
667 AUDIO_DEBUG_LOG("Audio category returned is: %{public}d", audioCategory);
668
669 return audioCategory;
670 }
671
SetAudioScene(AudioScene audioScene,DeviceType activeDevice)672 int32_t FastAudioCapturerSourceInner::SetAudioScene(AudioScene audioScene, DeviceType activeDevice)
673 {
674 AUDIO_INFO_LOG("SetAudioScene scene: %{public}d, device: %{public}d",
675 audioScene, activeDevice);
676 CHECK_AND_RETURN_RET_LOG(activeDevice == DEVICE_TYPE_BLUETOOTH_SCO, ERR_NOT_SUPPORTED,
677 "Type %{public}d is not supported", activeDevice);
678 CHECK_AND_RETURN_RET_LOG(audioScene >= AUDIO_SCENE_DEFAULT && audioScene < AUDIO_SCENE_MAX,
679 ERR_INVALID_PARAM, "invalid audioScene");
680 CHECK_AND_RETURN_RET_LOG(audioCapture_ != nullptr, ERR_INVALID_HANDLE,
681 "SetAudioScene failed audioCapture_ handle is null!");
682 AudioPortPin audioSceneInPort = PIN_IN_BLUETOOTH_SCO_HEADSET;
683
684 int32_t ret = SUCCESS;
685 if (audioScene != currentAudioScene_) {
686 struct AudioSceneDescriptor scene;
687 scene.scene.id = GetAudioCategory(audioScene);
688 scene.desc.pins = audioSceneInPort;
689 scene.desc.desc = (char *)"pin_in_bluetooth_sco_headset";
690
691 ret = audioCapture_->SelectScene(audioCapture_, &scene);
692 CHECK_AND_RETURN_RET_LOG(ret >= 0, ERR_OPERATION_FAILED,
693 "Select scene FAILED: %{public}d", ret);
694 currentAudioScene_ = audioScene;
695 }
696
697 ret = SetInputRoute(activeDevice, audioSceneInPort);
698 if (ret < 0) {
699 AUDIO_WARNING_LOG("Update route FAILED: %{public}d", ret);
700 }
701
702 AUDIO_DEBUG_LOG("Select audio scene SUCCESS: %{public}d", audioScene);
703 return SUCCESS;
704 }
705
GetAudioParameter(const AudioParamKey key,const std::string & condition)706 std::string FastAudioCapturerSourceInner::GetAudioParameter(const AudioParamKey key,
707 const std::string &condition)
708 {
709 AUDIO_INFO_LOG("GetAudioParameter, key: %{public}d, condition: %{public}s",
710 key, condition.c_str());
711 AudioExtParamKey hdiKey = AudioExtParamKey(key);
712 char value[PARAM_VALUE_LENTH];
713 CHECK_AND_RETURN_RET_LOG(audioAdapter_ != nullptr, "",
714 "GetAudioParameter failed, audioAdapter_ is null");
715 int32_t ret = audioAdapter_->GetExtraParams(audioAdapter_, hdiKey, condition.c_str(),
716 value, PARAM_VALUE_LENTH);
717 CHECK_AND_RETURN_RET_LOG(ret == SUCCESS, "",
718 "FRSource GetAudioParameter failed, error code:%{public}d", ret);
719 return value;
720 }
721
GetTransactionId()722 uint64_t FastAudioCapturerSourceInner::GetTransactionId()
723 {
724 return reinterpret_cast<uint64_t>(audioCapture_);
725 }
726
GetPresentationPosition(uint64_t & frames,int64_t & timeSec,int64_t & timeNanoSec)727 int32_t FastAudioCapturerSourceInner::GetPresentationPosition(uint64_t& frames, int64_t& timeSec, int64_t& timeNanoSec)
728 {
729 return ERR_DEVICE_NOT_SUPPORTED;
730 }
731
RegisterWakeupCloseCallback(IAudioSourceCallback * callback)732 void FastAudioCapturerSourceInner::RegisterWakeupCloseCallback(IAudioSourceCallback *callback)
733 {
734 AUDIO_ERR_LOG("RegisterWakeupCloseCallback FAILED");
735 }
736
RegisterAudioCapturerSourceCallback(std::unique_ptr<ICapturerStateCallback> callback)737 void FastAudioCapturerSourceInner::RegisterAudioCapturerSourceCallback(std::unique_ptr<ICapturerStateCallback> callback)
738 {
739 AUDIO_INFO_LOG("Register AudioCapturerSource Callback");
740 audioCapturerSourceCallback_ = std::move(callback);
741 }
742
RegisterParameterCallback(IAudioSourceCallback * callback)743 void FastAudioCapturerSourceInner::RegisterParameterCallback(IAudioSourceCallback *callback)
744 {
745 AUDIO_ERR_LOG("RegisterParameterCallback in fast mode is not supported!");
746 }
747
Stop(void)748 int32_t FastAudioCapturerSourceInner::Stop(void)
749 {
750 AUDIO_INFO_LOG("Enter");
751 #ifdef FEATURE_POWER_MANAGER
752 if (runningLockManager_ != nullptr) {
753 AUDIO_INFO_LOG("keepRunningLock unLock");
754 runningLockManager_->UnLock();
755 } else {
756 AUDIO_WARNING_LOG("keepRunningLock is null, capture can not work well!");
757 }
758 #endif
759
760 if (started_ && audioCapture_ != nullptr) {
761 int32_t ret = audioCapture_->Stop(audioCapture_);
762 if (audioCapturerSourceCallback_ != nullptr) {
763 audioCapturerSourceCallback_->OnCapturerState(false);
764 }
765 CHECK_AND_RETURN_RET_LOG(ret >= 0, ERR_OPERATION_FAILED, "Stop capture Failed");
766 }
767 started_ = false;
768
769 return SUCCESS;
770 }
771
Pause(void)772 int32_t FastAudioCapturerSourceInner::Pause(void)
773 {
774 if (started_ && audioCapture_ != nullptr) {
775 int32_t ret = audioCapture_->Pause(audioCapture_);
776 if (audioCapturerSourceCallback_ != nullptr) {
777 audioCapturerSourceCallback_->OnCapturerState(false);
778 }
779 CHECK_AND_RETURN_RET_LOG(ret == 0, ERR_OPERATION_FAILED, "pause capture Failed");
780 }
781 paused_ = true;
782
783 return SUCCESS;
784 }
785
Resume(void)786 int32_t FastAudioCapturerSourceInner::Resume(void)
787 {
788 if (paused_ && audioCapture_ != nullptr) {
789 int32_t ret = audioCapture_->Resume(audioCapture_);
790 if (audioCapturerSourceCallback_ != nullptr) {
791 audioCapturerSourceCallback_->OnCapturerState(true);
792 }
793 CHECK_AND_RETURN_RET_LOG(ret == 0, ERR_OPERATION_FAILED, "resume capture Failed");
794 }
795 paused_ = false;
796
797 return SUCCESS;
798 }
799
Reset(void)800 int32_t FastAudioCapturerSourceInner::Reset(void)
801 {
802 if (started_ && audioCapture_ != nullptr) {
803 audioCapture_->Flush(audioCapture_);
804 }
805
806 return SUCCESS;
807 }
808
Flush(void)809 int32_t FastAudioCapturerSourceInner::Flush(void)
810 {
811 if (started_ && audioCapture_ != nullptr) {
812 audioCapture_->Flush(audioCapture_);
813 }
814
815 return SUCCESS;
816 }
817
GetMaxAmplitude()818 float FastAudioCapturerSourceInner::GetMaxAmplitude()
819 {
820 AUDIO_WARNING_LOG("getMaxAmplitude in fast audio cap not support");
821 return 0;
822 }
823
UpdateAppsUid(const int32_t appsUid[PA_MAX_OUTPUTS_PER_SOURCE],const size_t size)824 int32_t FastAudioCapturerSourceInner::UpdateAppsUid(const int32_t appsUid[PA_MAX_OUTPUTS_PER_SOURCE],
825 const size_t size)
826 {
827 #ifdef FEATURE_POWER_MANAGER
828 if (!runningLockManager_) {
829 return ERROR;
830 }
831
832 return runningLockManager_->UpdateAppsUid(appsUid, appsUid + size);
833 #endif
834
835 return SUCCESS;
836 }
837
UpdateAppsUid(const std::vector<int32_t> & appsUid)838 int32_t FastAudioCapturerSourceInner::UpdateAppsUid(const std::vector<int32_t> &appsUid)
839 {
840 #ifdef FEATURE_POWER_MANAGER
841 if (!runningLockManager_) {
842 return ERROR;
843 }
844
845 runningLockManager_->UpdateAppsUid(appsUid.cbegin(), appsUid.cend());
846 runningLockManager_->UpdateAppsUidToPowerMgr();
847 #endif
848
849 return SUCCESS;
850 }
851 } // namespace AudioStandard
852 } // namesapce OHOS
853