1 /*
2 * Copyright (c) 2021-2025 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15 #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 #include <vector>
28
29 #include "securec.h"
30 #ifdef FEATURE_POWER_MANAGER
31 #include "power_mgr_client.h"
32 #include "running_lock.h"
33 #include "audio_running_lock_manager.h"
34 #endif
35 #include "v4_0/iaudio_manager.h"
36
37 #include "audio_hdi_log.h"
38 #include "audio_errors.h"
39 #include "volume_tools.h"
40 #include "audio_schedule.h"
41 #include "audio_utils.h"
42 #include "parameters.h"
43 #include "media_monitor_manager.h"
44 #include "audio_enhance_chain_manager.h"
45 #include "hdi_utils_ringbuffer.h"
46 #include "audio_dump_pcm.h"
47
48 namespace OHOS {
49 namespace AudioStandard {
50 namespace {
51 const int64_t SECOND_TO_NANOSECOND = 1000000000;
52 const unsigned int DEINIT_TIME_OUT_SECONDS = 5;
53 const uint16_t GET_MAX_AMPLITUDE_FRAMES_THRESHOLD = 10;
54 const int32_t BYTE_SIZE_SAMPLE_U8 = 1;
55 const int32_t BYTE_SIZE_SAMPLE_S16 = 2;
56 const int32_t BYTE_SIZE_SAMPLE_S24 = 3;
57 const int32_t BYTE_SIZE_SAMPLE_S32 = 4;
58 const uint32_t FRAME_TIME_LEN_MS = 20; // 20ms
59 const uint32_t MILLISECONDS_PER_SECOND_MS = 1000;
60 } // namespace
61
GetByteSizeByFormat(HdiAdapterFormat format)62 static int32_t GetByteSizeByFormat(HdiAdapterFormat format)
63 {
64 int32_t byteSize = 0;
65 switch (format) {
66 case SAMPLE_U8:
67 byteSize = BYTE_SIZE_SAMPLE_U8;
68 break;
69 case SAMPLE_S16:
70 byteSize = BYTE_SIZE_SAMPLE_S16;
71 break;
72 case SAMPLE_S24:
73 byteSize = BYTE_SIZE_SAMPLE_S24;
74 break;
75 case SAMPLE_S32:
76 byteSize = BYTE_SIZE_SAMPLE_S32;
77 break;
78 default:
79 byteSize = BYTE_SIZE_SAMPLE_S16;
80 break;
81 }
82
83 return byteSize;
84 }
85
IsNonblockingSource(int32_t source,const std::string & adapterName)86 static bool IsNonblockingSource(int32_t source, const std::string &adapterName)
87 {
88 return (source == SOURCE_TYPE_EC && adapterName != "dp") || (source == SOURCE_TYPE_MIC_REF);
89 }
90
GenerateUniqueIDBySource(int32_t source)91 static uint32_t GenerateUniqueIDBySource(int32_t source)
92 {
93 uint32_t sourceId = 0;
94 switch (source) {
95 case SOURCE_TYPE_EC:
96 sourceId = GenerateUniqueID(AUDIO_HDI_CAPTURE_ID_BASE, HDI_CAPTURE_OFFSET_EC);
97 break;
98 case SOURCE_TYPE_MIC_REF:
99 sourceId = GenerateUniqueID(AUDIO_HDI_CAPTURE_ID_BASE, HDI_CAPTURE_OFFSET_MIC_REF);
100 break;
101 case SOURCE_TYPE_WAKEUP:
102 sourceId = GenerateUniqueID(AUDIO_HDI_CAPTURE_ID_BASE, HDI_CAPTURE_OFFSET_WAKEUP);
103 break;
104 default:
105 sourceId = GenerateUniqueID(AUDIO_HDI_CAPTURE_ID_BASE, HDI_CAPTURE_OFFSET_PRIMARY);
106 break;
107 }
108 return sourceId;
109 }
110
GetChannelLayoutByCount(uint32_t channlCount)111 static uint64_t GetChannelLayoutByCount(uint32_t channlCount)
112 {
113 uint64_t channelLayout = 0;
114 switch (channlCount) {
115 case MONO:
116 channelLayout = CH_LAYOUT_MONO;
117 break;
118 case STEREO:
119 channelLayout = CH_LAYOUT_STEREO;
120 break;
121 case CHANNEL_4:
122 channelLayout = CH_LAYOUT_QUAD;
123 break;
124 case CHANNEL_8:
125 channelLayout = CH_LAYOUT_7POINT1;
126 break;
127 default:
128 channelLayout = CH_LAYOUT_STEREO;
129 break;
130 }
131 return channelLayout;
132 }
133
134 // inner class definations
135 class AudioCapturerSourceInner : public AudioCapturerSource {
136 public:
137 int32_t Init(const IAudioSourceAttr &attr) override;
138 int32_t InitWithoutAttr() override;
139 bool IsInited(void) override;
140 void DeInit(void) override;
141
142 int32_t Start(void) override;
143 int32_t Stop(void) override;
144 int32_t Flush(void) override;
145 int32_t Reset(void) override;
146 int32_t Pause(void) override;
147 int32_t Resume(void) override;
148 int32_t CaptureFrame(char *frame, uint64_t requestBytes, uint64_t &replyBytes) override;
149 int32_t CaptureFrameWithEc(
150 FrameDesc *fdesc, uint64_t &replyBytes,
151 FrameDesc *fdescEc, uint64_t &replyBytesEc) override;
152 int32_t SetVolume(float left, float right) override;
153 int32_t GetVolume(float &left, float &right) override;
154 int32_t SetMute(bool isMute) override;
155 int32_t GetMute(bool &isMute) override;
156
157 int32_t SetAudioScene(AudioScene audioScene, DeviceType activeDevice, const std::string &deviceName = "") override;
158
159 int32_t SetInputRoute(DeviceType inputDevice, const std::string &deviceName = "") override;
160 uint64_t GetTransactionId() override;
161 std::string GetAudioParameter(const AudioParamKey key, const std::string &condition) override;
162
163 int32_t GetPresentationPosition(uint64_t& frames, int64_t& timeSec, int64_t& timeNanoSec) override;
164
165 void RegisterWakeupCloseCallback(IAudioSourceCallback *callback) override;
166 void RegisterAudioCapturerSourceCallback(std::unique_ptr<ICapturerStateCallback> callback) override;
167 void RegisterParameterCallback(IAudioSourceCallback *callback) override;
168
169 int32_t Preload(const std::string &usbInfoStr) override;
170 float GetMaxAmplitude() override;
171 int32_t GetCaptureId(uint32_t &captureId) const override;
172
173 int32_t UpdateAppsUid(const int32_t appsUid[PA_MAX_OUTPUTS_PER_SOURCE],
174 const size_t size) final;
175 int32_t UpdateAppsUid(const std::vector<int32_t> &appsUid) final;
176
177 int32_t UpdateSourceType(SourceType sourceType) final;
178
179 void SetAddress(const std::string &address) override;
180
181 explicit AudioCapturerSourceInner(const std::string &halName = "primary");
182 explicit AudioCapturerSourceInner(CaptureAttr *attr);
183 ~AudioCapturerSourceInner();
184
185 private:
186 static constexpr int32_t HALF_FACTOR = 2;
187 static constexpr uint32_t MAX_AUDIO_ADAPTER_NUM = 5;
188 static constexpr float MAX_VOLUME_LEVEL = 15.0f;
189 static constexpr uint32_t USB_DEFAULT_BUFFERSIZE = 3840;
190 static constexpr uint32_t STEREO_CHANNEL_COUNT = 2;
191
192 int32_t CreateCapture(struct AudioPort &capturePort);
193 int32_t InitAudioManager();
194 void SetEcSampleAttributes(struct AudioSampleAttributes &attrs);
195 void InitAttrsCapture(struct AudioSampleAttributes &attrs);
196 AudioFormat ConvertToHdiFormat(HdiAdapterFormat format);
197
198 int32_t UpdateUsbAttrs(const std::string &usbInfoStr);
199 int32_t InitManagerAndAdapter();
200 int32_t InitAdapterAndCapture();
201
202 void InitLatencyMeasurement();
203 void DeinitLatencyMeasurement();
204 void CheckLatencySignal(uint8_t *frame, size_t replyBytes);
205
206 void CheckUpdateState(char *frame, uint64_t replyBytes);
207 int32_t SetAudioRouteInfoForEnhanceChain(const DeviceType &inputDevice, const std::string &deviceName = "");
208 int32_t SetInputRoute(DeviceType inputDevice, AudioPortPin &inputPortPin, const std::string &deviceName = "");
209 int32_t DoSetInputRoute(DeviceType inputDevice, AudioPortPin &inputPortPin, const std::string &deviceName = "");
210
211 void CaptureThreadLoop();
212 void CaptureFrameEcInternal(std::vector<uint8_t> &ecData);
213 int32_t ProcessCaptureBlockingEc(FrameDesc *fdescEc, uint64_t &replyBytesEc);
214 int32_t StartNonblockingCapture();
215 int32_t StopNonblockingCapture();
216 void DumpCapturerSourceData(char *frame, uint64_t &replyBytes);
217
218 int32_t DoStop();
219 int32_t StartCapture();
220
221 bool GetMuteState();
222 void SetMuteState(bool isMute);
223
224 CaptureAttr *hdiAttr_ = nullptr;
225 IAudioSourceAttr attr_ = {};
226 bool sourceInited_ = false;
227 bool captureInited_ = false;
228 bool started_ = false;
229 bool paused_ = false;
230 float leftVolume_ = 0.0f;
231 float rightVolume_ = 0.0f;
232
233 int32_t routeHandle_ = -1;
234 int32_t logMode_ = 0;
235 uint32_t openMic_ = 0;
236 uint32_t captureId_ = 0;
237 std::string adapterNameCase_ = "";
238 mutable int64_t volumeDataCount_ = 0;
239 std::string logUtilsTag_ = "AudioSource";
240
241 // for get amplitude
242 float maxAmplitude_ = 0;
243 int64_t lastGetMaxAmplitudeTime_ = 0;
244 int64_t last10FrameStartTime_ = 0;
245 bool startUpdate_ = false;
246 int capFrameNum_ = 0;
247
248 struct IAudioManager *audioManager_ = nullptr;
249 std::atomic<bool> adapterLoaded_ = false;
250 struct IAudioAdapter *audioAdapter_ = nullptr;
251 struct IAudioCapture *audioCapture_ = nullptr;
252 std::string halName_ = "";
253 struct AudioAdapterDescriptor adapterDesc_ = {};
254 struct AudioPort audioPort_ = {};
255 #ifdef FEATURE_POWER_MANAGER
256 std::shared_ptr<AudioRunningLockManager<PowerMgr::RunningLock>> runningLockManager_;
257 #endif
258 IAudioSourceCallback* wakeupCloseCallback_ = nullptr;
259 std::mutex wakeupClosecallbackMutex_;
260
261 std::unique_ptr<ICapturerStateCallback> audioCapturerSourceCallback_ = nullptr;
262 FILE *dumpFile_ = nullptr;
263 std::string dumpFileName_ = "";
264 std::mutex muteStateMutex_;
265 bool muteState_ = false;
266 DeviceType currentActiveDevice_ = DEVICE_TYPE_INVALID;
267 AudioScene currentAudioScene_ = AUDIO_SCENE_INVALID;
268 bool latencyMeasEnabled_ = false;
269 bool signalDetected_ = false;
270 std::shared_ptr<SignalDetectAgent> signalDetectAgent_ = nullptr;
271 std::mutex signalDetectAgentMutex_;
272
273 std::mutex statusMutex_;
274
275 // ec and mic ref feature
276 std::unique_ptr<std::thread> captureThread_ = nullptr;
277 bool threadRunning_ = false;
278 std::shared_ptr<HdiRingBuffer> ringBuffer_ = nullptr;
279
280 std::string address_;
281 };
282
283 class AudioCapturerSourceWakeup : public AudioCapturerSource {
284 public:
285 int32_t Init(const IAudioSourceAttr &attr) override;
286 bool IsInited(void) override;
287 void DeInit(void) override;
288
289 int32_t Start(void) override;
290 int32_t Stop(void) override;
291 int32_t Flush(void) override;
292 int32_t Reset(void) override;
293 int32_t Pause(void) override;
294 int32_t Resume(void) override;
295 int32_t CaptureFrame(char *frame, uint64_t requestBytes, uint64_t &replyBytes) override;
296 int32_t CaptureFrameWithEc(
297 FrameDesc *fdesc, uint64_t &replyBytes,
298 FrameDesc *fdescEc, uint64_t &replyBytesEc) override;
299 int32_t SetVolume(float left, float right) override;
300 int32_t GetVolume(float &left, float &right) override;
301 int32_t SetMute(bool isMute) override;
302 int32_t GetMute(bool &isMute) override;
303
304 int32_t SetAudioScene(AudioScene audioScene, DeviceType activeDevice, const std::string &deviceName = "") override;
305
306 int32_t SetInputRoute(DeviceType inputDevice, const std::string &deviceName = "") override;
307 uint64_t GetTransactionId() override;
308 int32_t GetPresentationPosition(uint64_t& frames, int64_t& timeSec, int64_t& timeNanoSec) override;
309 std::string GetAudioParameter(const AudioParamKey key, const std::string &condition) override;
310
311 void RegisterWakeupCloseCallback(IAudioSourceCallback *callback) override;
312 void RegisterAudioCapturerSourceCallback(std::unique_ptr<ICapturerStateCallback> callback) override;
313 void RegisterParameterCallback(IAudioSourceCallback *callback) override;
314 float GetMaxAmplitude() override;
315 int32_t GetCaptureId(uint32_t &captureId) const override;
316
317 int32_t UpdateAppsUid(const int32_t appsUid[PA_MAX_OUTPUTS_PER_SOURCE],
318 const size_t size) final;
319 int32_t UpdateAppsUid(const std::vector<int32_t> &appsUid) final;
320
321 AudioCapturerSourceWakeup() = default;
322 ~AudioCapturerSourceWakeup() = default;
323
324 private:
MemcpysAndCheck(void * dest,size_t destMax,const void * src,size_t count)325 static inline void MemcpysAndCheck(void *dest, size_t destMax, const void *src, size_t count)
326 {
327 if (memcpy_s(dest, destMax, src, count)) {
328 AUDIO_ERR_LOG("memcpy_s error");
329 }
330 }
331 class WakeupBuffer {
332 public:
WakeupBuffer(size_t sizeMax=BUFFER_SIZE_MAX)333 explicit WakeupBuffer(size_t sizeMax = BUFFER_SIZE_MAX)
334 : sizeMax_(sizeMax),
335 buffer_(std::make_unique<char[]>(sizeMax))
336 {
337 }
338
339 ~WakeupBuffer() = default;
340
Poll(char * frame,uint64_t requestBytes,uint64_t & replyBytes,uint64_t & noStart)341 int32_t Poll(char *frame, uint64_t requestBytes, uint64_t &replyBytes, uint64_t &noStart)
342 {
343 std::lock_guard<std::mutex> lock(mutex_);
344
345 if (noStart < headNum_) {
346 noStart = headNum_;
347 }
348
349 if (noStart >= (headNum_ + size_)) {
350 if (requestBytes > sizeMax_) {
351 requestBytes = sizeMax_;
352 }
353
354 int32_t res = audioCapturerSource_.CaptureFrame(frame, requestBytes, replyBytes);
355 Offer(frame, replyBytes);
356
357 return res;
358 }
359
360 if (requestBytes > size_) { // size_!=0
361 replyBytes = size_;
362 } else {
363 replyBytes = requestBytes;
364 }
365
366 uint64_t tail = (head_ + size_) % sizeMax_;
367
368 if (tail > head_) {
369 MemcpysAndCheck(frame, replyBytes, buffer_.get() + head_, replyBytes);
370 headNum_ += replyBytes;
371 size_ -= replyBytes;
372 head_ = (head_ + replyBytes) % sizeMax_;
373 } else {
374 uint64_t copySize = std::min((sizeMax_ - head_), replyBytes);
375 if (copySize != 0) {
376 MemcpysAndCheck(frame, replyBytes, buffer_.get() + head_, copySize);
377 headNum_ += copySize;
378 size_ -= copySize;
379 head_ = (head_ + copySize) % sizeMax_;
380 }
381
382 uint64_t remainCopySize = replyBytes - copySize;
383 if (remainCopySize != 0) {
384 MemcpysAndCheck(frame + copySize, remainCopySize, buffer_.get(), remainCopySize);
385 headNum_ += remainCopySize;
386 size_ -= remainCopySize;
387 head_ = (head_ + remainCopySize) % sizeMax_;
388 }
389 }
390
391 return SUCCESS;
392 }
393 private:
394 static constexpr size_t BUFFER_SIZE_MAX = 32000; // 2 seconds
395
396 const size_t sizeMax_;
397 size_t size_ = 0;
398
399 std::unique_ptr<char[]> buffer_;
400 std::mutex mutex_;
401
402 uint64_t head_ = 0;
403
404 uint64_t headNum_ = 0;
405
Offer(const char * frame,const uint64_t bufferBytes)406 void Offer(const char *frame, const uint64_t bufferBytes)
407 {
408 if ((size_ + bufferBytes) > sizeMax_) { // head_ need shift
409 u_int64_t shift = (size_ + bufferBytes) - sizeMax_; // 1 to sizeMax_
410 headNum_ += shift;
411 if (size_ > shift) {
412 size_ -= shift;
413 head_ = ((head_ + shift) % sizeMax_);
414 } else {
415 size_ = 0;
416 head_ = 0;
417 }
418 }
419
420 uint64_t tail = (head_ + size_) % sizeMax_;
421 if (tail < head_) {
422 MemcpysAndCheck((buffer_.get() + tail), bufferBytes, frame, bufferBytes);
423 } else {
424 uint64_t copySize = std::min(sizeMax_ - tail, bufferBytes);
425 MemcpysAndCheck((buffer_.get() + tail), sizeMax_ - tail, frame, copySize);
426
427 if (copySize < bufferBytes) {
428 MemcpysAndCheck((buffer_.get()), bufferBytes - copySize, frame + copySize, bufferBytes - copySize);
429 }
430 }
431 size_ += bufferBytes;
432 }
433 };
434
435 uint64_t noStart_ = 0;
436 std::atomic<bool> isInited = false;
437 static inline int initCount = 0;
438
439 std::atomic<bool> isStarted = false;
440 static inline int startCount = 0;
441
442 static inline std::unique_ptr<WakeupBuffer> wakeupBuffer_;
443 static inline std::mutex wakeupMutex_;
444
445 static inline AudioCapturerSourceInner audioCapturerSource_;
446 };
447 #ifdef FEATURE_POWER_MANAGER
448 constexpr int32_t RUNNINGLOCK_LOCK_TIMEOUTMS_LASTING = -1;
449 #endif
450
AudioCapturerSourceInner(const std::string & halName)451 AudioCapturerSourceInner::AudioCapturerSourceInner(const std::string &halName)
452 : sourceInited_(false), captureInited_(false), started_(false), paused_(false),
453 leftVolume_(MAX_VOLUME_LEVEL), rightVolume_(MAX_VOLUME_LEVEL), openMic_(0),
454 audioManager_(nullptr), audioAdapter_(nullptr), audioCapture_(nullptr), halName_(halName)
455 {
456 attr_ = {};
457 }
458
AudioCapturerSourceInner(CaptureAttr * attr)459 AudioCapturerSourceInner::AudioCapturerSourceInner(CaptureAttr *attr)
460 : sourceInited_(false), captureInited_(false), started_(false), paused_(false),
461 leftVolume_(MAX_VOLUME_LEVEL), rightVolume_(MAX_VOLUME_LEVEL), openMic_(0),
462 audioManager_(nullptr), audioAdapter_(nullptr), audioCapture_(nullptr), halName_("primary")
463 {
464 hdiAttr_ = attr;
465 attr_ = {};
466 }
467
~AudioCapturerSourceInner()468 AudioCapturerSourceInner::~AudioCapturerSourceInner()
469 {
470 AUDIO_WARNING_LOG("~AudioCapturerSourceInner");
471 AUDIO_INFO_LOG("[%{public}s] volume data counts: %{public}" PRId64, logUtilsTag_.c_str(), volumeDataCount_);
472
473 threadRunning_ = false;
474 if (hdiAttr_ != nullptr) {
475 free(hdiAttr_);
476 hdiAttr_ = nullptr;
477 }
478 }
479
Create(CaptureAttr * attr)480 AudioCapturerSource *AudioCapturerSource::Create(CaptureAttr *attr)
481 {
482 AudioCapturerSource *captureSource = new AudioCapturerSourceInner(attr);
483 return captureSource;
484 }
485
GetInstance(const std::string & halName,const SourceType sourceType,const char * sourceName)486 AudioCapturerSource *AudioCapturerSource::GetInstance(const std::string &halName,
487 const SourceType sourceType, const char *sourceName)
488 {
489 Trace trace("AudioCapturerSourceInner:GetInstance");
490 if (halName == "usb") {
491 static AudioCapturerSourceInner audioCapturerUsb(halName);
492 return &audioCapturerUsb;
493 }
494
495 switch (sourceType) {
496 case SourceType::SOURCE_TYPE_MIC:
497 case SourceType::SOURCE_TYPE_VOICE_CALL:
498 case SourceType::SOURCE_TYPE_CAMCORDER:
499 case SourceType::SOURCE_TYPE_UNPROCESSED:
500 return GetMicInstance();
501 case SourceType::SOURCE_TYPE_WAKEUP:
502 if (!strcmp(sourceName, "Built_in_wakeup_mirror")) {
503 return GetWakeupInstance(true);
504 } else {
505 return GetWakeupInstance(false);
506 }
507 default:
508 AUDIO_ERR_LOG("sourceType error %{public}d", sourceType);
509 return GetMicInstance();
510 }
511 }
512
ConvertToHDIAudioInputType(const int32_t currSourceType)513 static enum AudioInputType ConvertToHDIAudioInputType(const int32_t currSourceType)
514 {
515 enum AudioInputType hdiAudioInputType;
516 switch (currSourceType) {
517 case SOURCE_TYPE_INVALID:
518 hdiAudioInputType = AUDIO_INPUT_DEFAULT_TYPE;
519 break;
520 case SOURCE_TYPE_MIC:
521 case SOURCE_TYPE_PLAYBACK_CAPTURE:
522 case SOURCE_TYPE_ULTRASONIC:
523 hdiAudioInputType = AUDIO_INPUT_MIC_TYPE;
524 break;
525 case SOURCE_TYPE_WAKEUP:
526 hdiAudioInputType = AUDIO_INPUT_SPEECH_WAKEUP_TYPE;
527 break;
528 case SOURCE_TYPE_VOICE_TRANSCRIPTION:
529 case SOURCE_TYPE_VOICE_COMMUNICATION:
530 hdiAudioInputType = AUDIO_INPUT_VOICE_COMMUNICATION_TYPE;
531 break;
532 case SOURCE_TYPE_VOICE_RECOGNITION:
533 hdiAudioInputType = AUDIO_INPUT_VOICE_RECOGNITION_TYPE;
534 break;
535 case SOURCE_TYPE_VOICE_CALL:
536 hdiAudioInputType = AUDIO_INPUT_VOICE_CALL_TYPE;
537 break;
538 case SOURCE_TYPE_CAMCORDER:
539 hdiAudioInputType = AUDIO_INPUT_CAMCORDER_TYPE;
540 break;
541 case SOURCE_TYPE_EC:
542 hdiAudioInputType = AUDIO_INPUT_EC_TYPE;
543 break;
544 case SOURCE_TYPE_MIC_REF:
545 hdiAudioInputType = AUDIO_INPUT_NOISE_REDUCTION_TYPE;
546 break;
547 case SOURCE_TYPE_UNPROCESSED:
548 hdiAudioInputType = AUDIO_INPUT_RAW_TYPE;
549 break;
550 default:
551 hdiAudioInputType = AUDIO_INPUT_MIC_TYPE;
552 break;
553 }
554 return hdiAudioInputType;
555 }
556
GetMicInstance()557 AudioCapturerSource *AudioCapturerSource::GetMicInstance()
558 {
559 static AudioCapturerSourceInner audioCapturer;
560 return &audioCapturer;
561 }
562
GetWakeupInstance(bool isMirror)563 AudioCapturerSource *AudioCapturerSource::GetWakeupInstance(bool isMirror)
564 {
565 if (isMirror) {
566 static AudioCapturerSourceWakeup audioCapturerMirror;
567 return &audioCapturerMirror;
568 }
569 static AudioCapturerSourceWakeup audioCapturer;
570 return &audioCapturer;
571 }
572
IsInited(void)573 bool AudioCapturerSourceInner::IsInited(void)
574 {
575 return sourceInited_;
576 }
577
DeInit()578 void AudioCapturerSourceInner::DeInit()
579 {
580 std::lock_guard<std::mutex> statusLock(statusMutex_);
581 Trace trace("AudioCapturerSourceInner::DeInit");
582 AudioXCollie sourceXCollie("AudioCapturerSourceInner::DeInit", DEINIT_TIME_OUT_SECONDS);
583 AUDIO_INFO_LOG("Start deinit of source inner");
584 started_ = false;
585 sourceInited_ = false;
586
587 if (audioAdapter_ != nullptr) {
588 audioAdapter_->DestroyCapture(audioAdapter_, captureId_);
589 }
590 captureInited_ = false;
591
592 IAudioSourceCallback* callback = nullptr;
593 {
594 std::lock_guard<std::mutex> lck(wakeupClosecallbackMutex_);
595 callback = wakeupCloseCallback_;
596 }
597 if (callback != nullptr) {
598 callback->OnWakeupClose();
599 }
600
601 audioCapture_ = nullptr;
602 currentActiveDevice_ = DEVICE_TYPE_INVALID; // the current device must be rest when closing capturer.
603
604 // Only the usb hal needs to be unloadadapter at the moment.
605 if (halName_ == "usb") {
606 adapterLoaded_ = false;
607 if (audioManager_ != nullptr) {
608 audioManager_->UnloadAdapter(audioManager_, adapterDesc_.adapterName);
609 }
610 audioAdapter_ = nullptr;
611 audioManager_ = nullptr;
612 }
613
614 DumpFileUtil::CloseDumpFile(&dumpFile_);
615 }
616
InitAttrsCapture(struct AudioSampleAttributes & attrs)617 void AudioCapturerSourceInner::InitAttrsCapture(struct AudioSampleAttributes &attrs)
618 {
619 /* Initialization of audio parameters for playback */
620 attrs.format = AUDIO_FORMAT_TYPE_PCM_16_BIT;
621 attrs.channelCount = AUDIO_CHANNELCOUNT;
622 attrs.sampleRate = AUDIO_SAMPLE_RATE_48K;
623 attrs.interleaved = true;
624 attrs.streamId = static_cast<int32_t>(GenerateUniqueIDBySource(attr_.sourceType));
625 attrs.type = AUDIO_IN_MEDIA;
626 attrs.period = DEEP_BUFFER_CAPTURE_PERIOD_SIZE;
627 attrs.frameSize = PCM_16_BIT * attrs.channelCount / PCM_8_BIT;
628 attrs.isBigEndian = false;
629 attrs.isSignedData = true;
630 attrs.startThreshold = DEEP_BUFFER_CAPTURE_PERIOD_SIZE / (attrs.frameSize);
631 attrs.stopThreshold = INT_32_MAX;
632 /* 16 * 1024 */
633 attrs.silenceThreshold = AUDIO_BUFF_SIZE;
634 attrs.sourceType = SOURCE_TYPE_MIC;
635 }
636
SwitchAdapterCapture(struct AudioAdapterDescriptor * descs,uint32_t size,const std::string & adapterNameCase,enum AudioPortDirection portFlag,struct AudioPort & capturePort)637 int32_t SwitchAdapterCapture(struct AudioAdapterDescriptor *descs, uint32_t size, const std::string &adapterNameCase,
638 enum AudioPortDirection portFlag, struct AudioPort &capturePort)
639 {
640 if (descs == nullptr) {
641 return ERROR;
642 }
643
644 for (uint32_t index = 0; index < size; index++) {
645 struct AudioAdapterDescriptor *desc = &descs[index];
646 if (desc == nullptr || desc->adapterName == nullptr) {
647 continue;
648 }
649 AUDIO_INFO_LOG("size: %{public}d, adapterNameCase %{public}s, adapterName %{public}s",
650 size, adapterNameCase.c_str(), desc->adapterName);
651 if (!adapterNameCase.compare(desc->adapterName)) {
652 for (uint32_t port = 0; port < desc->portsLen; port++) {
653 // Only find out the port of out in the sound card
654 if (desc->ports[port].dir == portFlag) {
655 capturePort = desc->ports[port];
656 return index;
657 }
658 }
659 }
660 }
661 AUDIO_ERR_LOG("SwitchAdapterCapture Fail");
662
663 return ERR_INVALID_INDEX;
664 }
665
InitAudioManager()666 int32_t AudioCapturerSourceInner::InitAudioManager()
667 {
668 AUDIO_INFO_LOG("Initialize audio proxy manager");
669
670 if (audioManager_ == nullptr) {
671 audioManager_ = IAudioManagerGet(false);
672 }
673
674 if (audioManager_ == nullptr) {
675 return ERR_INVALID_HANDLE;
676 }
677
678 return 0;
679 }
680
ConvertToHdiFormat(HdiAdapterFormat format)681 AudioFormat AudioCapturerSourceInner::ConvertToHdiFormat(HdiAdapterFormat format)
682 {
683 AudioFormat hdiFormat;
684 switch (format) {
685 case SAMPLE_U8:
686 hdiFormat = AUDIO_FORMAT_TYPE_PCM_8_BIT;
687 break;
688 case SAMPLE_S16:
689 hdiFormat = AUDIO_FORMAT_TYPE_PCM_16_BIT;
690 break;
691 case SAMPLE_S24:
692 hdiFormat = AUDIO_FORMAT_TYPE_PCM_24_BIT;
693 break;
694 case SAMPLE_S32:
695 hdiFormat = AUDIO_FORMAT_TYPE_PCM_32_BIT;
696 break;
697 default:
698 hdiFormat = AUDIO_FORMAT_TYPE_PCM_16_BIT;
699 break;
700 }
701
702 return hdiFormat;
703 }
704
SetEcSampleAttributes(struct AudioSampleAttributes & attrs)705 void AudioCapturerSourceInner::SetEcSampleAttributes(struct AudioSampleAttributes &attrs)
706 {
707 attrs.ecSampleAttributes.ecInterleaved = true;
708 attrs.ecSampleAttributes.ecFormat = ConvertToHdiFormat(attr_.formatEc);
709 attrs.ecSampleAttributes.ecSampleRate = attr_.sampleRateEc;
710 attrs.ecSampleAttributes.ecChannelCount = attr_.channelEc;
711 attrs.ecSampleAttributes.ecChannelLayout = GetChannelLayoutByCount(attr_.channelEc);
712 attrs.ecSampleAttributes.ecPeriod = DEEP_BUFFER_CAPTURE_PERIOD_SIZE;
713 attrs.ecSampleAttributes.ecFrameSize = PCM_16_BIT * attrs.ecSampleAttributes.ecChannelCount / PCM_8_BIT;
714 attrs.ecSampleAttributes.ecIsBigEndian = false;
715 attrs.ecSampleAttributes.ecIsSignedData = true;
716 attrs.ecSampleAttributes.ecStartThreshold =
717 DEEP_BUFFER_CAPTURE_PERIOD_SIZE / (attrs.ecSampleAttributes.ecFrameSize);
718 attrs.ecSampleAttributes.ecStopThreshold = INT_32_MAX;
719 attrs.ecSampleAttributes.ecSilenceThreshold = AUDIO_BUFF_SIZE;
720 AUDIO_INFO_LOG("Ec config ecSampleRate: %{public}d ecChannel: %{public}u ecFormat: %{public}u",
721 attrs.ecSampleAttributes.ecSampleRate, attrs.ecSampleAttributes.ecChannelCount,
722 attrs.ecSampleAttributes.ecFormat);
723 }
724
CreateCapture(struct AudioPort & capturePort)725 int32_t AudioCapturerSourceInner::CreateCapture(struct AudioPort &capturePort)
726 {
727 Trace trace("AudioCapturerSourceInner:CreateCapture");
728
729 struct AudioSampleAttributes param;
730 // User needs to set
731 InitAttrsCapture(param);
732 param.sampleRate = attr_.sampleRate;
733 param.format = ConvertToHdiFormat(attr_.format);
734 param.isBigEndian = attr_.isBigEndian;
735 param.channelCount = attr_.channel;
736 param.channelLayout = GetChannelLayoutByCount(attr_.channel);
737 param.silenceThreshold = attr_.bufferSize;
738 param.frameSize = param.format * param.channelCount;
739 param.startThreshold = DEEP_BUFFER_CAPTURE_PERIOD_SIZE / (param.frameSize);
740 param.sourceType = static_cast<int32_t>(ConvertToHDIAudioInputType(attr_.sourceType));
741
742 if (attr_.hasEcConfig || attr_.sourceType == SOURCE_TYPE_EC) {
743 SetEcSampleAttributes(param);
744 }
745
746 struct AudioDeviceDescriptor deviceDesc;
747 deviceDesc.portId = capturePort.portId;
748 deviceDesc.pins = PIN_IN_MIC;
749 if (halName_ == "usb") {
750 deviceDesc.pins = PIN_IN_USB_HEADSET;
751 }
752 std::string desc = address_;
753 deviceDesc.desc = const_cast<char*>(desc.c_str());
754
755 AUDIO_INFO_LOG("Create capture sourceName:%{public}s, hdisource:%{public}d, " \
756 "rate:%{public}u channel:%{public}u format:%{public}u, devicePin:%{public}u desc:%{public}s",
757 halName_.c_str(), param.sourceType, param.sampleRate, param.channelCount,
758 param.format, deviceDesc.pins, deviceDesc.desc);
759 int32_t ret = audioAdapter_->CreateCapture(audioAdapter_, &deviceDesc, ¶m, &audioCapture_, &captureId_);
760 if (ret < 0 || audioCapture_ == nullptr) {
761 AUDIO_ERR_LOG("Create capture failed");
762 currentActiveDevice_ = DEVICE_TYPE_INVALID;
763 return ERR_NOT_STARTED;
764 }
765
766 return 0;
767 }
768
IsFormalSourceType(int32_t sourceType)769 static bool IsFormalSourceType(int32_t sourceType)
770 {
771 if (sourceType == SOURCE_TYPE_EC) {
772 return false;
773 }
774 if (sourceType == SOURCE_TYPE_MIC_REF) {
775 return false;
776 }
777 return true;
778 }
779
Init(const IAudioSourceAttr & attr)780 int32_t AudioCapturerSourceInner::Init(const IAudioSourceAttr &attr)
781 {
782 std::lock_guard<std::mutex> statusLock(statusMutex_);
783 attr_ = attr;
784 adapterNameCase_ = attr_.adapterName;
785 openMic_ = attr_.openMicSpeaker;
786 logMode_ = system::GetIntParameter("persist.multimedia.audiolog.switch", 0);
787
788 int32_t ret = InitAdapterAndCapture();
789 CHECK_AND_RETURN_RET_LOG(ret == SUCCESS, ret, "Init adapter and capture failed");
790
791 sourceInited_ = true;
792
793 if (GetMuteState() && IsFormalSourceType(attr_.sourceType)) {
794 SetMute(true);
795 }
796
797 return SUCCESS;
798 }
799
InitWithoutAttr()800 int32_t AudioCapturerSourceInner::InitWithoutAttr()
801 {
802 // build attr
803 IAudioSourceAttr attr = {};
804 attr.adapterName = hdiAttr_->adapterName;
805 attr.openMicSpeaker = hdiAttr_->openMicSpeaker;
806 attr.format = hdiAttr_->format;
807 attr.sampleRate = hdiAttr_->sampleRate;
808 attr.channel = hdiAttr_->channelCount;
809 attr.bufferSize = USB_DEFAULT_BUFFERSIZE;
810 attr.isBigEndian = hdiAttr_->isBigEndian;
811 attr.filePath = "";
812 attr.deviceNetworkId = "LocalDevice";
813 attr.deviceType = hdiAttr_->deviceType;
814 attr.sourceType = hdiAttr_->sourceType;
815 if (attr.sourceType == SOURCE_TYPE_EC) {
816 attr.formatEc = hdiAttr_->format;
817 attr.sampleRateEc = hdiAttr_->sampleRate;
818 attr.channelEc = hdiAttr_->channelCount;
819 }
820 Init(attr);
821
822 if (IsNonblockingSource(attr.sourceType, attr.adapterName)) {
823 ringBuffer_ = std::make_shared<HdiRingBuffer>();
824 ringBuffer_->Init(attr.sampleRate, attr.channel, GetByteSizeByFormat(attr.format));
825 }
826
827 return SUCCESS;
828 }
829
CaptureFrame(char * frame,uint64_t requestBytes,uint64_t & replyBytes)830 int32_t AudioCapturerSourceInner::CaptureFrame(char *frame, uint64_t requestBytes, uint64_t &replyBytes)
831 {
832 CHECK_AND_RETURN_RET_LOG(audioCapture_ != nullptr, ERR_INVALID_HANDLE, "Audio capture Handle is nullptr!");
833
834 Trace trace("AudioCapturerSourceInner::CaptureFrame");
835
836 // only mic ref use this
837 if (attr_.sourceType == SOURCE_TYPE_MIC_REF) {
838 if (ringBuffer_ != nullptr) {
839 Trace traceSec("CaptureRefOutput");
840 int32_t ret = ringBuffer_->ReadDataFromRingBuffer(reinterpret_cast<uint8_t *>(frame), requestBytes);
841 if (ret == SUCCESS) {
842 replyBytes = requestBytes;
843 } else {
844 AUDIO_ERR_LOG("read micRef data from ringBuffer fail");
845 replyBytes = 0;
846 }
847 }
848
849 return SUCCESS;
850 }
851
852 int64_t stamp = ClockTime::GetCurNano();
853 uint32_t frameLen = static_cast<uint32_t>(requestBytes);
854 int32_t ret = audioCapture_->CaptureFrame(audioCapture_, reinterpret_cast<int8_t*>(frame), &frameLen, &replyBytes);
855 CHECK_AND_RETURN_RET_LOG(ret >= 0, ERR_READ_FAILED, "Capture Frame Fail");
856 CheckLatencySignal(reinterpret_cast<uint8_t*>(frame), replyBytes);
857
858 DumpCapturerSourceData(frame, replyBytes);
859
860 CheckUpdateState(frame, requestBytes);
861
862 int64_t stampThreshold = 50; // 50ms
863 stamp = (ClockTime::GetCurNano() - stamp) / AUDIO_US_PER_SECOND;
864 if (logMode_ || stamp >= stampThreshold) {
865 AUDIO_WARNING_LOG("CaptureFrame len[%{public}" PRIu64 "] cost[%{public}" PRId64 "]ms", requestBytes, stamp);
866 }
867 return SUCCESS;
868 }
869
ProcessCaptureBlockingEc(FrameDesc * fdescEc,uint64_t & replyBytesEc)870 int32_t AudioCapturerSourceInner::ProcessCaptureBlockingEc(FrameDesc *fdescEc, uint64_t &replyBytesEc)
871 {
872 if (ringBuffer_ != nullptr) {
873 Trace traceSec("CaptureEcOutput");
874 int32_t ret = ringBuffer_->ReadDataFromRingBuffer(reinterpret_cast<uint8_t *>(fdescEc->frame),
875 fdescEc->frameLen);
876 if (ret == SUCCESS) {
877 replyBytesEc = fdescEc->frameLen;
878 } else {
879 AUDIO_ERR_LOG("read ec data from ringBuffer fail");
880 replyBytesEc = 0;
881 }
882 }
883
884 return SUCCESS;
885 }
886
CaptureFrameWithEc(FrameDesc * fdesc,uint64_t & replyBytes,FrameDesc * fdescEc,uint64_t & replyBytesEc)887 int32_t AudioCapturerSourceInner::CaptureFrameWithEc(FrameDesc *fdesc, uint64_t &replyBytes,
888 FrameDesc *fdescEc, uint64_t &replyBytesEc)
889 {
890 CHECK_AND_RETURN_RET_LOG(audioCapture_ != nullptr, ERR_INVALID_HANDLE, "Audio capture Handle is nullptr!");
891
892 // ec different adapter only check ec frame
893 if (attr_.sourceType != SOURCE_TYPE_EC) {
894 CHECK_AND_RETURN_RET_LOG(fdesc != nullptr && fdesc->frame != nullptr &&
895 fdescEc != nullptr && fdescEc->frame != nullptr, ERR_INVALID_PARAM, "frame desc error");
896 } else {
897 CHECK_AND_RETURN_RET_LOG(fdescEc != nullptr && fdescEc->frame != nullptr,
898 ERR_INVALID_PARAM, "frame desc error");
899 }
900
901 if (IsNonblockingSource(attr_.sourceType, adapterNameCase_)) {
902 return ProcessCaptureBlockingEc(fdescEc, replyBytesEc);
903 }
904
905 struct AudioFrameLen frameLen = {fdesc->frameLen, fdescEc->frameLen};
906 struct AudioCaptureFrameInfo frameInfo = {};
907
908 int32_t ret = audioCapture_->CaptureFrameEc(audioCapture_, &frameLen, &frameInfo);
909 if (ret < 0) {
910 AUDIO_ERR_LOG("Capture Frame with ec fail");
911 AudioCaptureFrameInfoFree(&frameInfo, false);
912 return ERR_READ_FAILED;
913 }
914
915 // same adapter reply length is mic + ec, different adapter is only ec, so we can't use reply bytes to copy
916 if (attr_.sourceType != SOURCE_TYPE_EC && frameInfo.frame != nullptr) {
917 if (frameInfo.replyBytes - fdescEc->frameLen < fdesc->frameLen) {
918 replyBytes = 0;
919 return ERR_INVALID_READ;
920 }
921 if (memcpy_s(fdesc->frame, fdesc->frameLen, frameInfo.frame, fdesc->frameLen) != EOK) {
922 AUDIO_ERR_LOG("memcpy error");
923 } else {
924 replyBytes = (attr_.sourceType == SOURCE_TYPE_EC) ? 0 : fdesc->frameLen;
925 DumpCapturerSourceData(fdesc->frame, replyBytes);
926 }
927 }
928 if (frameInfo.frameEc != nullptr) {
929 if (memcpy_s(fdescEc->frame, fdescEc->frameLen, frameInfo.frameEc, fdescEc->frameLen) != EOK) {
930 AUDIO_ERR_LOG("memcpy ec error");
931 } else {
932 replyBytesEc = (attr_.sourceType == SOURCE_TYPE_EC) ?
933 frameInfo.replyBytesEc : fdescEc->frameLen;
934 }
935 }
936 CheckUpdateState(fdesc->frame, replyBytes);
937 AudioCaptureFrameInfoFree(&frameInfo, false);
938
939 return SUCCESS;
940 }
941
DumpCapturerSourceData(char * frame,uint64_t & replyBytes)942 void AudioCapturerSourceInner::DumpCapturerSourceData(char *frame, uint64_t &replyBytes)
943 {
944 BufferDesc tmpBuffer = {reinterpret_cast<uint8_t*>(frame), replyBytes, replyBytes};
945 AudioStreamInfo streamInfo(static_cast<AudioSamplingRate>(attr_.sampleRate),
946 AudioEncodingType::ENCODING_PCM, static_cast<AudioSampleFormat>(attr_.format),
947 static_cast<AudioChannel>(attr_.channel));
948 VolumeTools::DfxOperation(tmpBuffer, streamInfo, logUtilsTag_, volumeDataCount_);
949 if (AudioDump::GetInstance().GetVersionType() == DumpFileUtil::BETA_VERSION) {
950 DumpFileUtil::WriteDumpFile(dumpFile_, frame, replyBytes);
951 Media::MediaMonitor::MediaMonitorManager::GetInstance().WriteAudioBuffer(dumpFileName_,
952 static_cast<void*>(frame), replyBytes);
953 }
954 }
955
CaptureFrameEcInternal(std::vector<uint8_t> & ecData)956 void AudioCapturerSourceInner::CaptureFrameEcInternal(std::vector<uint8_t> &ecData)
957 {
958 CHECK_AND_RETURN_LOG(audioCapture_, "audioCapture_ is nullptr");
959 // mic frame just used for check, ec frame must be right
960 struct AudioFrameLen frameLen = {};
961 frameLen.frameLen = static_cast<uint64_t>(ecData.size());
962 frameLen.frameEcLen = static_cast<uint64_t>(ecData.size());
963 struct AudioCaptureFrameInfo frameInfo = {};
964 int32_t ret = audioCapture_->CaptureFrameEc(audioCapture_, &frameLen, &frameInfo);
965 if (ret >= 0 && frameInfo.frameEc != nullptr) {
966 if (memcpy_s(ecData.data(), ecData.size(), frameInfo.frameEc, frameInfo.replyBytesEc) != EOK) {
967 AUDIO_ERR_LOG("memcpy ec error");
968 }
969 }
970 AudioCaptureFrameInfoFree(&frameInfo, false);
971 }
972
CaptureThreadLoop()973 void AudioCapturerSourceInner::CaptureThreadLoop()
974 {
975 if (ringBuffer_ == nullptr) {
976 AUDIO_ERR_LOG("ring buffer not init");
977 return;
978 }
979
980 uint32_t captureDataLen = FRAME_TIME_LEN_MS * attr_.sampleRate / MILLISECONDS_PER_SECOND_MS *
981 static_cast<uint32_t>(GetByteSizeByFormat(attr_.format)) * attr_.channel;
982 AUDIO_INFO_LOG("non blocking capture thread start, source type: %{public}d, captureDataLen: %{public}u",
983 attr_.sourceType, captureDataLen);
984 std::vector<uint8_t> tempBuf;
985 tempBuf.resize(captureDataLen);
986 ScheduleThreadInServer(getpid(), gettid());
987 while (threadRunning_) {
988 Trace trace("CaptureRefInput");
989 uint64_t replyBytes = 0;
990 uint32_t requestBytes = static_cast<uint32_t>(tempBuf.size());
991 if (attr_.sourceType == SOURCE_TYPE_MIC_REF) {
992 CHECK_AND_RETURN_LOG(audioCapture_, "audioCapture_ is nullptr");
993 int32_t ret = audioCapture_->CaptureFrame(
994 audioCapture_, reinterpret_cast<int8_t *>(tempBuf.data()), &requestBytes, &replyBytes);
995 if (ret != SUCCESS) {
996 AUDIO_ERR_LOG("Capture frame failed");
997 }
998 } else {
999 CaptureFrameEcInternal(tempBuf);
1000 }
1001
1002 ringBuffer_->WriteDataToRingBuffer(tempBuf.data(), tempBuf.size());
1003 }
1004 UnscheduleThreadInServer(getpid(), gettid());
1005 AUDIO_INFO_LOG("non blocking capture thread exit, source type: %{public}d", attr_.sourceType);
1006 }
1007
CheckUpdateState(char * frame,uint64_t replyBytes)1008 void AudioCapturerSourceInner::CheckUpdateState(char *frame, uint64_t replyBytes)
1009 {
1010 if (startUpdate_) {
1011 std::lock_guard<std::mutex> lock(statusMutex_);
1012 if (capFrameNum_ == 0) {
1013 last10FrameStartTime_ = ClockTime::GetCurNano();
1014 }
1015 capFrameNum_++;
1016 maxAmplitude_ = UpdateMaxAmplitude(static_cast<ConvertHdiFormat>(attr_.format), frame, replyBytes);
1017 if (capFrameNum_ == GET_MAX_AMPLITUDE_FRAMES_THRESHOLD) {
1018 capFrameNum_ = 0;
1019 if (last10FrameStartTime_ > lastGetMaxAmplitudeTime_) {
1020 startUpdate_ = false;
1021 maxAmplitude_ = 0;
1022 }
1023 }
1024 }
1025 }
1026
GetMaxAmplitude()1027 float AudioCapturerSourceInner::GetMaxAmplitude()
1028 {
1029 lastGetMaxAmplitudeTime_ = ClockTime::GetCurNano();
1030 startUpdate_ = true;
1031 return maxAmplitude_;
1032 }
1033
StartNonblockingCapture()1034 int32_t AudioCapturerSourceInner::StartNonblockingCapture()
1035 {
1036 CHECK_AND_RETURN_RET_LOG(audioCapture_, ERR_INVALID_HANDLE, "audioCapture_ is nullptr");
1037 if (!started_) {
1038 int32_t ret = audioCapture_->Start(audioCapture_);
1039 if (ret < 0) {
1040 return ERR_NOT_STARTED;
1041 }
1042 started_ = true;
1043
1044 // start non-blocking capture frame thread
1045 threadRunning_ = true;
1046 captureThread_ = std::make_unique<std::thread>(&AudioCapturerSourceInner::CaptureThreadLoop, this);
1047
1048 std::string threadName = "OS_Capture";
1049 threadName += (attr_.sourceType == SOURCE_TYPE_EC) ? "Ec" : "MicRef";
1050 pthread_setname_np(captureThread_->native_handle(), threadName.c_str());
1051 }
1052
1053 return SUCCESS;
1054 }
1055
Start(void)1056 int32_t AudioCapturerSourceInner::Start(void)
1057 {
1058 std::lock_guard<std::mutex> statusLock(statusMutex_);
1059
1060 AUDIO_INFO_LOG("sourceName %{public}s", halName_.c_str());
1061 Trace trace("AudioCapturerSourceInner::Start");
1062
1063 if (IsNonblockingSource(attr_.sourceType, adapterNameCase_)) {
1064 return StartNonblockingCapture();
1065 }
1066
1067 InitLatencyMeasurement();
1068 #ifdef FEATURE_POWER_MANAGER
1069 std::shared_ptr<PowerMgr::RunningLock> keepRunningLock;
1070 if (runningLockManager_ == nullptr) {
1071 WatchTimeout guard("PowerMgr::PowerMgrClient::GetInstance().CreateRunningLock:Start");
1072 switch (attr_.sourceType) {
1073 case SOURCE_TYPE_WAKEUP:
1074 keepRunningLock = PowerMgr::PowerMgrClient::GetInstance().CreateRunningLock("AudioWakeupCapturer",
1075 PowerMgr::RunningLockType::RUNNINGLOCK_BACKGROUND_AUDIO);
1076 break;
1077 case SOURCE_TYPE_MIC:
1078 case SOURCE_TYPE_CAMCORDER:
1079 case SOURCE_TYPE_UNPROCESSED:
1080 default:
1081 keepRunningLock = PowerMgr::PowerMgrClient::GetInstance().CreateRunningLock("AudioPrimaryCapturer",
1082 PowerMgr::RunningLockType::RUNNINGLOCK_BACKGROUND_AUDIO);
1083 }
1084 guard.CheckCurrTimeout();
1085 if (keepRunningLock) {
1086 runningLockManager_ = std::make_shared<AudioRunningLockManager<PowerMgr::RunningLock>> (keepRunningLock);
1087 }
1088 }
1089 if (runningLockManager_ != nullptr) {
1090 AUDIO_INFO_LOG("keepRunningLock lock result: %{public}d",
1091 runningLockManager_->Lock(RUNNINGLOCK_LOCK_TIMEOUTMS_LASTING)); // -1 for lasting.
1092 } else {
1093 AUDIO_WARNING_LOG("keepRunningLock is null, capture can not work well!");
1094 }
1095 #endif
1096 // eg: primary_0_20240527202236189_source_44100_2_1.pcm
1097 dumpFileName_ = halName_ + "_" + std::to_string(attr_.sourceType) + "_" + GetTime()
1098 + "_source_" + std::to_string(attr_.sampleRate) + "_" + std::to_string(attr_.channel)
1099 + "_" + std::to_string(attr_.format) + ".pcm";
1100 DumpFileUtil::OpenDumpFile(DumpFileUtil::DUMP_SERVER_PARA, dumpFileName_, &dumpFile_);
1101
1102 return StartCapture();
1103 }
1104
StartCapture()1105 int32_t AudioCapturerSourceInner::StartCapture()
1106 {
1107 if (!started_) {
1108 if (audioCapturerSourceCallback_ != nullptr) {
1109 audioCapturerSourceCallback_->OnCapturerState(true);
1110 }
1111 CHECK_AND_RETURN_RET_LOG(audioCapture_, ERR_INVALID_HANDLE, "audioCapture_ is nullptr");
1112 int32_t ret = audioCapture_->Start(audioCapture_);
1113 CHECK_AND_RETURN_RET(ret >= 0, ERR_NOT_STARTED);
1114 started_ = true;
1115 }
1116
1117 return SUCCESS;
1118 }
1119
SetVolume(float left,float right)1120 int32_t AudioCapturerSourceInner::SetVolume(float left, float right)
1121 {
1122 float volume;
1123 CHECK_AND_RETURN_RET_LOG(audioCapture_ != nullptr, ERR_INVALID_HANDLE,
1124 "SetVolume failed audioCapture_ null");
1125
1126 rightVolume_ = right;
1127 leftVolume_ = left;
1128 if ((leftVolume_ == 0) && (rightVolume_ != 0)) {
1129 volume = rightVolume_;
1130 } else if ((leftVolume_ != 0) && (rightVolume_ == 0)) {
1131 volume = leftVolume_;
1132 } else {
1133 volume = (leftVolume_ + rightVolume_) / HALF_FACTOR;
1134 }
1135
1136 audioCapture_->SetVolume(audioCapture_, volume);
1137
1138 return SUCCESS;
1139 }
1140
GetVolume(float & left,float & right)1141 int32_t AudioCapturerSourceInner::GetVolume(float &left, float &right)
1142 {
1143 CHECK_AND_RETURN_RET_LOG(audioCapture_, ERR_INVALID_HANDLE, "audioCapture_ is nullptr");
1144 float val = 0.0;
1145 audioCapture_->GetVolume(audioCapture_, &val);
1146 left = val;
1147 right = val;
1148
1149 return SUCCESS;
1150 }
1151
SetMuteState(bool isMute)1152 void AudioCapturerSourceInner::SetMuteState(bool isMute)
1153 {
1154 std::lock_guard<std::mutex> statusLock(muteStateMutex_);
1155 muteState_ = isMute;
1156 }
1157
GetMuteState()1158 bool AudioCapturerSourceInner::GetMuteState()
1159 {
1160 std::lock_guard<std::mutex> statusLock(muteStateMutex_);
1161 return muteState_;
1162 }
1163
SetMute(bool isMute)1164 int32_t AudioCapturerSourceInner::SetMute(bool isMute)
1165 {
1166 SetMuteState(isMute);
1167
1168 if (IsInited() && audioCapture_) {
1169 int32_t ret = audioCapture_->SetMute(audioCapture_, isMute);
1170 if (ret != 0) {
1171 AUDIO_WARNING_LOG("SetMute for hdi capturer failed");
1172 } else {
1173 AUDIO_INFO_LOG("SetMute for hdi capture success");
1174 }
1175 }
1176
1177 if ((halName_ == "primary") && !adapterLoaded_) {
1178 InitManagerAndAdapter();
1179 }
1180
1181 if (audioAdapter_ != nullptr) {
1182 int32_t ret = audioAdapter_->SetMicMute(audioAdapter_, isMute);
1183 if (ret != 0) {
1184 AUDIO_WARNING_LOG("SetMicMute for hdi adapter failed");
1185 } else {
1186 AUDIO_INFO_LOG("SetMicMute for hdi adapter success");
1187 }
1188 }
1189
1190 AUDIO_INFO_LOG("halName:%{public}s isMute=%{public}d", halName_.c_str(), isMute);
1191
1192 return SUCCESS;
1193 }
1194
GetMute(bool & isMute)1195 int32_t AudioCapturerSourceInner::GetMute(bool &isMute)
1196 {
1197 CHECK_AND_RETURN_RET_LOG(audioCapture_ != nullptr, ERR_INVALID_HANDLE,
1198 "GetMute failed audioCapture_ handle is null!");
1199
1200 bool isHdiMute = false;
1201 int32_t ret = audioCapture_->GetMute(audioCapture_, &isHdiMute);
1202 if (ret != 0) {
1203 AUDIO_WARNING_LOG("GetMute failed from hdi");
1204 }
1205
1206 isMute = GetMuteState();
1207
1208 return SUCCESS;
1209 }
1210
GetAudioCategory(AudioScene audioScene)1211 static AudioCategory GetAudioCategory(AudioScene audioScene)
1212 {
1213 AudioCategory audioCategory;
1214 switch (audioScene) {
1215 case AUDIO_SCENE_PHONE_CALL:
1216 audioCategory = AUDIO_IN_CALL;
1217 break;
1218 case AUDIO_SCENE_PHONE_CHAT:
1219 audioCategory = AUDIO_IN_COMMUNICATION;
1220 break;
1221 case AUDIO_SCENE_RINGING:
1222 case AUDIO_SCENE_VOICE_RINGING:
1223 audioCategory = AUDIO_IN_RINGTONE;
1224 break;
1225 case AUDIO_SCENE_DEFAULT:
1226 audioCategory = AUDIO_IN_MEDIA;
1227 break;
1228 default:
1229 audioCategory = AUDIO_IN_MEDIA;
1230 break;
1231 }
1232 AUDIO_DEBUG_LOG("Audio category returned is: %{public}d", audioCategory);
1233
1234 return audioCategory;
1235 }
1236
SetInputPortPin(DeviceType inputDevice,AudioRouteNode & source)1237 static int32_t SetInputPortPin(DeviceType inputDevice, AudioRouteNode &source)
1238 {
1239 int32_t ret = SUCCESS;
1240
1241 switch (inputDevice) {
1242 case DEVICE_TYPE_MIC:
1243 case DEVICE_TYPE_EARPIECE:
1244 case DEVICE_TYPE_SPEAKER:
1245 case DEVICE_TYPE_BLUETOOTH_A2DP_IN:
1246 source.ext.device.type = PIN_IN_MIC;
1247 source.ext.device.desc = (char *)"pin_in_mic";
1248 break;
1249 case DEVICE_TYPE_WIRED_HEADSET:
1250 source.ext.device.type = PIN_IN_HS_MIC;
1251 source.ext.device.desc = (char *)"pin_in_hs_mic";
1252 break;
1253 case DEVICE_TYPE_USB_ARM_HEADSET:
1254 source.ext.device.type = PIN_IN_USB_HEADSET;
1255 source.ext.device.desc = (char *)"pin_in_usb_headset";
1256 break;
1257 case DEVICE_TYPE_USB_HEADSET:
1258 source.ext.device.type = PIN_IN_USB_EXT;
1259 source.ext.device.desc = (char *)"pin_in_usb_ext";
1260 break;
1261 case DEVICE_TYPE_BLUETOOTH_SCO:
1262 source.ext.device.type = PIN_IN_BLUETOOTH_SCO_HEADSET;
1263 source.ext.device.desc = (char *)"pin_in_bluetooth_sco_headset";
1264 break;
1265 default:
1266 ret = ERR_NOT_SUPPORTED;
1267 break;
1268 }
1269
1270 return ret;
1271 }
1272
SetInputRoute(DeviceType inputDevice,const std::string & deviceName)1273 int32_t AudioCapturerSourceInner::SetInputRoute(DeviceType inputDevice, const std::string &deviceName)
1274 {
1275 std::lock_guard<std::mutex> statusLock(statusMutex_);
1276 AudioPortPin inputPortPin = PIN_IN_MIC;
1277 return SetInputRoute(inputDevice, inputPortPin, deviceName);
1278 }
1279
SetInputRoute(DeviceType inputDevice,AudioPortPin & inputPortPin,const std::string & deviceName)1280 int32_t AudioCapturerSourceInner::SetInputRoute(DeviceType inputDevice, AudioPortPin &inputPortPin,
1281 const std::string &deviceName)
1282 {
1283 if (inputDevice == currentActiveDevice_) {
1284 AUDIO_INFO_LOG("input device not change. currentActiveDevice %{public}d sourceType %{public}d",
1285 currentActiveDevice_, attr_.sourceType);
1286 return SUCCESS;
1287 }
1288
1289 return DoSetInputRoute(inputDevice, inputPortPin, deviceName);
1290 }
1291
DoSetInputRoute(DeviceType inputDevice,AudioPortPin & inputPortPin,const std::string & deviceName)1292 int32_t AudioCapturerSourceInner::DoSetInputRoute(DeviceType inputDevice,
1293 AudioPortPin &inputPortPin, const std::string &deviceName)
1294 {
1295 AudioRouteNode source = {};
1296 AudioRouteNode sink = {};
1297
1298 int32_t ret = SetInputPortPin(inputDevice, source);
1299 CHECK_AND_RETURN_RET_LOG(ret == SUCCESS, ret, "DoSetInputRoute FAILED: %{public}d", ret);
1300
1301 inputPortPin = source.ext.device.type;
1302 AUDIO_INFO_LOG("Input PIN is: 0x%{public}X", inputPortPin);
1303 source.portId = static_cast<int32_t>(audioPort_.portId);
1304 source.role = AUDIO_PORT_SOURCE_ROLE;
1305 source.type = AUDIO_PORT_DEVICE_TYPE;
1306 source.ext.device.moduleId = 0;
1307 source.ext.device.desc = (char *)"";
1308
1309 sink.portId = 0;
1310 sink.role = AUDIO_PORT_SINK_ROLE;
1311 sink.type = AUDIO_PORT_MIX_TYPE;
1312 sink.ext.mix.moduleId = 0;
1313 sink.ext.mix.streamId = static_cast<int32_t>(GenerateUniqueIDBySource(attr_.sourceType));
1314 sink.ext.mix.source = static_cast<int32_t>(ConvertToHDIAudioInputType(attr_.sourceType));
1315 sink.ext.device.desc = (char *)"";
1316
1317 AudioRoute route = {
1318 .sources = &source,
1319 .sourcesLen = 1,
1320 .sinks = &sink,
1321 .sinksLen = 1,
1322 };
1323
1324 CHECK_AND_RETURN_RET_LOG(audioAdapter_ != nullptr, ERR_OPERATION_FAILED,
1325 "AudioAdapter object is null.");
1326
1327 ret = audioAdapter_->UpdateAudioRoute(audioAdapter_, &route, &routeHandle_);
1328 CHECK_AND_RETURN_RET_LOG(ret == 0, ERR_OPERATION_FAILED, "UpdateAudioRoute failed");
1329
1330 currentActiveDevice_ = inputDevice;
1331 return SUCCESS;
1332 }
1333
SetAudioScene(AudioScene audioScene,DeviceType activeDevice,const std::string & deviceName)1334 int32_t AudioCapturerSourceInner::SetAudioScene(AudioScene audioScene, DeviceType activeDevice,
1335 const std::string &deviceName)
1336 {
1337 AUDIO_INFO_LOG("SetAudioScene scene: %{public}d, device: %{public}d",
1338 audioScene, activeDevice);
1339 CHECK_AND_RETURN_RET_LOG(audioScene >= AUDIO_SCENE_DEFAULT && audioScene < AUDIO_SCENE_MAX,
1340 ERR_INVALID_PARAM, "invalid audioScene");
1341 CHECK_AND_RETURN_RET_LOG(audioCapture_ != nullptr, ERR_INVALID_HANDLE,
1342 "SetAudioScene failed audioCapture_ handle is null!");
1343 if (openMic_) {
1344 AudioPortPin audioSceneInPort = PIN_IN_MIC;
1345 if (halName_ == "usb") {
1346 audioSceneInPort = PIN_IN_USB_HEADSET;
1347 }
1348
1349 int32_t ret = SUCCESS;
1350 if (audioScene != currentAudioScene_) {
1351 struct AudioSceneDescriptor scene;
1352 scene.scene.id = GetAudioCategory(audioScene);
1353 scene.desc.pins = audioSceneInPort;
1354 scene.desc.desc = const_cast<char *>("");
1355
1356 ret = audioCapture_->SelectScene(audioCapture_, &scene);
1357 CHECK_AND_RETURN_RET_LOG(ret >= 0, ERR_OPERATION_FAILED,
1358 "Select scene FAILED: %{public}d", ret);
1359 currentAudioScene_ = audioScene;
1360 }
1361
1362 std::lock_guard<std::mutex> statusLock(statusMutex_);
1363 ret = SetInputRoute(activeDevice, audioSceneInPort, deviceName);
1364 if (ret < 0) {
1365 AUDIO_WARNING_LOG("Update route FAILED: %{public}d", ret);
1366 }
1367 }
1368 AUDIO_DEBUG_LOG("Select audio scene SUCCESS: %{public}d", audioScene);
1369 return SUCCESS;
1370 }
1371
GetTransactionId()1372 uint64_t AudioCapturerSourceInner::GetTransactionId()
1373 {
1374 return reinterpret_cast<uint64_t>(audioCapture_);
1375 }
1376
GetPresentationPosition(uint64_t & frames,int64_t & timeSec,int64_t & timeNanoSec)1377 int32_t AudioCapturerSourceInner::GetPresentationPosition(uint64_t& frames, int64_t& timeSec, int64_t& timeNanoSec)
1378 {
1379 if (audioCapture_ == nullptr) {
1380 AUDIO_ERR_LOG("failed audioCapture_ is NULL");
1381 return ERR_INVALID_HANDLE;
1382 }
1383 struct AudioTimeStamp timestamp = {};
1384 int32_t ret = audioCapture_->GetCapturePosition(audioCapture_, &frames, ×tamp);
1385 if (ret != 0) {
1386 AUDIO_ERR_LOG("get position failed");
1387 return ERR_OPERATION_FAILED;
1388 }
1389 int64_t maxSec = 9223372036; // (9223372036 + 1) * 10^9 > INT64_MAX, seconds should not bigger than it;
1390 if (timestamp.tvSec < 0 || timestamp.tvSec > maxSec || timestamp.tvNSec < 0 ||
1391 timestamp.tvNSec > SECOND_TO_NANOSECOND) {
1392 AUDIO_ERR_LOG(
1393 "Hdi GetRenderPosition get invaild second:%{public}" PRIu64 " or nanosecond:%{public}" PRIu64 " !",
1394 timestamp.tvSec, timestamp.tvNSec);
1395 return ERR_OPERATION_FAILED;
1396 }
1397
1398 timeSec = timestamp.tvSec;
1399 timeNanoSec = timestamp.tvNSec;
1400 return ret;
1401 }
1402
StopNonblockingCapture()1403 int32_t AudioCapturerSourceInner::StopNonblockingCapture()
1404 {
1405 threadRunning_ = false;
1406 if (captureThread_ && captureThread_->joinable()) {
1407 captureThread_->join();
1408 }
1409
1410 if (started_ && audioCapture_ != nullptr) {
1411 int32_t ret = audioCapture_->Stop(audioCapture_);
1412 if (ret != SUCCESS) {
1413 AUDIO_ERR_LOG("hdi stop capture failed");
1414 }
1415 }
1416 started_ = false;
1417
1418 return SUCCESS;
1419 }
1420
DoStop()1421 int32_t AudioCapturerSourceInner::DoStop()
1422 {
1423 AUDIO_INFO_LOG("sourceName %{public}s", halName_.c_str());
1424
1425 Trace trace("AudioCapturerSourceInner::DoStop");
1426
1427 if (IsNonblockingSource(attr_.sourceType, adapterNameCase_)) {
1428 return StopNonblockingCapture();
1429 }
1430
1431 DeinitLatencyMeasurement();
1432
1433 #ifdef FEATURE_POWER_MANAGER
1434 if (runningLockManager_ != nullptr) {
1435 AUDIO_INFO_LOG("keepRunningLock unlock");
1436 runningLockManager_->UnLock();
1437 } else {
1438 AUDIO_WARNING_LOG("keepRunningLock is null, stop can not work well!");
1439 }
1440 #endif
1441
1442 if (started_ && audioCapture_ != nullptr) {
1443 int32_t ret = audioCapture_->Stop(audioCapture_);
1444 CHECK_AND_RETURN_RET_LOG(ret >= 0, ERR_OPERATION_FAILED, "Stop capture Failed");
1445 }
1446 started_ = false;
1447
1448 if (audioCapturerSourceCallback_ != nullptr) {
1449 audioCapturerSourceCallback_->OnCapturerState(false);
1450 }
1451
1452 return SUCCESS;
1453 }
1454
Stop(void)1455 int32_t AudioCapturerSourceInner::Stop(void)
1456 {
1457 Trace trace("AudioCapturerSourceInner::Stop");
1458 std::promise<void> promiseEnsueThreadLock;
1459 auto futureWaitThreadLock = promiseEnsueThreadLock.get_future();
1460 std::thread threadAsyncStop([&promiseEnsueThreadLock, this] {
1461 std::lock_guard<std::mutex> statusLock(statusMutex_);
1462 promiseEnsueThreadLock.set_value();
1463 DoStop();
1464 });
1465 futureWaitThreadLock.get();
1466 threadAsyncStop.detach();
1467
1468 return SUCCESS;
1469 }
1470
Pause(void)1471 int32_t AudioCapturerSourceInner::Pause(void)
1472 {
1473 std::lock_guard<std::mutex> statusLock(statusMutex_);
1474 AUDIO_INFO_LOG("sourceName %{public}s", halName_.c_str());
1475
1476 Trace trace("AudioCapturerSourceInner::Pause");
1477 if (started_ && audioCapture_ != nullptr) {
1478 int32_t ret = audioCapture_->Pause(audioCapture_);
1479 CHECK_AND_RETURN_RET_LOG(ret == 0, ERR_OPERATION_FAILED, "pause capture Failed");
1480 }
1481 paused_ = true;
1482
1483 return SUCCESS;
1484 }
1485
Resume(void)1486 int32_t AudioCapturerSourceInner::Resume(void)
1487 {
1488 std::lock_guard<std::mutex> statusLock(statusMutex_);
1489 AUDIO_INFO_LOG("sourceName %{public}s", halName_.c_str());
1490 Trace trace("AudioCapturerSourceInner::Resume");
1491 if (paused_ && audioCapture_ != nullptr) {
1492 int32_t ret = audioCapture_->Resume(audioCapture_);
1493 CHECK_AND_RETURN_RET_LOG(ret == 0, ERR_OPERATION_FAILED, "resume capture Failed");
1494 }
1495 paused_ = false;
1496
1497 return SUCCESS;
1498 }
1499
Reset(void)1500 int32_t AudioCapturerSourceInner::Reset(void)
1501 {
1502 std::lock_guard<std::mutex> statusLock(statusMutex_);
1503 AUDIO_INFO_LOG("sourceName %{public}s", halName_.c_str());
1504 Trace trace("AudioCapturerSourceInner::Reset");
1505 if (started_ && audioCapture_ != nullptr) {
1506 audioCapture_->Flush(audioCapture_);
1507 }
1508
1509 return SUCCESS;
1510 }
1511
Flush(void)1512 int32_t AudioCapturerSourceInner::Flush(void)
1513 {
1514 std::lock_guard<std::mutex> statusLock(statusMutex_);
1515 AUDIO_INFO_LOG("sourceName %{public}s", halName_.c_str());
1516 Trace trace("AudioCapturerSourceInner::Flush");
1517 if (started_ && audioCapture_ != nullptr) {
1518 audioCapture_->Flush(audioCapture_);
1519 }
1520
1521 return SUCCESS;
1522 }
1523
RegisterWakeupCloseCallback(IAudioSourceCallback * callback)1524 void AudioCapturerSourceInner::RegisterWakeupCloseCallback(IAudioSourceCallback *callback)
1525 {
1526 AUDIO_INFO_LOG("Register WakeupClose Callback");
1527 std::lock_guard<std::mutex> lck(wakeupClosecallbackMutex_);
1528 wakeupCloseCallback_ = callback;
1529 }
1530
RegisterAudioCapturerSourceCallback(std::unique_ptr<ICapturerStateCallback> callback)1531 void AudioCapturerSourceInner::RegisterAudioCapturerSourceCallback(std::unique_ptr<ICapturerStateCallback> callback)
1532 {
1533 AUDIO_INFO_LOG("Register AudioCapturerSource Callback");
1534 audioCapturerSourceCallback_ = std::move(callback);
1535 }
1536
RegisterParameterCallback(IAudioSourceCallback * callback)1537 void AudioCapturerSourceInner::RegisterParameterCallback(IAudioSourceCallback *callback)
1538 {
1539 AUDIO_WARNING_LOG("RegisterParameterCallback is not supported!");
1540 }
1541
Preload(const std::string & usbInfoStr)1542 int32_t AudioCapturerSourceInner::Preload(const std::string &usbInfoStr)
1543 {
1544 CHECK_AND_RETURN_RET_LOG(halName_ == "usb", ERR_INVALID_OPERATION, "Preload only supported for usb");
1545
1546 std::lock_guard<std::mutex> statusLock(statusMutex_);
1547 int32_t ret = UpdateUsbAttrs(usbInfoStr);
1548 CHECK_AND_RETURN_RET_LOG(ret == SUCCESS, ret, "Preload failed when init attr");
1549
1550 ret = InitAdapterAndCapture();
1551 CHECK_AND_RETURN_RET_LOG(ret == SUCCESS, ret, "Preload failed when init adapter and capture");
1552
1553 return SUCCESS;
1554 }
1555
ParseAudioFormat(const std::string & format)1556 static HdiAdapterFormat ParseAudioFormat(const std::string &format)
1557 {
1558 if (format == "AUDIO_FORMAT_PCM_16_BIT") {
1559 return HdiAdapterFormat::SAMPLE_S16;
1560 } else if (format == "AUDIO_FORMAT_PCM_24_BIT" || format == "AUDIO_FORMAT_PCM_24_BIT_PACKED") {
1561 return HdiAdapterFormat::SAMPLE_S24;
1562 } else if (format == "AUDIO_FORMAT_PCM_32_BIT") {
1563 return HdiAdapterFormat::SAMPLE_S32;
1564 } else {
1565 return HdiAdapterFormat::SAMPLE_S16;
1566 }
1567 }
1568
UpdateUsbAttrs(const std::string & usbInfoStr)1569 int32_t AudioCapturerSourceInner::UpdateUsbAttrs(const std::string &usbInfoStr)
1570 {
1571 CHECK_AND_RETURN_RET_LOG(usbInfoStr != "", ERR_INVALID_PARAM, "usb info string error");
1572
1573 auto sourceRate_begin = usbInfoStr.find("source_rate:");
1574 auto sourceRate_end = usbInfoStr.find_first_of(";", sourceRate_begin);
1575 std::string sampleRateStr = usbInfoStr.substr(sourceRate_begin + std::strlen("source_rate:"),
1576 sourceRate_end - sourceRate_begin - std::strlen("source_rate:"));
1577 auto sourceFormat_begin = usbInfoStr.find("source_format:");
1578 auto sourceFormat_end = usbInfoStr.find_first_of(";", sourceFormat_begin);
1579 std::string formatStr = usbInfoStr.substr(sourceFormat_begin + std::strlen("source_format:"),
1580 sourceFormat_end - sourceFormat_begin - std::strlen("source_format:"));
1581
1582 // usb default config
1583 CHECK_AND_RETURN_RET_LOG(StringConverter(sampleRateStr, attr_.sampleRate), ERR_INVALID_PARAM,
1584 "convert invalid sampleRate: %{public}s", sampleRateStr.c_str());
1585 attr_.channel = STEREO_CHANNEL_COUNT;
1586 attr_.format = ParseAudioFormat(formatStr);
1587 attr_.isBigEndian = false;
1588 attr_.bufferSize = USB_DEFAULT_BUFFERSIZE;
1589 attr_.sourceType = SOURCE_TYPE_MIC;
1590
1591 adapterNameCase_ = "usb";
1592 openMic_ = 0;
1593
1594 return SUCCESS;
1595 }
1596
InitManagerAndAdapter()1597 int32_t AudioCapturerSourceInner::InitManagerAndAdapter()
1598 {
1599 int32_t err = InitAudioManager();
1600 CHECK_AND_RETURN_RET_LOG(err == 0, ERR_NOT_STARTED, "Init audio manager Fail");
1601
1602 AudioAdapterDescriptor descs[MAX_AUDIO_ADAPTER_NUM];
1603 uint32_t size = MAX_AUDIO_ADAPTER_NUM;
1604 int32_t ret = audioManager_->GetAllAdapters(audioManager_, (struct AudioAdapterDescriptor *)&descs, &size);
1605 CHECK_AND_RETURN_RET_LOG(size <= MAX_AUDIO_ADAPTER_NUM && size != 0 && ret == 0,
1606 ERR_NOT_STARTED, "Get adapters Fail");
1607 if (adapterNameCase_ == "" && halName_ == "primary") {
1608 adapterNameCase_ = "primary";
1609 }
1610 // Get qualified sound card and port
1611 int32_t index = SwitchAdapterCapture((struct AudioAdapterDescriptor *)&descs,
1612 size, adapterNameCase_, PORT_IN, audioPort_);
1613 CHECK_AND_RETURN_RET_LOG(index >= 0, ERR_NOT_STARTED, "Switch Adapter Capture Fail");
1614 adapterDesc_ = descs[index];
1615
1616 if (audioAdapter_ == nullptr) {
1617 struct IAudioAdapter *iAudioAdapter = nullptr;
1618 int32_t loadAdapter = audioManager_->LoadAdapter(audioManager_, &adapterDesc_, &iAudioAdapter);
1619 CHECK_AND_RETURN_RET_LOG(loadAdapter == 0, ERR_NOT_STARTED, "Load Adapter Fail");
1620 CHECK_AND_RETURN_RET_LOG(iAudioAdapter != nullptr, ERR_NOT_STARTED, "Load audio device failed");
1621
1622 // Inittialization port information, can fill through mode and other parameters
1623 int32_t initAllPorts = iAudioAdapter->InitAllPorts(iAudioAdapter);
1624 CHECK_AND_RETURN_RET_LOG(initAllPorts == 0, ERR_DEVICE_INIT, "InitAllPorts failed");
1625 audioAdapter_ = iAudioAdapter;
1626 adapterLoaded_ = true;
1627 }
1628 return SUCCESS;
1629 }
1630
InitAdapterAndCapture()1631 int32_t AudioCapturerSourceInner::InitAdapterAndCapture()
1632 {
1633 AUDIO_INFO_LOG("Init adapter start sourceName %{public}s", halName_.c_str());
1634
1635 if (captureInited_) {
1636 AUDIO_INFO_LOG("Adapter already inited");
1637 return SUCCESS;
1638 }
1639
1640 int32_t err = InitManagerAndAdapter();
1641 CHECK_AND_RETURN_RET_LOG(err == 0, err, "Init audio manager and adapater failed");
1642
1643 int32_t createCapture = CreateCapture(audioPort_);
1644 CHECK_AND_RETURN_RET_LOG(createCapture == 0, ERR_NOT_STARTED, "Create capture failed");
1645 if (openMic_) {
1646 int32_t ret;
1647 AudioPortPin inputPortPin = PIN_IN_MIC;
1648 if (halName_ == "usb") {
1649 ret = SetInputRoute(DEVICE_TYPE_USB_ARM_HEADSET, inputPortPin);
1650 } else {
1651 DeviceType deviceType = static_cast<DeviceType>(attr_.deviceType);
1652 ret = SetInputRoute(deviceType, inputPortPin);
1653 }
1654 if (ret < 0) {
1655 AUDIO_WARNING_LOG("update route FAILED: %{public}d", ret);
1656 }
1657 ret = SetAudioRouteInfoForEnhanceChain(currentActiveDevice_, "");
1658 if (ret != SUCCESS) {
1659 AUDIO_WARNING_LOG("set device %{public}d failed", currentActiveDevice_);
1660 }
1661 }
1662
1663 captureInited_ = true;
1664
1665 return SUCCESS;
1666 }
1667
GetAudioParameter(const AudioParamKey key,const std::string & condition)1668 std::string AudioCapturerSourceInner::GetAudioParameter(const AudioParamKey key,
1669 const std::string &condition)
1670 {
1671 AUDIO_WARNING_LOG("not supported yet");
1672 return "";
1673 }
1674
InitLatencyMeasurement()1675 void AudioCapturerSourceInner::InitLatencyMeasurement()
1676 {
1677 std::lock_guard<std::mutex> lock(signalDetectAgentMutex_);
1678
1679 if (!AudioLatencyMeasurement::CheckIfEnabled()) {
1680 return;
1681 }
1682 signalDetectAgent_ = std::make_shared<SignalDetectAgent>();
1683 CHECK_AND_RETURN_LOG(signalDetectAgent_ != nullptr, "LatencyMeas signalDetectAgent_ is nullptr");
1684 signalDetectAgent_->sampleFormat_ = attr_.format;
1685 signalDetectAgent_->formatByteSize_ = GetFormatByteSize(attr_.format);
1686 latencyMeasEnabled_ = true;
1687 }
1688
DeinitLatencyMeasurement()1689 void AudioCapturerSourceInner::DeinitLatencyMeasurement()
1690 {
1691 std::lock_guard<std::mutex> lock(signalDetectAgentMutex_);
1692
1693 signalDetected_ = false;
1694 signalDetectAgent_ = nullptr;
1695 }
1696
CheckLatencySignal(uint8_t * frame,size_t replyBytes)1697 void AudioCapturerSourceInner::CheckLatencySignal(uint8_t *frame, size_t replyBytes)
1698 {
1699 std::lock_guard<std::mutex> lock(signalDetectAgentMutex_);
1700 if (!latencyMeasEnabled_) {
1701 return;
1702 }
1703 CHECK_AND_RETURN_LOG(signalDetectAgent_ != nullptr, "LatencyMeas signalDetectAgent_ is nullptr");
1704 signalDetected_ = signalDetectAgent_->CheckAudioData(frame, replyBytes);
1705 if (signalDetected_) {
1706 char value[GET_EXTRA_PARAM_LEN];
1707 AudioParamKey key = NONE;
1708 AudioExtParamKey hdiKey = AudioExtParamKey(key);
1709 std::string condition = "debug_audio_latency_measurement";
1710 int32_t ret = audioAdapter_->GetExtraParams(audioAdapter_, hdiKey, condition.c_str(),
1711 value, DumpFileUtil::PARAM_VALUE_LENTH);
1712 AUDIO_INFO_LOG("GetExtraParam ret:%{public}d", ret);
1713 LatencyMonitor::GetInstance().UpdateDspTime(value);
1714 LatencyMonitor::GetInstance().UpdateSinkOrSourceTime(false,
1715 signalDetectAgent_->lastPeakBufferTime_);
1716 AUDIO_INFO_LOG("LatencyMeas primarySource signal detected");
1717 signalDetected_ = false;
1718 }
1719 }
1720
UpdateAppsUid(const int32_t appsUid[PA_MAX_OUTPUTS_PER_SOURCE],const size_t size)1721 int32_t AudioCapturerSourceInner::UpdateAppsUid(const int32_t appsUid[PA_MAX_OUTPUTS_PER_SOURCE],
1722 const size_t size)
1723 {
1724 #ifdef FEATURE_POWER_MANAGER
1725 if (!runningLockManager_) {
1726 return ERROR;
1727 }
1728
1729 runningLockManager_->UpdateAppsUid(appsUid, appsUid + size);
1730 runningLockManager_->UpdateAppsUidToPowerMgr();
1731 #endif
1732
1733 return SUCCESS;
1734 }
1735
UpdateAppsUid(const std::vector<int32_t> & appsUid)1736 int32_t AudioCapturerSourceInner::UpdateAppsUid(const std::vector<int32_t> &appsUid)
1737 {
1738 #ifdef FEATURE_POWER_MANAGER
1739 if (!runningLockManager_) {
1740 return ERROR;
1741 }
1742
1743 runningLockManager_->UpdateAppsUid(appsUid.cbegin(), appsUid.cend());
1744 runningLockManager_->UpdateAppsUidToPowerMgr();
1745 #endif
1746
1747 return SUCCESS;
1748 }
1749
GetCaptureId(uint32_t & captureId) const1750 int32_t AudioCapturerSourceInner::GetCaptureId(uint32_t &captureId) const
1751 {
1752 if (halName_ == "usb") {
1753 captureId = GenerateUniqueID(AUDIO_HDI_CAPTURE_ID_BASE, HDI_CAPTURE_OFFSET_USB);
1754 } else {
1755 captureId = GenerateUniqueID(AUDIO_HDI_CAPTURE_ID_BASE, HDI_CAPTURE_OFFSET_PRIMARY);
1756 }
1757 return SUCCESS;
1758 }
1759
SetAudioRouteInfoForEnhanceChain(const DeviceType & inputDevice,const std::string & deviceName)1760 int32_t AudioCapturerSourceInner::SetAudioRouteInfoForEnhanceChain(const DeviceType &inputDevice,
1761 const std::string &deviceName)
1762 {
1763 if (IsNonblockingSource(attr_.sourceType, attr_.adapterName)) {
1764 AUDIO_ERR_LOG("non blocking source not support SetAudioRouteInfoForEnhanceChain");
1765 return SUCCESS;
1766 }
1767 AudioEnhanceChainManager *audioEnhanceChainManager = AudioEnhanceChainManager::GetInstance();
1768 CHECK_AND_RETURN_RET_LOG(audioEnhanceChainManager != nullptr, ERROR, "audioEnhanceChainManager is nullptr");
1769 uint32_t captureId = 0;
1770 int32_t ret = GetCaptureId(captureId);
1771 if (ret != SUCCESS) {
1772 AUDIO_WARNING_LOG("GetCaptureId failed");
1773 }
1774 if (halName_ == "usb") {
1775 audioEnhanceChainManager->SetInputDevice(captureId, DEVICE_TYPE_USB_ARM_HEADSET, deviceName);
1776 } else {
1777 audioEnhanceChainManager->SetInputDevice(captureId, inputDevice, deviceName);
1778 }
1779 return SUCCESS;
1780 }
1781
UpdateSourceType(SourceType sourceType)1782 int32_t AudioCapturerSourceInner::UpdateSourceType(SourceType sourceType)
1783 {
1784 std::lock_guard<std::mutex> lock(statusMutex_);
1785 if (attr_.sourceType == sourceType) {
1786 AUDIO_INFO_LOG("input sourceType not change. currentActiveDevice %{public}d sourceType %{public}d",
1787 currentActiveDevice_, attr_.sourceType);
1788 return SUCCESS;
1789 }
1790
1791 attr_.sourceType = sourceType;
1792 AUDIO_INFO_LOG("change source type to %{public}d", attr_.sourceType);
1793 AudioPortPin inputPortPin = PIN_IN_MIC;
1794 return DoSetInputRoute(currentActiveDevice_, inputPortPin);
1795 }
1796
SetAddress(const std::string & address)1797 void AudioCapturerSourceInner::SetAddress(const std::string &address)
1798 {
1799 address_ = address;
1800 }
1801
Init(const IAudioSourceAttr & attr)1802 int32_t AudioCapturerSourceWakeup::Init(const IAudioSourceAttr &attr)
1803 {
1804 std::lock_guard<std::mutex> lock(wakeupMutex_);
1805 int32_t res = SUCCESS;
1806 if (isInited) {
1807 return res;
1808 }
1809 noStart_ = 0;
1810 if (initCount == 0) {
1811 if (wakeupBuffer_ == nullptr) {
1812 wakeupBuffer_ = std::make_unique<WakeupBuffer>();
1813 }
1814 res = audioCapturerSource_.Init(attr);
1815 }
1816 if (res == SUCCESS) {
1817 isInited = true;
1818 initCount++;
1819 }
1820 return res;
1821 }
1822
IsInited(void)1823 bool AudioCapturerSourceWakeup::IsInited(void)
1824 {
1825 return isInited;
1826 }
1827
DeInit(void)1828 void AudioCapturerSourceWakeup::DeInit(void)
1829 {
1830 AudioXCollie wakeupXCollie("AudioCapturerSourceWakeup::DeInit", DEINIT_TIME_OUT_SECONDS);
1831 AUDIO_INFO_LOG("Start deinit of source wakeup");
1832 std::lock_guard<std::mutex> lock(wakeupMutex_);
1833 if (!isInited) {
1834 return;
1835 }
1836 isInited = false;
1837 initCount--;
1838 if (initCount == 0) {
1839 wakeupBuffer_.reset();
1840 audioCapturerSource_.DeInit();
1841 }
1842 }
1843
Start(void)1844 int32_t AudioCapturerSourceWakeup::Start(void)
1845 {
1846 std::lock_guard<std::mutex> lock(wakeupMutex_);
1847 int32_t res = SUCCESS;
1848 if (isStarted) {
1849 return res;
1850 }
1851 if (startCount == 0) {
1852 res = audioCapturerSource_.Start();
1853 }
1854 if (res == SUCCESS) {
1855 isStarted = true;
1856 startCount++;
1857 }
1858 return res;
1859 }
1860
Stop(void)1861 int32_t AudioCapturerSourceWakeup::Stop(void)
1862 {
1863 std::lock_guard<std::mutex> lock(wakeupMutex_);
1864 int32_t res = SUCCESS;
1865 if (!isStarted) {
1866 return res;
1867 }
1868 if (startCount == 1) {
1869 res = audioCapturerSource_.Stop();
1870 }
1871 if (res == SUCCESS) {
1872 isStarted = false;
1873 startCount--;
1874 }
1875 return res;
1876 }
1877
Flush(void)1878 int32_t AudioCapturerSourceWakeup::Flush(void)
1879 {
1880 return audioCapturerSource_.Flush();
1881 }
1882
Reset(void)1883 int32_t AudioCapturerSourceWakeup::Reset(void)
1884 {
1885 return audioCapturerSource_.Reset();
1886 }
1887
Pause(void)1888 int32_t AudioCapturerSourceWakeup::Pause(void)
1889 {
1890 return audioCapturerSource_.Pause();
1891 }
1892
Resume(void)1893 int32_t AudioCapturerSourceWakeup::Resume(void)
1894 {
1895 return audioCapturerSource_.Resume();
1896 }
1897
CaptureFrame(char * frame,uint64_t requestBytes,uint64_t & replyBytes)1898 int32_t AudioCapturerSourceWakeup::CaptureFrame(char *frame, uint64_t requestBytes, uint64_t &replyBytes)
1899 {
1900 int32_t res = wakeupBuffer_->Poll(frame, requestBytes, replyBytes, noStart_);
1901 noStart_ += replyBytes;
1902 return res;
1903 }
1904
CaptureFrameWithEc(FrameDesc * fdesc,uint64_t & replyBytes,FrameDesc * fdescEc,uint64_t & replyBytesEc)1905 int32_t AudioCapturerSourceWakeup::CaptureFrameWithEc(
1906 FrameDesc *fdesc, uint64_t &replyBytes,
1907 FrameDesc *fdescEc, uint64_t &replyBytesEc)
1908 {
1909 AUDIO_ERR_LOG("not supported!");
1910 return ERR_DEVICE_NOT_SUPPORTED;
1911 }
1912
SetVolume(float left,float right)1913 int32_t AudioCapturerSourceWakeup::SetVolume(float left, float right)
1914 {
1915 return audioCapturerSource_.SetVolume(left, right);
1916 }
1917
GetVolume(float & left,float & right)1918 int32_t AudioCapturerSourceWakeup::GetVolume(float &left, float &right)
1919 {
1920 return audioCapturerSource_.GetVolume(left, right);
1921 }
1922
SetMute(bool isMute)1923 int32_t AudioCapturerSourceWakeup::SetMute(bool isMute)
1924 {
1925 return audioCapturerSource_.SetMute(isMute);
1926 }
1927
GetMute(bool & isMute)1928 int32_t AudioCapturerSourceWakeup::GetMute(bool &isMute)
1929 {
1930 return audioCapturerSource_.GetMute(isMute);
1931 }
1932
SetAudioScene(AudioScene audioScene,DeviceType activeDevice,const std::string & deviceName)1933 int32_t AudioCapturerSourceWakeup::SetAudioScene(AudioScene audioScene, DeviceType activeDevice,
1934 const std::string &deviceName)
1935 {
1936 return audioCapturerSource_.SetAudioScene(audioScene, activeDevice);
1937 }
1938
SetInputRoute(DeviceType inputDevice,const std::string & deviceName)1939 int32_t AudioCapturerSourceWakeup::SetInputRoute(DeviceType inputDevice, const std::string &deviceName)
1940 {
1941 return audioCapturerSource_.SetInputRoute(inputDevice);
1942 }
1943
GetTransactionId()1944 uint64_t AudioCapturerSourceWakeup::GetTransactionId()
1945 {
1946 return audioCapturerSource_.GetTransactionId();
1947 }
1948
GetPresentationPosition(uint64_t & frames,int64_t & timeSec,int64_t & timeNanoSec)1949 int32_t AudioCapturerSourceWakeup::GetPresentationPosition(uint64_t& frames, int64_t& timeSec, int64_t& timeNanoSec)
1950 {
1951 return audioCapturerSource_.GetPresentationPosition(frames, timeSec, timeNanoSec);
1952 }
1953
GetAudioParameter(const AudioParamKey key,const std::string & condition)1954 std::string AudioCapturerSourceWakeup::GetAudioParameter(const AudioParamKey key,
1955 const std::string &condition)
1956 {
1957 AUDIO_WARNING_LOG("not supported yet");
1958 return "";
1959 }
1960
RegisterWakeupCloseCallback(IAudioSourceCallback * callback)1961 void AudioCapturerSourceWakeup::RegisterWakeupCloseCallback(IAudioSourceCallback *callback)
1962 {
1963 audioCapturerSource_.RegisterWakeupCloseCallback(callback);
1964 }
1965
RegisterAudioCapturerSourceCallback(std::unique_ptr<ICapturerStateCallback> callback)1966 void AudioCapturerSourceWakeup::RegisterAudioCapturerSourceCallback(std::unique_ptr<ICapturerStateCallback> callback)
1967 {
1968 audioCapturerSource_.RegisterAudioCapturerSourceCallback(std::move(callback));
1969 }
1970
RegisterParameterCallback(IAudioSourceCallback * callback)1971 void AudioCapturerSourceWakeup::RegisterParameterCallback(IAudioSourceCallback *callback)
1972 {
1973 AUDIO_WARNING_LOG("AudioCapturerSourceWakeup: RegisterParameterCallback is not supported!");
1974 }
1975
GetMaxAmplitude()1976 float AudioCapturerSourceWakeup::GetMaxAmplitude()
1977 {
1978 return audioCapturerSource_.GetMaxAmplitude();
1979 }
1980
UpdateAppsUid(const int32_t appsUid[PA_MAX_OUTPUTS_PER_SOURCE],const size_t size)1981 int32_t AudioCapturerSourceWakeup::UpdateAppsUid(const int32_t appsUid[PA_MAX_OUTPUTS_PER_SOURCE],
1982 const size_t size)
1983 {
1984 return audioCapturerSource_.UpdateAppsUid(appsUid, size);
1985 }
1986
UpdateAppsUid(const std::vector<int32_t> & appsUid)1987 int32_t AudioCapturerSourceWakeup::UpdateAppsUid(const std::vector<int32_t> &appsUid)
1988 {
1989 return audioCapturerSource_.UpdateAppsUid(appsUid);
1990 }
1991
GetCaptureId(uint32_t & captureId) const1992 int32_t AudioCapturerSourceWakeup::GetCaptureId(uint32_t &captureId) const
1993 {
1994 int ret = audioCapturerSource_.GetCaptureId(captureId);
1995 return ret;
1996 }
1997 } // namespace AudioStandard
1998 } // namesapce OHOS
1999