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