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