1 /*
2 * Copyright (c) 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
16 #ifndef LOG_TAG
17 #define LOG_TAG "AudioCaptureSource"
18 #endif
19
20 #include "source/audio_capture_source.h"
21 #include <climits>
22 #include <future>
23 #include "parameters.h"
24 #include "audio_hdi_log.h"
25 #include "audio_errors.h"
26 #include "audio_dump_pcm.h"
27 #include "volume_tools.h"
28 #include "audio_schedule.h"
29 #include "media_monitor_manager.h"
30 #include "audio_enhance_chain_manager.h"
31 #include "common/hdi_adapter_info.h"
32 #include "manager/hdi_adapter_manager.h"
33 #include "manager/hdi_monitor.h"
34 #include "capturer_clock_manager.h"
35 #include "audio_setting_provider.h"
36
37 namespace OHOS {
38 namespace AudioStandard {
39
40 static constexpr uint32_t DECIMAL_BASE = 10;
41
AudioCaptureSource(const uint32_t captureId,const std::string & halName)42 AudioCaptureSource::AudioCaptureSource(const uint32_t captureId, const std::string &halName)
43 : captureId_(captureId), halName_(halName)
44 {
45 audioSrcClock_ = std::make_shared<AudioCapturerSourceClock>();
46 CapturerClockManager::GetInstance().RegisterAudioSourceClock(captureId, audioSrcClock_);
47 }
48
~AudioCaptureSource()49 AudioCaptureSource::~AudioCaptureSource()
50 {
51 isCaptureThreadRunning_ = false;
52 AUDIO_INFO_LOG("[%{public}s] volumeDataCount: %{public}" PRId64, logUtilsTag_.c_str(), volumeDataCount_);
53 CapturerClockManager::GetInstance().DeleteAudioSourceClock(captureId_);
54 }
55
Init(const IAudioSourceAttr & attr)56 int32_t AudioCaptureSource::Init(const IAudioSourceAttr &attr)
57 {
58 AUDIO_INFO_LOG("in");
59 std::lock_guard<std::mutex> lock(statusMutex_);
60 if (attr.sourceType == SOURCE_TYPE_MIC_REF || attr.sourceType == SOURCE_TYPE_EC) {
61 InitEcOrMicRefAttr(attr);
62 } else {
63 attr_ = attr;
64 }
65 adapterNameCase_ = attr_.adapterName;
66 if (adapterNameCase_ == "" && halName_ == "primary") {
67 adapterNameCase_ = "primary";
68 }
69 openMic_ = attr_.openMicSpeaker;
70 logMode_ = system::GetIntParameter("persist.multimedia.audiolog.switch", 0);
71
72 int32_t ret = InitCapture();
73 CHECK_AND_RETURN_RET(ret == SUCCESS, ret);
74 if (muteState_.load() && IsFormalSourceType(attr_.sourceType)) {
75 SetMute(true);
76 }
77 sourceInited_ = true;
78 if ((attr.sourceType == SOURCE_TYPE_MIC_REF || attr.sourceType == SOURCE_TYPE_EC) &&
79 IsNonblockingSource(attr.adapterName)) {
80 ringBufferHandler_ = std::make_shared<RingBufferHandler>();
81 ringBufferHandler_->Init(attr.sampleRate, attr.channel, GetByteSizeByFormat(attr.format));
82 }
83
84 if (audioSrcClock_ != nullptr) {
85 audioSrcClock_->Init(attr.sampleRate, attr.format, attr.channel);
86 }
87
88 return SUCCESS;
89 }
90
DeInit(void)91 void AudioCaptureSource::DeInit(void)
92 {
93 std::lock_guard<std::mutex> lock(statusMutex_);
94 Trace trace("AudioCaptureSource::DeInit");
95 AudioXCollie audioXCollie("AudioCaptureSource::DeInit", TIMEOUT_SECONDS_5,
96 nullptr, nullptr, AUDIO_XCOLLIE_FLAG_LOG);
97
98 AUDIO_INFO_LOG("halName: %{public}s, sourceType: %{public}d", halName_.c_str(), attr_.sourceType);
99 sourceInited_ = false;
100 started_.store(false);
101 HdiAdapterManager &manager = HdiAdapterManager::GetInstance();
102 std::shared_ptr<IDeviceManager> deviceManager = manager.GetDeviceManager(HDI_DEVICE_MANAGER_TYPE_LOCAL);
103 CHECK_AND_RETURN(deviceManager != nullptr);
104 captureInited_ = false;
105 deviceManager->DestroyCapture(adapterNameCase_, hdiCaptureId_);
106 audioCapture_ = nullptr;
107
108 IAudioSourceCallback *callback = nullptr;
109 {
110 std::lock_guard<std::mutex> lock(callbackMutex_);
111 callback = &callback_;
112 }
113 if (callback != nullptr) {
114 callback->OnWakeupClose();
115 }
116 currentActiveDevice_ = DEVICE_TYPE_INVALID;
117 DumpFileUtil::CloseDumpFile(&dumpFile_);
118 }
119
IsInited(void)120 bool AudioCaptureSource::IsInited(void)
121 {
122 return sourceInited_;
123 }
124
InitRunningLock(void)125 void AudioCaptureSource::InitRunningLock(void)
126 {
127 #ifdef FEATURE_POWER_MANAGER
128 if (runningLock_ == nullptr) {
129 WatchTimeout guard("create AudioRunningLock start");
130 switch (attr_.sourceType) {
131 case SOURCE_TYPE_WAKEUP:
132 runningLock_ = std::make_shared<AudioRunningLock>(std::string(RUNNING_LOCK_NAME_WAKEUP));
133 break;
134 case SOURCE_TYPE_MIC:
135 case SOURCE_TYPE_CAMCORDER:
136 case SOURCE_TYPE_UNPROCESSED:
137 case SOURCE_TYPE_LIVE:
138 default:
139 runningLock_ = std::make_shared<AudioRunningLock>(std::string(RUNNING_LOCK_NAME));
140 }
141 guard.CheckCurrTimeout();
142 }
143 if (runningLock_ != nullptr) {
144 runningLock_->Lock(RUNNING_LOCK_TIMEOUTMS_LASTING);
145 } else {
146 AUDIO_ERR_LOG("running lock is null, playback can not work well");
147 }
148 #endif
149 }
150
Start(void)151 int32_t AudioCaptureSource::Start(void)
152 {
153 std::lock_guard<std::mutex> lock(statusMutex_);
154 AUDIO_INFO_LOG("halName: %{public}s, sourceType: %{public}d", halName_.c_str(), attr_.sourceType);
155 Trace trace("AudioCaptureSource::Start");
156 if (audioSrcClock_ != nullptr) {
157 audioSrcClock_->Reset();
158 }
159
160 if (IsNonblockingSource(adapterNameCase_)) {
161 return NonblockingStart();
162 }
163
164 InitLatencyMeasurement();
165 InitRunningLock();
166
167 // eg: primary_source_0_20240527202236189_44100_2_1.pcm
168 dumpFileName_ = halName_ + "_source_" + std::to_string(attr_.sourceType) + "_" + GetTime() + "_" +
169 std::to_string(attr_.sampleRate) + "_" + std::to_string(attr_.channel) + "_" +
170 std::to_string(attr_.format) + ".pcm";
171 DumpFileUtil::OpenDumpFile(DumpFileUtil::DUMP_SERVER_PARA, dumpFileName_, &dumpFile_);
172 logUtilsTag_ = "AudioSource";
173
174 if (started_.load()) {
175 return SUCCESS;
176 }
177 callback_.OnCaptureState(true);
178 CHECK_AND_RETURN_RET_LOG(audioCapture_ != nullptr, ERR_INVALID_HANDLE, "capture is nullptr");
179 int32_t ret = audioCapture_->Start(audioCapture_);
180 CHECK_AND_RETURN_RET_LOG(ret == SUCCESS, ERR_NOT_STARTED, "start fail");
181 started_.store(true);
182
183 if (halName_ == HDI_ID_INFO_ACCESSORY && dmDeviceTypeMap_[DEVICE_TYPE_ACCESSORY] == DM_DEVICE_TYPE_PENCIL) {
184 SetAccessoryDeviceState(true);
185 }
186
187 return SUCCESS;
188 }
189
Stop(void)190 int32_t AudioCaptureSource::Stop(void)
191 {
192 Trace trace("AudioCaptureSource::Stop");
193 std::promise<void> promiseEnsureLock;
194 auto futurePromiseEnsureLock = promiseEnsureLock.get_future();
195 std::thread stopThread([&promiseEnsureLock, this] {
196 std::lock_guard<std::mutex> lock(statusMutex_);
197 promiseEnsureLock.set_value();
198 DoStop();
199 });
200 futurePromiseEnsureLock.get();
201 stopThread.detach();
202
203 if (halName_ == HDI_ID_INFO_ACCESSORY && dmDeviceTypeMap_[DEVICE_TYPE_ACCESSORY] == DM_DEVICE_TYPE_PENCIL) {
204 SetAccessoryDeviceState(false);
205 }
206
207 return SUCCESS;
208 }
209
Resume(void)210 int32_t AudioCaptureSource::Resume(void)
211 {
212 std::lock_guard<std::mutex> lock(statusMutex_);
213 AUDIO_INFO_LOG("halName: %{public}s", halName_.c_str());
214 Trace trace("AudioCaptureSource::Resume");
215 CHECK_AND_RETURN_RET_LOG(audioCapture_ != nullptr, ERR_INVALID_HANDLE, "capture is nullptr");
216
217 if (!paused_) {
218 return SUCCESS;
219 }
220 int32_t ret = audioCapture_->Resume(audioCapture_);
221 CHECK_AND_RETURN_RET_LOG(ret == SUCCESS, ERR_OPERATION_FAILED, "resume fail");
222 paused_ = false;
223 return SUCCESS;
224 }
225
Pause(void)226 int32_t AudioCaptureSource::Pause(void)
227 {
228 std::lock_guard<std::mutex> lock(statusMutex_);
229 AUDIO_INFO_LOG("halName: %{public}s, sourceType: %{public}d", halName_.c_str(), attr_.sourceType);
230 Trace trace("AudioCaptureSource::Pause");
231 CHECK_AND_RETURN_RET_LOG(audioCapture_ != nullptr, ERR_INVALID_HANDLE, "capture is nullptr");
232 CHECK_AND_RETURN_RET_LOG(started_.load(), ERR_OPERATION_FAILED, "not start, invalid state");
233
234 int32_t ret = audioCapture_->Pause(audioCapture_);
235 CHECK_AND_RETURN_RET_LOG(ret == SUCCESS, ERR_OPERATION_FAILED, "pause fail");
236 paused_ = true;
237 return SUCCESS;
238 }
239
Flush(void)240 int32_t AudioCaptureSource::Flush(void)
241 {
242 std::lock_guard<std::mutex> lock(statusMutex_);
243 AUDIO_INFO_LOG("halName: %{public}s, sourceType: %{public}d", halName_.c_str(), attr_.sourceType);
244 Trace trace("AudioCaptureSource::Flush");
245 CHECK_AND_RETURN_RET_LOG(audioCapture_ != nullptr, ERR_INVALID_HANDLE, "capture is nullptr");
246 CHECK_AND_RETURN_RET_LOG(started_.load(), ERR_OPERATION_FAILED, "not start, invalid state");
247
248 int32_t ret = audioCapture_->Flush(audioCapture_);
249 CHECK_AND_RETURN_RET_LOG(ret == SUCCESS, ERR_OPERATION_FAILED, "flush fail");
250 return SUCCESS;
251 }
252
Reset(void)253 int32_t AudioCaptureSource::Reset(void)
254 {
255 std::lock_guard<std::mutex> lock(statusMutex_);
256 AUDIO_INFO_LOG("halName: %{public}s, sourceType: %{public}d", halName_.c_str(), attr_.sourceType);
257 Trace trace("AudioCaptureSource::Reset");
258 CHECK_AND_RETURN_RET_LOG(audioCapture_ != nullptr, ERR_INVALID_HANDLE, "capture is nullptr");
259 CHECK_AND_RETURN_RET_LOG(started_.load(), ERR_OPERATION_FAILED, "not start, invalid state");
260
261 int32_t ret = audioCapture_->Flush(audioCapture_);
262 CHECK_AND_RETURN_RET_LOG(ret == SUCCESS, ERR_OPERATION_FAILED, "reset fail");
263 return SUCCESS;
264 }
265
GetFirstTimeStampFromAlgo(const std::string & adapterNameCase)266 static uint64_t GetFirstTimeStampFromAlgo(const std::string &adapterNameCase)
267 {
268 HdiAdapterManager &manager = HdiAdapterManager::GetInstance();
269 std::shared_ptr<IDeviceManager> deviceManager = manager.GetDeviceManager(HDI_DEVICE_MANAGER_TYPE_LOCAL);
270 CHECK_AND_RETURN_RET_LOG(deviceManager != nullptr, 0, "GetDeviceManager fail!");
271
272 AudioParamKey key = NONE;
273 std::string value = deviceManager->GetAudioParameter(adapterNameCase, key, "record_algo_first_ts");
274 CHECK_AND_RETURN_RET_LOG(value != "", 0, "record_algo_first_ts fail!");
275
276 uint64_t firstTimeStamp = std::strtoull(value.c_str(), nullptr, DECIMAL_BASE);
277 AUDIO_INFO_LOG("record_algo_first_ts:%{public}" PRIu64, firstTimeStamp);
278 return firstTimeStamp;
279 }
280
CaptureFrame(char * frame,uint64_t requestBytes,uint64_t & replyBytes)281 int32_t AudioCaptureSource::CaptureFrame(char *frame, uint64_t requestBytes, uint64_t &replyBytes)
282 {
283 CHECK_AND_RETURN_RET_LOG(audioCapture_ != nullptr, ERR_INVALID_HANDLE, "capture is nullptr");
284 if (!started_.load()) {
285 AUDIO_WARNING_LOG("not start, invalid state");
286 return ERR_ILLEGAL_STATE;
287 }
288
289 Trace trace("AudioCaptureSource::CaptureFrame");
290 AudioCapturerSourceTsRecorder recorder(replyBytes, audioSrcClock_);
291
292 // only mic ref
293 if (attr_.sourceType == SOURCE_TYPE_MIC_REF) {
294 if (ringBufferHandler_ != nullptr) {
295 Trace micRefTrace("AudioCaptureSource::CaptureFrame::micRef");
296 int32_t ret = ringBufferHandler_->ReadDataFromRingBuffer(reinterpret_cast<uint8_t *>(frame), requestBytes);
297 if (ret == SUCCESS) {
298 replyBytes = requestBytes;
299 } else {
300 AUDIO_ERR_LOG("read data from ring buffer fail");
301 replyBytes = 0;
302 }
303 }
304 return SUCCESS;
305 }
306
307 int64_t stamp = ClockTime::GetCurNano();
308 uint32_t frameLen = static_cast<uint32_t>(requestBytes);
309 int32_t ret = audioCapture_->CaptureFrame(audioCapture_, reinterpret_cast<int8_t *>(frame), &frameLen, &replyBytes);
310 CHECK_AND_RETURN_RET_LOG(ret >= 0, ERR_READ_FAILED, "fail, ret: %{public}x", ret);
311 if (audioSrcClock_ != nullptr && audioSrcClock_->GetFrameCnt() == 0) {
312 audioSrcClock_->SetFirstTimestampFromHdi(GetFirstTimeStampFromAlgo(adapterNameCase_));
313 }
314 CheckLatencySignal(reinterpret_cast<uint8_t *>(frame), replyBytes);
315
316 DumpData(frame, replyBytes);
317 CheckUpdateState(frame, requestBytes);
318 stamp = (ClockTime::GetCurNano() - stamp) / AUDIO_US_PER_SECOND;
319 int64_t stampThreshold = 50; // 50ms
320 if (logMode_ || stamp >= stampThreshold) {
321 AUDIO_WARNING_LOG("len: [%{public}" PRIu64 "], cost: [%{public}" PRId64 "]ms", requestBytes, stamp);
322 }
323 return SUCCESS;
324 }
325
CaptureFrameWithEc(FrameDesc * fdesc,uint64_t & replyBytes,FrameDesc * fdescEc,uint64_t & replyBytesEc)326 int32_t AudioCaptureSource::CaptureFrameWithEc(FrameDesc *fdesc, uint64_t &replyBytes, FrameDesc *fdescEc,
327 uint64_t &replyBytesEc)
328 {
329 CHECK_AND_RETURN_RET_LOG(audioCapture_ != nullptr, ERR_INVALID_HANDLE, "capture is nullptr");
330 if (attr_.sourceType != SOURCE_TYPE_EC) {
331 CHECK_AND_RETURN_RET_LOG(fdesc != nullptr && fdesc->frame != nullptr && fdescEc != nullptr &&
332 fdescEc->frame != nullptr, ERR_INVALID_PARAM, "desc frame is nullptr");
333 } else { // only check ec frame
334 CHECK_AND_RETURN_RET_LOG(fdescEc != nullptr && fdescEc->frame != nullptr, ERR_INVALID_PARAM,
335 "desc frame is nullptr");
336 }
337
338 if (IsNonblockingSource(adapterNameCase_)) {
339 return NonblockingCaptureFrameWithEc(fdescEc, replyBytesEc);
340 }
341
342 struct AudioFrameLen frameLen = { fdesc->frameLen, fdescEc->frameLen };
343 struct AudioCaptureFrameInfo frameInfo = {};
344 int32_t ret = audioCapture_->CaptureFrameEc(audioCapture_, &frameLen, &frameInfo);
345 if (ret < 0) {
346 AUDIO_ERR_LOG("fail, ret: %{public}x", ret);
347 AudioCaptureFrameInfoFree(&frameInfo, false);
348 return ERR_READ_FAILED;
349 }
350
351 if (attr_.sourceType != SOURCE_TYPE_EC && frameInfo.frame != nullptr) {
352 if (frameInfo.replyBytes - fdescEc->frameLen < fdesc->frameLen) {
353 replyBytes = 0;
354 return ERR_INVALID_READ;
355 }
356 if (memcpy_s(fdesc->frame, fdesc->frameLen, frameInfo.frame, fdesc->frameLen) != EOK) {
357 AUDIO_ERR_LOG("copy desc fail");
358 } else {
359 replyBytes = (attr_.sourceType == SOURCE_TYPE_EC) ? 0 : fdesc->frameLen;
360 DumpData(fdesc->frame, replyBytes);
361 }
362 }
363 if (frameInfo.frameEc != nullptr) {
364 if (memcpy_s(fdescEc->frame, fdescEc->frameLen, frameInfo.frameEc, fdescEc->frameLen) != EOK) {
365 AUDIO_ERR_LOG("copy desc ec fail");
366 } else {
367 replyBytesEc = (attr_.sourceType == SOURCE_TYPE_EC) ? frameInfo.replyBytesEc : fdescEc->frameLen;
368 }
369 }
370 CheckUpdateState(fdesc->frame, replyBytes);
371 AudioCaptureFrameInfoFree(&frameInfo, false);
372
373 return SUCCESS;
374 }
375
GetAudioParameter(const AudioParamKey key,const std::string & condition)376 std::string AudioCaptureSource::GetAudioParameter(const AudioParamKey key, const std::string &condition)
377 {
378 return "";
379 }
380
SetVolume(float left,float right)381 int32_t AudioCaptureSource::SetVolume(float left, float right)
382 {
383 CHECK_AND_RETURN_RET_LOG(audioCapture_ != nullptr, ERR_INVALID_HANDLE, "capture is nullptr");
384
385 leftVolume_ = left;
386 rightVolume_ = right;
387 float volume;
388 if ((leftVolume_ == 0) && (rightVolume_ != 0)) {
389 volume = rightVolume_;
390 } else if ((leftVolume_ != 0) && (rightVolume_ == 0)) {
391 volume = leftVolume_;
392 } else {
393 volume = (leftVolume_ + rightVolume_) / HALF_FACTOR;
394 }
395
396 int32_t ret = audioCapture_->SetVolume(audioCapture_, volume);
397 if (ret != SUCCESS) {
398 AUDIO_WARNING_LOG("set volume fail");
399 }
400
401 return ret;
402 }
403
GetVolume(float & left,float & right)404 int32_t AudioCaptureSource::GetVolume(float &left, float &right)
405 {
406 CHECK_AND_RETURN_RET_LOG(audioCapture_ != nullptr, ERR_INVALID_HANDLE, "capture is nullptr");
407
408 float val = 0.0;
409 audioCapture_->GetVolume(audioCapture_, &val);
410 left = val;
411 right = val;
412 return SUCCESS;
413 }
414
SetMute(bool isMute)415 int32_t AudioCaptureSource::SetMute(bool isMute)
416 {
417 AUDIO_INFO_LOG("halName: %{public}s, isMute: %{public}d", halName_.c_str(), isMute);
418
419 muteState_.store(isMute);
420 if (audioCapture_ != nullptr) {
421 int32_t ret = audioCapture_->SetMute(audioCapture_, isMute);
422 if (ret != SUCCESS) {
423 AUDIO_WARNING_LOG("set mute fail");
424 } else {
425 AUDIO_INFO_LOG("set mute succ");
426 }
427 }
428
429 HdiAdapterManager &manager = HdiAdapterManager::GetInstance();
430 std::shared_ptr<IDeviceManager> deviceManager = manager.GetDeviceManager(HDI_DEVICE_MANAGER_TYPE_LOCAL);
431 if (deviceManager != nullptr) {
432 deviceManager->SetMicMute(adapterNameCase_, isMute);
433 }
434 AUDIO_INFO_LOG("end");
435 return SUCCESS;
436 }
437
GetMute(bool & isMute)438 int32_t AudioCaptureSource::GetMute(bool &isMute)
439 {
440 CHECK_AND_RETURN_RET_LOG(audioCapture_ != nullptr, ERR_INVALID_HANDLE, "capture is nullptr");
441 bool hdiMuteState = false;
442 int32_t ret = audioCapture_->GetMute(audioCapture_, &hdiMuteState);
443 if (ret != SUCCESS) {
444 AUDIO_WARNING_LOG("get mute fail");
445 }
446 AUDIO_DEBUG_LOG("hdiMuteState: %{public}d, muteState: %{public}d", hdiMuteState, muteState_.load());
447 isMute = muteState_.load();
448 return SUCCESS;
449 }
450
GetTransactionId(void)451 uint64_t AudioCaptureSource::GetTransactionId(void)
452 {
453 return reinterpret_cast<uint64_t>(audioCapture_);
454 }
455
GetPresentationPosition(uint64_t & frames,int64_t & timeSec,int64_t & timeNanoSec)456 int32_t AudioCaptureSource::GetPresentationPosition(uint64_t &frames, int64_t &timeSec, int64_t &timeNanoSec)
457 {
458 CHECK_AND_RETURN_RET_LOG(audioCapture_ != nullptr, ERR_INVALID_HANDLE, "capture is nullptr");
459
460 struct AudioTimeStamp stamp = {};
461 int32_t ret = audioCapture_->GetCapturePosition(audioCapture_, &frames, &stamp);
462 CHECK_AND_RETURN_RET_LOG(ret == SUCCESS, ERR_OPERATION_FAILED, "get capture position fail, ret: %{public}d", ret);
463 int64_t maxSec = 9223372036; // (9223372036 + 1) * 10^9 > INT64_MAX, seconds should not bigger than it
464 CHECK_AND_RETURN_RET_LOG(stamp.tvSec >= 0 && stamp.tvSec <= maxSec && stamp.tvNSec >= 0 &&
465 stamp.tvNSec <= SECOND_TO_NANOSECOND, ERR_OPERATION_FAILED,
466 "get invalid time, second: %{public}" PRId64 ", nanosecond: %{public}" PRId64, stamp.tvSec, stamp.tvNSec);
467 timeSec = stamp.tvSec;
468 timeNanoSec = stamp.tvNSec;
469 return ret;
470 }
471
GetMaxAmplitude(void)472 float AudioCaptureSource::GetMaxAmplitude(void)
473 {
474 lastGetMaxAmplitudeTime_ = ClockTime::GetCurNano();
475 startUpdate_ = true;
476 return maxAmplitude_;
477 }
478
SetAudioScene(AudioScene audioScene,bool scoExcludeFlag)479 int32_t AudioCaptureSource::SetAudioScene(AudioScene audioScene, bool scoExcludeFlag)
480 {
481 CHECK_AND_RETURN_RET_LOG(audioScene >= AUDIO_SCENE_DEFAULT && audioScene < AUDIO_SCENE_MAX, ERR_INVALID_PARAM,
482 "invalid scene");
483 AUDIO_INFO_LOG("scene: %{public}d, current scene : %{public}d, scoExcludeFlag: %{public}d",
484 audioScene, currentAudioScene_, scoExcludeFlag);
485
486 if (audioScene != currentAudioScene_ && !scoExcludeFlag) {
487 struct AudioSceneDescriptor sceneDesc;
488 InitSceneDesc(sceneDesc, audioScene);
489
490 CHECK_AND_RETURN_RET_LOG(audioCapture_ != nullptr, ERR_INVALID_HANDLE, "capture is nullptr");
491 int32_t ret = audioCapture_->SelectScene(audioCapture_, &sceneDesc);
492 CHECK_AND_RETURN_RET_LOG(ret >= 0, ERR_OPERATION_FAILED, "select scene fail, ret: %{public}d", ret);
493 }
494 if (audioScene != currentAudioScene_) {
495 currentAudioScene_ = audioScene;
496 }
497 return SUCCESS;
498 }
499
UpdateActiveDevice(DeviceType inputDevice)500 int32_t AudioCaptureSource::UpdateActiveDevice(DeviceType inputDevice)
501 {
502 std::lock_guard<std::mutex> lock(statusMutex_);
503 return UpdateActiveDeviceWithoutLock(inputDevice);
504 }
505
UpdateSourceType(SourceType sourceType)506 int32_t AudioCaptureSource::UpdateSourceType(SourceType sourceType)
507 {
508 std::lock_guard<std::mutex> lock(statusMutex_);
509 if (attr_.sourceType == sourceType) {
510 AUDIO_INFO_LOG("not change, currentActiveDevice: %{public}d, sourceType: %{public}d", currentActiveDevice_,
511 attr_.sourceType);
512 return SUCCESS;
513 }
514 AUDIO_INFO_LOG("sourceType: %{public}d", sourceType);
515 attr_.sourceType = sourceType;
516 return DoSetInputRoute(currentActiveDevice_);
517 }
518
RegistCallback(uint32_t type,IAudioSourceCallback * callback)519 void AudioCaptureSource::RegistCallback(uint32_t type, IAudioSourceCallback *callback)
520 {
521 AUDIO_INFO_LOG("in");
522 callback_.RegistCallback(type, callback);
523 }
524
RegistCallback(uint32_t type,std::shared_ptr<IAudioSourceCallback> callback)525 void AudioCaptureSource::RegistCallback(uint32_t type, std::shared_ptr<IAudioSourceCallback> callback)
526 {
527 AUDIO_INFO_LOG("in");
528 callback_.RegistCallback(type, callback);
529 }
530
UpdateAppsUid(const int32_t appsUid[PA_MAX_OUTPUTS_PER_SOURCE],const size_t size)531 int32_t AudioCaptureSource::UpdateAppsUid(const int32_t appsUid[PA_MAX_OUTPUTS_PER_SOURCE], const size_t size)
532 {
533 #ifdef FEATURE_POWER_MANAGER
534 CHECK_AND_RETURN_RET_LOG(runningLock_, ERR_INVALID_HANDLE, "running lock is nullptr");
535 runningLock_->UpdateAppsUid(appsUid, appsUid + size);
536 runningLock_->UpdateAppsUidToPowerMgr();
537 #endif
538 return SUCCESS;
539 }
540
UpdateAppsUid(const std::vector<int32_t> & appsUid)541 int32_t AudioCaptureSource::UpdateAppsUid(const std::vector<int32_t> &appsUid)
542 {
543 #ifdef FEATURE_POWER_MANAGER
544 CHECK_AND_RETURN_RET_LOG(runningLock_, ERR_INVALID_HANDLE, "running lock is nullptr");
545 runningLock_->UpdateAppsUid(appsUid.cbegin(), appsUid.cend());
546 runningLock_->UpdateAppsUidToPowerMgr();
547 #endif
548 return SUCCESS;
549 }
550
SetAddress(const std::string & address)551 void AudioCaptureSource::SetAddress(const std::string &address)
552 {
553 address_ = address;
554 }
555
DumpInfo(std::string & dumpString)556 void AudioCaptureSource::DumpInfo(std::string &dumpString)
557 {
558 dumpString += "type: PrimarySource\tstarted: " + std::string(started_.load() ? "true" : "false") + "\thalName: " +
559 halName_ + "\tcurrentActiveDevice: " + std::to_string(currentActiveDevice_) + "\tsourceType: " +
560 std::to_string(attr_.sourceType) + "\n";
561 }
562
ConvertToHdiFormat(AudioSampleFormat format)563 AudioFormat AudioCaptureSource::ConvertToHdiFormat(AudioSampleFormat format)
564 {
565 AudioFormat hdiFormat;
566 switch (format) {
567 case SAMPLE_U8:
568 hdiFormat = AUDIO_FORMAT_TYPE_PCM_8_BIT;
569 break;
570 case SAMPLE_S16LE:
571 hdiFormat = AUDIO_FORMAT_TYPE_PCM_16_BIT;
572 break;
573 case SAMPLE_S24LE:
574 hdiFormat = AUDIO_FORMAT_TYPE_PCM_24_BIT;
575 break;
576 case SAMPLE_S32LE:
577 hdiFormat = AUDIO_FORMAT_TYPE_PCM_32_BIT;
578 break;
579 default:
580 hdiFormat = AUDIO_FORMAT_TYPE_PCM_16_BIT;
581 break;
582 }
583 return hdiFormat;
584 }
585
GetChannelLayoutByChannelCount(uint32_t channelCount)586 uint64_t AudioCaptureSource::GetChannelLayoutByChannelCount(uint32_t channelCount)
587 {
588 uint64_t channelLayout = 0;
589 switch (channelCount) {
590 case MONO:
591 channelLayout = CH_LAYOUT_MONO;
592 break;
593 case STEREO:
594 channelLayout = CH_LAYOUT_STEREO;
595 break;
596 case CHANNEL_4:
597 channelLayout = CH_LAYOUT_QUAD;
598 break;
599 case CHANNEL_8:
600 channelLayout = CH_LAYOUT_7POINT1;
601 break;
602 default:
603 channelLayout = CH_LAYOUT_STEREO;
604 break;
605 }
606 return channelLayout;
607 }
608
ConvertToHDIAudioInputType(int32_t sourceType)609 enum AudioInputType AudioCaptureSource::ConvertToHDIAudioInputType(int32_t sourceType)
610 {
611 enum AudioInputType hdiAudioInputType;
612 switch (sourceType) {
613 case SOURCE_TYPE_INVALID:
614 hdiAudioInputType = AUDIO_INPUT_DEFAULT_TYPE;
615 break;
616 case SOURCE_TYPE_MIC:
617 case SOURCE_TYPE_PLAYBACK_CAPTURE:
618 case SOURCE_TYPE_ULTRASONIC:
619 hdiAudioInputType = AUDIO_INPUT_MIC_TYPE;
620 break;
621 case SOURCE_TYPE_WAKEUP:
622 hdiAudioInputType = AUDIO_INPUT_SPEECH_WAKEUP_TYPE;
623 break;
624 case SOURCE_TYPE_VOICE_TRANSCRIPTION:
625 case SOURCE_TYPE_VOICE_COMMUNICATION:
626 hdiAudioInputType = AUDIO_INPUT_VOICE_COMMUNICATION_TYPE;
627 break;
628 case SOURCE_TYPE_VOICE_RECOGNITION:
629 hdiAudioInputType = AUDIO_INPUT_VOICE_RECOGNITION_TYPE;
630 break;
631 case SOURCE_TYPE_VOICE_CALL:
632 hdiAudioInputType = AUDIO_INPUT_VOICE_CALL_TYPE;
633 break;
634 case SOURCE_TYPE_CAMCORDER:
635 hdiAudioInputType = AUDIO_INPUT_CAMCORDER_TYPE;
636 break;
637 case SOURCE_TYPE_EC:
638 hdiAudioInputType = AUDIO_INPUT_EC_TYPE;
639 break;
640 case SOURCE_TYPE_MIC_REF:
641 hdiAudioInputType = AUDIO_INPUT_NOISE_REDUCTION_TYPE;
642 break;
643 case SOURCE_TYPE_UNPROCESSED:
644 hdiAudioInputType = AUDIO_INPUT_RAW_TYPE;
645 break;
646 case SOURCE_TYPE_LIVE:
647 hdiAudioInputType = AUDIO_INPUT_LIVE_TYPE;
648 break;
649 default:
650 hdiAudioInputType = AUDIO_INPUT_MIC_TYPE;
651 break;
652 }
653 return hdiAudioInputType;
654 }
655
CheckAcousticEchoCancelerSupported(int32_t sourceType,int32_t & hdiAudioInputType)656 void AudioCaptureSource::CheckAcousticEchoCancelerSupported(int32_t sourceType, int32_t &hdiAudioInputType)
657 {
658 CHECK_AND_RETURN(sourceType == SOURCE_TYPE_LIVE);
659 HdiAdapterManager &manager = HdiAdapterManager::GetInstance();
660 std::shared_ptr<IDeviceManager> deviceManager = manager.GetDeviceManager(HDI_DEVICE_MANAGER_TYPE_LOCAL);
661 CHECK_AND_RETURN_LOG(deviceManager != nullptr, "local device manager is nullptr");
662 std::string value = deviceManager->GetAudioParameter("primary", AudioParamKey::PARAM_KEY_STATE,
663 "source_type_live_aec_supported");
664 if (value != "true") {
665 AUDIO_ERR_LOG("SOURCE_TYPE_LIVE not supported will be changed to SOURCE_TYPE_MIC");
666 hdiAudioInputType = AUDIO_INPUT_MIC_TYPE;
667 }
668 }
669
ParseAudioFormat(const std::string & format)670 AudioSampleFormat AudioCaptureSource::ParseAudioFormat(const std::string &format)
671 {
672 if (format == "AUDIO_FORMAT_PCM_16_BIT") {
673 return SAMPLE_S16LE;
674 } else if (format == "AUDIO_FORMAT_PCM_24_BIT" || format == "AUDIO_FORMAT_PCM_24_BIT_PACKED") {
675 return SAMPLE_S24LE;
676 } else if (format == "AUDIO_FORMAT_PCM_32_BIT") {
677 return SAMPLE_S32LE;
678 } else {
679 return SAMPLE_S16LE;
680 }
681 }
682
GetAudioCategory(AudioScene audioScene)683 AudioCategory AudioCaptureSource::GetAudioCategory(AudioScene audioScene)
684 {
685 AudioCategory audioCategory;
686 switch (audioScene) {
687 case AUDIO_SCENE_DEFAULT:
688 audioCategory = AUDIO_IN_MEDIA;
689 break;
690 case AUDIO_SCENE_RINGING:
691 case AUDIO_SCENE_VOICE_RINGING:
692 audioCategory = AUDIO_IN_RINGTONE;
693 break;
694 case AUDIO_SCENE_PHONE_CALL:
695 audioCategory = AUDIO_IN_CALL;
696 break;
697 case AUDIO_SCENE_PHONE_CHAT:
698 audioCategory = AUDIO_IN_COMMUNICATION;
699 break;
700 default:
701 audioCategory = AUDIO_IN_MEDIA;
702 break;
703 }
704 AUDIO_DEBUG_LOG("audioCategory: %{public}d", audioCategory);
705
706 return audioCategory;
707 }
708
GetByteSizeByFormat(AudioSampleFormat format)709 int32_t AudioCaptureSource::GetByteSizeByFormat(AudioSampleFormat format)
710 {
711 int32_t byteSize = 0;
712 switch (format) {
713 case SAMPLE_U8:
714 byteSize = BYTE_SIZE_SAMPLE_U8;
715 break;
716 case SAMPLE_S16LE:
717 byteSize = BYTE_SIZE_SAMPLE_S16;
718 break;
719 case SAMPLE_S24LE:
720 byteSize = BYTE_SIZE_SAMPLE_S24;
721 break;
722 case SAMPLE_S32LE:
723 byteSize = BYTE_SIZE_SAMPLE_S32;
724 break;
725 default:
726 byteSize = BYTE_SIZE_SAMPLE_S16;
727 break;
728 }
729
730 return byteSize;
731 }
732
IsFormalSourceType(int32_t sourceType)733 bool AudioCaptureSource::IsFormalSourceType(int32_t sourceType)
734 {
735 if (sourceType == SOURCE_TYPE_EC || sourceType == SOURCE_TYPE_MIC_REF) {
736 return false;
737 }
738 return true;
739 }
740
GetUniqueId(void) const741 uint32_t AudioCaptureSource::GetUniqueId(void) const
742 {
743 if (halName_ == HDI_ID_INFO_USB) {
744 return GenerateUniqueID(AUDIO_HDI_CAPTURE_ID_BASE, HDI_CAPTURE_OFFSET_USB);
745 } else if (halName_ == HDI_ID_INFO_ACCESSORY) {
746 return GenerateUniqueID(AUDIO_HDI_CAPTURE_ID_BASE, HDI_CAPTURE_OFFSET_ACCESSORY);
747 }
748 return GenerateUniqueID(AUDIO_HDI_CAPTURE_ID_BASE, HDI_CAPTURE_OFFSET_PRIMARY);
749 }
750
GetUniqueIdBySourceType(void) const751 uint32_t AudioCaptureSource::GetUniqueIdBySourceType(void) const
752 {
753 switch (attr_.sourceType) {
754 case SOURCE_TYPE_EC:
755 return GenerateUniqueID(AUDIO_HDI_CAPTURE_ID_BASE, HDI_CAPTURE_OFFSET_EC);
756 case SOURCE_TYPE_MIC_REF:
757 return GenerateUniqueID(AUDIO_HDI_CAPTURE_ID_BASE, HDI_CAPTURE_OFFSET_MIC_REF);
758 case SOURCE_TYPE_WAKEUP:
759 return GenerateUniqueID(AUDIO_HDI_CAPTURE_ID_BASE, HDI_CAPTURE_OFFSET_WAKEUP);
760 default:
761 return GenerateUniqueID(AUDIO_HDI_CAPTURE_ID_BASE, HDI_CAPTURE_OFFSET_PRIMARY);
762 }
763 }
764
InitEcOrMicRefAttr(const IAudioSourceAttr & attr)765 void AudioCaptureSource::InitEcOrMicRefAttr(const IAudioSourceAttr &attr)
766 {
767 attr_.adapterName = attr.adapterName;
768 attr_.openMicSpeaker = attr.openMicSpeaker;
769 attr_.format = attr.format;
770 attr_.sampleRate = attr.sampleRate;
771 attr_.channel = attr.channel;
772 attr_.bufferSize = USB_DEFAULT_BUFFER_SIZE;
773 attr_.isBigEndian = attr.isBigEndian;
774 attr_.filePath = "";
775 attr_.deviceNetworkId = "LocalDevice";
776 attr_.deviceType = attr.deviceType;
777 attr_.sourceType = attr.sourceType;
778 if (attr_.sourceType == SOURCE_TYPE_EC) {
779 attr_.formatEc = attr.format;
780 attr_.sampleRateEc = attr.sampleRate;
781 attr_.channelEc = attr.channel;
782 }
783 }
784
InitAudioSampleAttr(struct AudioSampleAttributes & param)785 void AudioCaptureSource::InitAudioSampleAttr(struct AudioSampleAttributes ¶m)
786 {
787 param.format = AUDIO_FORMAT_TYPE_PCM_16_BIT;
788 param.channelCount = AUDIO_CHANNELCOUNT;
789 param.sampleRate = AUDIO_SAMPLE_RATE_48K;
790 param.interleaved = true;
791 param.streamId = static_cast<int32_t>(GetUniqueIdBySourceType());
792 param.type = AUDIO_IN_MEDIA;
793 param.period = DEEP_BUFFER_CAPTURE_PERIOD_SIZE;
794 param.frameSize = PCM_16_BIT * param.channelCount / PCM_8_BIT;
795 param.isBigEndian = false;
796 param.isSignedData = true;
797 if (param.frameSize != 0) {
798 param.startThreshold = DEEP_BUFFER_CAPTURE_PERIOD_SIZE / (param.frameSize);
799 }
800 param.stopThreshold = INT_MAX;
801 param.silenceThreshold = AUDIO_BUFFER_SIZE;
802 param.sourceType = SOURCE_TYPE_MIC;
803
804 param.sampleRate = attr_.sampleRate;
805 param.format = ConvertToHdiFormat(attr_.format);
806 param.isBigEndian = attr_.isBigEndian;
807 param.channelCount = attr_.channel;
808 param.channelLayout = attr_.channelLayout;
809 if (param.channelLayout == CH_LAYOUT_UNKNOWN) {
810 param.channelLayout = GetChannelLayoutByChannelCount(attr_.channel);
811 }
812 param.silenceThreshold = attr_.bufferSize;
813 param.frameSize = param.format * param.channelCount;
814 if (param.frameSize != 0) {
815 param.startThreshold = DEEP_BUFFER_CAPTURE_PERIOD_SIZE / (param.frameSize);
816 }
817 param.sourceType = static_cast<int32_t>(ConvertToHDIAudioInputType(attr_.sourceType));
818 CheckAcousticEchoCancelerSupported(attr_.sourceType, param.sourceType);
819
820 if ((attr_.hasEcConfig || attr_.sourceType == SOURCE_TYPE_EC) && attr_.channelEc != 0) {
821 param.ecSampleAttributes.ecInterleaved = true;
822 param.ecSampleAttributes.ecFormat = ConvertToHdiFormat(attr_.formatEc);
823 param.ecSampleAttributes.ecSampleRate = attr_.sampleRateEc;
824 param.ecSampleAttributes.ecChannelCount = attr_.channelEc;
825 param.ecSampleAttributes.ecChannelLayout = GetChannelLayoutByChannelCount(attr_.channelEc);
826 param.ecSampleAttributes.ecPeriod = DEEP_BUFFER_CAPTURE_PERIOD_SIZE;
827 param.ecSampleAttributes.ecFrameSize = PCM_16_BIT * param.ecSampleAttributes.ecChannelCount / PCM_8_BIT;
828 param.ecSampleAttributes.ecIsBigEndian = false;
829 param.ecSampleAttributes.ecIsSignedData = true;
830 param.ecSampleAttributes.ecStartThreshold =
831 DEEP_BUFFER_CAPTURE_PERIOD_SIZE / (param.ecSampleAttributes.ecFrameSize);
832 param.ecSampleAttributes.ecStopThreshold = INT_MAX;
833 param.ecSampleAttributes.ecSilenceThreshold = AUDIO_BUFFER_SIZE;
834 }
835 }
836
InitDeviceDesc(struct AudioDeviceDescriptor & deviceDesc)837 void AudioCaptureSource::InitDeviceDesc(struct AudioDeviceDescriptor &deviceDesc)
838 {
839 deviceDesc.pins = PIN_IN_MIC;
840 if (halName_ == HDI_ID_INFO_USB) {
841 deviceDesc.pins = PIN_IN_USB_HEADSET;
842 } else if (halName_ == HDI_ID_INFO_ACCESSORY) {
843 if (dmDeviceTypeMap_[DEVICE_TYPE_ACCESSORY] == DM_DEVICE_TYPE_PENCIL) {
844 deviceDesc.pins = PIN_IN_PENCIL;
845 } else if (dmDeviceTypeMap_[DEVICE_TYPE_ACCESSORY] == DM_DEVICE_TYPE_UWB) {
846 deviceDesc.pins = PIN_IN_UWB;
847 }
848 }
849 deviceDesc.desc = const_cast<char *>(address_.c_str());
850 }
851
InitSceneDesc(struct AudioSceneDescriptor & sceneDesc,AudioScene audioScene)852 void AudioCaptureSource::InitSceneDesc(struct AudioSceneDescriptor &sceneDesc, AudioScene audioScene)
853 {
854 sceneDesc.scene.id = GetAudioCategory(audioScene);
855
856 AudioPortPin port = PIN_IN_MIC;
857 if (halName_ == HDI_ID_INFO_USB) {
858 port = PIN_IN_USB_HEADSET;
859 } else if (halName_ == HDI_ID_INFO_ACCESSORY) {
860 if (dmDeviceTypeMap_[DEVICE_TYPE_ACCESSORY] == DM_DEVICE_TYPE_PENCIL) {
861 port = PIN_IN_PENCIL;
862 } else if (dmDeviceTypeMap_[DEVICE_TYPE_ACCESSORY] == DM_DEVICE_TYPE_UWB) {
863 port = PIN_IN_UWB;
864 }
865 }
866 AUDIO_DEBUG_LOG("port: %{public}d", port);
867 sceneDesc.desc.pins = port;
868 sceneDesc.desc.desc = const_cast<char *>("");
869 }
870
871 // LCOV_EXCL_START
SetAudioRouteInfoForEnhanceChain(void)872 void AudioCaptureSource::SetAudioRouteInfoForEnhanceChain(void)
873 {
874 if (IsNonblockingSource(attr_.adapterName)) {
875 AUDIO_ERR_LOG("non blocking source not support");
876 return;
877 }
878 int32_t engineFlag = GetEngineFlag();
879 if (engineFlag != 1) {
880 AudioEnhanceChainManager *audioEnhanceChainManager = AudioEnhanceChainManager::GetInstance();
881 CHECK_AND_RETURN_LOG(audioEnhanceChainManager != nullptr, "audioEnhanceChainManager is nullptr");
882 if (halName_ == HDI_ID_INFO_USB) {
883 audioEnhanceChainManager->SetInputDevice(captureId_, DEVICE_TYPE_USB_ARM_HEADSET, "");
884 } else {
885 audioEnhanceChainManager->SetInputDevice(captureId_, currentActiveDevice_, "");
886 }
887 }
888 }
889 // LCOV_EXCL_STOP
890
IsCaptureInvalid(void)891 bool AudioCaptureSource::IsCaptureInvalid(void)
892 {
893 if (audioCapture_ == nullptr) {
894 AUDIO_ERR_LOG("audioCapture_ is nullptr!");
895 std::string errorMsg = attr_.adapterName + " load adapter fail, ret: " + std::to_string(ERR_NOT_STARTED);
896 HdiMonitor::ReportHdiException(HdiType::LOCAL, ErrorCase::CALL_HDI_FAILED, ERR_NOT_STARTED, errorMsg);
897 return false;
898 }
899 return true;
900 }
901
CreateCapture(void)902 int32_t AudioCaptureSource::CreateCapture(void)
903 {
904 Trace trace("AudioCaptureSource::CreateCapture");
905
906 struct AudioSampleAttributes param;
907 struct AudioDeviceDescriptor deviceDesc;
908 InitAudioSampleAttr(param);
909 InitDeviceDesc(deviceDesc);
910
911 AUDIO_INFO_LOG("create capture, halName: %{public}s, hdiSourceType: %{public}d, rate: %{public}u, "
912 "channel: %{public}u, format: %{public}u, devicePin: %{public}u, desc: %{public}s", halName_.c_str(),
913 param.sourceType, param.sampleRate, param.channelCount, param.format, deviceDesc.pins, deviceDesc.desc);
914 if (attr_.hasEcConfig || attr_.sourceType == SOURCE_TYPE_EC) {
915 AUDIO_INFO_LOG("config ec, rate: %{public}d, channel: %{public}u, format: %{public}u",
916 param.ecSampleAttributes.ecSampleRate, param.ecSampleAttributes.ecChannelCount,
917 param.ecSampleAttributes.ecFormat);
918 }
919 HdiAdapterManager &manager = HdiAdapterManager::GetInstance();
920 std::shared_ptr<IDeviceManager> deviceManager = manager.GetDeviceManager(HDI_DEVICE_MANAGER_TYPE_LOCAL);
921 CHECK_AND_RETURN_RET(deviceManager != nullptr, ERR_INVALID_HANDLE);
922 void *capture = deviceManager->CreateCapture(adapterNameCase_, ¶m, &deviceDesc, hdiCaptureId_);
923 audioCapture_ = static_cast<struct IAudioCapture *>(capture);
924 CHECK_AND_RETURN_RET(IsCaptureInvalid(), ERR_NOT_STARTED);
925
926 AUDIO_INFO_LOG("create capture success, hdiCaptureId: %{public}u, desc: %{public}s", hdiCaptureId_,
927 deviceDesc.desc);
928 return SUCCESS;
929 }
930
DoSetInputRoute(DeviceType inputDevice)931 int32_t AudioCaptureSource::DoSetInputRoute(DeviceType inputDevice)
932 {
933 HdiAdapterManager &manager = HdiAdapterManager::GetInstance();
934 std::shared_ptr<IDeviceManager> deviceManager = manager.GetDeviceManager(HDI_DEVICE_MANAGER_TYPE_LOCAL);
935 CHECK_AND_RETURN_RET(deviceManager != nullptr, ERR_INVALID_HANDLE);
936 int32_t streamId = static_cast<int32_t>(GetUniqueIdBySourceType());
937 int32_t inputType = static_cast<int32_t>(ConvertToHDIAudioInputType(attr_.sourceType));
938 CheckAcousticEchoCancelerSupported(attr_.sourceType, inputType);
939 AUDIO_INFO_LOG("adapterName: %{public}s, inputDevice: %{public}d, streamId: %{public}d, inputType: %{public}d",
940 attr_.adapterName.c_str(), inputDevice, streamId, inputType);
941 int32_t ret = deviceManager->SetInputRoute(adapterNameCase_, inputDevice, streamId, inputType);
942 return ret;
943 }
944
InitCapture(void)945 int32_t AudioCaptureSource::InitCapture(void)
946 {
947 if (captureInited_) {
948 AUDIO_INFO_LOG("capture already inited");
949 return SUCCESS;
950 }
951 AUDIO_INFO_LOG("In, openMicL %{public}u, halName: %{public}s", openMic_, halName_.c_str());
952 int32_t ret = CreateCapture();
953 CHECK_AND_RETURN_RET_LOG(ret == SUCCESS, ERR_NOT_STARTED, "create capture fail");
954 if (openMic_) {
955 ret = SUCCESS;
956 DeviceType inputDevice;
957 if (halName_ == HDI_ID_INFO_USB) {
958 inputDevice = DEVICE_TYPE_USB_ARM_HEADSET;
959 } else {
960 inputDevice = static_cast<DeviceType>(attr_.deviceType);
961 }
962 ret = UpdateActiveDeviceWithoutLock(inputDevice);
963 if (ret != SUCCESS) {
964 AUDIO_WARNING_LOG("update route fail, ret: %{public}d", ret);
965 }
966 SetAudioRouteInfoForEnhanceChain();
967 }
968 captureInited_ = true;
969 return SUCCESS;
970 }
971
InitLatencyMeasurement(void)972 void AudioCaptureSource::InitLatencyMeasurement(void)
973 {
974 std::lock_guard<std::mutex> lock(signalDetectMutex_);
975
976 CHECK_AND_RETURN(AudioLatencyMeasurement::CheckIfEnabled());
977 signalDetectAgent_ = std::make_shared<SignalDetectAgent>();
978 CHECK_AND_RETURN_LOG(signalDetectAgent_ != nullptr, "signalDetectAgent is nullptr");
979 signalDetectAgent_->sampleFormat_ = attr_.format;
980 signalDetectAgent_->formatByteSize_ = GetFormatByteSize(attr_.format);
981 }
982
DeInitLatencyMeasurement(void)983 void AudioCaptureSource::DeInitLatencyMeasurement(void)
984 {
985 std::lock_guard<std::mutex> lock(signalDetectMutex_);
986
987 signalDetected_ = false;
988 signalDetectAgent_ = nullptr;
989 }
990
CheckLatencySignal(uint8_t * frame,size_t replyBytes)991 void AudioCaptureSource::CheckLatencySignal(uint8_t *frame, size_t replyBytes)
992 {
993 std::lock_guard<std::mutex> lock(signalDetectMutex_);
994 CHECK_AND_RETURN(signalDetectAgent_ != nullptr);
995 signalDetected_ = signalDetectAgent_->CheckAudioData(frame, replyBytes);
996 if (signalDetected_) {
997 AudioParamKey key = NONE;
998 std::string condition = "debug_audio_latency_measurement";
999 HdiAdapterManager &manager = HdiAdapterManager::GetInstance();
1000 std::shared_ptr<IDeviceManager> deviceManager = manager.GetDeviceManager(HDI_DEVICE_MANAGER_TYPE_LOCAL);
1001 CHECK_AND_RETURN(deviceManager != nullptr);
1002 std::string value = deviceManager->GetAudioParameter(adapterNameCase_, key, condition);
1003
1004 LatencyMonitor::GetInstance().UpdateDspTime(value.c_str());
1005 LatencyMonitor::GetInstance().UpdateSinkOrSourceTime(false, signalDetectAgent_->lastPeakBufferTime_);
1006 AUDIO_INFO_LOG("signal detected");
1007 signalDetected_ = false;
1008 }
1009 }
1010
CheckUpdateState(char * frame,size_t replyBytes)1011 void AudioCaptureSource::CheckUpdateState(char *frame, size_t replyBytes)
1012 {
1013 if (startUpdate_) {
1014 std::lock_guard<std::mutex> lock(statusMutex_);
1015 if (captureFrameNum_ == 0) {
1016 last10FrameStartTime_ = ClockTime::GetCurNano();
1017 }
1018 captureFrameNum_++;
1019 maxAmplitude_ = UpdateMaxAmplitude(static_cast<ConvertHdiFormat>(attr_.format), frame, replyBytes);
1020 if (captureFrameNum_ == GET_MAX_AMPLITUDE_FRAMES_THRESHOLD) {
1021 captureFrameNum_ = 0;
1022 if (last10FrameStartTime_ > lastGetMaxAmplitudeTime_) {
1023 startUpdate_ = false;
1024 maxAmplitude_ = 0;
1025 }
1026 }
1027 }
1028 }
1029
IsNonblockingSource(const std::string & adapterName)1030 bool AudioCaptureSource::IsNonblockingSource(const std::string &adapterName)
1031 {
1032 return (attr_.sourceType == SOURCE_TYPE_EC && adapterName != "dp") ||
1033 (attr_.sourceType == SOURCE_TYPE_MIC_REF);
1034 }
1035
NonblockingStart(void)1036 int32_t AudioCaptureSource::NonblockingStart(void)
1037 {
1038 if (started_.load()) {
1039 return SUCCESS;
1040 }
1041 CHECK_AND_RETURN_RET_LOG(audioCapture_ != nullptr, ERR_INVALID_HANDLE, "capture is nullptr");
1042 int32_t ret = audioCapture_->Start(audioCapture_);
1043 CHECK_AND_RETURN_RET_LOG(ret == SUCCESS, ERR_NOT_STARTED, "start fail");
1044 started_.store(true);
1045
1046 isCaptureThreadRunning_ = true;
1047 captureThread_ = std::make_unique<std::thread>(&AudioCaptureSource::CaptureThreadLoop, this);
1048 std::string threadName = "OS_Capture";
1049 threadName += (attr_.sourceType == SOURCE_TYPE_EC) ? "Ec" : "MicRef";
1050 pthread_setname_np(captureThread_->native_handle(), threadName.c_str());
1051 return SUCCESS;
1052 }
1053
NonblockingStop(void)1054 int32_t AudioCaptureSource::NonblockingStop(void)
1055 {
1056 isCaptureThreadRunning_ = false;
1057 if (captureThread_ != nullptr && captureThread_->joinable()) {
1058 captureThread_->join();
1059 }
1060
1061 if (!started_.load()) {
1062 return SUCCESS;
1063 }
1064 CHECK_AND_RETURN_RET_LOG(audioCapture_ != nullptr, ERR_INVALID_HANDLE, "capture is nullptr");
1065 int32_t ret = audioCapture_->Stop(audioCapture_);
1066 CHECK_AND_RETURN_RET_LOG(ret == SUCCESS, ERR_NOT_STARTED, "stop fail");
1067 started_.store(false);
1068 return SUCCESS;
1069 }
1070
NonblockingCaptureFrameWithEc(FrameDesc * fdescEc,uint64_t & replyBytesEc)1071 int32_t AudioCaptureSource::NonblockingCaptureFrameWithEc(FrameDesc *fdescEc, uint64_t &replyBytesEc)
1072 {
1073 if (ringBufferHandler_ != nullptr) {
1074 Trace trace("AudioCaptureSource::NonblockingCaptureFrameWithEc");
1075 int32_t ret = ringBufferHandler_->ReadDataFromRingBuffer(reinterpret_cast<uint8_t *>(fdescEc->frame),
1076 fdescEc->frameLen);
1077 if (ret == SUCCESS) {
1078 replyBytesEc = fdescEc->frameLen;
1079 } else {
1080 AUDIO_ERR_LOG("read ec data from ringBuffer fail");
1081 replyBytesEc = 0;
1082 }
1083 }
1084 return SUCCESS;
1085 }
1086
CaptureFrameOnlyEc(std::vector<uint8_t> & ecData)1087 void AudioCaptureSource::CaptureFrameOnlyEc(std::vector<uint8_t> &ecData)
1088 {
1089 struct AudioFrameLen frameLen = {};
1090 frameLen.frameLen = static_cast<uint64_t>(ecData.size());
1091 frameLen.frameEcLen = static_cast<uint64_t>(ecData.size());
1092 struct AudioCaptureFrameInfo frameInfo = {};
1093 CHECK_AND_RETURN_LOG(audioCapture_ != nullptr, "capture is nullptr");
1094 int32_t ret = audioCapture_->CaptureFrameEc(audioCapture_, &frameLen, &frameInfo);
1095 if (ret >= 0 && frameInfo.frameEc != nullptr) {
1096 if (memcpy_s(ecData.data(), ecData.size(), frameInfo.frameEc, frameInfo.replyBytesEc) != EOK) {
1097 AUDIO_ERR_LOG("copy ec fail");
1098 }
1099 }
1100 AudioCaptureFrameInfoFree(&frameInfo, false);
1101 }
1102
CaptureThreadLoop(void)1103 void AudioCaptureSource::CaptureThreadLoop(void)
1104 {
1105 CHECK_AND_RETURN_LOG(ringBufferHandler_ != nullptr, "ringBufferHandler is nullptr");
1106
1107 uint32_t captureDataLen = FRAME_TIME_LEN_MS * attr_.sampleRate / SECOND_TO_MILLISECOND *
1108 static_cast<uint32_t>(GetByteSizeByFormat(attr_.format)) * attr_.channel;
1109 AUDIO_INFO_LOG("start, sourceType: %{public}d, captureDataLen: %{public}u", attr_.sourceType, captureDataLen);
1110 std::vector<uint8_t> buffer;
1111 buffer.resize(captureDataLen);
1112 ScheduleThreadInServer(getpid(), gettid());
1113 while (isCaptureThreadRunning_) {
1114 Trace trace("CaptureRefInput");
1115 uint64_t replyBytes = 0;
1116 uint32_t requestBytes = static_cast<uint32_t>(buffer.size());
1117 int32_t ret = SUCCESS;
1118 if (attr_.sourceType == SOURCE_TYPE_MIC_REF) {
1119 CHECK_AND_RETURN_LOG(audioCapture_ != nullptr, "capture is nullptr");
1120 ret = audioCapture_->CaptureFrame(audioCapture_, reinterpret_cast<int8_t *>(buffer.data()), &requestBytes,
1121 &replyBytes);
1122 } else {
1123 CaptureFrameOnlyEc(buffer);
1124 }
1125 if (ret != SUCCESS) {
1126 AUDIO_ERR_LOG("capture frame fail");
1127 }
1128 ringBufferHandler_->WriteDataToRingBuffer(buffer.data(), buffer.size());
1129 }
1130 UnscheduleThreadInServer(getpid(), gettid());
1131 AUDIO_INFO_LOG("exit, sourceType: %{public}d", attr_.sourceType);
1132 }
1133
UpdateActiveDeviceWithoutLock(DeviceType inputDevice)1134 int32_t AudioCaptureSource::UpdateActiveDeviceWithoutLock(DeviceType inputDevice)
1135 {
1136 AUDIO_INFO_LOG("current active device: %{public}d, inputDevice: %{public}d", currentActiveDevice_, inputDevice);
1137 if (currentActiveDevice_ == inputDevice) {
1138 AUDIO_INFO_LOG("input device not change, device: %{public}d, sourceType: %{public}d", inputDevice,
1139 attr_.sourceType);
1140 return SUCCESS;
1141 }
1142
1143 int32_t ret = DoSetInputRoute(inputDevice);
1144 CHECK_AND_RETURN_RET(ret == SUCCESS, ret);
1145 currentActiveDevice_ = inputDevice;
1146 if (inputDevice == DEVICE_TYPE_ACCESSORY) {
1147 SetAudioRouteInfoForEnhanceChain();
1148 }
1149 return SUCCESS;
1150 }
1151
SetAccessoryDeviceState(bool state)1152 int32_t AudioCaptureSource::SetAccessoryDeviceState(bool state)
1153 {
1154 ErrCode ret;
1155 AudioSettingProvider &settingProvider = AudioSettingProvider::GetInstance(AUDIO_POLICY_SERVICE_ID);
1156 CHECK_AND_RETURN_RET_LOG(settingProvider.CheckOsAccountReady(), ERROR, "os account not ready");
1157 if (state) {
1158 ret = settingProvider.PutStringValue("hw.pencil.mic_ack.state", "1", "global");
1159 } else {
1160 ret = settingProvider.PutStringValue("hw.pencil.mic_ack.state", "0", "global");
1161 }
1162 CHECK_AND_RETURN_RET_LOG(ret == SUCCESS, ERR_OPERATION_FAILED, "Write Accessory state to Database failed");
1163 AUDIO_INFO_LOG("success write hw.pencil.mic_ack.state %{public}d to Database", state);
1164 return SUCCESS;
1165 }
1166
DoStop(void)1167 int32_t AudioCaptureSource::DoStop(void)
1168 {
1169 AUDIO_INFO_LOG("halName: %{public}s", halName_.c_str());
1170 Trace trace("AudioCaptureSource::DoStop");
1171
1172 if (IsNonblockingSource(adapterNameCase_)) {
1173 return NonblockingStop();
1174 }
1175
1176 DeInitLatencyMeasurement();
1177 #ifdef FEATURE_POWER_MANAGER
1178 if (runningLock_ != nullptr) {
1179 AUDIO_INFO_LOG("running lock unlock");
1180 runningLock_->UnLock();
1181 } else {
1182 AUDIO_WARNING_LOG("running lock is null, playback can not work well");
1183 }
1184 #endif
1185 CHECK_AND_RETURN_RET_LOG(audioCapture_ != nullptr, ERR_INVALID_HANDLE, "capture is nullptr");
1186 int32_t ret = audioCapture_->Stop(audioCapture_);
1187 CHECK_AND_RETURN_RET_LOG(ret == SUCCESS, ERR_NOT_STARTED, "stop fail");
1188 started_.store(false);
1189 callback_.OnCaptureState(false);
1190 return SUCCESS;
1191 }
1192
DumpData(char * frame,uint64_t & replyBytes)1193 void AudioCaptureSource::DumpData(char *frame, uint64_t &replyBytes)
1194 {
1195 BufferDesc buffer = { reinterpret_cast<uint8_t*>(frame), replyBytes, replyBytes };
1196 AudioStreamInfo streamInfo(static_cast<AudioSamplingRate>(attr_.sampleRate), AudioEncodingType::ENCODING_PCM,
1197 static_cast<AudioSampleFormat>(attr_.format), static_cast<AudioChannel>(attr_.channel));
1198 VolumeTools::DfxOperation(buffer, streamInfo, logUtilsTag_, volumeDataCount_);
1199 if (AudioDump::GetInstance().GetVersionType() == DumpFileUtil::BETA_VERSION) {
1200 DumpFileUtil::WriteDumpFile(dumpFile_, frame, replyBytes);
1201 AudioCacheMgr::GetInstance().CacheData(dumpFileName_, static_cast<void *>(frame), replyBytes);
1202 }
1203 }
1204
SetDmDeviceType(uint16_t dmDeviceType,DeviceType deviceType)1205 void AudioCaptureSource::SetDmDeviceType(uint16_t dmDeviceType, DeviceType deviceType)
1206 {
1207 std::lock_guard<std::mutex> lock(statusMutex_);
1208 bool isDmDeviceTypeUpdated = (deviceType == currentActiveDevice_ && dmDeviceTypeMap_[deviceType] != dmDeviceType);
1209 dmDeviceTypeMap_[deviceType] = dmDeviceType;
1210 HdiAdapterManager &manager = HdiAdapterManager::GetInstance();
1211 std::shared_ptr<IDeviceManager> deviceManager = manager.GetDeviceManager(HDI_DEVICE_MANAGER_TYPE_LOCAL);
1212 CHECK_AND_RETURN_LOG(deviceManager != nullptr, "deviceManager is nullptr");
1213 deviceManager->SetDmDeviceType(dmDeviceType, deviceType);
1214
1215 if (isDmDeviceTypeUpdated) {
1216 AUDIO_INFO_LOG("dm deviceType update, need update input port pin");
1217 int32_t ret = DoSetInputRoute(currentActiveDevice_);
1218 CHECK_AND_RETURN_LOG(ret == SUCCESS, "DoSetInputRoute fails");
1219 }
1220 }
1221
1222 } // namespace AudioStandard
1223 } // namespace OHOS
1224