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