1 /*
2 * Copyright (c) 2021-2023 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15 #ifndef LOG_TAG
16 #define LOG_TAG "AudioCapturerSourceInner"
17 #endif
18
19 #include "audio_capturer_source.h"
20
21 #include <cstring>
22 #include <dlfcn.h>
23 #include <string>
24 #include <cinttypes>
25 #include <thread>
26 #include <future>
27
28 #include "securec.h"
29 #ifdef FEATURE_POWER_MANAGER
30 #include "power_mgr_client.h"
31 #include "running_lock.h"
32 #include "audio_running_lock_manager.h"
33 #endif
34 #include "v4_0/iaudio_manager.h"
35
36 #include "audio_hdi_log.h"
37 #include "audio_errors.h"
38 #include "audio_log_utils.h"
39 #include "audio_utils.h"
40 #include "parameters.h"
41 #include "media_monitor_manager.h"
42 #include "audio_dump_pcm.h"
43
44 using namespace std;
45
46 namespace OHOS {
47 namespace AudioStandard {
48 namespace {
49 const int64_t SECOND_TO_NANOSECOND = 1000000000;
50 const unsigned int DEINIT_TIME_OUT_SECONDS = 5;
51 const uint16_t GET_MAX_AMPLITUDE_FRAMES_THRESHOLD = 10;
52 }
53 class AudioCapturerSourceInner : public AudioCapturerSource {
54 public:
55 int32_t Init(const IAudioSourceAttr &attr) override;
56 bool IsInited(void) override;
57 void DeInit(void) override;
58
59 int32_t Start(void) override;
60 int32_t Stop(void) override;
61 int32_t Flush(void) override;
62 int32_t Reset(void) override;
63 int32_t Pause(void) override;
64 int32_t Resume(void) override;
65 int32_t CaptureFrame(char *frame, uint64_t requestBytes, uint64_t &replyBytes) override;
66 int32_t SetVolume(float left, float right) override;
67 int32_t GetVolume(float &left, float &right) override;
68 int32_t SetMute(bool isMute) override;
69 int32_t GetMute(bool &isMute) override;
70
71 int32_t SetAudioScene(AudioScene audioScene, DeviceType activeDevice) override;
72
73 int32_t SetInputRoute(DeviceType inputDevice) override;
74 uint64_t GetTransactionId() override;
75 std::string GetAudioParameter(const AudioParamKey key, const std::string &condition) override;
76
77 int32_t GetPresentationPosition(uint64_t& frames, int64_t& timeSec, int64_t& timeNanoSec) override;
78
79 void RegisterWakeupCloseCallback(IAudioSourceCallback *callback) override;
80 void RegisterAudioCapturerSourceCallback(std::unique_ptr<ICapturerStateCallback> callback) override;
81 void RegisterParameterCallback(IAudioSourceCallback *callback) override;
82
83 int32_t Preload(const std::string &usbInfoStr) override;
84 float GetMaxAmplitude() override;
85
86 int32_t UpdateAppsUid(const int32_t appsUid[PA_MAX_OUTPUTS_PER_SOURCE],
87 const size_t size) final;
88 int32_t UpdateAppsUid(const std::vector<int32_t> &appsUid) final;
89
90 int32_t UpdateSourceType(SourceType souceType) final;
91
92 explicit AudioCapturerSourceInner(const std::string &halName = "primary");
93 ~AudioCapturerSourceInner();
94
95 private:
96 static constexpr int32_t HALF_FACTOR = 2;
97 static constexpr uint32_t MAX_AUDIO_ADAPTER_NUM = 5;
98 static constexpr float MAX_VOLUME_LEVEL = 15.0f;
99 static constexpr uint32_t USB_DEFAULT_BUFFERSIZE = 3840;
100 static constexpr uint32_t STEREO_CHANNEL_COUNT = 2;
101
102 int32_t CreateCapture(struct AudioPort &capturePort);
103 int32_t InitAudioManager();
104 void InitAttrsCapture(struct AudioSampleAttributes &attrs);
105 AudioFormat ConvertToHdiFormat(HdiAdapterFormat format);
106
107 int32_t UpdateUsbAttrs(const std::string &usbInfoStr);
108 int32_t InitManagerAndAdapter();
109 int32_t InitAdapterAndCapture();
110
111 void InitLatencyMeasurement();
112 void DeinitLatencyMeasurement();
113 void CheckLatencySignal(uint8_t *frame, size_t replyBytes);
114
115 void CheckUpdateState(char *frame, uint64_t replyBytes);
116 void DfxOperation(BufferDesc &buffer, AudioSampleFormat format, AudioChannel channel) const;
117 int32_t SetInputRoute(DeviceType inputDevice, AudioPortPin &inputPortPin);
118 int32_t DoSetInputRoute(DeviceType inputDevice, AudioPortPin &inputPortPin);
119 int32_t DoStop();
120 bool GetMuteState();
121 void SetMuteState(bool isMute);
122
123 IAudioSourceAttr attr_ = {};
124 bool sourceInited_ = false;
125 bool captureInited_ = false;
126 bool started_ = false;
127 bool paused_ = false;
128 float leftVolume_ = 0.0f;
129 float rightVolume_ = 0.0f;
130
131 int32_t routeHandle_ = -1;
132 int32_t logMode_ = 0;
133 uint32_t openMic_ = 0;
134 uint32_t captureId_ = 0;
135 std::string adapterNameCase_ = "";
136 mutable int64_t volumeDataCount_ = 0;
137 std::string logUtilsTag_ = "";
138
139 // for get amplitude
140 float maxAmplitude_ = 0;
141 int64_t lastGetMaxAmplitudeTime_ = 0;
142 int64_t last10FrameStartTime_ = 0;
143 bool startUpdate_ = false;
144 int capFrameNum_ = 0;
145
146 struct IAudioManager *audioManager_ = nullptr;
147 std::atomic<bool> adapterLoaded_ = false;
148 struct IAudioAdapter *audioAdapter_ = nullptr;
149 struct IAudioCapture *audioCapture_ = nullptr;
150 const std::string halName_ = "";
151 struct AudioAdapterDescriptor adapterDesc_ = {};
152 struct AudioPort audioPort_ = {};
153 #ifdef FEATURE_POWER_MANAGER
154 std::shared_ptr<AudioRunningLockManager<PowerMgr::RunningLock>> runningLockManager_;
155 #endif
156 IAudioSourceCallback* wakeupCloseCallback_ = nullptr;
157 std::mutex wakeupClosecallbackMutex_;
158
159 std::unique_ptr<ICapturerStateCallback> audioCapturerSourceCallback_ = nullptr;
160 FILE *dumpFile_ = nullptr;
161 std::string dumpFileName_ = "";
162 std::mutex muteStateMutex_;
163 bool muteState_ = false;
164 DeviceType currentActiveDevice_ = DEVICE_TYPE_INVALID;
165 AudioScene currentAudioScene_ = AUDIO_SCENE_INVALID;
166 bool latencyMeasEnabled_ = false;
167 bool signalDetected_ = false;
168 std::shared_ptr<SignalDetectAgent> signalDetectAgent_ = nullptr;
169 std::mutex signalDetectAgentMutex_;
170
171 std::mutex statusMutex_;
172 };
173
174 class AudioCapturerSourceWakeup : public AudioCapturerSource {
175 public:
176 int32_t Init(const IAudioSourceAttr &attr) override;
177 bool IsInited(void) override;
178 void DeInit(void) override;
179
180 int32_t Start(void) override;
181 int32_t Stop(void) override;
182 int32_t Flush(void) override;
183 int32_t Reset(void) override;
184 int32_t Pause(void) override;
185 int32_t Resume(void) override;
186 int32_t CaptureFrame(char *frame, uint64_t requestBytes, uint64_t &replyBytes) override;
187 int32_t SetVolume(float left, float right) override;
188 int32_t GetVolume(float &left, float &right) override;
189 int32_t SetMute(bool isMute) override;
190 int32_t GetMute(bool &isMute) override;
191
192 int32_t SetAudioScene(AudioScene audioScene, DeviceType activeDevice) override;
193
194 int32_t SetInputRoute(DeviceType inputDevice) override;
195 uint64_t GetTransactionId() override;
196 int32_t GetPresentationPosition(uint64_t& frames, int64_t& timeSec, int64_t& timeNanoSec) override;
197 std::string GetAudioParameter(const AudioParamKey key, const std::string &condition) override;
198
199 void RegisterWakeupCloseCallback(IAudioSourceCallback *callback) override;
200 void RegisterAudioCapturerSourceCallback(std::unique_ptr<ICapturerStateCallback> callback) override;
201 void RegisterParameterCallback(IAudioSourceCallback *callback) override;
202 float GetMaxAmplitude() override;
203
204 int32_t UpdateAppsUid(const int32_t appsUid[PA_MAX_OUTPUTS_PER_SOURCE],
205 const size_t size) final;
206 int32_t UpdateAppsUid(const std::vector<int32_t> &appsUid) final;
207
208 AudioCapturerSourceWakeup() = default;
209 ~AudioCapturerSourceWakeup() = default;
210
211 private:
MemcpysAndCheck(void * dest,size_t destMax,const void * src,size_t count)212 static inline void MemcpysAndCheck(void *dest, size_t destMax, const void *src, size_t count)
213 {
214 if (memcpy_s(dest, destMax, src, count)) {
215 AUDIO_ERR_LOG("memcpy_s error");
216 }
217 }
218 class WakeupBuffer {
219 public:
WakeupBuffer(size_t sizeMax=BUFFER_SIZE_MAX)220 explicit WakeupBuffer(size_t sizeMax = BUFFER_SIZE_MAX)
221 : sizeMax_(sizeMax),
222 buffer_(std::make_unique<char[]>(sizeMax))
223 {
224 }
225
226 ~WakeupBuffer() = default;
227
Poll(char * frame,uint64_t requestBytes,uint64_t & replyBytes,uint64_t & noStart)228 int32_t Poll(char *frame, uint64_t requestBytes, uint64_t &replyBytes, uint64_t &noStart)
229 {
230 std::lock_guard<std::mutex> lock(mutex_);
231
232 if (noStart < headNum_) {
233 noStart = headNum_;
234 }
235
236 if (noStart >= (headNum_ + size_)) {
237 if (requestBytes > sizeMax_) {
238 requestBytes = sizeMax_;
239 }
240
241 int32_t res = audioCapturerSource_.CaptureFrame(frame, requestBytes, replyBytes);
242 Offer(frame, replyBytes);
243
244 return res;
245 }
246
247 if (requestBytes > size_) { // size_!=0
248 replyBytes = size_;
249 } else {
250 replyBytes = requestBytes;
251 }
252
253 uint64_t tail = (head_ + size_) % sizeMax_;
254
255 if (tail > head_) {
256 MemcpysAndCheck(frame, replyBytes, buffer_.get() + head_, replyBytes);
257 headNum_ += replyBytes;
258 size_ -= replyBytes;
259 head_ = (head_ + replyBytes) % sizeMax_;
260 } else {
261 uint64_t copySize = min((sizeMax_ - head_), replyBytes);
262 if (copySize != 0) {
263 MemcpysAndCheck(frame, replyBytes, buffer_.get() + head_, copySize);
264 headNum_ += copySize;
265 size_ -= copySize;
266 head_ = (head_ + copySize) % sizeMax_;
267 }
268
269 uint64_t remainCopySize = replyBytes - copySize;
270 if (remainCopySize != 0) {
271 MemcpysAndCheck(frame + copySize, remainCopySize, buffer_.get(), remainCopySize);
272 headNum_ += remainCopySize;
273 size_ -= remainCopySize;
274 head_ = (head_ + remainCopySize) % sizeMax_;
275 }
276 }
277
278 return SUCCESS;
279 }
280 private:
281 static constexpr size_t BUFFER_SIZE_MAX = 32000; // 2 seconds
282
283 const size_t sizeMax_;
284 size_t size_ = 0;
285
286 std::unique_ptr<char[]> buffer_;
287 std::mutex mutex_;
288
289 uint64_t head_ = 0;
290
291 uint64_t headNum_ = 0;
292
Offer(const char * frame,const uint64_t bufferBytes)293 void Offer(const char *frame, const uint64_t bufferBytes)
294 {
295 if ((size_ + bufferBytes) > sizeMax_) { // head_ need shift
296 u_int64_t shift = (size_ + bufferBytes) - sizeMax_; // 1 to sizeMax_
297 headNum_ += shift;
298 if (size_ > shift) {
299 size_ -= shift;
300 head_ = ((head_ + shift) % sizeMax_);
301 } else {
302 size_ = 0;
303 head_ = 0;
304 }
305 }
306
307 uint64_t tail = (head_ + size_) % sizeMax_;
308 if (tail < head_) {
309 MemcpysAndCheck((buffer_.get() + tail), bufferBytes, frame, bufferBytes);
310 } else {
311 uint64_t copySize = min(sizeMax_ - tail, bufferBytes);
312 MemcpysAndCheck((buffer_.get() + tail), sizeMax_ - tail, frame, copySize);
313
314 if (copySize < bufferBytes) {
315 MemcpysAndCheck((buffer_.get()), bufferBytes - copySize, frame + copySize, bufferBytes - copySize);
316 }
317 }
318 size_ += bufferBytes;
319 }
320 };
321
322 uint64_t noStart_ = 0;
323 std::atomic<bool> isInited = false;
324 static inline int initCount = 0;
325
326 std::atomic<bool> isStarted = false;
327 static inline int startCount = 0;
328
329 static inline std::unique_ptr<WakeupBuffer> wakeupBuffer_;
330 static inline std::mutex wakeupMutex_;
331
332 static inline AudioCapturerSourceInner audioCapturerSource_;
333 };
334 #ifdef FEATURE_POWER_MANAGER
335 constexpr int32_t RUNNINGLOCK_LOCK_TIMEOUTMS_LASTING = -1;
336 #endif
337
AudioCapturerSourceInner(const std::string & halName)338 AudioCapturerSourceInner::AudioCapturerSourceInner(const std::string &halName)
339 : sourceInited_(false), captureInited_(false), started_(false), paused_(false),
340 leftVolume_(MAX_VOLUME_LEVEL), rightVolume_(MAX_VOLUME_LEVEL), openMic_(0),
341 audioManager_(nullptr), audioAdapter_(nullptr), audioCapture_(nullptr), halName_(halName)
342 {
343 attr_ = {};
344 }
345
~AudioCapturerSourceInner()346 AudioCapturerSourceInner::~AudioCapturerSourceInner()
347 {
348 AUDIO_WARNING_LOG("~AudioCapturerSourceInner");
349 AUDIO_INFO_LOG("[%{public}s] volume data counts: %{public}" PRId64, logUtilsTag_.c_str(), volumeDataCount_);
350 }
351
GetInstance(const std::string & halName,const SourceType sourceType,const char * sourceName)352 AudioCapturerSource *AudioCapturerSource::GetInstance(const std::string &halName,
353 const SourceType sourceType, const char *sourceName)
354 {
355 Trace trace("AudioCapturerSourceInner:GetInstance");
356 if (halName == "usb") {
357 static AudioCapturerSourceInner audioCapturerUsb(halName);
358 return &audioCapturerUsb;
359 }
360
361 switch (sourceType) {
362 case SourceType::SOURCE_TYPE_MIC:
363 case SourceType::SOURCE_TYPE_VOICE_CALL:
364 case SourceType::SOURCE_TYPE_CAMCORDER:
365 case SourceType::SOURCE_TYPE_UNPROCESSED:
366 return GetMicInstance();
367 case SourceType::SOURCE_TYPE_WAKEUP:
368 if (!strcmp(sourceName, "Built_in_wakeup_mirror")) {
369 return GetWakeupInstance(true);
370 } else {
371 return GetWakeupInstance(false);
372 }
373 default:
374 AUDIO_ERR_LOG("sourceType error %{public}d", sourceType);
375 return GetMicInstance();
376 }
377 }
378
ConvertToHDIAudioInputType(const int32_t currSourceType)379 static enum AudioInputType ConvertToHDIAudioInputType(const int32_t currSourceType)
380 {
381 enum AudioInputType hdiAudioInputType;
382 switch (currSourceType) {
383 case SOURCE_TYPE_INVALID:
384 hdiAudioInputType = AUDIO_INPUT_DEFAULT_TYPE;
385 break;
386 case SOURCE_TYPE_MIC:
387 case SOURCE_TYPE_PLAYBACK_CAPTURE:
388 case SOURCE_TYPE_ULTRASONIC:
389 hdiAudioInputType = AUDIO_INPUT_MIC_TYPE;
390 break;
391 case SOURCE_TYPE_WAKEUP:
392 hdiAudioInputType = AUDIO_INPUT_SPEECH_WAKEUP_TYPE;
393 break;
394 case SOURCE_TYPE_VOICE_COMMUNICATION:
395 hdiAudioInputType = AUDIO_INPUT_VOICE_COMMUNICATION_TYPE;
396 break;
397 case SOURCE_TYPE_VOICE_RECOGNITION:
398 hdiAudioInputType = AUDIO_INPUT_VOICE_RECOGNITION_TYPE;
399 break;
400 case SOURCE_TYPE_VOICE_CALL:
401 hdiAudioInputType = AUDIO_INPUT_VOICE_CALL_TYPE;
402 break;
403 case SOURCE_TYPE_CAMCORDER:
404 hdiAudioInputType = AUDIO_INPUT_CAMCORDER_TYPE;
405 break;
406 case SOURCE_TYPE_UNPROCESSED:
407 hdiAudioInputType = AUDIO_INPUT_RAW_TYPE;
408 break;
409 default:
410 hdiAudioInputType = AUDIO_INPUT_MIC_TYPE;
411 break;
412 }
413 return hdiAudioInputType;
414 }
415
GenerateUniqueIDBySource(int32_t source)416 static uint32_t GenerateUniqueIDBySource(int32_t source)
417 {
418 uint32_t sourceId = 0;
419 switch (source) {
420 case SOURCE_TYPE_WAKEUP:
421 sourceId = GenerateUniqueID(AUDIO_HDI_CAPTURE_ID_BASE, HDI_CAPTURE_OFFSET_WAKEUP);
422 break;
423 default:
424 sourceId = GenerateUniqueID(AUDIO_HDI_CAPTURE_ID_BASE, HDI_CAPTURE_OFFSET_PRIMARY);
425 break;
426 }
427 return sourceId;
428 }
429
GetMicInstance()430 AudioCapturerSource *AudioCapturerSource::GetMicInstance()
431 {
432 static AudioCapturerSourceInner audioCapturer;
433 return &audioCapturer;
434 }
435
GetWakeupInstance(bool isMirror)436 AudioCapturerSource *AudioCapturerSource::GetWakeupInstance(bool isMirror)
437 {
438 if (isMirror) {
439 static AudioCapturerSourceWakeup audioCapturerMirror;
440 return &audioCapturerMirror;
441 }
442 static AudioCapturerSourceWakeup audioCapturer;
443 return &audioCapturer;
444 }
445
IsInited(void)446 bool AudioCapturerSourceInner::IsInited(void)
447 {
448 return sourceInited_;
449 }
450
DeInit()451 void AudioCapturerSourceInner::DeInit()
452 {
453 std::lock_guard<std::mutex> statusLock(statusMutex_);
454 Trace trace("AudioCapturerSourceInner::DeInit");
455 AudioXCollie sourceXCollie("AudioCapturerSourceInner::DeInit", DEINIT_TIME_OUT_SECONDS);
456 AUDIO_INFO_LOG("Start deinit of source inner");
457 started_ = false;
458 sourceInited_ = false;
459
460 if (audioAdapter_ != nullptr) {
461 audioAdapter_->DestroyCapture(audioAdapter_, captureId_);
462 }
463 captureInited_ = false;
464
465 IAudioSourceCallback* callback = nullptr;
466 {
467 std::lock_guard<std::mutex> lck(wakeupClosecallbackMutex_);
468 callback = wakeupCloseCallback_;
469 }
470 if (callback != nullptr) {
471 callback->OnWakeupClose();
472 }
473
474 audioCapture_ = nullptr;
475 currentActiveDevice_ = DEVICE_TYPE_INVALID; // the current device must be rest when closing capturer.
476
477 // Only the usb hal needs to be unloadadapter at the moment.
478 if (halName_ == "usb") {
479 adapterLoaded_ = false;
480 if (audioManager_ != nullptr) {
481 audioManager_->UnloadAdapter(audioManager_, adapterDesc_.adapterName);
482 }
483 audioAdapter_ = nullptr;
484 audioManager_ = nullptr;
485 }
486
487 DumpFileUtil::CloseDumpFile(&dumpFile_);
488 }
489
InitAttrsCapture(struct AudioSampleAttributes & attrs)490 void AudioCapturerSourceInner::InitAttrsCapture(struct AudioSampleAttributes &attrs)
491 {
492 /* Initialization of audio parameters for playback */
493 attrs.format = AUDIO_FORMAT_TYPE_PCM_16_BIT;
494 attrs.channelCount = AUDIO_CHANNELCOUNT;
495 attrs.sampleRate = AUDIO_SAMPLE_RATE_48K;
496 attrs.interleaved = true;
497 attrs.streamId = static_cast<int32_t>(GenerateUniqueIDBySource(attr_.sourceType));
498 attrs.type = AUDIO_IN_MEDIA;
499 attrs.period = DEEP_BUFFER_CAPTURE_PERIOD_SIZE;
500 attrs.frameSize = PCM_16_BIT * attrs.channelCount / PCM_8_BIT;
501 attrs.isBigEndian = false;
502 attrs.isSignedData = true;
503 attrs.startThreshold = DEEP_BUFFER_CAPTURE_PERIOD_SIZE / (attrs.frameSize);
504 attrs.stopThreshold = INT_32_MAX;
505 /* 16 * 1024 */
506 attrs.silenceThreshold = AUDIO_BUFF_SIZE;
507 attrs.sourceType = SOURCE_TYPE_MIC;
508 }
509
SwitchAdapterCapture(struct AudioAdapterDescriptor * descs,uint32_t size,const std::string & adapterNameCase,enum AudioPortDirection portFlag,struct AudioPort & capturePort)510 int32_t SwitchAdapterCapture(struct AudioAdapterDescriptor *descs, uint32_t size, const std::string &adapterNameCase,
511 enum AudioPortDirection portFlag, struct AudioPort &capturePort)
512 {
513 if (descs == nullptr) {
514 return ERROR;
515 }
516
517 for (uint32_t index = 0; index < size; index++) {
518 struct AudioAdapterDescriptor *desc = &descs[index];
519 if (desc == nullptr || desc->adapterName == nullptr) {
520 continue;
521 }
522 AUDIO_INFO_LOG("size: %{public}d, adapterNameCase %{public}s, adapterName %{public}s",
523 size, adapterNameCase.c_str(), desc->adapterName);
524 if (!adapterNameCase.compare(desc->adapterName)) {
525 for (uint32_t port = 0; port < desc->portsLen; port++) {
526 // Only find out the port of out in the sound card
527 if (desc->ports[port].dir == portFlag) {
528 capturePort = desc->ports[port];
529 return index;
530 }
531 }
532 }
533 }
534 AUDIO_ERR_LOG("SwitchAdapterCapture Fail");
535
536 return ERR_INVALID_INDEX;
537 }
538
InitAudioManager()539 int32_t AudioCapturerSourceInner::InitAudioManager()
540 {
541 AUDIO_INFO_LOG("Initialize audio proxy manager");
542
543 if (audioManager_ == nullptr) {
544 audioManager_ = IAudioManagerGet(false);
545 }
546
547 if (audioManager_ == nullptr) {
548 return ERR_INVALID_HANDLE;
549 }
550
551 return 0;
552 }
553
ConvertToHdiFormat(HdiAdapterFormat format)554 AudioFormat AudioCapturerSourceInner::ConvertToHdiFormat(HdiAdapterFormat format)
555 {
556 AudioFormat hdiFormat;
557 switch (format) {
558 case SAMPLE_U8:
559 hdiFormat = AUDIO_FORMAT_TYPE_PCM_8_BIT;
560 break;
561 case SAMPLE_S16:
562 hdiFormat = AUDIO_FORMAT_TYPE_PCM_16_BIT;
563 break;
564 case SAMPLE_S24:
565 hdiFormat = AUDIO_FORMAT_TYPE_PCM_24_BIT;
566 break;
567 case SAMPLE_S32:
568 hdiFormat = AUDIO_FORMAT_TYPE_PCM_32_BIT;
569 break;
570 default:
571 hdiFormat = AUDIO_FORMAT_TYPE_PCM_16_BIT;
572 break;
573 }
574
575 return hdiFormat;
576 }
577
CreateCapture(struct AudioPort & capturePort)578 int32_t AudioCapturerSourceInner::CreateCapture(struct AudioPort &capturePort)
579 {
580 Trace trace("AudioCapturerSourceInner:CreateCapture");
581
582 struct AudioSampleAttributes param;
583 // User needs to set
584 InitAttrsCapture(param);
585 param.sampleRate = attr_.sampleRate;
586 param.format = ConvertToHdiFormat(attr_.format);
587 param.isBigEndian = attr_.isBigEndian;
588 param.channelCount = attr_.channel;
589 if (param.channelCount == MONO) {
590 param.channelLayout = CH_LAYOUT_MONO;
591 } else if (param.channelCount == STEREO) {
592 param.channelLayout = CH_LAYOUT_STEREO;
593 } else if (param.channelCount == CHANNEL_4) {
594 param.channelLayout = CH_LAYOUT_QUAD;
595 }
596 param.silenceThreshold = attr_.bufferSize;
597 param.frameSize = param.format * param.channelCount;
598 param.startThreshold = DEEP_BUFFER_CAPTURE_PERIOD_SIZE / (param.frameSize);
599 param.sourceType = static_cast<int32_t>(ConvertToHDIAudioInputType(attr_.sourceType));
600
601 struct AudioDeviceDescriptor deviceDesc;
602 deviceDesc.portId = capturePort.portId;
603 deviceDesc.pins = PIN_IN_MIC;
604 if (halName_ == "usb") {
605 deviceDesc.pins = PIN_IN_USB_HEADSET;
606 }
607 deviceDesc.desc = (char *)"";
608
609 AUDIO_INFO_LOG("Create capture sourceName:%{public}s, hdisource:%{public}d, " \
610 "rate:%{public}u channel:%{public}u format:%{public}u, devicePin:%{public}u",
611 halName_.c_str(), param.sourceType, param.sampleRate, param.channelCount, param.format, deviceDesc.pins);
612 int32_t ret = audioAdapter_->CreateCapture(audioAdapter_, &deviceDesc, ¶m, &audioCapture_, &captureId_);
613 CHECK_AND_RETURN_RET_LOG(audioCapture_ != nullptr && ret >= 0, ERR_NOT_STARTED, "Create capture failed");
614
615 return 0;
616 }
617
Init(const IAudioSourceAttr & attr)618 int32_t AudioCapturerSourceInner::Init(const IAudioSourceAttr &attr)
619 {
620 std::lock_guard<std::mutex> statusLock(statusMutex_);
621 attr_ = attr;
622 adapterNameCase_ = attr_.adapterName;
623 openMic_ = attr_.openMicSpeaker;
624 logMode_ = system::GetIntParameter("persist.multimedia.audiolog.switch", 0);
625
626 int32_t ret = InitAdapterAndCapture();
627 CHECK_AND_RETURN_RET_LOG(ret == SUCCESS, ret, "Init adapter and capture failed");
628
629 sourceInited_ = true;
630
631 if (GetMuteState()) {
632 SetMute(true);
633 }
634
635 return SUCCESS;
636 }
637
CaptureFrame(char * frame,uint64_t requestBytes,uint64_t & replyBytes)638 int32_t AudioCapturerSourceInner::CaptureFrame(char *frame, uint64_t requestBytes, uint64_t &replyBytes)
639 {
640 CHECK_AND_RETURN_RET_LOG(audioCapture_ != nullptr, ERR_INVALID_HANDLE, "Audio capture Handle is nullptr!");
641
642 Trace trace("AudioCapturerSourceInner::CaptureFrame");
643
644 int64_t stamp = ClockTime::GetCurNano();
645 uint32_t frameLen = static_cast<uint32_t>(requestBytes);
646 int32_t ret = audioCapture_->CaptureFrame(audioCapture_, reinterpret_cast<int8_t*>(frame), &frameLen, &replyBytes);
647 CHECK_AND_RETURN_RET_LOG(ret >= 0, ERR_READ_FAILED, "Capture Frame Fail");
648 CheckLatencySignal(reinterpret_cast<uint8_t*>(frame), replyBytes);
649
650 BufferDesc tmpBuffer = {reinterpret_cast<uint8_t*>(frame), replyBytes, replyBytes};
651 DfxOperation(tmpBuffer, static_cast<AudioSampleFormat>(attr_.format), static_cast<AudioChannel>(attr_.channel));
652 if (AudioDump::GetInstance().GetVersionType() == BETA_VERSION) {
653 DumpFileUtil::WriteDumpFile(dumpFile_, frame, replyBytes);
654 AudioCacheMgr::GetInstance().CacheData(dumpFileName_, static_cast<void*>(frame), replyBytes);
655 }
656 CheckUpdateState(frame, requestBytes);
657
658 stamp = (ClockTime::GetCurNano() - stamp) / AUDIO_US_PER_SECOND;
659 if (logMode_) {
660 AUDIO_DEBUG_LOG("RenderFrame len[%{public}" PRIu64 "] cost[%{public}" PRId64 "]ms", requestBytes, stamp);
661 }
662 return SUCCESS;
663 }
664
DfxOperation(BufferDesc & buffer,AudioSampleFormat format,AudioChannel channel) const665 void AudioCapturerSourceInner::DfxOperation(BufferDesc &buffer, AudioSampleFormat format, AudioChannel channel) const
666 {
667 ChannelVolumes vols = VolumeTools::CountVolumeLevel(buffer, format, channel);
668 if (channel == MONO) {
669 Trace::Count(logUtilsTag_, vols.volStart[0]);
670 } else {
671 Trace::Count(logUtilsTag_, (vols.volStart[0] + vols.volStart[1]) / HALF_FACTOR);
672 }
673 AudioLogUtils::ProcessVolumeData(logUtilsTag_, vols, volumeDataCount_);
674 }
675
CheckUpdateState(char * frame,uint64_t replyBytes)676 void AudioCapturerSourceInner::CheckUpdateState(char *frame, uint64_t replyBytes)
677 {
678 if (startUpdate_) {
679 std::lock_guard<std::mutex> lock(statusMutex_);
680 if (capFrameNum_ == 0) {
681 last10FrameStartTime_ = ClockTime::GetCurNano();
682 }
683 capFrameNum_++;
684 maxAmplitude_ = UpdateMaxAmplitude(static_cast<ConvertHdiFormat>(attr_.format), frame, replyBytes);
685 if (capFrameNum_ == GET_MAX_AMPLITUDE_FRAMES_THRESHOLD) {
686 capFrameNum_ = 0;
687 if (last10FrameStartTime_ > lastGetMaxAmplitudeTime_) {
688 startUpdate_ = false;
689 maxAmplitude_ = 0;
690 }
691 }
692 }
693 }
694
GetMaxAmplitude()695 float AudioCapturerSourceInner::GetMaxAmplitude()
696 {
697 lastGetMaxAmplitudeTime_ = ClockTime::GetCurNano();
698 startUpdate_ = true;
699 return maxAmplitude_;
700 }
701
Start(void)702 int32_t AudioCapturerSourceInner::Start(void)
703 {
704 std::lock_guard<std::mutex> statusLock(statusMutex_);
705
706 AUDIO_INFO_LOG("sourceName %{public}s", halName_.c_str());
707 Trace trace("AudioCapturerSourceInner::Start");
708
709 InitLatencyMeasurement();
710 #ifdef FEATURE_POWER_MANAGER
711 std::shared_ptr<PowerMgr::RunningLock> keepRunningLock;
712 if (runningLockManager_ == nullptr) {
713 WatchTimeout guard("PowerMgr::PowerMgrClient::GetInstance().CreateRunningLock:Start");
714 switch (attr_.sourceType) {
715 case SOURCE_TYPE_WAKEUP:
716 keepRunningLock = PowerMgr::PowerMgrClient::GetInstance().CreateRunningLock("AudioWakeupCapturer",
717 PowerMgr::RunningLockType::RUNNINGLOCK_BACKGROUND_AUDIO);
718 break;
719 case SOURCE_TYPE_MIC:
720 case SOURCE_TYPE_CAMCORDER:
721 case SOURCE_TYPE_UNPROCESSED:
722 default:
723 keepRunningLock = PowerMgr::PowerMgrClient::GetInstance().CreateRunningLock("AudioPrimaryCapturer",
724 PowerMgr::RunningLockType::RUNNINGLOCK_BACKGROUND_AUDIO);
725 }
726 guard.CheckCurrTimeout();
727 if (keepRunningLock) {
728 runningLockManager_ = std::make_shared<AudioRunningLockManager<PowerMgr::RunningLock>> (keepRunningLock);
729 }
730 }
731 if (runningLockManager_ != nullptr) {
732 AUDIO_INFO_LOG("keepRunningLock lock result: %{public}d",
733 runningLockManager_->Lock(RUNNINGLOCK_LOCK_TIMEOUTMS_LASTING)); // -1 for lasting.
734 } else {
735 AUDIO_WARNING_LOG("keepRunningLock is null, capture can not work well!");
736 }
737 #endif
738 // eg: primary_0_20240527202236189_source_44100_2_1.pcm
739 dumpFileName_ = halName_ + "_" + std::to_string(attr_.sourceType) + "_" + GetTime()
740 + "_source_" + std::to_string(attr_.sampleRate) + "_" + std::to_string(attr_.channel)
741 + "_" + std::to_string(attr_.format) + ".pcm";
742 DumpFileUtil::OpenDumpFile(DUMP_SERVER_PARA, dumpFileName_, &dumpFile_);
743 logUtilsTag_ = "AudioSource";
744
745 if (!started_) {
746 if (audioCapturerSourceCallback_ != nullptr) {
747 audioCapturerSourceCallback_->OnCapturerState(true);
748 }
749
750 int32_t ret = audioCapture_->Start(audioCapture_);
751 CHECK_AND_RETURN_RET(ret >= 0, ERR_NOT_STARTED);
752 started_ = true;
753 }
754
755 return SUCCESS;
756 }
757
SetVolume(float left,float right)758 int32_t AudioCapturerSourceInner::SetVolume(float left, float right)
759 {
760 float volume;
761 CHECK_AND_RETURN_RET_LOG(audioCapture_ != nullptr, ERR_INVALID_HANDLE,
762 "SetVolume failed audioCapture_ null");
763
764 rightVolume_ = right;
765 leftVolume_ = left;
766 if ((leftVolume_ == 0) && (rightVolume_ != 0)) {
767 volume = rightVolume_;
768 } else if ((leftVolume_ != 0) && (rightVolume_ == 0)) {
769 volume = leftVolume_;
770 } else {
771 volume = (leftVolume_ + rightVolume_) / HALF_FACTOR;
772 }
773
774 audioCapture_->SetVolume(audioCapture_, volume);
775
776 return SUCCESS;
777 }
778
GetVolume(float & left,float & right)779 int32_t AudioCapturerSourceInner::GetVolume(float &left, float &right)
780 {
781 float val = 0.0;
782 audioCapture_->GetVolume(audioCapture_, &val);
783 left = val;
784 right = val;
785
786 return SUCCESS;
787 }
788
SetMuteState(bool isMute)789 void AudioCapturerSourceInner::SetMuteState(bool isMute)
790 {
791 std::lock_guard<std::mutex> statusLock(muteStateMutex_);
792 muteState_ = isMute;
793 }
794
GetMuteState()795 bool AudioCapturerSourceInner::GetMuteState()
796 {
797 std::lock_guard<std::mutex> statusLock(muteStateMutex_);
798 return muteState_;
799 }
800
SetMute(bool isMute)801 int32_t AudioCapturerSourceInner::SetMute(bool isMute)
802 {
803 SetMuteState(isMute);
804
805 if (IsInited() && audioCapture_) {
806 int32_t ret = audioCapture_->SetMute(audioCapture_, isMute);
807 if (ret != 0) {
808 AUDIO_WARNING_LOG("SetMute for hdi capturer failed");
809 } else {
810 AUDIO_INFO_LOG("SetMute for hdi capture success");
811 }
812 }
813
814 if ((halName_ == "primary") && !adapterLoaded_) {
815 InitManagerAndAdapter();
816 }
817
818 if (audioAdapter_ != nullptr) {
819 int32_t ret = audioAdapter_->SetMicMute(audioAdapter_, isMute);
820 if (ret != 0) {
821 AUDIO_WARNING_LOG("SetMicMute for hdi adapter failed");
822 } else {
823 AUDIO_INFO_LOG("SetMicMute for hdi adapter success");
824 }
825 }
826
827 AUDIO_INFO_LOG("halName:%{public}s isMute=%{public}d", halName_.c_str(), isMute);
828
829 return SUCCESS;
830 }
831
GetMute(bool & isMute)832 int32_t AudioCapturerSourceInner::GetMute(bool &isMute)
833 {
834 CHECK_AND_RETURN_RET_LOG(audioCapture_ != nullptr, ERR_INVALID_HANDLE,
835 "GetMute failed audioCapture_ handle is null!");
836
837 bool isHdiMute = false;
838 int32_t ret = audioCapture_->GetMute(audioCapture_, &isHdiMute);
839 if (ret != 0) {
840 AUDIO_WARNING_LOG("GetMute failed from hdi");
841 }
842
843 isMute = GetMuteState();
844
845 return SUCCESS;
846 }
847
GetAudioCategory(AudioScene audioScene)848 static AudioCategory GetAudioCategory(AudioScene audioScene)
849 {
850 AudioCategory audioCategory;
851 switch (audioScene) {
852 case AUDIO_SCENE_PHONE_CALL:
853 audioCategory = AUDIO_IN_CALL;
854 break;
855 case AUDIO_SCENE_PHONE_CHAT:
856 audioCategory = AUDIO_IN_COMMUNICATION;
857 break;
858 case AUDIO_SCENE_RINGING:
859 case AUDIO_SCENE_VOICE_RINGING:
860 audioCategory = AUDIO_IN_RINGTONE;
861 break;
862 case AUDIO_SCENE_DEFAULT:
863 audioCategory = AUDIO_IN_MEDIA;
864 break;
865 default:
866 audioCategory = AUDIO_IN_MEDIA;
867 break;
868 }
869 AUDIO_DEBUG_LOG("Audio category returned is: %{public}d", audioCategory);
870
871 return audioCategory;
872 }
873
SetInputPortPin(DeviceType inputDevice,AudioRouteNode & source)874 static int32_t SetInputPortPin(DeviceType inputDevice, AudioRouteNode &source)
875 {
876 int32_t ret = SUCCESS;
877
878 switch (inputDevice) {
879 case DEVICE_TYPE_MIC:
880 case DEVICE_TYPE_EARPIECE:
881 case DEVICE_TYPE_SPEAKER:
882 source.ext.device.type = PIN_IN_MIC;
883 source.ext.device.desc = (char *)"pin_in_mic";
884 break;
885 case DEVICE_TYPE_WIRED_HEADSET:
886 source.ext.device.type = PIN_IN_HS_MIC;
887 source.ext.device.desc = (char *)"pin_in_hs_mic";
888 break;
889 case DEVICE_TYPE_USB_ARM_HEADSET:
890 source.ext.device.type = PIN_IN_USB_HEADSET;
891 source.ext.device.desc = (char *)"pin_in_usb_headset";
892 break;
893 case DEVICE_TYPE_USB_HEADSET:
894 source.ext.device.type = PIN_IN_USB_EXT;
895 source.ext.device.desc = (char *)"pin_in_usb_ext";
896 break;
897 case DEVICE_TYPE_BLUETOOTH_SCO:
898 source.ext.device.type = PIN_IN_BLUETOOTH_SCO_HEADSET;
899 source.ext.device.desc = (char *)"pin_in_bluetooth_sco_headset";
900 break;
901 default:
902 ret = ERR_NOT_SUPPORTED;
903 break;
904 }
905
906 return ret;
907 }
908
SetInputRoute(DeviceType inputDevice)909 int32_t AudioCapturerSourceInner::SetInputRoute(DeviceType inputDevice)
910 {
911 std::lock_guard<std::mutex> statusLock(statusMutex_);
912 AudioPortPin inputPortPin = PIN_IN_MIC;
913 return SetInputRoute(inputDevice, inputPortPin);
914 }
915
SetInputRoute(DeviceType inputDevice,AudioPortPin & inputPortPin)916 int32_t AudioCapturerSourceInner::SetInputRoute(DeviceType inputDevice, AudioPortPin &inputPortPin)
917 {
918 if (inputDevice == currentActiveDevice_) {
919 AUDIO_INFO_LOG("input device not change. currentActiveDevice %{public}d sourceType %{public}d",
920 currentActiveDevice_, attr_.sourceType);
921
922 return SUCCESS;
923 }
924
925 return DoSetInputRoute(inputDevice, inputPortPin);
926 }
927
DoSetInputRoute(DeviceType inputDevice,AudioPortPin & inputPortPin)928 int32_t AudioCapturerSourceInner::DoSetInputRoute(DeviceType inputDevice, AudioPortPin &inputPortPin)
929 {
930 AudioRouteNode source = {};
931 AudioRouteNode sink = {};
932
933 int32_t ret = SetInputPortPin(inputDevice, source);
934 CHECK_AND_RETURN_RET_LOG(ret == SUCCESS, ret, "DoSetInputRoute FAILED: %{public}d", ret);
935
936 inputPortPin = source.ext.device.type;
937 AUDIO_INFO_LOG("Input PIN is: 0x%{public}X", inputPortPin);
938 source.portId = static_cast<int32_t>(audioPort_.portId);
939 source.role = AUDIO_PORT_SOURCE_ROLE;
940 source.type = AUDIO_PORT_DEVICE_TYPE;
941 source.ext.device.moduleId = 0;
942 source.ext.device.desc = (char *)"";
943
944 sink.portId = 0;
945 sink.role = AUDIO_PORT_SINK_ROLE;
946 sink.type = AUDIO_PORT_MIX_TYPE;
947 sink.ext.mix.moduleId = 0;
948 sink.ext.mix.streamId = static_cast<int32_t>(GenerateUniqueIDBySource(attr_.sourceType));
949 sink.ext.mix.source = static_cast<int32_t>(ConvertToHDIAudioInputType(attr_.sourceType));
950 sink.ext.device.desc = (char *)"";
951
952 AudioRoute route = {
953 .sources = &source,
954 .sourcesLen = 1,
955 .sinks = &sink,
956 .sinksLen = 1,
957 };
958
959 CHECK_AND_RETURN_RET_LOG(audioAdapter_ != nullptr, ERR_OPERATION_FAILED,
960 "AudioAdapter object is null.");
961
962 ret = audioAdapter_->UpdateAudioRoute(audioAdapter_, &route, &routeHandle_);
963 CHECK_AND_RETURN_RET_LOG(ret == 0, ERR_OPERATION_FAILED, "UpdateAudioRoute failed");
964
965 return SUCCESS;
966 }
967
SetAudioScene(AudioScene audioScene,DeviceType activeDevice)968 int32_t AudioCapturerSourceInner::SetAudioScene(AudioScene audioScene, DeviceType activeDevice)
969 {
970 AUDIO_INFO_LOG("SetAudioScene scene: %{public}d, device: %{public}d",
971 audioScene, activeDevice);
972 CHECK_AND_RETURN_RET_LOG(audioScene >= AUDIO_SCENE_DEFAULT && audioScene < AUDIO_SCENE_MAX,
973 ERR_INVALID_PARAM, "invalid audioScene");
974 CHECK_AND_RETURN_RET_LOG(audioCapture_ != nullptr, ERR_INVALID_HANDLE,
975 "SetAudioScene failed audioCapture_ handle is null!");
976 if (openMic_) {
977 AudioPortPin audioSceneInPort = PIN_IN_MIC;
978 if (halName_ == "usb") {
979 audioSceneInPort = PIN_IN_USB_HEADSET;
980 }
981
982 int32_t ret = SUCCESS;
983 if (audioScene != currentAudioScene_) {
984 struct AudioSceneDescriptor scene;
985 scene.scene.id = GetAudioCategory(audioScene);
986 scene.desc.pins = audioSceneInPort;
987 scene.desc.desc = const_cast<char *>("");
988
989 ret = audioCapture_->SelectScene(audioCapture_, &scene);
990 CHECK_AND_RETURN_RET_LOG(ret >= 0, ERR_OPERATION_FAILED,
991 "Select scene FAILED: %{public}d", ret);
992 currentAudioScene_ = audioScene;
993 }
994
995 std::lock_guard<std::mutex> statusLock(statusMutex_);
996 ret = SetInputRoute(activeDevice, audioSceneInPort);
997 if (ret < 0) {
998 AUDIO_WARNING_LOG("Update route FAILED: %{public}d", ret);
999 }
1000 }
1001 AUDIO_DEBUG_LOG("Select audio scene SUCCESS: %{public}d", audioScene);
1002 return SUCCESS;
1003 }
1004
GetTransactionId()1005 uint64_t AudioCapturerSourceInner::GetTransactionId()
1006 {
1007 return reinterpret_cast<uint64_t>(audioCapture_);
1008 }
1009
GetPresentationPosition(uint64_t & frames,int64_t & timeSec,int64_t & timeNanoSec)1010 int32_t AudioCapturerSourceInner::GetPresentationPosition(uint64_t& frames, int64_t& timeSec, int64_t& timeNanoSec)
1011 {
1012 if (audioCapture_ == nullptr) {
1013 AUDIO_ERR_LOG("failed audioCapture_ is NULL");
1014 return ERR_INVALID_HANDLE;
1015 }
1016 struct AudioTimeStamp timestamp = {};
1017 int32_t ret = audioCapture_->GetCapturePosition(audioCapture_, &frames, ×tamp);
1018 if (ret != 0) {
1019 AUDIO_ERR_LOG("get position failed");
1020 return ERR_OPERATION_FAILED;
1021 }
1022 int64_t maxSec = 9223372036; // (9223372036 + 1) * 10^9 > INT64_MAX, seconds should not bigger than it;
1023 if (timestamp.tvSec < 0 || timestamp.tvSec > maxSec || timestamp.tvNSec < 0 ||
1024 timestamp.tvNSec > SECOND_TO_NANOSECOND) {
1025 AUDIO_ERR_LOG(
1026 "Hdi GetRenderPosition get invaild second:%{public}" PRIu64 " or nanosecond:%{public}" PRIu64 " !",
1027 timestamp.tvSec, timestamp.tvNSec);
1028 return ERR_OPERATION_FAILED;
1029 }
1030
1031 timeSec = timestamp.tvSec;
1032 timeNanoSec = timestamp.tvNSec;
1033 return ret;
1034 }
1035
DoStop()1036 int32_t AudioCapturerSourceInner::DoStop()
1037 {
1038 AUDIO_INFO_LOG("sourceName %{public}s", halName_.c_str());
1039
1040 Trace trace("AudioCapturerSourceInner::DoStop");
1041
1042 DeinitLatencyMeasurement();
1043
1044 #ifdef FEATURE_POWER_MANAGER
1045 if (runningLockManager_ != nullptr) {
1046 AUDIO_INFO_LOG("keepRunningLock unlock");
1047 runningLockManager_->UnLock();
1048 } else {
1049 AUDIO_WARNING_LOG("keepRunningLock is null, stop can not work well!");
1050 }
1051 #endif
1052
1053 if (started_ && audioCapture_ != nullptr) {
1054 int32_t ret = audioCapture_->Stop(audioCapture_);
1055 CHECK_AND_RETURN_RET_LOG(ret >= 0, ERR_OPERATION_FAILED, "Stop capture Failed");
1056 }
1057 started_ = false;
1058
1059 if (audioCapturerSourceCallback_ != nullptr) {
1060 audioCapturerSourceCallback_->OnCapturerState(false);
1061 }
1062
1063 return SUCCESS;
1064 }
1065
Stop(void)1066 int32_t AudioCapturerSourceInner::Stop(void)
1067 {
1068 Trace trace("AudioCapturerSourceInner::Stop");
1069 std::promise<void> promiseEnsueThreadLock;
1070 auto futureWaitThreadLock = promiseEnsueThreadLock.get_future();
1071 std::thread threadAsyncStop([&promiseEnsueThreadLock, this] {
1072 std::lock_guard<std::mutex> statusLock(statusMutex_);
1073 promiseEnsueThreadLock.set_value();
1074 DoStop();
1075 });
1076 futureWaitThreadLock.get();
1077 threadAsyncStop.detach();
1078
1079 return SUCCESS;
1080 }
1081
Pause(void)1082 int32_t AudioCapturerSourceInner::Pause(void)
1083 {
1084 std::lock_guard<std::mutex> statusLock(statusMutex_);
1085 AUDIO_INFO_LOG("sourceName %{public}s", halName_.c_str());
1086
1087 Trace trace("AudioCapturerSourceInner::Pause");
1088 if (started_ && audioCapture_ != nullptr) {
1089 int32_t ret = audioCapture_->Pause(audioCapture_);
1090 CHECK_AND_RETURN_RET_LOG(ret == 0, ERR_OPERATION_FAILED, "pause capture Failed");
1091 }
1092 paused_ = true;
1093
1094 return SUCCESS;
1095 }
1096
Resume(void)1097 int32_t AudioCapturerSourceInner::Resume(void)
1098 {
1099 std::lock_guard<std::mutex> statusLock(statusMutex_);
1100 AUDIO_INFO_LOG("sourceName %{public}s", halName_.c_str());
1101 Trace trace("AudioCapturerSourceInner::Resume");
1102 if (paused_ && audioCapture_ != nullptr) {
1103 int32_t ret = audioCapture_->Resume(audioCapture_);
1104 CHECK_AND_RETURN_RET_LOG(ret == 0, ERR_OPERATION_FAILED, "resume capture Failed");
1105 }
1106 paused_ = false;
1107
1108 return SUCCESS;
1109 }
1110
Reset(void)1111 int32_t AudioCapturerSourceInner::Reset(void)
1112 {
1113 std::lock_guard<std::mutex> statusLock(statusMutex_);
1114 AUDIO_INFO_LOG("sourceName %{public}s", halName_.c_str());
1115 Trace trace("AudioCapturerSourceInner::Reset");
1116 if (started_ && audioCapture_ != nullptr) {
1117 audioCapture_->Flush(audioCapture_);
1118 }
1119
1120 return SUCCESS;
1121 }
1122
Flush(void)1123 int32_t AudioCapturerSourceInner::Flush(void)
1124 {
1125 std::lock_guard<std::mutex> statusLock(statusMutex_);
1126 AUDIO_INFO_LOG("sourceName %{public}s", halName_.c_str());
1127 Trace trace("AudioCapturerSourceInner::Flush");
1128 if (started_ && audioCapture_ != nullptr) {
1129 audioCapture_->Flush(audioCapture_);
1130 }
1131
1132 return SUCCESS;
1133 }
1134
RegisterWakeupCloseCallback(IAudioSourceCallback * callback)1135 void AudioCapturerSourceInner::RegisterWakeupCloseCallback(IAudioSourceCallback *callback)
1136 {
1137 AUDIO_INFO_LOG("Register WakeupClose Callback");
1138 std::lock_guard<std::mutex> lck(wakeupClosecallbackMutex_);
1139 wakeupCloseCallback_ = callback;
1140 }
1141
RegisterAudioCapturerSourceCallback(std::unique_ptr<ICapturerStateCallback> callback)1142 void AudioCapturerSourceInner::RegisterAudioCapturerSourceCallback(std::unique_ptr<ICapturerStateCallback> callback)
1143 {
1144 AUDIO_INFO_LOG("Register AudioCapturerSource Callback");
1145 audioCapturerSourceCallback_ = std::move(callback);
1146 }
1147
RegisterParameterCallback(IAudioSourceCallback * callback)1148 void AudioCapturerSourceInner::RegisterParameterCallback(IAudioSourceCallback *callback)
1149 {
1150 AUDIO_WARNING_LOG("RegisterParameterCallback is not supported!");
1151 }
1152
Preload(const std::string & usbInfoStr)1153 int32_t AudioCapturerSourceInner::Preload(const std::string &usbInfoStr)
1154 {
1155 CHECK_AND_RETURN_RET_LOG(halName_ == "usb", ERR_INVALID_OPERATION, "Preload only supported for usb");
1156
1157 std::lock_guard<std::mutex> statusLock(statusMutex_);
1158 int32_t ret = UpdateUsbAttrs(usbInfoStr);
1159 CHECK_AND_RETURN_RET_LOG(ret == SUCCESS, ret, "Preload failed when init attr");
1160
1161 ret = InitAdapterAndCapture();
1162 CHECK_AND_RETURN_RET_LOG(ret == SUCCESS, ret, "Preload failed when init adapter and capture");
1163
1164 return SUCCESS;
1165 }
1166
ParseAudioFormat(const std::string & format)1167 static HdiAdapterFormat ParseAudioFormat(const std::string &format)
1168 {
1169 if (format == "AUDIO_FORMAT_PCM_16_BIT") {
1170 return HdiAdapterFormat::SAMPLE_S16;
1171 } else if (format == "AUDIO_FORMAT_PCM_24_BIT") {
1172 return HdiAdapterFormat::SAMPLE_S24;
1173 } else if (format == "AUDIO_FORMAT_PCM_32_BIT") {
1174 return HdiAdapterFormat::SAMPLE_S32;
1175 } else {
1176 return HdiAdapterFormat::SAMPLE_S16;
1177 }
1178 }
1179
UpdateUsbAttrs(const std::string & usbInfoStr)1180 int32_t AudioCapturerSourceInner::UpdateUsbAttrs(const std::string &usbInfoStr)
1181 {
1182 CHECK_AND_RETURN_RET_LOG(usbInfoStr != "", ERR_INVALID_PARAM, "usb info string error");
1183
1184 auto sourceRate_begin = usbInfoStr.find("source_rate:");
1185 auto sourceRate_end = usbInfoStr.find_first_of(";", sourceRate_begin);
1186 std::string sampleRateStr = usbInfoStr.substr(sourceRate_begin + std::strlen("source_rate:"),
1187 sourceRate_end - sourceRate_begin - std::strlen("source_rate:"));
1188 auto sourceFormat_begin = usbInfoStr.find("source_format:");
1189 auto sourceFormat_end = usbInfoStr.find_first_of(";", sourceFormat_begin);
1190 std::string formatStr = usbInfoStr.substr(sourceFormat_begin + std::strlen("source_format:"),
1191 sourceFormat_end - sourceFormat_begin - std::strlen("source_format:"));
1192
1193 // usb default config
1194 attr_.sampleRate = static_cast<uint32_t>(stoi(sampleRateStr));
1195 attr_.channel = STEREO_CHANNEL_COUNT;
1196 attr_.format = ParseAudioFormat(formatStr);
1197 attr_.isBigEndian = false;
1198 attr_.bufferSize = USB_DEFAULT_BUFFERSIZE;
1199 attr_.sourceType = SOURCE_TYPE_MIC;
1200
1201 adapterNameCase_ = "usb";
1202 openMic_ = 0;
1203
1204 return SUCCESS;
1205 }
1206
InitManagerAndAdapter()1207 int32_t AudioCapturerSourceInner::InitManagerAndAdapter()
1208 {
1209 int32_t err = InitAudioManager();
1210 CHECK_AND_RETURN_RET_LOG(err == 0, ERR_NOT_STARTED, "Init audio manager Fail");
1211
1212 AudioAdapterDescriptor descs[MAX_AUDIO_ADAPTER_NUM];
1213 uint32_t size = MAX_AUDIO_ADAPTER_NUM;
1214 int32_t ret = audioManager_->GetAllAdapters(audioManager_, (struct AudioAdapterDescriptor *)&descs, &size);
1215 CHECK_AND_RETURN_RET_LOG(size <= MAX_AUDIO_ADAPTER_NUM && size != 0 && ret == 0,
1216 ERR_NOT_STARTED, "Get adapters Fail");
1217 if (adapterNameCase_ == "" && halName_ == "primary") {
1218 adapterNameCase_ = "primary";
1219 }
1220 // Get qualified sound card and port
1221 int32_t index = SwitchAdapterCapture((struct AudioAdapterDescriptor *)&descs,
1222 size, adapterNameCase_, PORT_IN, audioPort_);
1223 CHECK_AND_RETURN_RET_LOG(index >= 0, ERR_NOT_STARTED, "Switch Adapter Capture Fail");
1224 adapterDesc_ = descs[index];
1225
1226 if (audioAdapter_ == nullptr) {
1227 struct IAudioAdapter *iAudioAdapter = nullptr;
1228 int32_t loadAdapter = audioManager_->LoadAdapter(audioManager_, &adapterDesc_, &iAudioAdapter);
1229 CHECK_AND_RETURN_RET_LOG(loadAdapter == 0, ERR_NOT_STARTED, "Load Adapter Fail");
1230 CHECK_AND_RETURN_RET_LOG(iAudioAdapter != nullptr, ERR_NOT_STARTED, "Load audio device failed");
1231
1232 // Inittialization port information, can fill through mode and other parameters
1233 int32_t initAllPorts = iAudioAdapter->InitAllPorts(iAudioAdapter);
1234 CHECK_AND_RETURN_RET_LOG(initAllPorts == 0, ERR_DEVICE_INIT, "InitAllPorts failed");
1235 audioAdapter_ = iAudioAdapter;
1236 adapterLoaded_ = true;
1237 }
1238 return SUCCESS;
1239 }
1240
InitAdapterAndCapture()1241 int32_t AudioCapturerSourceInner::InitAdapterAndCapture()
1242 {
1243 AUDIO_INFO_LOG("Init adapter start sourceName %{public}s", halName_.c_str());
1244
1245 if (captureInited_) {
1246 AUDIO_INFO_LOG("Adapter already inited");
1247 return SUCCESS;
1248 }
1249
1250 int32_t err = InitManagerAndAdapter();
1251 CHECK_AND_RETURN_RET_LOG(err == 0, err, "Init audio manager and adapater failed");
1252
1253 int32_t createCapture = CreateCapture(audioPort_);
1254 CHECK_AND_RETURN_RET_LOG(createCapture == 0, ERR_NOT_STARTED, "Create capture failed");
1255 if (openMic_) {
1256 int32_t ret;
1257 AudioPortPin inputPortPin = PIN_IN_MIC;
1258 if (halName_ == "usb") {
1259 ret = SetInputRoute(DEVICE_TYPE_USB_ARM_HEADSET, inputPortPin);
1260 } else {
1261 ret = SetInputRoute(DEVICE_TYPE_MIC, inputPortPin);
1262 }
1263 if (ret < 0) {
1264 AUDIO_WARNING_LOG("update route FAILED: %{public}d", ret);
1265 }
1266 }
1267
1268 captureInited_ = true;
1269
1270 return SUCCESS;
1271 }
1272
GetAudioParameter(const AudioParamKey key,const std::string & condition)1273 std::string AudioCapturerSourceInner::GetAudioParameter(const AudioParamKey key,
1274 const std::string &condition)
1275 {
1276 AUDIO_WARNING_LOG("not supported yet");
1277 return "";
1278 }
1279
InitLatencyMeasurement()1280 void AudioCapturerSourceInner::InitLatencyMeasurement()
1281 {
1282 std::lock_guard<std::mutex> lock(signalDetectAgentMutex_);
1283
1284 if (!AudioLatencyMeasurement::CheckIfEnabled()) {
1285 return;
1286 }
1287 signalDetectAgent_ = std::make_shared<SignalDetectAgent>();
1288 CHECK_AND_RETURN_LOG(signalDetectAgent_ != nullptr, "LatencyMeas signalDetectAgent_ is nullptr");
1289 signalDetectAgent_->sampleFormat_ = attr_.format;
1290 signalDetectAgent_->formatByteSize_ = GetFormatByteSize(attr_.format);
1291 latencyMeasEnabled_ = true;
1292 }
1293
DeinitLatencyMeasurement()1294 void AudioCapturerSourceInner::DeinitLatencyMeasurement()
1295 {
1296 std::lock_guard<std::mutex> lock(signalDetectAgentMutex_);
1297
1298 signalDetected_ = false;
1299 signalDetectAgent_ = nullptr;
1300 }
1301
CheckLatencySignal(uint8_t * frame,size_t replyBytes)1302 void AudioCapturerSourceInner::CheckLatencySignal(uint8_t *frame, size_t replyBytes)
1303 {
1304 std::lock_guard<std::mutex> lock(signalDetectAgentMutex_);
1305 if (!latencyMeasEnabled_) {
1306 return;
1307 }
1308 CHECK_AND_RETURN_LOG(signalDetectAgent_ != nullptr, "LatencyMeas signalDetectAgent_ is nullptr");
1309 signalDetected_ = signalDetectAgent_->CheckAudioData(frame, replyBytes);
1310 if (signalDetected_) {
1311 char value[GET_EXTRA_PARAM_LEN];
1312 AudioParamKey key = NONE;
1313 AudioExtParamKey hdiKey = AudioExtParamKey(key);
1314 std::string condition = "debug_audio_latency_measurement";
1315 int32_t ret = audioAdapter_->GetExtraParams(audioAdapter_, hdiKey, condition.c_str(),
1316 value, PARAM_VALUE_LENTH);
1317 AUDIO_INFO_LOG("GetExtraParam ret:%{public}d", ret);
1318 LatencyMonitor::GetInstance().UpdateDspTime(value);
1319 LatencyMonitor::GetInstance().UpdateSinkOrSourceTime(false,
1320 signalDetectAgent_->lastPeakBufferTime_);
1321 AUDIO_INFO_LOG("LatencyMeas primarySource signal detected");
1322 signalDetected_ = false;
1323 }
1324 }
1325
UpdateAppsUid(const int32_t appsUid[PA_MAX_OUTPUTS_PER_SOURCE],const size_t size)1326 int32_t AudioCapturerSourceInner::UpdateAppsUid(const int32_t appsUid[PA_MAX_OUTPUTS_PER_SOURCE],
1327 const size_t size)
1328 {
1329 #ifdef FEATURE_POWER_MANAGER
1330 if (!runningLockManager_) {
1331 return ERROR;
1332 }
1333
1334 runningLockManager_->UpdateAppsUid(appsUid, appsUid + size);
1335 runningLockManager_->UpdateAppsUidToPowerMgr();
1336 #endif
1337
1338 return SUCCESS;
1339 }
1340
UpdateAppsUid(const std::vector<int32_t> & appsUid)1341 int32_t AudioCapturerSourceInner::UpdateAppsUid(const std::vector<int32_t> &appsUid)
1342 {
1343 #ifdef FEATURE_POWER_MANAGER
1344 if (!runningLockManager_) {
1345 return ERROR;
1346 }
1347
1348 runningLockManager_->UpdateAppsUid(appsUid.cbegin(), appsUid.cend());
1349 runningLockManager_->UpdateAppsUidToPowerMgr();
1350 #endif
1351
1352 return SUCCESS;
1353 }
1354
UpdateSourceType(SourceType sourceType)1355 int32_t AudioCapturerSourceInner::UpdateSourceType(SourceType sourceType)
1356 {
1357 std::lock_guard<std::mutex> lock(statusMutex_);
1358 if (attr_.sourceType == sourceType) {
1359 AUDIO_INFO_LOG("input sourceType not change. currentActiveDevice %{public}d sourceType %{public}d",
1360 currentActiveDevice_, attr_.sourceType);
1361 return SUCCESS;
1362 }
1363
1364 attr_.sourceType = sourceType;
1365 AudioPortPin inputPortPin = PIN_IN_MIC;
1366 return DoSetInputRoute(currentActiveDevice_, inputPortPin);
1367 }
1368
Init(const IAudioSourceAttr & attr)1369 int32_t AudioCapturerSourceWakeup::Init(const IAudioSourceAttr &attr)
1370 {
1371 std::lock_guard<std::mutex> lock(wakeupMutex_);
1372 int32_t res = SUCCESS;
1373 if (isInited) {
1374 return res;
1375 }
1376 noStart_ = 0;
1377 if (initCount == 0) {
1378 if (wakeupBuffer_ == nullptr) {
1379 wakeupBuffer_ = std::make_unique<WakeupBuffer>();
1380 }
1381 res = audioCapturerSource_.Init(attr);
1382 }
1383 if (res == SUCCESS) {
1384 isInited = true;
1385 initCount++;
1386 }
1387 return res;
1388 }
1389
IsInited(void)1390 bool AudioCapturerSourceWakeup::IsInited(void)
1391 {
1392 return isInited;
1393 }
1394
DeInit(void)1395 void AudioCapturerSourceWakeup::DeInit(void)
1396 {
1397 AudioXCollie wakeupXCollie("AudioCapturerSourceWakeup::DeInit", DEINIT_TIME_OUT_SECONDS);
1398 AUDIO_INFO_LOG("Start deinit of source wakeup");
1399 std::lock_guard<std::mutex> lock(wakeupMutex_);
1400 if (!isInited) {
1401 return;
1402 }
1403 isInited = false;
1404 initCount--;
1405 if (initCount == 0) {
1406 wakeupBuffer_.reset();
1407 audioCapturerSource_.DeInit();
1408 }
1409 }
1410
Start(void)1411 int32_t AudioCapturerSourceWakeup::Start(void)
1412 {
1413 std::lock_guard<std::mutex> lock(wakeupMutex_);
1414 int32_t res = SUCCESS;
1415 if (isStarted) {
1416 return res;
1417 }
1418 if (startCount == 0) {
1419 res = audioCapturerSource_.Start();
1420 }
1421 if (res == SUCCESS) {
1422 isStarted = true;
1423 startCount++;
1424 }
1425 return res;
1426 }
1427
Stop(void)1428 int32_t AudioCapturerSourceWakeup::Stop(void)
1429 {
1430 std::lock_guard<std::mutex> lock(wakeupMutex_);
1431 int32_t res = SUCCESS;
1432 if (!isStarted) {
1433 return res;
1434 }
1435 if (startCount == 1) {
1436 res = audioCapturerSource_.Stop();
1437 }
1438 if (res == SUCCESS) {
1439 isStarted = false;
1440 startCount--;
1441 }
1442 return res;
1443 }
1444
Flush(void)1445 int32_t AudioCapturerSourceWakeup::Flush(void)
1446 {
1447 return audioCapturerSource_.Flush();
1448 }
1449
Reset(void)1450 int32_t AudioCapturerSourceWakeup::Reset(void)
1451 {
1452 return audioCapturerSource_.Reset();
1453 }
1454
Pause(void)1455 int32_t AudioCapturerSourceWakeup::Pause(void)
1456 {
1457 return audioCapturerSource_.Pause();
1458 }
1459
Resume(void)1460 int32_t AudioCapturerSourceWakeup::Resume(void)
1461 {
1462 return audioCapturerSource_.Resume();
1463 }
1464
CaptureFrame(char * frame,uint64_t requestBytes,uint64_t & replyBytes)1465 int32_t AudioCapturerSourceWakeup::CaptureFrame(char *frame, uint64_t requestBytes, uint64_t &replyBytes)
1466 {
1467 int32_t res = wakeupBuffer_->Poll(frame, requestBytes, replyBytes, noStart_);
1468 noStart_ += replyBytes;
1469 return res;
1470 }
1471
SetVolume(float left,float right)1472 int32_t AudioCapturerSourceWakeup::SetVolume(float left, float right)
1473 {
1474 return audioCapturerSource_.SetVolume(left, right);
1475 }
1476
GetVolume(float & left,float & right)1477 int32_t AudioCapturerSourceWakeup::GetVolume(float &left, float &right)
1478 {
1479 return audioCapturerSource_.GetVolume(left, right);
1480 }
1481
SetMute(bool isMute)1482 int32_t AudioCapturerSourceWakeup::SetMute(bool isMute)
1483 {
1484 return audioCapturerSource_.SetMute(isMute);
1485 }
1486
GetMute(bool & isMute)1487 int32_t AudioCapturerSourceWakeup::GetMute(bool &isMute)
1488 {
1489 return audioCapturerSource_.GetMute(isMute);
1490 }
1491
SetAudioScene(AudioScene audioScene,DeviceType activeDevice)1492 int32_t AudioCapturerSourceWakeup::SetAudioScene(AudioScene audioScene, DeviceType activeDevice)
1493 {
1494 return audioCapturerSource_.SetAudioScene(audioScene, activeDevice);
1495 }
1496
SetInputRoute(DeviceType inputDevice)1497 int32_t AudioCapturerSourceWakeup::SetInputRoute(DeviceType inputDevice)
1498 {
1499 return audioCapturerSource_.SetInputRoute(inputDevice);
1500 }
1501
GetTransactionId()1502 uint64_t AudioCapturerSourceWakeup::GetTransactionId()
1503 {
1504 return audioCapturerSource_.GetTransactionId();
1505 }
1506
GetPresentationPosition(uint64_t & frames,int64_t & timeSec,int64_t & timeNanoSec)1507 int32_t AudioCapturerSourceWakeup::GetPresentationPosition(uint64_t& frames, int64_t& timeSec, int64_t& timeNanoSec)
1508 {
1509 return audioCapturerSource_.GetPresentationPosition(frames, timeSec, timeNanoSec);
1510 }
1511
GetAudioParameter(const AudioParamKey key,const std::string & condition)1512 std::string AudioCapturerSourceWakeup::GetAudioParameter(const AudioParamKey key,
1513 const std::string &condition)
1514 {
1515 AUDIO_WARNING_LOG("not supported yet");
1516 return "";
1517 }
1518
RegisterWakeupCloseCallback(IAudioSourceCallback * callback)1519 void AudioCapturerSourceWakeup::RegisterWakeupCloseCallback(IAudioSourceCallback *callback)
1520 {
1521 audioCapturerSource_.RegisterWakeupCloseCallback(callback);
1522 }
1523
RegisterAudioCapturerSourceCallback(std::unique_ptr<ICapturerStateCallback> callback)1524 void AudioCapturerSourceWakeup::RegisterAudioCapturerSourceCallback(std::unique_ptr<ICapturerStateCallback> callback)
1525 {
1526 audioCapturerSource_.RegisterAudioCapturerSourceCallback(std::move(callback));
1527 }
1528
RegisterParameterCallback(IAudioSourceCallback * callback)1529 void AudioCapturerSourceWakeup::RegisterParameterCallback(IAudioSourceCallback *callback)
1530 {
1531 AUDIO_WARNING_LOG("AudioCapturerSourceWakeup: RegisterParameterCallback is not supported!");
1532 }
1533
GetMaxAmplitude()1534 float AudioCapturerSourceWakeup::GetMaxAmplitude()
1535 {
1536 return audioCapturerSource_.GetMaxAmplitude();
1537 }
1538
UpdateAppsUid(const int32_t appsUid[PA_MAX_OUTPUTS_PER_SOURCE],const size_t size)1539 int32_t AudioCapturerSourceWakeup::UpdateAppsUid(const int32_t appsUid[PA_MAX_OUTPUTS_PER_SOURCE],
1540 const size_t size)
1541 {
1542 return audioCapturerSource_.UpdateAppsUid(appsUid, size);
1543 }
1544
UpdateAppsUid(const std::vector<int32_t> & appsUid)1545 int32_t AudioCapturerSourceWakeup::UpdateAppsUid(const std::vector<int32_t> &appsUid)
1546 {
1547 return audioCapturerSource_.UpdateAppsUid(appsUid);
1548 }
1549 } // namespace AudioStandard
1550 } // namesapce OHOS
1551