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