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
16 #include <cstring>
17 #include <dlfcn.h>
18 #include <string>
19 #include <cinttypes>
20 #include "power_mgr_client.h"
21 #include "running_lock.h"
22 #include "audio_errors.h"
23 #include "audio_log.h"
24 #include "audio_utils.h"
25 #include "audio_capturer_source.h"
26 #include "v1_0/iaudio_manager.h"
27 #include "securec.h"
28
29 using namespace std;
30
31 namespace OHOS {
32 namespace AudioStandard {
33 class AudioCapturerSourceInner : public AudioCapturerSource {
34 public:
35 int32_t Init(IAudioSourceAttr &attr) override;
36 bool IsInited(void) override;
37 void DeInit(void) override;
38
39 int32_t Start(void) override;
40 int32_t Stop(void) override;
41 int32_t Flush(void) override;
42 int32_t Reset(void) override;
43 int32_t Pause(void) override;
44 int32_t Resume(void) override;
45 int32_t CaptureFrame(char *frame, uint64_t requestBytes, uint64_t &replyBytes) override;
46 int32_t SetVolume(float left, float right) override;
47 int32_t GetVolume(float &left, float &right) override;
48 int32_t SetMute(bool isMute) override;
49 int32_t GetMute(bool &isMute) override;
50
51 int32_t SetAudioScene(AudioScene audioScene, DeviceType activeDevice) override;
52
53 int32_t SetInputRoute(DeviceType inputDevice, AudioPortPin &inputPortPin);
54
55 int32_t SetInputRoute(DeviceType inputDevice) override;
56 uint64_t GetTransactionId() override;
57
58 void RegisterWakeupCloseCallback(IAudioSourceCallback* callback) override;
59 void RegisterAudioCapturerSourceCallback(IAudioSourceCallback* callback) override;
60
61 AudioCapturerSourceInner();
62 ~AudioCapturerSourceInner();
63
64 private:
65 static constexpr int32_t HALF_FACTOR = 2;
66 static constexpr uint32_t MAX_AUDIO_ADAPTER_NUM = 5;
67 static constexpr float MAX_VOLUME_LEVEL = 15.0f;
68 static constexpr uint32_t PRIMARY_INPUT_STREAM_ID = 14; // 14 + 0 * 8
69
70 int32_t CreateCapture(struct AudioPort &capturePort);
71 int32_t InitAudioManager();
72 void InitAttrsCapture(struct AudioSampleAttributes &attrs);
73 void OpenDumpFile();
74
75 IAudioSourceAttr attr_;
76 bool capturerInited_;
77 bool started_;
78 bool paused_;
79 float leftVolume_;
80 float rightVolume_;
81
82 int32_t routeHandle_ = -1;
83 uint32_t openMic_;
84 uint32_t captureId_ = 0;
85 std::string adapterNameCase_;
86 struct IAudioManager *audioManager_;
87 struct IAudioAdapter *audioAdapter_;
88 struct IAudioCapture *audioCapture_;
89 struct AudioAdapterDescriptor adapterDesc_;
90 struct AudioPort audioPort;
91
92 std::shared_ptr<PowerMgr::RunningLock> keepRunningLock_;
93
94 IAudioSourceCallback* wakeupCloseCallback_ = nullptr;
95 std::mutex wakeupClosecallbackMutex_;
96
97 IAudioSourceCallback* audioCapturerSourceCallback_ = nullptr;
98 std::mutex audioCapturerSourceCallbackMutex_;
99 #ifdef CAPTURE_DUMP
100 FILE *pfd_;
101 #endif
102 };
103
104 class AudioCapturerSourceWakeup : public AudioCapturerSource {
105 public:
106 int32_t Init(IAudioSourceAttr &attr) override;
107 bool IsInited(void) override;
108 void DeInit(void) override;
109
110 int32_t Start(void) override;
111 int32_t Stop(void) override;
112 int32_t Flush(void) override;
113 int32_t Reset(void) override;
114 int32_t Pause(void) override;
115 int32_t Resume(void) override;
116 int32_t CaptureFrame(char *frame, uint64_t requestBytes, uint64_t &replyBytes) override;
117 int32_t SetVolume(float left, float right) override;
118 int32_t GetVolume(float &left, float &right) override;
119 int32_t SetMute(bool isMute) override;
120 int32_t GetMute(bool &isMute) override;
121
122 int32_t SetAudioScene(AudioScene audioScene, DeviceType activeDevice) override;
123
124 int32_t SetInputRoute(DeviceType inputDevice) override;
125 uint64_t GetTransactionId() override;
126
127 void RegisterWakeupCloseCallback(IAudioSourceCallback* callback) override;
128 void RegisterAudioCapturerSourceCallback(IAudioSourceCallback* callback) override;
129
130 AudioCapturerSourceWakeup() = default;
131 ~AudioCapturerSourceWakeup() = default;
132
133 private:
MemcpysAndCheck(void * dest,size_t destMax,const void * src,size_t count)134 static inline void MemcpysAndCheck(void *dest, size_t destMax, const void *src, size_t count)
135 {
136 if (memcpy_s(dest, destMax, src, count)) {
137 AUDIO_ERR_LOG("memcpy_s error");
138 }
139 }
140 class WakeupBuffer {
141 public:
WakeupBuffer(size_t sizeMax=BUFFER_SIZE_MAX)142 explicit WakeupBuffer(size_t sizeMax = BUFFER_SIZE_MAX)
143 : sizeMax_(sizeMax),
144 buffer_(std::make_unique<char[]>(sizeMax))
145 {
146 }
147
148 ~WakeupBuffer() = default;
149
Poll(char * frame,uint64_t requestBytes,uint64_t & replyBytes,uint64_t & noStart)150 int32_t Poll(char *frame, uint64_t requestBytes, uint64_t &replyBytes, uint64_t &noStart)
151 {
152 std::lock_guard<std::mutex> lock(mutex_);
153
154 if (noStart < headNum_) {
155 noStart = headNum_;
156 }
157
158 if (noStart >= (headNum_ + size_)) {
159 if (requestBytes > sizeMax_) {
160 requestBytes = sizeMax_;
161 }
162
163 int32_t res = audioCapturerSource_.CaptureFrame(frame, requestBytes, replyBytes);
164 Offer(frame, replyBytes);
165
166 return res;
167 }
168
169 if (requestBytes > size_) { // size_!=0
170 replyBytes = size_;
171 } else {
172 replyBytes = requestBytes;
173 }
174
175 uint64_t tail = (head_ + size_) % sizeMax_;
176
177 if (tail > head_) {
178 MemcpysAndCheck(frame, replyBytes, buffer_.get() + head_, replyBytes);
179 headNum_ += replyBytes;
180 size_ -= replyBytes;
181 head_ = (head_ + replyBytes) % sizeMax_;
182 } else {
183 uint64_t copySize = min((sizeMax_ - head_), replyBytes);
184 if (copySize != 0) {
185 MemcpysAndCheck(frame, replyBytes, buffer_.get() + head_, copySize);
186 headNum_ += copySize;
187 size_ -= copySize;
188 head_ = (head_ + copySize) % sizeMax_;
189 }
190
191 uint64_t remainCopySize = replyBytes - copySize;
192 if (remainCopySize != 0) {
193 MemcpysAndCheck(frame + copySize, remainCopySize, buffer_.get(), remainCopySize);
194 headNum_ += remainCopySize;
195 size_ -= remainCopySize;
196 head_ = (head_ + remainCopySize) % sizeMax_;
197 }
198 }
199
200 return SUCCESS;
201 }
202 private:
203 static constexpr size_t BUFFER_SIZE_MAX = 32000; // 2 seconds
204
205 const size_t sizeMax_;
206 size_t size_ = 0;
207
208 std::unique_ptr<char[]> buffer_;
209 std::mutex mutex_;
210
211 uint64_t head_ = 0;
212
213 uint64_t headNum_ = 0;
214
Offer(const char * frame,const uint64_t bufferBytes)215 void Offer(const char *frame, const uint64_t bufferBytes)
216 {
217 if ((size_ + bufferBytes) > sizeMax_) { // head_ need shift
218 u_int64_t shift = (size_ + bufferBytes) - sizeMax_; // 1 to sizeMax_
219 headNum_ += shift;
220 if (size_ > shift) {
221 size_ -= shift;
222 head_ = ((head_ + shift) % sizeMax_);
223 } else {
224 size_ = 0;
225 head_ = 0;
226 }
227 }
228
229 uint64_t tail = (head_ + size_) % sizeMax_;
230 if (tail < head_) {
231 MemcpysAndCheck((buffer_.get() + tail), bufferBytes, frame, bufferBytes);
232 } else {
233 uint64_t copySize = min(sizeMax_ - tail, bufferBytes);
234 MemcpysAndCheck((buffer_.get() + tail), sizeMax_ - tail, frame, copySize);
235
236 if (copySize < bufferBytes) {
237 MemcpysAndCheck((buffer_.get()), bufferBytes - copySize, frame + copySize, bufferBytes - copySize);
238 }
239 }
240 size_ += bufferBytes;
241 }
242 };
243
244 uint64_t noStart_ = 0;
245 std::atomic<bool> isInited = false;
246 static inline int initCount = 0;
247
248 std::atomic<bool> isStarted = false;
249 static inline int startCount = 0;
250
251 static inline std::unique_ptr<WakeupBuffer> wakeupBuffer_;
252 static inline std::mutex wakeupMutex_;
253
254 static inline AudioCapturerSourceInner audioCapturerSource_;
255 };
256
257 #ifdef CAPTURE_DUMP
258 const char *g_audioOutTestFilePath = "/data/data/.pulse_dir/dump_audiosource.pcm";
259 #endif // CAPTURE_DUMP
260 bool AudioCapturerSource::micMuteState_ = false;
261 constexpr int32_t RUNNINGLOCK_LOCK_TIMEOUTMS_LASTING = -1;
262
AudioCapturerSourceInner()263 AudioCapturerSourceInner::AudioCapturerSourceInner()
264 : capturerInited_(false), started_(false), paused_(false), leftVolume_(MAX_VOLUME_LEVEL),
265 rightVolume_(MAX_VOLUME_LEVEL), openMic_(0), audioManager_(nullptr), audioAdapter_(nullptr),
266 audioCapture_(nullptr)
267 {
268 attr_ = {};
269 #ifdef CAPTURE_DUMP
270 pfd_ = nullptr;
271 #endif // CAPTURE_DUMP
272 }
273
~AudioCapturerSourceInner()274 AudioCapturerSourceInner::~AudioCapturerSourceInner()
275 {
276 AUDIO_ERR_LOG("~AudioCapturerSourceInner");
277 }
278
GetInstance(const SourceType sourceType,const char * sourceName)279 AudioCapturerSource *AudioCapturerSource::GetInstance(const SourceType sourceType, const char *sourceName)
280 {
281 switch (sourceType) {
282 case SourceType::SOURCE_TYPE_MIC:
283 return GetMicInstance();
284 case SourceType::SOURCE_TYPE_WAKEUP:
285 if (!strcmp(sourceName, "Built_in_wakeup_mirror")) {
286 return GetWakeupInstance(true);
287 } else {
288 return GetWakeupInstance(false);
289 }
290 default:
291 AUDIO_ERR_LOG("sourceType error %{public}d", sourceType);
292 return GetMicInstance();
293 }
294 }
295
ConvertToHDIAudioInputType(const int32_t currSourceType)296 static enum AudioInputType ConvertToHDIAudioInputType(const int32_t currSourceType)
297 {
298 enum AudioInputType hdiAudioInputType;
299 switch (currSourceType) {
300 case SOURCE_TYPE_INVALID:
301 hdiAudioInputType = AUDIO_INPUT_DEFAULT_TYPE;
302 break;
303 case SOURCE_TYPE_MIC:
304 case SOURCE_TYPE_PLAYBACK_CAPTURE:
305 case SOURCE_TYPE_ULTRASONIC:
306 hdiAudioInputType = AUDIO_INPUT_MIC_TYPE;
307 break;
308 case SOURCE_TYPE_WAKEUP:
309 hdiAudioInputType = AUDIO_INPUT_SPEECH_WAKEUP_TYPE;
310 break;
311 case SOURCE_TYPE_VOICE_COMMUNICATION:
312 hdiAudioInputType = AUDIO_INPUT_VOICE_COMMUNICATION_TYPE;
313 break;
314 case SOURCE_TYPE_VOICE_RECOGNITION:
315 hdiAudioInputType = AUDIO_INPUT_VOICE_RECOGNITION_TYPE;
316 break;
317 default:
318 hdiAudioInputType = AUDIO_INPUT_MIC_TYPE;
319 break;
320 }
321 return hdiAudioInputType;
322 }
323
GetMicInstance()324 AudioCapturerSource *AudioCapturerSource::GetMicInstance()
325 {
326 static AudioCapturerSourceInner audioCapturer;
327 return &audioCapturer;
328 }
329
GetWakeupInstance(bool isMirror)330 AudioCapturerSource *AudioCapturerSource::GetWakeupInstance(bool isMirror)
331 {
332 if (isMirror) {
333 static AudioCapturerSourceWakeup audioCapturerMirror;
334 return &audioCapturerMirror;
335 }
336 static AudioCapturerSourceWakeup audioCapturer;
337 return &audioCapturer;
338 }
339
IsInited(void)340 bool AudioCapturerSourceInner::IsInited(void)
341 {
342 return capturerInited_;
343 }
344
DeInit()345 void AudioCapturerSourceInner::DeInit()
346 {
347 started_ = false;
348 capturerInited_ = false;
349
350 if (audioAdapter_ != nullptr) {
351 audioAdapter_->DestroyCapture(audioAdapter_, captureId_);
352 }
353
354 IAudioSourceCallback* callback = nullptr;
355 {
356 std::lock_guard<std::mutex> lck(wakeupClosecallbackMutex_);
357 callback = wakeupCloseCallback_;
358 }
359 if (callback != nullptr) {
360 callback->OnWakeupClose();
361 }
362
363 audioCapture_ = nullptr;
364
365 if (audioManager_ != nullptr) {
366 audioManager_->UnloadAdapter(audioManager_, adapterDesc_.adapterName);
367 }
368 audioAdapter_ = nullptr;
369 audioManager_ = nullptr;
370 #ifdef CAPTURE_DUMP
371 if (pfd_) {
372 fclose(pfd_);
373 pfd_ = nullptr;
374 }
375 #endif // CAPTURE_DUMP
376 }
377
InitAttrsCapture(struct AudioSampleAttributes & attrs)378 void AudioCapturerSourceInner::InitAttrsCapture(struct AudioSampleAttributes &attrs)
379 {
380 /* Initialization of audio parameters for playback */
381 attrs.format = AUDIO_FORMAT_TYPE_PCM_16_BIT;
382 attrs.channelCount = AUDIO_CHANNELCOUNT;
383 attrs.sampleRate = AUDIO_SAMPLE_RATE_48K;
384 attrs.interleaved = true;
385 attrs.streamId = PRIMARY_INPUT_STREAM_ID;
386 attrs.type = AUDIO_IN_MEDIA;
387 attrs.period = DEEP_BUFFER_CAPTURE_PERIOD_SIZE;
388 attrs.frameSize = PCM_16_BIT * attrs.channelCount / PCM_8_BIT;
389 attrs.isBigEndian = false;
390 attrs.isSignedData = true;
391 attrs.startThreshold = DEEP_BUFFER_CAPTURE_PERIOD_SIZE / (attrs.frameSize);
392 attrs.stopThreshold = INT_32_MAX;
393 /* 16 * 1024 */
394 attrs.silenceThreshold = AUDIO_BUFF_SIZE;
395 attrs.sourceType = SOURCE_TYPE_MIC;
396 }
397
SwitchAdapterCapture(struct AudioAdapterDescriptor * descs,uint32_t size,const std::string & adapterNameCase,enum AudioPortDirection portFlag,struct AudioPort & capturePort)398 int32_t SwitchAdapterCapture(struct AudioAdapterDescriptor *descs, uint32_t size, const std::string &adapterNameCase,
399 enum AudioPortDirection portFlag, struct AudioPort &capturePort)
400 {
401 if (descs == nullptr) {
402 return ERROR;
403 }
404
405 for (uint32_t index = 0; index < size; index++) {
406 struct AudioAdapterDescriptor *desc = &descs[index];
407 if (desc == nullptr || desc->adapterName == nullptr) {
408 continue;
409 }
410 if (!adapterNameCase.compare(desc->adapterName)) {
411 for (uint32_t port = 0; port < desc->portsLen; port++) {
412 // Only find out the port of out in the sound card
413 if (desc->ports[port].dir == portFlag) {
414 capturePort = desc->ports[port];
415 return index;
416 }
417 }
418 }
419 }
420 AUDIO_ERR_LOG("SwitchAdapterCapture Fail");
421
422 return ERR_INVALID_INDEX;
423 }
424
InitAudioManager()425 int32_t AudioCapturerSourceInner::InitAudioManager()
426 {
427 AUDIO_INFO_LOG("Initialize audio proxy manager");
428
429 audioManager_ = IAudioManagerGet(false);
430 if (audioManager_ == nullptr) {
431 return ERR_INVALID_HANDLE;
432 }
433
434 return 0;
435 }
436
CreateCapture(struct AudioPort & capturePort)437 int32_t AudioCapturerSourceInner::CreateCapture(struct AudioPort &capturePort)
438 {
439 int32_t ret;
440 struct AudioSampleAttributes param;
441 // User needs to set
442 InitAttrsCapture(param);
443 param.sampleRate = attr_.sampleRate;
444 param.format = (AudioFormat)(attr_.format);
445 param.isBigEndian = attr_.isBigEndian;
446 param.channelCount = attr_.channel;
447 param.silenceThreshold = attr_.bufferSize;
448 param.frameSize = param.format * param.channelCount;
449 param.startThreshold = DEEP_BUFFER_CAPTURE_PERIOD_SIZE / (param.frameSize);
450 param.sourceType = static_cast<int32_t>(ConvertToHDIAudioInputType(attr_.sourceType));
451
452 struct AudioDeviceDescriptor deviceDesc;
453 deviceDesc.portId = capturePort.portId;
454 deviceDesc.pins = PIN_IN_MIC;
455 deviceDesc.desc = (char *)"";
456
457 ret = audioAdapter_->CreateCapture(audioAdapter_, &deviceDesc, ¶m, &audioCapture_, &captureId_);
458 AUDIO_INFO_LOG("CreateCapture param.sourceType: %{public}d", param.sourceType);
459 if (audioCapture_ == nullptr || ret < 0) {
460 AUDIO_ERR_LOG("Create capture failed");
461 return ERR_NOT_STARTED;
462 }
463
464 return 0;
465 }
466
Init(IAudioSourceAttr & attr)467 int32_t AudioCapturerSourceInner::Init(IAudioSourceAttr &attr)
468 {
469 if (InitAudioManager() != 0) {
470 AUDIO_ERR_LOG("Init audio manager Fail");
471 return ERR_INVALID_HANDLE;
472 }
473 attr_ = attr;
474 int32_t ret;
475 int32_t index;
476 uint32_t size = MAX_AUDIO_ADAPTER_NUM;
477 AudioAdapterDescriptor descs[MAX_AUDIO_ADAPTER_NUM];
478 ret = audioManager_->GetAllAdapters(audioManager_, (struct AudioAdapterDescriptor *)&descs, &size);
479 if (size > MAX_AUDIO_ADAPTER_NUM || size == 0 || ret != 0) {
480 AUDIO_ERR_LOG("Get adapters Fail");
481 return ERR_NOT_STARTED;
482 }
483 // Get qualified sound card and port
484 adapterNameCase_ = attr_.adapterName;
485 openMic_ = attr_.open_mic_speaker;
486 index = SwitchAdapterCapture((struct AudioAdapterDescriptor *)&descs, size, adapterNameCase_, PORT_IN, audioPort);
487 if (index < 0) {
488 AUDIO_ERR_LOG("Switch Adapter Capture Fail");
489 return ERR_NOT_STARTED;
490 }
491 adapterDesc_ = descs[index];
492 if (audioManager_->LoadAdapter(audioManager_, &adapterDesc_, &audioAdapter_) != 0) {
493 AUDIO_ERR_LOG("Load Adapter Fail");
494 return ERR_NOT_STARTED;
495 }
496 CHECK_AND_RETURN_RET_LOG(audioAdapter_ != nullptr, ERR_NOT_STARTED, "Load audio device failed");
497
498 // Inittialization port information, can fill through mode and other parameters
499 if (audioAdapter_->InitAllPorts(audioAdapter_) != 0) {
500 AUDIO_ERR_LOG("InitAllPorts failed");
501 return ERR_DEVICE_INIT;
502 }
503 if (CreateCapture(audioPort) != 0) {
504 AUDIO_ERR_LOG("Create capture failed");
505 return ERR_NOT_STARTED;
506 }
507 if (openMic_) {
508 ret = SetInputRoute(DEVICE_TYPE_MIC);
509 if (ret < 0) {
510 AUDIO_ERR_LOG("update route FAILED: %{public}d", ret);
511 }
512 }
513 capturerInited_ = true;
514
515 OpenDumpFile();
516 return SUCCESS;
517 }
518
OpenDumpFile()519 void AudioCapturerSourceInner::OpenDumpFile()
520 {
521 #ifdef CAPTURE_DUMP
522 pfd_ = fopen(g_audioOutTestFilePath, "wb+");
523 if (pfd_ == nullptr) {
524 AUDIO_ERR_LOG("Error opening pcm test file!");
525 }
526 #endif // CAPTURE_DUMP
527 }
528
CaptureFrame(char * frame,uint64_t requestBytes,uint64_t & replyBytes)529 int32_t AudioCapturerSourceInner::CaptureFrame(char *frame, uint64_t requestBytes, uint64_t &replyBytes)
530 {
531 int64_t stamp = ClockTime::GetCurNano();
532 int32_t ret;
533 if (audioCapture_ == nullptr) {
534 AUDIO_ERR_LOG("Audio capture Handle is nullptr!");
535 return ERR_INVALID_HANDLE;
536 }
537
538 uint32_t frameLen = static_cast<uint32_t>(requestBytes);
539 ret = audioCapture_->CaptureFrame(audioCapture_, reinterpret_cast<int8_t*>(frame), &frameLen, &replyBytes);
540 if (ret < 0) {
541 AUDIO_ERR_LOG("Capture Frame Fail");
542 return ERR_READ_FAILED;
543 }
544
545 #ifdef CAPTURE_DUMP
546 if (pfd_) {
547 size_t writeResult = fwrite(frame, 1, replyBytes, pfd_);
548 if (writeResult != replyBytes) {
549 AUDIO_ERR_LOG("Failed to write the file.");
550 }
551 }
552 #endif // CAPTURE_DUMP
553
554 stamp = (ClockTime::GetCurNano() - stamp) / AUDIO_US_PER_SECOND;
555 AUDIO_DEBUG_LOG("RenderFrame len[%{public}" PRIu64 "] cost[%{public}" PRId64 "]ms", requestBytes, stamp);
556 return SUCCESS;
557 }
558
Start(void)559 int32_t AudioCapturerSourceInner::Start(void)
560 {
561 AUDIO_INFO_LOG("Start.");
562 if (keepRunningLock_ == nullptr) {
563 switch (attr_.sourceType) {
564 case SOURCE_TYPE_WAKEUP:
565 keepRunningLock_ = PowerMgr::PowerMgrClient::GetInstance().CreateRunningLock("AudioWakeupCapturer",
566 PowerMgr::RunningLockType::RUNNINGLOCK_BACKGROUND_AUDIO);
567 break;
568 case SOURCE_TYPE_MIC:
569 default:
570 keepRunningLock_ = PowerMgr::PowerMgrClient::GetInstance().CreateRunningLock("AudioPrimaryCapturer",
571 PowerMgr::RunningLockType::RUNNINGLOCK_BACKGROUND_AUDIO);
572 }
573 }
574 if (keepRunningLock_ != nullptr) {
575 AUDIO_INFO_LOG("AudioCapturerSourceInner call KeepRunningLock lock");
576 keepRunningLock_->Lock(RUNNINGLOCK_LOCK_TIMEOUTMS_LASTING); // -1 for lasting.
577 } else {
578 AUDIO_ERR_LOG("keepRunningLock_ is null, start can not work well!");
579 }
580
581 int32_t ret;
582 if (!started_) {
583 IAudioSourceCallback* callback = nullptr;
584 {
585 std::lock_guard<std::mutex> lck(audioCapturerSourceCallbackMutex_);
586 callback = audioCapturerSourceCallback_;
587 }
588 if (callback != nullptr) {
589 callback->OnCapturerState(true);
590 }
591
592 ret = audioCapture_->Start(audioCapture_);
593 if (ret < 0) {
594 return ERR_NOT_STARTED;
595 }
596 started_ = true;
597 }
598
599 return SUCCESS;
600 }
601
SetVolume(float left,float right)602 int32_t AudioCapturerSourceInner::SetVolume(float left, float right)
603 {
604 float volume;
605 if (audioCapture_ == nullptr) {
606 AUDIO_ERR_LOG("SetVolume failed audioCapture_ null");
607 return ERR_INVALID_HANDLE;
608 }
609
610 rightVolume_ = right;
611 leftVolume_ = left;
612 if ((leftVolume_ == 0) && (rightVolume_ != 0)) {
613 volume = rightVolume_;
614 } else if ((leftVolume_ != 0) && (rightVolume_ == 0)) {
615 volume = leftVolume_;
616 } else {
617 volume = (leftVolume_ + rightVolume_) / HALF_FACTOR;
618 }
619
620 audioCapture_->SetVolume(audioCapture_, volume);
621
622 return SUCCESS;
623 }
624
GetVolume(float & left,float & right)625 int32_t AudioCapturerSourceInner::GetVolume(float &left, float &right)
626 {
627 float val = 0.0;
628 audioCapture_->GetVolume(audioCapture_, &val);
629 left = val;
630 right = val;
631
632 return SUCCESS;
633 }
634
SetMute(bool isMute)635 int32_t AudioCapturerSourceInner::SetMute(bool isMute)
636 {
637 int32_t ret;
638 if (audioCapture_ == nullptr) {
639 AUDIO_ERR_LOG("SetMute failed audioCapture_ handle is null!");
640 return ERR_INVALID_HANDLE;
641 }
642
643 ret = audioCapture_->SetMute(audioCapture_, isMute);
644 if (ret != 0) {
645 AUDIO_ERR_LOG("SetMute failed from hdi");
646 }
647
648 if (audioAdapter_ != nullptr) {
649 ret = audioAdapter_->SetMicMute(audioAdapter_, isMute);
650 if (ret != 0) {
651 AUDIO_ERR_LOG("SetMicMute failed from hdi");
652 }
653 }
654
655 AudioCapturerSource::micMuteState_ = isMute;
656
657 return SUCCESS;
658 }
659
GetMute(bool & isMute)660 int32_t AudioCapturerSourceInner::GetMute(bool &isMute)
661 {
662 int32_t ret;
663 if (audioCapture_ == nullptr) {
664 AUDIO_ERR_LOG("GetMute failed audioCapture_ handle is null!");
665 return ERR_INVALID_HANDLE;
666 }
667
668 bool isHdiMute = false;
669 ret = audioCapture_->GetMute(audioCapture_, &isHdiMute);
670 if (ret != 0) {
671 AUDIO_ERR_LOG("GetMute failed from hdi");
672 }
673
674 isMute = AudioCapturerSource::micMuteState_;
675
676 return SUCCESS;
677 }
678
GetAudioCategory(AudioScene audioScene)679 static AudioCategory GetAudioCategory(AudioScene audioScene)
680 {
681 AudioCategory audioCategory;
682 switch (audioScene) {
683 case AUDIO_SCENE_PHONE_CALL:
684 audioCategory = AUDIO_IN_CALL;
685 break;
686 case AUDIO_SCENE_PHONE_CHAT:
687 audioCategory = AUDIO_IN_COMMUNICATION;
688 break;
689 case AUDIO_SCENE_RINGING:
690 audioCategory = AUDIO_IN_RINGTONE;
691 break;
692 case AUDIO_SCENE_DEFAULT:
693 audioCategory = AUDIO_IN_MEDIA;
694 break;
695 default:
696 audioCategory = AUDIO_IN_MEDIA;
697 break;
698 }
699 AUDIO_DEBUG_LOG("Audio category returned is: %{public}d", audioCategory);
700
701 return audioCategory;
702 }
703
SetInputPortPin(DeviceType inputDevice,AudioRouteNode & source)704 static int32_t SetInputPortPin(DeviceType inputDevice, AudioRouteNode &source)
705 {
706 int32_t ret = SUCCESS;
707
708 switch (inputDevice) {
709 case DEVICE_TYPE_MIC:
710 case DEVICE_TYPE_EARPIECE:
711 case DEVICE_TYPE_SPEAKER:
712 source.ext.device.type = PIN_IN_MIC;
713 source.ext.device.desc = (char *)"pin_in_mic";
714 break;
715 case DEVICE_TYPE_WIRED_HEADSET:
716 source.ext.device.type = PIN_IN_HS_MIC;
717 source.ext.device.desc = (char *)"pin_in_hs_mic";
718 break;
719 case DEVICE_TYPE_USB_HEADSET:
720 source.ext.device.type = PIN_IN_USB_EXT;
721 source.ext.device.desc = (char *)"pin_in_usb_ext";
722 break;
723 case DEVICE_TYPE_BLUETOOTH_SCO:
724 source.ext.device.type = PIN_IN_BLUETOOTH_SCO_HEADSET;
725 source.ext.device.desc = (char *)"pin_in_bluetooth_sco_headset";
726 break;
727 default:
728 ret = ERR_NOT_SUPPORTED;
729 break;
730 }
731
732 return ret;
733 }
734
SetInputRoute(DeviceType inputDevice)735 int32_t AudioCapturerSourceInner::SetInputRoute(DeviceType inputDevice)
736 {
737 AudioPortPin inputPortPin = PIN_IN_MIC;
738 return SetInputRoute(inputDevice, inputPortPin);
739 }
740
SetInputRoute(DeviceType inputDevice,AudioPortPin & inputPortPin)741 int32_t AudioCapturerSourceInner::SetInputRoute(DeviceType inputDevice, AudioPortPin &inputPortPin)
742 {
743 AudioRouteNode source = {};
744 AudioRouteNode sink = {};
745
746 int32_t ret = SetInputPortPin(inputDevice, source);
747 if (ret != SUCCESS) {
748 AUDIO_ERR_LOG("SetOutputRoute FAILED: %{public}d", ret);
749 return ret;
750 }
751
752 inputPortPin = source.ext.device.type;
753 AUDIO_INFO_LOG("Input PIN is: 0x%{public}X", inputPortPin);
754 source.portId = static_cast<int32_t>(audioPort.portId);
755 source.role = AUDIO_PORT_SOURCE_ROLE;
756 source.type = AUDIO_PORT_DEVICE_TYPE;
757 source.ext.device.moduleId = 0;
758 source.ext.device.desc = (char *)"";
759
760 sink.portId = 0;
761 sink.role = AUDIO_PORT_SINK_ROLE;
762 sink.type = AUDIO_PORT_MIX_TYPE;
763 sink.ext.mix.moduleId = 0;
764 sink.ext.mix.streamId = PRIMARY_INPUT_STREAM_ID;
765 sink.ext.device.desc = (char *)"";
766
767 AudioRoute route = {
768 .sources = &source,
769 .sourcesLen = 1,
770 .sinks = &sink,
771 .sinksLen = 1,
772 };
773
774 if (audioAdapter_ == nullptr) {
775 AUDIO_ERR_LOG("AudioAdapter object is null.");
776 return ERR_OPERATION_FAILED;
777 }
778
779 ret = audioAdapter_->UpdateAudioRoute(audioAdapter_, &route, &routeHandle_);
780 if (ret != 0) {
781 AUDIO_ERR_LOG("UpdateAudioRoute failed");
782 return ERR_OPERATION_FAILED;
783 }
784
785 return SUCCESS;
786 }
787
SetAudioScene(AudioScene audioScene,DeviceType activeDevice)788 int32_t AudioCapturerSourceInner::SetAudioScene(AudioScene audioScene, DeviceType activeDevice)
789 {
790 AUDIO_INFO_LOG("SetAudioScene scene: %{public}d, device: %{public}d",
791 audioScene, activeDevice);
792 CHECK_AND_RETURN_RET_LOG(audioScene >= AUDIO_SCENE_DEFAULT && audioScene <= AUDIO_SCENE_PHONE_CHAT,
793 ERR_INVALID_PARAM, "invalid audioScene");
794 if (audioCapture_ == nullptr) {
795 AUDIO_ERR_LOG("SetAudioScene failed audioCapture_ handle is null!");
796 return ERR_INVALID_HANDLE;
797 }
798 if (openMic_) {
799 AudioPortPin audioSceneInPort = PIN_IN_MIC;
800 int32_t ret = SetInputRoute(activeDevice, audioSceneInPort);
801 if (ret < 0) {
802 AUDIO_ERR_LOG("Update route FAILED: %{public}d", ret);
803 }
804 struct AudioSceneDescriptor scene;
805 scene.scene.id = GetAudioCategory(audioScene);
806 scene.desc.pins = audioSceneInPort;
807 scene.desc.desc = (char *)"";
808
809 ret = audioCapture_->SelectScene(audioCapture_, &scene);
810 if (ret < 0) {
811 AUDIO_ERR_LOG("Select scene FAILED: %{public}d", ret);
812 return ERR_OPERATION_FAILED;
813 }
814 }
815 AUDIO_DEBUG_LOG("Select audio scene SUCCESS: %{public}d", audioScene);
816 return SUCCESS;
817 }
818
GetTransactionId()819 uint64_t AudioCapturerSourceInner::GetTransactionId()
820 {
821 AUDIO_INFO_LOG("GetTransactionId in");
822 return reinterpret_cast<uint64_t>(audioCapture_);
823 }
824
Stop(void)825 int32_t AudioCapturerSourceInner::Stop(void)
826 {
827 AUDIO_INFO_LOG("Stop.");
828
829 if (keepRunningLock_ != nullptr) {
830 AUDIO_INFO_LOG("AudioCapturerSourceInner call KeepRunningLock UnLock");
831 keepRunningLock_->UnLock();
832 } else {
833 AUDIO_ERR_LOG("keepRunningLock_ is null, stop can not work well!");
834 }
835
836 int32_t ret;
837 if (started_ && audioCapture_ != nullptr) {
838 ret = audioCapture_->Stop(audioCapture_);
839 if (ret < 0) {
840 AUDIO_ERR_LOG("Stop capture Failed");
841 return ERR_OPERATION_FAILED;
842 }
843 }
844 started_ = false;
845
846 IAudioSourceCallback* callback = nullptr;
847 {
848 std::lock_guard<std::mutex> lck(audioCapturerSourceCallbackMutex_);
849 callback = audioCapturerSourceCallback_;
850 }
851 if (callback != nullptr) {
852 callback->OnCapturerState(false);
853 }
854
855 return SUCCESS;
856 }
857
Pause(void)858 int32_t AudioCapturerSourceInner::Pause(void)
859 {
860 int32_t ret;
861 if (started_ && audioCapture_ != nullptr) {
862 ret = audioCapture_->Pause(audioCapture_);
863 if (ret != 0) {
864 AUDIO_ERR_LOG("pause capture Failed");
865 return ERR_OPERATION_FAILED;
866 }
867 }
868 paused_ = true;
869
870 return SUCCESS;
871 }
872
Resume(void)873 int32_t AudioCapturerSourceInner::Resume(void)
874 {
875 int32_t ret;
876 if (paused_ && audioCapture_ != nullptr) {
877 ret = audioCapture_->Resume(audioCapture_);
878 if (ret != 0) {
879 AUDIO_ERR_LOG("resume capture Failed");
880 return ERR_OPERATION_FAILED;
881 }
882 }
883 paused_ = false;
884
885 return SUCCESS;
886 }
887
Reset(void)888 int32_t AudioCapturerSourceInner::Reset(void)
889 {
890 if (started_ && audioCapture_ != nullptr) {
891 audioCapture_->Flush(audioCapture_);
892 }
893
894 return SUCCESS;
895 }
896
Flush(void)897 int32_t AudioCapturerSourceInner::Flush(void)
898 {
899 if (started_ && audioCapture_ != nullptr) {
900 audioCapture_->Flush(audioCapture_);
901 }
902
903 return SUCCESS;
904 }
905
RegisterWakeupCloseCallback(IAudioSourceCallback * callback)906 void AudioCapturerSourceInner::RegisterWakeupCloseCallback(IAudioSourceCallback* callback)
907 {
908 AUDIO_INFO_LOG("Register WakeupClose Callback");
909 std::lock_guard<std::mutex> lck(wakeupClosecallbackMutex_);
910 wakeupCloseCallback_ = callback;
911 }
912
RegisterAudioCapturerSourceCallback(IAudioSourceCallback * callback)913 void AudioCapturerSourceInner::RegisterAudioCapturerSourceCallback(IAudioSourceCallback* callback)
914 {
915 AUDIO_INFO_LOG("Register AudioCapturerSource Callback");
916 std::lock_guard<std::mutex> lck(audioCapturerSourceCallbackMutex_);
917 audioCapturerSourceCallback_ = callback;
918 }
919
Init(IAudioSourceAttr & attr)920 int32_t AudioCapturerSourceWakeup::Init(IAudioSourceAttr &attr)
921 {
922 std::lock_guard<std::mutex> lock(wakeupMutex_);
923 int32_t res = SUCCESS;
924 if (isInited) {
925 return res;
926 }
927 noStart_ = 0;
928 if (initCount == 0) {
929 if (wakeupBuffer_ == nullptr) {
930 wakeupBuffer_ = std::make_unique<WakeupBuffer>();
931 }
932 res = audioCapturerSource_.Init(attr);
933 }
934 if (res == SUCCESS) {
935 isInited = true;
936 initCount++;
937 }
938 return res;
939 }
940
IsInited(void)941 bool AudioCapturerSourceWakeup::IsInited(void)
942 {
943 return isInited;
944 }
945
DeInit(void)946 void AudioCapturerSourceWakeup::DeInit(void)
947 {
948 std::lock_guard<std::mutex> lock(wakeupMutex_);
949 if (!isInited) {
950 return;
951 }
952 isInited = false;
953 initCount--;
954 if (initCount == 0) {
955 wakeupBuffer_.reset();
956 audioCapturerSource_.DeInit();
957 }
958 }
959
Start(void)960 int32_t AudioCapturerSourceWakeup::Start(void)
961 {
962 std::lock_guard<std::mutex> lock(wakeupMutex_);
963 int32_t res = SUCCESS;
964 if (isStarted) {
965 return res;
966 }
967 if (startCount == 0) {
968 res = audioCapturerSource_.Start();
969 }
970 if (res == SUCCESS) {
971 isStarted = true;
972 startCount++;
973 }
974 return res;
975 }
976
Stop(void)977 int32_t AudioCapturerSourceWakeup::Stop(void)
978 {
979 std::lock_guard<std::mutex> lock(wakeupMutex_);
980 int32_t res = SUCCESS;
981 if (!isStarted) {
982 return res;
983 }
984 if (startCount == 1) {
985 res = audioCapturerSource_.Stop();
986 }
987 if (res == SUCCESS) {
988 isStarted = false;
989 startCount--;
990 }
991 return res;
992 }
993
Flush(void)994 int32_t AudioCapturerSourceWakeup::Flush(void)
995 {
996 return audioCapturerSource_.Flush();
997 }
998
Reset(void)999 int32_t AudioCapturerSourceWakeup::Reset(void)
1000 {
1001 return audioCapturerSource_.Reset();
1002 }
1003
Pause(void)1004 int32_t AudioCapturerSourceWakeup::Pause(void)
1005 {
1006 return audioCapturerSource_.Pause();
1007 }
1008
Resume(void)1009 int32_t AudioCapturerSourceWakeup::Resume(void)
1010 {
1011 return audioCapturerSource_.Resume();
1012 }
1013
CaptureFrame(char * frame,uint64_t requestBytes,uint64_t & replyBytes)1014 int32_t AudioCapturerSourceWakeup::CaptureFrame(char *frame, uint64_t requestBytes, uint64_t &replyBytes)
1015 {
1016 int32_t res = wakeupBuffer_->Poll(frame, requestBytes, replyBytes, noStart_);
1017 noStart_ += replyBytes;
1018 return res;
1019 }
1020
SetVolume(float left,float right)1021 int32_t AudioCapturerSourceWakeup::SetVolume(float left, float right)
1022 {
1023 return audioCapturerSource_.SetVolume(left, right);
1024 }
1025
GetVolume(float & left,float & right)1026 int32_t AudioCapturerSourceWakeup::GetVolume(float &left, float &right)
1027 {
1028 return audioCapturerSource_.GetVolume(left, right);
1029 }
1030
SetMute(bool isMute)1031 int32_t AudioCapturerSourceWakeup::SetMute(bool isMute)
1032 {
1033 return audioCapturerSource_.SetMute(isMute);
1034 }
1035
GetMute(bool & isMute)1036 int32_t AudioCapturerSourceWakeup::GetMute(bool &isMute)
1037 {
1038 return audioCapturerSource_.GetMute(isMute);
1039 }
1040
SetAudioScene(AudioScene audioScene,DeviceType activeDevice)1041 int32_t AudioCapturerSourceWakeup::SetAudioScene(AudioScene audioScene, DeviceType activeDevice)
1042 {
1043 return audioCapturerSource_.SetAudioScene(audioScene, activeDevice);
1044 }
1045
SetInputRoute(DeviceType inputDevice)1046 int32_t AudioCapturerSourceWakeup::SetInputRoute(DeviceType inputDevice)
1047 {
1048 return audioCapturerSource_.SetInputRoute(inputDevice);
1049 }
1050
GetTransactionId()1051 uint64_t AudioCapturerSourceWakeup::GetTransactionId()
1052 {
1053 return audioCapturerSource_.GetTransactionId();
1054 }
1055
RegisterWakeupCloseCallback(IAudioSourceCallback * callback)1056 void AudioCapturerSourceWakeup::RegisterWakeupCloseCallback(IAudioSourceCallback* callback)
1057 {
1058 audioCapturerSource_.RegisterWakeupCloseCallback(callback);
1059 }
1060
RegisterAudioCapturerSourceCallback(IAudioSourceCallback * callback)1061 void AudioCapturerSourceWakeup::RegisterAudioCapturerSourceCallback(IAudioSourceCallback* callback)
1062 {
1063 audioCapturerSource_.RegisterAudioCapturerSourceCallback(callback);
1064 }
1065
1066 } // namespace AudioStandard
1067 } // namesapce OHOS
1068