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 "BluetoothAudioCaptureSource"
18 #endif
19
20 #include "source/bluetooth_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 "media_monitor_manager.h"
29 #include "audio_enhance_chain_manager.h"
30 #include "common/hdi_adapter_info.h"
31 #include "manager/hdi_adapter_manager.h"
32 #include "adapter/i_device_manager.h"
33
34 using namespace OHOS::HDI::Audio_Bluetooth;
35
36 namespace OHOS {
37 namespace AudioStandard {
BluetoothAudioCaptureSource(const uint32_t captureId)38 BluetoothAudioCaptureSource::BluetoothAudioCaptureSource(const uint32_t captureId)
39 : captureId_(captureId)
40 {
41 halName_ = "bt_hdap";
42 }
43
~BluetoothAudioCaptureSource()44 BluetoothAudioCaptureSource::~BluetoothAudioCaptureSource()
45 {
46 if (sourceInited_) {
47 DeInit();
48 }
49 AUDIO_INFO_LOG("[%{public}s] volumeDataCount: %{public}" PRId64, logUtilsTag_.c_str(), volumeDataCount_);
50 }
51
Init(const IAudioSourceAttr & attr)52 int32_t BluetoothAudioCaptureSource::Init(const IAudioSourceAttr &attr)
53 {
54 if (sourceInited_) {
55 AUDIO_WARNING_LOG("source already inited");
56 return SUCCESS;
57 }
58
59 std::lock_guard<std::mutex> lock(statusMutex_);
60 attr_ = attr;
61 logMode_ = system::GetIntParameter("persist.multimedia.audiolog.switch", 0);
62
63 int32_t ret = CreateCapture();
64 CHECK_AND_RETURN_RET(ret == SUCCESS, ret);
65 SetMute(muteState_);
66 sourceInited_ = true;
67 return SUCCESS;
68 }
69
DeInit(void)70 void BluetoothAudioCaptureSource::DeInit(void)
71 {
72 std::lock_guard<std::mutex> lock(statusMutex_);
73 Trace trace("BluetoothAudioCaptureSource::DeInit");
74
75 sourceInited_ = false;
76 started_ = false;
77 HdiAdapterManager &manager = HdiAdapterManager::GetInstance();
78 std::shared_ptr<IDeviceManager> deviceManager = manager.GetDeviceManager(HDI_DEVICE_MANAGER_TYPE_BLUETOOTH);
79 CHECK_AND_RETURN(deviceManager != nullptr);
80 deviceManager->DestroyCapture(adapterNameCase_, hdiCaptureId_);
81 audioCapture_ = nullptr;
82 DumpFileUtil::CloseDumpFile(&dumpFile_);
83 }
84
IsInited(void)85 bool BluetoothAudioCaptureSource::IsInited(void)
86 {
87 return sourceInited_;
88 }
89
Start(void)90 int32_t BluetoothAudioCaptureSource::Start(void)
91 {
92 std::lock_guard<std::mutex> lock(statusMutex_);
93 Trace trace("BluetoothAudioCaptureSource::Start");
94 AUDIO_INFO_LOG("in, halName: %{public}s", halName_.c_str());
95
96 InitLatencyMeasurement();
97 #ifdef FEATURE_POWER_MANAGER
98 if (runningLock_ == nullptr) {
99 WatchTimeout guard("create AudioRunningLock start");
100 runningLock_ = std::make_shared<AudioRunningLock>(std::string(RUNNING_LOCK_NAME));
101 guard.CheckCurrTimeout();
102 }
103 if (runningLock_ != nullptr) {
104 runningLock_->Lock(RUNNING_LOCK_TIMEOUTMS_LASTING);
105 } else {
106 AUDIO_ERR_LOG("running lock is null, playback can not work well");
107 }
108 #endif
109 dumpFileName_ = halName_ + "_bluetooth_source_" + std::to_string(attr_.sourceType) + "_" + GetTime() + "_" +
110 std::to_string(attr_.sampleRate) + "_" + std::to_string(attr_.channel) + "_" +
111 std::to_string(attr_.format) + ".pcm";
112 DumpFileUtil::OpenDumpFile(DumpFileUtil::DUMP_SERVER_PARA, dumpFileName_, &dumpFile_);
113
114 if (started_) {
115 return SUCCESS;
116 }
117 callback_.OnCaptureState(true);
118 CHECK_AND_RETURN_RET_LOG(audioCapture_ != nullptr, ERR_INVALID_HANDLE, "capture is nullptr");
119 int32_t ret = audioCapture_->control.Start(reinterpret_cast<AudioHandle>(audioCapture_));
120 if (ret < 0) {
121 AUDIO_ERR_LOG("start fail");
122 #ifdef FEATURE_POWER_MANAGER
123 if (runningLock_ != nullptr) {
124 AUDIO_INFO_LOG("running lock unlock");
125 runningLock_->UnLock();
126 } else {
127 AUDIO_WARNING_LOG("running lock is null, playback can not work well");
128 }
129 #endif
130 return ERR_NOT_STARTED;
131 }
132 started_ = true;
133 return SUCCESS;
134 }
135
Stop(void)136 int32_t BluetoothAudioCaptureSource::Stop(void)
137 {
138 Trace trace("BluetoothAudioCaptureSource::Stop");
139 std::promise<void> promiseEnsureLock;
140 auto futurePromiseEnsureLock = promiseEnsureLock.get_future();
141 std::thread stopThread([&promiseEnsureLock, this] {
142 std::lock_guard<std::mutex> lock(statusMutex_);
143 promiseEnsureLock.set_value();
144 DoStop();
145 });
146 futurePromiseEnsureLock.get();
147 stopThread.detach();
148 return SUCCESS;
149 }
150
Resume(void)151 int32_t BluetoothAudioCaptureSource::Resume(void)
152 {
153 std::lock_guard<std::mutex> lock(statusMutex_);
154 AUDIO_INFO_LOG("in");
155 CHECK_AND_RETURN_RET_LOG(audioCapture_ != nullptr, ERR_INVALID_HANDLE, "capture is nullptr");
156 CHECK_AND_RETURN_RET_LOG(started_, ERR_OPERATION_FAILED, "not start, invalid state");
157
158 Trace trace("BluetoothAudioCaptureSource::Resume");
159 int32_t ret = audioCapture_->control.Resume(reinterpret_cast<AudioHandle>(audioCapture_));
160 CHECK_AND_RETURN_RET_LOG(ret == SUCCESS, ERR_OPERATION_FAILED, "resume fail");
161 paused_ = false;
162 return SUCCESS;
163 }
164
Pause(void)165 int32_t BluetoothAudioCaptureSource::Pause(void)
166 {
167 std::lock_guard<std::mutex> lock(statusMutex_);
168 AUDIO_INFO_LOG("in");
169 CHECK_AND_RETURN_RET_LOG(audioCapture_ != nullptr, ERR_INVALID_HANDLE, "capture is nullptr");
170 CHECK_AND_RETURN_RET_LOG(started_, ERR_OPERATION_FAILED, "not start, invalid state");
171
172 Trace trace("BluetoothAudioCaptureSource::Pause");
173 int32_t ret = audioCapture_->control.Pause(reinterpret_cast<AudioHandle>(audioCapture_));
174 CHECK_AND_RETURN_RET_LOG(ret == SUCCESS, ERR_OPERATION_FAILED, "pause fail");
175 paused_ = true;
176 return SUCCESS;
177 }
178
Flush(void)179 int32_t BluetoothAudioCaptureSource::Flush(void)
180 {
181 AUDIO_INFO_LOG("in");
182 CHECK_AND_RETURN_RET_LOG(audioCapture_ != nullptr, ERR_INVALID_HANDLE, "capture is nullptr");
183 CHECK_AND_RETURN_RET_LOG(started_, ERR_OPERATION_FAILED, "not start, invalid state");
184
185 Trace trace("BluetoothAudioCaptureSource::Flush");
186 int32_t ret = audioCapture_->control.Flush(reinterpret_cast<AudioHandle>(audioCapture_));
187 CHECK_AND_RETURN_RET_LOG(ret == SUCCESS, ERR_OPERATION_FAILED, "flush fail");
188 return SUCCESS;
189 }
190
Reset(void)191 int32_t BluetoothAudioCaptureSource::Reset(void)
192 {
193 AUDIO_INFO_LOG("in");
194 CHECK_AND_RETURN_RET_LOG(audioCapture_ != nullptr, ERR_INVALID_HANDLE, "capture is nullptr");
195 CHECK_AND_RETURN_RET_LOG(started_, ERR_OPERATION_FAILED, "not start, invalid state");
196
197 Trace trace("BluetoothAudioCaptureSource::Reset");
198 int32_t ret = audioCapture_->control.Flush(reinterpret_cast<AudioHandle>(audioCapture_));
199 CHECK_AND_RETURN_RET_LOG(ret == SUCCESS, ERR_OPERATION_FAILED, "reset fail");
200 return SUCCESS;
201 }
202
CaptureFrame(char * frame,uint64_t requestBytes,uint64_t & replyBytes)203 int32_t BluetoothAudioCaptureSource::CaptureFrame(char *frame, uint64_t requestBytes, uint64_t &replyBytes)
204 {
205 CHECK_AND_RETURN_RET_LOG(audioCapture_ != nullptr, ERR_INVALID_HANDLE, "capture is nullptr");
206 Trace trace("BluetoothAudioCaptureSource::CaptureFrame");
207
208 int64_t stamp = ClockTime::GetCurNano();
209 uint32_t frameLen = static_cast<uint32_t>(requestBytes);
210 int32_t ret = audioCapture_->CaptureFrame(audioCapture_, reinterpret_cast<int8_t *>(frame), frameLen, &replyBytes);
211 CHECK_AND_RETURN_RET_LOG(ret >= 0, ERR_READ_FAILED, "fail, ret: %{public}x", ret);
212 CheckLatencySignal(reinterpret_cast<uint8_t *>(frame), replyBytes);
213
214 BufferDesc buffer = { reinterpret_cast<uint8_t*>(frame), replyBytes, replyBytes };
215 AudioStreamInfo streamInfo(static_cast<AudioSamplingRate>(attr_.sampleRate), AudioEncodingType::ENCODING_PCM,
216 static_cast<AudioSampleFormat>(attr_.format), static_cast<AudioChannel>(attr_.channel));
217 VolumeTools::DfxOperation(buffer, streamInfo, logUtilsTag_, volumeDataCount_);
218 if (AudioDump::GetInstance().GetVersionType() == DumpFileUtil::BETA_VERSION) {
219 DumpFileUtil::WriteDumpFile(dumpFile_, frame, replyBytes);
220 AudioCacheMgr::GetInstance().CacheData(dumpFileName_, static_cast<void *>(frame), replyBytes);
221 }
222 CheckUpdateState(frame, requestBytes);
223 stamp = (ClockTime::GetCurNano() - stamp) / AUDIO_US_PER_SECOND;
224 if (logMode_) {
225 AUDIO_WARNING_LOG("len: [%{public}" PRIu64 "], cost: [%{public}" PRId64 "]ms", requestBytes, stamp);
226 }
227 return SUCCESS;
228 }
229
CaptureFrameWithEc(FrameDesc * fdesc,uint64_t & replyBytes,FrameDesc * fdescEc,uint64_t & replyBytesEc)230 int32_t BluetoothAudioCaptureSource::CaptureFrameWithEc(FrameDesc *fdesc, uint64_t &replyBytes, FrameDesc *fdescEc,
231 uint64_t &replyBytesEc)
232 {
233 AUDIO_INFO_LOG("not support");
234 return ERR_NOT_SUPPORTED;
235 }
236
GetAudioParameter(const AudioParamKey key,const std::string & condition)237 std::string BluetoothAudioCaptureSource::GetAudioParameter(const AudioParamKey key, const std::string &condition)
238 {
239 return "";
240 }
241
SetVolume(float left,float right)242 int32_t BluetoothAudioCaptureSource::SetVolume(float left, float right)
243 {
244 CHECK_AND_RETURN_RET_LOG(audioCapture_ != nullptr, ERR_INVALID_HANDLE, "capture is nullptr");
245
246 leftVolume_ = left;
247 rightVolume_ = right;
248 float volume;
249 if ((leftVolume_ == 0) && (rightVolume_ != 0)) {
250 volume = rightVolume_;
251 } else if ((leftVolume_ != 0) && (rightVolume_ == 0)) {
252 volume = leftVolume_;
253 } else {
254 volume = (leftVolume_ + rightVolume_) / HALF_FACTOR;
255 }
256
257 audioCapture_->volume.SetVolume(reinterpret_cast<AudioHandle>(audioCapture_), volume);
258
259 return SUCCESS;
260 }
261
GetVolume(float & left,float & right)262 int32_t BluetoothAudioCaptureSource::GetVolume(float &left, float &right)
263 {
264 CHECK_AND_RETURN_RET_LOG(audioCapture_ != nullptr, ERR_INVALID_HANDLE, "capture is nullptr");
265
266 float val = 0.0;
267 audioCapture_->volume.GetVolume(reinterpret_cast<AudioHandle>(audioCapture_), &val);
268 left = val;
269 right = val;
270 return SUCCESS;
271 }
272
SetMute(bool isMute)273 int32_t BluetoothAudioCaptureSource::SetMute(bool isMute)
274 {
275 AUDIO_INFO_LOG("isMute: %{public}d", isMute);
276 muteState_ = isMute;
277 CHECK_AND_RETURN_RET_LOG(audioCapture_ != nullptr, ERR_INVALID_HANDLE, "capture is nullptr");
278
279 if (sourceInited_) {
280 int32_t ret = audioCapture_->volume.SetMute(reinterpret_cast<AudioHandle>(audioCapture_), isMute);
281 if (ret != SUCCESS) {
282 AUDIO_WARNING_LOG("set mute fail");
283 } else {
284 AUDIO_INFO_LOG("set mute succ");
285 }
286 }
287 AUDIO_INFO_LOG("end");
288 return SUCCESS;
289 }
290
GetMute(bool & isMute)291 int32_t BluetoothAudioCaptureSource::GetMute(bool &isMute)
292 {
293 CHECK_AND_RETURN_RET_LOG(audioCapture_ != nullptr, ERR_INVALID_HANDLE, "capture is nullptr");
294 bool hdiMuteState = false;
295 int32_t ret = audioCapture_->volume.GetMute(reinterpret_cast<AudioHandle>(audioCapture_), &hdiMuteState);
296 if (ret != SUCCESS) {
297 AUDIO_WARNING_LOG("get mute fail");
298 }
299 AUDIO_DEBUG_LOG("hdiMuteState: %{public}d, muteState: %{public}d", hdiMuteState, muteState_);
300 isMute = muteState_;
301 return SUCCESS;
302 }
303
GetTransactionId(void)304 uint64_t BluetoothAudioCaptureSource::GetTransactionId(void)
305 {
306 return reinterpret_cast<uint64_t>(audioCapture_);
307 }
308
GetPresentationPosition(uint64_t & frames,int64_t & timeSec,int64_t & timeNanoSec)309 int32_t BluetoothAudioCaptureSource::GetPresentationPosition(uint64_t &frames, int64_t &timeSec, int64_t &timeNanoSec)
310 {
311 AUDIO_INFO_LOG("not support");
312 return ERR_NOT_SUPPORTED;
313 }
314
GetMaxAmplitude(void)315 float BluetoothAudioCaptureSource::GetMaxAmplitude(void)
316 {
317 lastGetMaxAmplitudeTime_ = ClockTime::GetCurNano();
318 startUpdate_ = true;
319 return maxAmplitude_;
320 }
321
SetAudioScene(AudioScene audioScene,DeviceType activeDevice)322 int32_t BluetoothAudioCaptureSource::SetAudioScene(AudioScene audioScene, DeviceType activeDevice)
323 {
324 AUDIO_INFO_LOG("not support");
325 return ERR_NOT_SUPPORTED;
326 }
327
UpdateActiveDevice(DeviceType inputDevice)328 int32_t BluetoothAudioCaptureSource::UpdateActiveDevice(DeviceType inputDevice)
329 {
330 AUDIO_INFO_LOG("not support");
331 return ERR_NOT_SUPPORTED;
332 }
333
RegistCallback(uint32_t type,std::shared_ptr<IAudioSourceCallback> callback)334 void BluetoothAudioCaptureSource::RegistCallback(uint32_t type, std::shared_ptr<IAudioSourceCallback> callback)
335 {
336 AUDIO_INFO_LOG("in");
337 callback_.RegistCallback(type, callback);
338 }
339
UpdateAppsUid(const int32_t appsUid[PA_MAX_OUTPUTS_PER_SOURCE],const size_t size)340 int32_t BluetoothAudioCaptureSource::UpdateAppsUid(const int32_t appsUid[PA_MAX_OUTPUTS_PER_SOURCE], const size_t size)
341 {
342 #ifdef FEATURE_POWER_MANAGER
343 CHECK_AND_RETURN_RET_LOG(runningLock_, ERR_INVALID_HANDLE, "running lock is nullptr");
344 runningLock_->UpdateAppsUid(appsUid, appsUid + size);
345 runningLock_->UpdateAppsUidToPowerMgr();
346 #endif
347 return SUCCESS;
348 }
349
UpdateAppsUid(const std::vector<int32_t> & appsUid)350 int32_t BluetoothAudioCaptureSource::UpdateAppsUid(const std::vector<int32_t> &appsUid)
351 {
352 #ifdef FEATURE_POWER_MANAGER
353 CHECK_AND_RETURN_RET_LOG(runningLock_, ERR_INVALID_HANDLE, "running lock is nullptr");
354 runningLock_->UpdateAppsUid(appsUid.cbegin(), appsUid.cend());
355 runningLock_->UpdateAppsUidToPowerMgr();
356 #endif
357 return SUCCESS;
358 }
359
DumpInfo(std::string & dumpString)360 void BluetoothAudioCaptureSource::DumpInfo(std::string &dumpString)
361 {
362 dumpString += "type: BtSource\tstarted: " + std::string(started_ ? "true" : "false") + "\thalName: " + halName_ +
363 "\n";
364 }
365
ConvertToHdiFormat(AudioSampleFormat format)366 AudioFormat BluetoothAudioCaptureSource::ConvertToHdiFormat(AudioSampleFormat format)
367 {
368 AudioFormat hdiFormat;
369 switch (format) {
370 case SAMPLE_U8:
371 hdiFormat = AUDIO_FORMAT_TYPE_PCM_8_BIT;
372 break;
373 case SAMPLE_S16LE:
374 hdiFormat = AUDIO_FORMAT_TYPE_PCM_16_BIT;
375 break;
376 case SAMPLE_S24LE:
377 hdiFormat = AUDIO_FORMAT_TYPE_PCM_24_BIT;
378 break;
379 case SAMPLE_S32LE:
380 hdiFormat = AUDIO_FORMAT_TYPE_PCM_32_BIT;
381 break;
382 default:
383 hdiFormat = AUDIO_FORMAT_TYPE_PCM_16_BIT;
384 break;
385 }
386
387 return hdiFormat;
388 }
389
InitAudioSampleAttr(struct AudioSampleAttributes & param)390 void BluetoothAudioCaptureSource::InitAudioSampleAttr(struct AudioSampleAttributes ¶m)
391 {
392 param.format = AUDIO_FORMAT_TYPE_PCM_16_BIT;
393 param.channelCount = AUDIO_CHANNELCOUNT;
394 param.sampleRate = AUDIO_SAMPLE_RATE_48K;
395 param.interleaved = true;
396 param.type = AUDIO_IN_MEDIA;
397 param.period = DEEP_BUFFER_CAPTURE_PERIOD_SIZE;
398 param.frameSize = PCM_16_BIT * param.channelCount / PCM_8_BIT;
399 param.isBigEndian = false;
400 param.isSignedData = true;
401 param.startThreshold = DEEP_BUFFER_CAPTURE_PERIOD_SIZE / (param.frameSize);
402 param.stopThreshold = INT_MAX;
403 param.silenceThreshold = AUDIO_BUFFER_SIZE; // 16 * 1024
404
405 param.sampleRate = attr_.sampleRate;
406 param.format = ConvertToHdiFormat(attr_.format);
407 param.isBigEndian = attr_.isBigEndian;
408 param.channelCount = attr_.channel;
409 param.silenceThreshold = attr_.bufferSize;
410 param.frameSize = param.format * param.channelCount;
411 param.startThreshold = DEEP_BUFFER_CAPTURE_PERIOD_SIZE / (param.frameSize);
412 }
413
InitDeviceDesc(struct AudioDeviceDescriptor & deviceDesc)414 void BluetoothAudioCaptureSource::InitDeviceDesc(struct AudioDeviceDescriptor &deviceDesc)
415 {
416 deviceDesc.pins = PIN_IN_MIC;
417 deviceDesc.desc = nullptr;
418 }
419
SetAudioRouteInfoForEnhanceChain(void)420 void BluetoothAudioCaptureSource::SetAudioRouteInfoForEnhanceChain(void)
421 {
422 AudioEnhanceChainManager *audioEnhanceChainManager = AudioEnhanceChainManager::GetInstance();
423 CHECK_AND_RETURN_LOG(audioEnhanceChainManager != nullptr, "audioEnhanceChainManager is nullptr");
424 audioEnhanceChainManager->SetInputDevice(captureId_, currentActiveDevice_, "");
425 }
426
CreateCapture(void)427 int32_t BluetoothAudioCaptureSource::CreateCapture(void)
428 {
429 Trace trace("BluetoothAudioCaptureSource::CreateCapture");
430
431 struct AudioSampleAttributes param;
432 struct AudioDeviceDescriptor deviceDesc;
433 InitAudioSampleAttr(param);
434 InitDeviceDesc(deviceDesc);
435
436 AUDIO_INFO_LOG("create capture, halName: %{public}s, rate: %{public}u, channel: %{public}u, format: %{public}u, "
437 "devicePin: %{public}u", halName_.c_str(), param.sampleRate, param.channelCount, param.format, deviceDesc.pins);
438 HdiAdapterManager &manager = HdiAdapterManager::GetInstance();
439 std::shared_ptr<IDeviceManager> deviceManager = manager.GetDeviceManager(HDI_DEVICE_MANAGER_TYPE_BLUETOOTH);
440 CHECK_AND_RETURN_RET(deviceManager != nullptr, ERR_INVALID_HANDLE);
441 void *capture = deviceManager->CreateCapture(adapterNameCase_, ¶m, &deviceDesc, hdiCaptureId_);
442 audioCapture_ = static_cast<struct AudioCapture *>(capture);
443 CHECK_AND_RETURN_RET(audioCapture_ != nullptr, ERR_NOT_STARTED);
444 SetAudioRouteInfoForEnhanceChain();
445 return SUCCESS;
446 }
447
InitLatencyMeasurement(void)448 void BluetoothAudioCaptureSource::InitLatencyMeasurement(void)
449 {
450 std::lock_guard<std::mutex> lock(signalDetectMutex_);
451 if (!AudioLatencyMeasurement::CheckIfEnabled()) {
452 return;
453 }
454
455 signalDetectAgent_ = std::make_shared<SignalDetectAgent>();
456 CHECK_AND_RETURN_LOG(signalDetectAgent_ != nullptr, "signalDetectAgent is nullptr");
457 signalDetectAgent_->sampleFormat_ = attr_.format;
458 signalDetectAgent_->formatByteSize_ = GetFormatByteSize(attr_.format);
459 }
460
DeInitLatencyMeasurement(void)461 void BluetoothAudioCaptureSource::DeInitLatencyMeasurement(void)
462 {
463 std::lock_guard<std::mutex> lock(signalDetectMutex_);
464
465 signalDetected_ = false;
466 signalDetectAgent_ = nullptr;
467 }
468
CheckLatencySignal(uint8_t * frame,size_t replyBytes)469 void BluetoothAudioCaptureSource::CheckLatencySignal(uint8_t *frame, size_t replyBytes)
470 {
471 std::lock_guard<std::mutex> lock(signalDetectMutex_);
472 CHECK_AND_RETURN(signalDetectAgent_ != nullptr);
473 signalDetected_ = signalDetectAgent_->CheckAudioData(frame, replyBytes);
474 if (signalDetected_) {
475 AudioParamKey key = NONE;
476 std::string condition = "debug_audio_latency_measurement";
477 HdiAdapterManager &manager = HdiAdapterManager::GetInstance();
478 std::shared_ptr<IDeviceManager> deviceManager = manager.GetDeviceManager(HDI_DEVICE_MANAGER_TYPE_BLUETOOTH);
479 CHECK_AND_RETURN(deviceManager != nullptr);
480 std::string value = deviceManager->GetAudioParameter(adapterNameCase_, key, condition);
481
482 LatencyMonitor::GetInstance().UpdateDspTime(value.c_str());
483 LatencyMonitor::GetInstance().UpdateSinkOrSourceTime(false, signalDetectAgent_->lastPeakBufferTime_);
484 AUDIO_INFO_LOG("signal detected");
485 signalDetected_ = false;
486 }
487 }
488
CheckUpdateState(char * frame,size_t replyBytes)489 void BluetoothAudioCaptureSource::CheckUpdateState(char *frame, size_t replyBytes)
490 {
491 if (startUpdate_) {
492 if (captureFrameNum_ == 0) {
493 last10FrameStartTime_ = ClockTime::GetCurNano();
494 }
495 captureFrameNum_++;
496 maxAmplitude_ = UpdateMaxAmplitude(static_cast<ConvertHdiFormat>(attr_.format), frame, replyBytes);
497 if (captureFrameNum_ == GET_MAX_AMPLITUDE_FRAMES_THRESHOLD) {
498 captureFrameNum_ = 0;
499 if (last10FrameStartTime_ > lastGetMaxAmplitudeTime_) {
500 startUpdate_ = false;
501 maxAmplitude_ = 0;
502 }
503 }
504 }
505 }
506
DoStop(void)507 int32_t BluetoothAudioCaptureSource::DoStop(void)
508 {
509 AUDIO_INFO_LOG("halName: %{public}s", halName_.c_str());
510 Trace trace("BluetoothAudioCaptureSource::DoStop");
511
512 DeInitLatencyMeasurement();
513 #ifdef FEATURE_POWER_MANAGER
514 if (runningLock_ != nullptr) {
515 AUDIO_INFO_LOG("running lock unlock");
516 runningLock_->UnLock();
517 } else {
518 AUDIO_WARNING_LOG("running lock is null, playback can not work well");
519 }
520 #endif
521 CHECK_AND_RETURN_RET_LOG(audioCapture_ != nullptr, ERR_INVALID_HANDLE, "capture is nullptr");
522 CHECK_AND_RETURN_RET_LOG(started_, ERR_OPERATION_FAILED, "not start, invalid state");
523 int32_t ret = audioCapture_->control.Stop(reinterpret_cast<AudioHandle>(audioCapture_));
524 CHECK_AND_RETURN_RET_LOG(ret >= 0, ERR_OPERATION_FAILED, "stop fail");
525 started_ = false;
526 paused_ = false;
527 callback_.OnCaptureState(false);
528 return SUCCESS;
529 }
530
531 } // namespace AudioStandard
532 } // namespace OHOS
533