1 /*
2 * Copyright (c) 2022-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 "RemoteAudioCapturerSourceInner"
17 #endif
18
19 #include "remote_audio_capturer_source.h"
20
21 #include <cstring>
22 #include <dlfcn.h>
23 #include <string>
24 #include <mutex>
25 #include "securec.h"
26
27 #include "audio_errors.h"
28 #include "audio_hdi_log.h"
29 #include "audio_utils.h"
30 #include "i_audio_device_adapter.h"
31 #include "i_audio_device_manager.h"
32
33 using namespace std;
34 using OHOS::HDI::DistributedAudio::Audio::V1_0::IAudioAdapter;
35 using OHOS::HDI::DistributedAudio::Audio::V1_0::AudioAdapterDescriptor;
36 using OHOS::HDI::DistributedAudio::Audio::V1_0::AudioFormat;
37 using OHOS::HDI::DistributedAudio::Audio::V1_0::AudioPort;
38 using OHOS::HDI::DistributedAudio::Audio::V1_0::AudioPortDirection;
39 using OHOS::HDI::DistributedAudio::Audio::V1_0::IAudioManager;
40 using OHOS::HDI::DistributedAudio::Audio::V1_0::IAudioCapture;
41 using OHOS::HDI::DistributedAudio::Audio::V1_0::AudioSampleAttributes;
42 using OHOS::HDI::DistributedAudio::Audio::V1_0::AudioDeviceDescriptor;
43 using OHOS::HDI::DistributedAudio::Audio::V1_0::AudioCategory;
44 using OHOS::HDI::DistributedAudio::Audio::V1_0::AudioRouteNode;
45 using OHOS::HDI::DistributedAudio::Audio::V1_0::AudioExtParamKey;
46 using OHOS::HDI::DistributedAudio::Audio::V1_0::AudioRoute;
47 using OHOS::HDI::DistributedAudio::Audio::V1_0::AudioSceneDescriptor;
48 using OHOS::HDI::DistributedAudio::Audio::V1_0::IAudioCallback;
49 using OHOS::HDI::DistributedAudio::Audio::V1_0::AudioPortPin;
50 using OHOS::HDI::DistributedAudio::Audio::V1_0::AudioPortType;
51 using OHOS::HDI::DistributedAudio::Audio::V1_0::AudioPortRole;
52
53 namespace OHOS {
54 namespace AudioStandard {
55 namespace {
56 const uint16_t GET_MAX_AMPLITUDE_FRAMES_THRESHOLD = 10;
57 const char* DUMP_REMOTE_CAPTURE_SOURCE_FILENAME = "dump_remote_capture_audiosource.pcm";
58 } // namespace
59
60 class RemoteAudioCapturerSourceInner : public RemoteAudioCapturerSource, public IAudioDeviceAdapterCallback {
61 public:
62 explicit RemoteAudioCapturerSourceInner(const std::string &deviceNetworkId);
63 ~RemoteAudioCapturerSourceInner();
64
65 int32_t Init(const IAudioSourceAttr &attr) override;
66 bool IsInited(void) override;
67 void DeInit(void) override;
68
69 int32_t Start(void) override;
70 int32_t Stop(void) override;
71 int32_t Flush(void) override;
72 int32_t Reset(void) override;
73 int32_t Pause(void) override;
74 int32_t Resume(void) override;
75 int32_t CaptureFrame(char *frame, uint64_t requestBytes, uint64_t &replyBytes) override;
76 int32_t CaptureFrameWithEc(
77 FrameDesc *fdesc, uint64_t &replyBytes,
78 FrameDesc *fdescEc, uint64_t &replyBytesEc) override;
79 int32_t SetVolume(float left, float right) override;
80 int32_t GetVolume(float &left, float &right) override;
81 int32_t SetMute(bool isMute) override;
82 int32_t GetMute(bool &isMute) override;
83 int32_t SetAudioScene(AudioScene audioScene, DeviceType activeDevice, const std::string &deviceName = "") override;
84 int32_t SetInputRoute(DeviceType inputDevice, const std::string &deviceName = "") override;
85 uint64_t GetTransactionId() override;
86 int32_t GetPresentationPosition(uint64_t& frames, int64_t& timeSec, int64_t& timeNanoSec) override;
87 std::string GetAudioParameter(const AudioParamKey key, const std::string &condition) override;
88 void RegisterWakeupCloseCallback(IAudioSourceCallback *callback) override;
89 void RegisterAudioCapturerSourceCallback(std::unique_ptr<ICapturerStateCallback> callback) override;
90 void RegisterParameterCallback(IAudioSourceCallback *callback) override;
91
92 void OnAudioParamChange(const std::string &adapterName, const AudioParamKey key, const std::string &condition,
93 const std::string &value) override;
94
95 float GetMaxAmplitude() override;
96 int32_t GetCaptureId(uint32_t &captureId) const override;
97
98 int32_t UpdateAppsUid(const int32_t appsUid[PA_MAX_OUTPUTS_PER_SOURCE], const size_t size) final;
99 int32_t UpdateAppsUid(const std::vector<int32_t> &appsUid) final;
100 private:
101 int32_t CreateCapture(const AudioPort &capturePort);
102 int32_t SetInputPortPin(DeviceType inputDevice, AudioRouteNode &source);
103 AudioCategory GetAudioCategory(AudioScene audioScene);
104 void ClearCapture();
105 AudioFormat ConvertToHdiFormat(HdiAdapterFormat format);
106 void CheckUpdateState(char *frame, uint64_t replyBytes);
107
108 private:
109 const uint32_t maxInt32 = 0x7fffffff;
110 const uint32_t audioBufferSize = 16 * 1024;
111 const uint32_t deepBufferCapturePeriodSize = 4096;
112 // for get amplitude
113 float maxAmplitude_ = 0;
114 int64_t lastGetMaxAmplitudeTime_ = 0;
115 int64_t last10FrameStartTime_ = 0;
116 bool startUpdate_ = false;
117 int capFrameNum_ = 0;
118
119 IAudioSourceAttr attr_ = {};
120 std::string deviceNetworkId_ = "";
121 std::atomic<bool> capturerInited_ = false;
122 std::atomic<bool> isCapturerCreated_ = false;
123 std::atomic<bool> started_ = false;
124 std::atomic<bool> paused_ = false;
125
126 std::shared_ptr<IAudioDeviceManager> audioManager_ = nullptr;
127 std::mutex audioMangerMutex_;
128
129 std::shared_ptr<IAudioDeviceAdapter> audioAdapter_ = nullptr;
130 std::mutex audioAdapterMutex_;
131
132 IAudioSourceCallback *paramCb_ = nullptr;
133 sptr<IAudioCapture> audioCapture_ = nullptr;
134 struct AudioPort audioPort_ = {};
135 FILE *dumpFile_ = nullptr;
136 bool muteState_ = false;
137 std::mutex createCaptureMutex_;
138 uint32_t captureId_ = 0;
139 };
140
141 std::mutex g_capturerRemoteSourcesMutex;
142 std::map<std::string, RemoteAudioCapturerSourceInner *> allRemoteSources;
GetInstance(const std::string & deviceNetworkId)143 RemoteAudioCapturerSource *RemoteAudioCapturerSource::GetInstance(const std::string &deviceNetworkId)
144 {
145 std::lock_guard<std::mutex> lock(g_capturerRemoteSourcesMutex);
146 AUDIO_INFO_LOG("GetInstance.");
147 bool isEmpty = deviceNetworkId.empty();
148 CHECK_AND_RETURN_RET_LOG(!isEmpty, nullptr, "Remote capture device networkId is null.");
149
150 if (allRemoteSources.count(deviceNetworkId)) {
151 return allRemoteSources[deviceNetworkId];
152 }
153 RemoteAudioCapturerSourceInner *audioCapturer = new(std::nothrow) RemoteAudioCapturerSourceInner(deviceNetworkId);
154 AUDIO_INFO_LOG("New daudio remote capture device [%{public}s].", GetEncryptStr(deviceNetworkId).c_str());
155 allRemoteSources[deviceNetworkId] = audioCapturer;
156 return audioCapturer;
157 }
158
GetAllInstance(std::vector<IAudioCapturerSource * > & allInstance)159 void RemoteAudioCapturerSource::GetAllInstance(std::vector<IAudioCapturerSource *> &allInstance)
160 {
161 std::lock_guard<std::mutex> lock(g_capturerRemoteSourcesMutex);
162 for (auto it = allRemoteSources.begin(); it != allRemoteSources.end(); it++) {
163 allInstance.push_back((*it).second);
164 }
165 }
166
RemoteAudioCapturerSourceInner(const std::string & deviceNetworkId)167 RemoteAudioCapturerSourceInner::RemoteAudioCapturerSourceInner(const std::string &deviceNetworkId)
168 : deviceNetworkId_(deviceNetworkId) {}
169
~RemoteAudioCapturerSourceInner()170 RemoteAudioCapturerSourceInner::~RemoteAudioCapturerSourceInner()
171 {
172 if (capturerInited_.load()) {
173 RemoteAudioCapturerSourceInner::DeInit();
174 } else {
175 AUDIO_DEBUG_LOG("RemoteAudioCapturerSource has already DeInit.");
176 }
177 }
178
ClearCapture()179 void RemoteAudioCapturerSourceInner::ClearCapture()
180 {
181 AUDIO_INFO_LOG("Clear capture enter.");
182 capturerInited_.store(false);
183 isCapturerCreated_.store(false);
184 started_.store(false);
185 paused_.store(false);
186
187 std::shared_ptr<IAudioDeviceAdapter> audioAdapter;
188 {
189 std::lock_guard<std::mutex> lock(audioAdapterMutex_);
190 audioAdapter = std::move(audioAdapter_);
191 audioAdapter_ = nullptr;
192 }
193
194 if (audioAdapter != nullptr) {
195 audioAdapter->DestroyCapture(audioCapture_, captureId_);
196 audioAdapter->Release();
197 }
198 audioCapture_ = nullptr;
199 audioAdapter = nullptr;
200
201 std::shared_ptr<IAudioDeviceManager> audioManager;
202 {
203 std::lock_guard<std::mutex> lock(audioMangerMutex_);
204 audioManager = std::move(audioManager_);
205 audioManager_ = nullptr;
206 }
207
208 if (audioManager != nullptr) {
209 audioManager->UnloadAdapter(deviceNetworkId_);
210 }
211 audioManager = nullptr;
212
213 AudioDeviceManagerFactory::GetInstance().DestoryDeviceManager(REMOTE_DEV_MGR);
214 DumpFileUtil::CloseDumpFile(&dumpFile_);
215 AUDIO_DEBUG_LOG("Clear capture end.");
216 }
217
DeInit()218 void RemoteAudioCapturerSourceInner::DeInit()
219 {
220 AUDIO_INFO_LOG("RemoteAudioCapturerSourceInner::DeInit");
221 ClearCapture();
222
223 std::lock_guard<std::mutex> lock(g_capturerRemoteSourcesMutex);
224 // remove map recorder.
225
226 CHECK_AND_RETURN_LOG(allRemoteSources.count(this->deviceNetworkId_) > 0,
227 "not find %{public}s", this->deviceNetworkId_.c_str());
228
229 RemoteAudioCapturerSource *temp = allRemoteSources[this->deviceNetworkId_];
230 allRemoteSources.erase(this->deviceNetworkId_);
231 if (temp == nullptr) {
232 AUDIO_ERR_LOG("temp is nullptr");
233 } else {
234 delete temp;
235 }
236
237 AUDIO_INFO_LOG("end.");
238 }
239
Init(const IAudioSourceAttr & attr)240 int32_t RemoteAudioCapturerSourceInner::Init(const IAudioSourceAttr &attr)
241 {
242 AUDIO_INFO_LOG("RemoteAudioCapturerSourceInner::Init");
243 attr_ = attr;
244
245 auto audioManager = AudioDeviceManagerFactory::GetInstance().CreatDeviceManager(REMOTE_DEV_MGR);
246 CHECK_AND_RETURN_RET_LOG(audioManager != nullptr, ERR_NOT_STARTED, "Init audio manager fail.");
247
248 {
249 std::lock_guard<std::mutex> lock(audioMangerMutex_);
250 audioManager_ = audioManager;
251 }
252
253 struct AudioAdapterDescriptor *desc = audioManager->GetTargetAdapterDesc(deviceNetworkId_, false);
254 CHECK_AND_RETURN_RET_LOG(desc != nullptr, ERR_NOT_STARTED, "Get target adapters descriptor fail.");
255 for (uint32_t port = 0; port < desc->ports.size(); port++) {
256 if (desc->ports[port].portId == AudioPortPin::PIN_IN_MIC) {
257 audioPort_ = desc->ports[port];
258 break;
259 }
260 CHECK_AND_RETURN_RET_LOG(port != (desc->ports.size() - 1), ERR_INVALID_INDEX,
261 "Not found the audio mic port.");
262 }
263
264 auto audioAdapter = audioManager->LoadAdapters(deviceNetworkId_, false);
265 CHECK_AND_RETURN_RET_LOG(audioAdapter != nullptr, ERR_NOT_STARTED, "Load audio device adapter failed.");
266
267 {
268 std::lock_guard<std::mutex> lock(audioAdapterMutex_);
269 audioAdapter_ = audioAdapter;
270 }
271
272 int32_t ret = audioAdapter->Init();
273 CHECK_AND_RETURN_RET_LOG(ret == SUCCESS, ret, "Audio adapter init fail, ret %{public}d.", ret);
274
275 capturerInited_.store(true);
276
277 SetMute(muteState_);
278
279 AUDIO_DEBUG_LOG("RemoteAudioCapturerSource: Init end.");
280 return SUCCESS;
281 }
282
IsInited(void)283 bool RemoteAudioCapturerSourceInner::IsInited(void)
284 {
285 return capturerInited_.load();
286 }
287
ConvertToHdiFormat(HdiAdapterFormat format)288 AudioFormat RemoteAudioCapturerSourceInner::ConvertToHdiFormat(HdiAdapterFormat format)
289 {
290 AudioFormat hdiFormat;
291 switch (format) {
292 case SAMPLE_U8:
293 hdiFormat = AudioFormat::AUDIO_FORMAT_TYPE_PCM_8_BIT;
294 break;
295 case SAMPLE_S16:
296 hdiFormat = AudioFormat::AUDIO_FORMAT_TYPE_PCM_16_BIT;
297 break;
298 case SAMPLE_S24:
299 hdiFormat = AudioFormat::AUDIO_FORMAT_TYPE_PCM_24_BIT;
300 break;
301 case SAMPLE_S32:
302 hdiFormat = AudioFormat::AUDIO_FORMAT_TYPE_PCM_32_BIT;
303 break;
304 default:
305 hdiFormat = AudioFormat::AUDIO_FORMAT_TYPE_PCM_16_BIT;
306 break;
307 }
308
309 return hdiFormat;
310 }
311
CreateCapture(const struct AudioPort & capturePort)312 int32_t RemoteAudioCapturerSourceInner::CreateCapture(const struct AudioPort &capturePort)
313 {
314 struct AudioSampleAttributes param;
315 param.type = AudioCategory::AUDIO_IN_MEDIA;
316 param.period = deepBufferCapturePeriodSize;
317 param.streamId = static_cast<int32_t>(GenerateUniqueID(AUDIO_HDI_CAPTURE_ID_BASE, HDI_CAPTURE_OFFSET_REMOTE));
318 param.isSignedData = true;
319 param.stopThreshold = maxInt32;
320 param.silenceThreshold = audioBufferSize;
321 // User needs to set
322 param.sampleRate = attr_.sampleRate;
323 param.format = ConvertToHdiFormat(attr_.format);
324 param.isBigEndian = attr_.isBigEndian;
325 param.channelCount = attr_.channel;
326 param.silenceThreshold = attr_.bufferSize;
327 param.frameSize = param.format * param.channelCount;
328 param.startThreshold = deepBufferCapturePeriodSize / (param.frameSize);
329 param.sourceType = attr_.sourceType;
330
331 struct AudioDeviceDescriptor deviceDesc;
332 deviceDesc.portId = capturePort.portId;
333 deviceDesc.pins = AudioPortPin::PIN_IN_MIC;
334 deviceDesc.desc = "";
335
336 std::shared_ptr<IAudioDeviceAdapter> audioAdapter;
337 {
338 std::lock_guard<std::mutex> lock(audioAdapterMutex_);
339 audioAdapter = audioAdapter_;
340 }
341
342 CHECK_AND_RETURN_RET_LOG(audioAdapter != nullptr, ERR_INVALID_HANDLE, "CreateCapture: Audio adapter is null.");
343 int32_t ret = audioAdapter->CreateCapture(deviceDesc, param, audioCapture_, this, captureId_);
344 CHECK_AND_RETURN_RET_LOG(ret == SUCCESS && audioCapture_ != nullptr, ret,
345 "Create capture failed, ret %{public}d.", ret);
346
347 isCapturerCreated_.store(true);
348 return SUCCESS;
349 }
350
CaptureFrame(char * frame,uint64_t requestBytes,uint64_t & replyBytes)351 int32_t RemoteAudioCapturerSourceInner::CaptureFrame(char *frame, uint64_t requestBytes, uint64_t &replyBytes)
352 {
353 std::lock_guard<std::mutex> lock(audioAdapterMutex_);
354 CHECK_AND_RETURN_RET_LOG((audioCapture_ != nullptr) && (audioAdapter_ != nullptr),
355 ERR_INVALID_HANDLE, "CaptureFrame: Audio capture or audio adapter is null.");
356 if (!started_.load()) {
357 AUDIO_DEBUG_LOG("AudioRendererSinkInner::RenderFrame invalid state not started!");
358 return ERR_ILLEGAL_STATE;
359 }
360 std::vector<int8_t> frameHal(requestBytes);
361 int32_t ret = audioCapture_->CaptureFrame(frameHal, replyBytes);
362 CHECK_AND_RETURN_RET_LOG(ret == 0, ERR_READ_FAILED, "Capture frame fail, ret %{public}x.", ret);
363
364 ret = memcpy_s(frame, requestBytes, frameHal.data(), requestBytes);
365 if (ret != EOK) {
366 AUDIO_ERR_LOG("Copy capture frame failed, error code %d.", ret);
367 return ERR_MEMORY_ALLOC_FAILED;
368 }
369 replyBytes = requestBytes;
370
371 DumpFileUtil::WriteDumpFile(dumpFile_, frame, requestBytes);
372 CheckUpdateState(frame, requestBytes);
373
374 return SUCCESS;
375 }
376
CaptureFrameWithEc(FrameDesc * fdesc,uint64_t & replyBytes,FrameDesc * fdescEc,uint64_t & replyBytesEc)377 int32_t RemoteAudioCapturerSourceInner::CaptureFrameWithEc(
378 FrameDesc *fdesc, uint64_t &replyBytes,
379 FrameDesc *fdescEc, uint64_t &replyBytesEc)
380 {
381 AUDIO_ERR_LOG("not supported!");
382 return ERR_DEVICE_NOT_SUPPORTED;
383 }
384
CheckUpdateState(char * frame,uint64_t replyBytes)385 void RemoteAudioCapturerSourceInner::CheckUpdateState(char *frame, uint64_t replyBytes)
386 {
387 if (startUpdate_) {
388 if (capFrameNum_ == 0) {
389 last10FrameStartTime_ = ClockTime::GetCurNano();
390 }
391 capFrameNum_++;
392 maxAmplitude_ = UpdateMaxAmplitude(static_cast<ConvertHdiFormat>(attr_.format), frame, replyBytes);
393 if (capFrameNum_ == GET_MAX_AMPLITUDE_FRAMES_THRESHOLD) {
394 capFrameNum_ = 0;
395 if (last10FrameStartTime_ > lastGetMaxAmplitudeTime_) {
396 startUpdate_ = false;
397 maxAmplitude_ = 0;
398 }
399 }
400 }
401 }
402
GetMaxAmplitude()403 float RemoteAudioCapturerSourceInner::GetMaxAmplitude()
404 {
405 lastGetMaxAmplitudeTime_ = ClockTime::GetCurNano();
406 startUpdate_ = true;
407 return maxAmplitude_;
408 }
409
Start(void)410 int32_t RemoteAudioCapturerSourceInner::Start(void)
411 {
412 AUDIO_INFO_LOG("RemoteAudioCapturerSourceInner::Start");
413 std::lock_guard<std::mutex> lock(createCaptureMutex_);
414 DumpFileUtil::OpenDumpFile(DumpFileUtil::DUMP_SERVER_PARA, DUMP_REMOTE_CAPTURE_SOURCE_FILENAME, &dumpFile_);
415 if (!isCapturerCreated_.load()) {
416 CHECK_AND_RETURN_RET_LOG(CreateCapture(audioPort_) == SUCCESS, ERR_NOT_STARTED,
417 "Create capture fail, audio port %{public}d", audioPort_.portId);
418 }
419
420 if (started_.load()) {
421 AUDIO_INFO_LOG("Remote capture is already started.");
422 return SUCCESS;
423 }
424
425 CHECK_AND_RETURN_RET_LOG((audioCapture_ != nullptr), ERR_INVALID_HANDLE, "Audio capture Handle is nullptr!");
426 int32_t ret = audioCapture_->Start();
427 CHECK_AND_RETURN_RET_LOG(ret == 0, ERR_NOT_STARTED, "Start fail, ret %{public}d.", ret);
428 started_.store(true);
429 return SUCCESS;
430 }
431
Stop(void)432 int32_t RemoteAudioCapturerSourceInner::Stop(void)
433 {
434 AUDIO_INFO_LOG("RemoteAudioCapturerSourceInner::Stop");
435 if (!started_.load()) {
436 AUDIO_INFO_LOG("Remote capture is already stopped.");
437 return SUCCESS;
438 }
439
440 CHECK_AND_RETURN_RET_LOG(audioCapture_ != nullptr, ERR_INVALID_HANDLE, "Stop: Audio capture is null.");
441 int32_t ret = audioCapture_->Stop();
442 CHECK_AND_RETURN_RET_LOG(ret == 0, ERR_OPERATION_FAILED, "Stop fail, ret %{public}d.", ret);
443 started_.store(false);
444 std::shared_ptr<IAudioDeviceAdapter> audioAdapter = nullptr;
445 {
446 std::lock_guard<std::mutex> lock(audioAdapterMutex_);
447 audioAdapter = audioAdapter_;
448 }
449 if (isCapturerCreated_.load() && audioAdapter != nullptr) {
450 audioAdapter->DestroyCapture(audioCapture_, captureId_);
451 AUDIO_INFO_LOG("RemoteAudioCapturerSourceInner::destroy capture end");
452 audioCapture_ = nullptr;
453 captureId_ = 0;
454 isCapturerCreated_.store(false);
455 }
456 return SUCCESS;
457 }
458
Pause(void)459 int32_t RemoteAudioCapturerSourceInner::Pause(void)
460 {
461 AUDIO_INFO_LOG("RemoteAudioCapturerSourceInner::Pause");
462 CHECK_AND_RETURN_RET_LOG(started_.load(), ERR_ILLEGAL_STATE, "Pause invalid state!");
463
464 if (paused_.load()) {
465 AUDIO_INFO_LOG("Remote render is already paused.");
466 return SUCCESS;
467 }
468
469 CHECK_AND_RETURN_RET_LOG(audioCapture_ != nullptr, ERR_INVALID_HANDLE, "Pause: Audio capture is null.");
470 int32_t ret = audioCapture_->Pause();
471 CHECK_AND_RETURN_RET_LOG(ret == 0, ERR_OPERATION_FAILED, "Pause fail, ret %{public}d.", ret);
472 paused_.store(true);
473 return SUCCESS;
474 }
475
Resume(void)476 int32_t RemoteAudioCapturerSourceInner::Resume(void)
477 {
478 AUDIO_INFO_LOG("RemoteAudioCapturerSourceInner::Resume");
479 CHECK_AND_RETURN_RET_LOG(started_.load(), ERR_ILLEGAL_STATE, "Resume invalid state!");
480
481 if (!paused_.load()) {
482 AUDIO_INFO_LOG("Remote render is already resumed.");
483 return SUCCESS;
484 }
485
486 CHECK_AND_RETURN_RET_LOG(audioCapture_ != nullptr, ERR_INVALID_HANDLE, "Resume: Audio capture is null.");
487 int32_t ret = audioCapture_->Resume();
488 CHECK_AND_RETURN_RET_LOG(ret == 0, ERR_OPERATION_FAILED, "Resume fail, ret %{public}d.", ret);
489 paused_.store(false);
490 return SUCCESS;
491 }
492
Reset(void)493 int32_t RemoteAudioCapturerSourceInner::Reset(void)
494 {
495 AUDIO_INFO_LOG("RemoteAudioCapturerSourceInner::Reset");
496 CHECK_AND_RETURN_RET_LOG(started_.load(), ERR_ILLEGAL_STATE, "Reset invalid state!");
497
498 CHECK_AND_RETURN_RET_LOG(audioCapture_ != nullptr, ERR_INVALID_HANDLE, "Reset: Audio capture is null.");
499 int32_t ret = audioCapture_->Flush();
500 CHECK_AND_RETURN_RET_LOG(ret == 0, ERR_OPERATION_FAILED, "Reset fail, ret %{public}d.", ret);
501 return SUCCESS;
502 }
503
Flush(void)504 int32_t RemoteAudioCapturerSourceInner::Flush(void)
505 {
506 AUDIO_INFO_LOG("RemoteAudioCapturerSourceInner::Flush");
507 CHECK_AND_RETURN_RET_LOG(started_.load(), ERR_ILLEGAL_STATE, "Flush invalid state!");
508
509 CHECK_AND_RETURN_RET_LOG(audioCapture_ != nullptr, ERR_INVALID_HANDLE, "Flush: Audio capture is null.");
510 int32_t ret = audioCapture_->Flush();
511 CHECK_AND_RETURN_RET_LOG(ret == 0, ERR_OPERATION_FAILED, "Flush fail, ret %{public}d.", ret);
512 return SUCCESS;
513 }
514
SetVolume(float left,float right)515 int32_t RemoteAudioCapturerSourceInner::SetVolume(float left, float right)
516 {
517 // remote setvolume may not supported
518 float volume = 0.5;
519 CHECK_AND_RETURN_RET_LOG(audioCapture_ != nullptr, ERR_INVALID_HANDLE, "SetVolume: Audio capture is null.");
520
521 float leftVolume = left;
522 float rightVolume = right;
523 float half = 0.5;
524 if ((leftVolume == 0) && (rightVolume != 0)) {
525 volume = rightVolume;
526 } else if ((leftVolume != 0) && (rightVolume == 0)) {
527 volume = leftVolume;
528 } else {
529 volume = (leftVolume + rightVolume) * half;
530 }
531
532 int32_t ret = audioCapture_->SetVolume(volume);
533 AUDIO_INFO_LOG("remote setVolume(%{public}f, %{public}f):%{public}d", left, right, ret);
534 return ret;
535 }
536
GetVolume(float & left,float & right)537 int32_t RemoteAudioCapturerSourceInner::GetVolume(float &left, float &right)
538 {
539 CHECK_AND_RETURN_RET_LOG(audioCapture_ != nullptr, ERR_INVALID_HANDLE, "GetVolume: Audio capture is null.");
540 float val = 0.0;
541 audioCapture_->GetVolume(val);
542 left = val;
543 right = val;
544
545 return SUCCESS;
546 }
547
SetMute(bool isMute)548 int32_t RemoteAudioCapturerSourceInner::SetMute(bool isMute)
549 {
550 muteState_ = isMute;
551
552 if (!IsInited()) {
553 AUDIO_INFO_LOG("SetMute before init, only record mute state");
554 return SUCCESS;
555 }
556
557 CHECK_AND_RETURN_RET_LOG(audioCapture_ != nullptr, ERR_INVALID_HANDLE, "SetMute: Audio capture is null.");
558
559 int32_t ret = audioCapture_->SetMute(isMute);
560 if (ret != 0) {
561 AUDIO_ERR_LOG("SetMute failed from hdi");
562 }
563
564 return SUCCESS;
565 }
566
GetMute(bool & isMute)567 int32_t RemoteAudioCapturerSourceInner::GetMute(bool &isMute)
568 {
569 isMute = muteState_;
570
571 CHECK_AND_RETURN_RET_LOG(audioCapture_ != nullptr, ERR_INVALID_HANDLE, "GetMute: Audio capture is null.");
572
573 bool isHdiMute = false;
574 int32_t ret = audioCapture_->GetMute(isHdiMute);
575 if (ret != 0) {
576 AUDIO_ERR_LOG("AudioCapturerSource::GetMute failed from hdi");
577 }
578
579 return SUCCESS;
580 }
581
SetInputPortPin(DeviceType inputDevice,AudioRouteNode & source)582 int32_t RemoteAudioCapturerSourceInner::SetInputPortPin(DeviceType inputDevice, AudioRouteNode &source)
583 {
584 int32_t ret = SUCCESS;
585
586 switch (inputDevice) {
587 case DEVICE_TYPE_MIC:
588 source.ext.device.type = AudioPortPin::PIN_IN_MIC;
589 source.ext.device.desc = "pin_in_mic";
590 break;
591 case DEVICE_TYPE_WIRED_HEADSET:
592 source.ext.device.type = AudioPortPin::PIN_IN_HS_MIC;
593 source.ext.device.desc = "pin_in_hs_mic";
594 break;
595 case DEVICE_TYPE_USB_HEADSET:
596 source.ext.device.type = AudioPortPin::PIN_IN_USB_EXT;
597 source.ext.device.desc = "pin_in_usb_ext";
598 break;
599 default:
600 ret = ERR_NOT_SUPPORTED;
601 break;
602 }
603
604 return ret;
605 }
606
SetInputRoute(DeviceType inputDevice,const std::string & deviceName)607 int32_t RemoteAudioCapturerSourceInner::SetInputRoute(DeviceType inputDevice, const std::string &deviceName)
608 {
609 AudioRouteNode source = {};
610 AudioRouteNode sink = {};
611
612 int32_t ret = SetInputPortPin(inputDevice, source);
613 CHECK_AND_RETURN_RET_LOG(ret == SUCCESS, ret, "Set input port pin fail, ret %{public}d", ret);
614
615 source.portId = static_cast<int32_t>(audioPort_.portId);
616 source.role = AudioPortRole::AUDIO_PORT_SOURCE_ROLE;
617 source.type = AudioPortType::AUDIO_PORT_DEVICE_TYPE;
618 source.ext.device.moduleId = 0;
619
620 sink.portId = 0;
621 sink.role = AudioPortRole::AUDIO_PORT_SINK_ROLE;
622 sink.type = AudioPortType::AUDIO_PORT_MIX_TYPE;
623 sink.ext.mix.moduleId = 0;
624 sink.ext.mix.streamId = static_cast<int32_t>(GenerateUniqueID(AUDIO_HDI_CAPTURE_ID_BASE,
625 HDI_CAPTURE_OFFSET_REMOTE));
626
627 AudioRoute route;
628 route.sources.push_back(source);
629 route.sinks.push_back(sink);
630
631 std::shared_ptr<IAudioDeviceAdapter> audioAdapter;
632 {
633 std::lock_guard<std::mutex> lock(audioAdapterMutex_);
634 audioAdapter = audioAdapter_;
635 }
636
637 CHECK_AND_RETURN_RET_LOG(audioAdapter != nullptr, ERR_INVALID_HANDLE, "SetInputRoute: Audio adapter is null.");
638 ret = audioAdapter->UpdateAudioRoute(route);
639 CHECK_AND_RETURN_RET_LOG(ret == SUCCESS, ret, "Update audio route fail, ret %{public}d", ret);
640 return SUCCESS;
641 }
642
GetAudioCategory(AudioScene audioScene)643 AudioCategory RemoteAudioCapturerSourceInner::GetAudioCategory(AudioScene audioScene)
644 {
645 AudioCategory audioCategory;
646 switch (audioScene) {
647 case AUDIO_SCENE_DEFAULT:
648 audioCategory = AudioCategory::AUDIO_IN_MEDIA;
649 break;
650 case AUDIO_SCENE_RINGING:
651 case AUDIO_SCENE_VOICE_RINGING:
652 audioCategory = AudioCategory::AUDIO_IN_RINGTONE;
653 break;
654 case AUDIO_SCENE_PHONE_CALL:
655 audioCategory = AudioCategory::AUDIO_IN_CALL;
656 break;
657 case AUDIO_SCENE_PHONE_CHAT:
658 audioCategory = AudioCategory::AUDIO_IN_COMMUNICATION;
659 break;
660 default:
661 audioCategory = AudioCategory::AUDIO_IN_MEDIA;
662 break;
663 }
664 AUDIO_DEBUG_LOG("RemoteAudioCapturerSource: Audio category returned is: %{public}d", audioCategory);
665
666 return audioCategory;
667 }
668
SetAudioScene(AudioScene audioScene,DeviceType activeDevice,const std::string & deviceName)669 int32_t RemoteAudioCapturerSourceInner::SetAudioScene(AudioScene audioScene, DeviceType activeDevice,
670 const std::string &deviceName)
671 {
672 CHECK_AND_RETURN_RET_LOG(audioCapture_ != nullptr, ERR_INVALID_HANDLE, "SetAudioScene: Audio capture is null.");
673 struct AudioSceneDescriptor scene;
674 scene.scene.id = GetAudioCategory(audioScene);
675 scene.desc.pins = AudioPortPin::PIN_IN_MIC;
676 CHECK_AND_RETURN_RET_LOG(audioScene >= AUDIO_SCENE_DEFAULT && audioScene < AUDIO_SCENE_MAX,
677 ERR_INVALID_PARAM, "invalid audioScene");
678
679 AUDIO_INFO_LOG("AudioCapturerSource::SelectScene start");
680 int32_t ret = audioCapture_->SelectScene(scene);
681 AUDIO_INFO_LOG("AudioCapturerSource::SelectScene over");
682 CHECK_AND_RETURN_RET_LOG(ret >= 0, ERR_OPERATION_FAILED,
683 "AudioCapturerSource: Select scene FAILED: %{public}d", ret);
684 AUDIO_INFO_LOG("AudioCapturerSource::Select audio scene SUCCESS: %{public}d", audioScene);
685 return SUCCESS;
686 }
687
GetTransactionId()688 uint64_t RemoteAudioCapturerSourceInner::GetTransactionId()
689 {
690 return ERR_NOT_SUPPORTED;
691 }
692
GetPresentationPosition(uint64_t & frames,int64_t & timeSec,int64_t & timeNanoSec)693 int32_t RemoteAudioCapturerSourceInner::GetPresentationPosition(uint64_t& frames, int64_t& timeSec,
694 int64_t& timeNanoSec)
695 {
696 return ERR_OPERATION_FAILED;
697 }
698
GetAudioParameter(const AudioParamKey key,const std::string & condition)699 std::string RemoteAudioCapturerSourceInner::GetAudioParameter(const AudioParamKey key,
700 const std::string &condition)
701 {
702 AUDIO_WARNING_LOG("not supported yet");
703 return "";
704 }
705
RegisterWakeupCloseCallback(IAudioSourceCallback * callback)706 void RemoteAudioCapturerSourceInner::RegisterWakeupCloseCallback(IAudioSourceCallback *callback)
707 {
708 AUDIO_ERR_LOG("RegisterWakeupCloseCallback FAILED");
709 }
710
RegisterAudioCapturerSourceCallback(std::unique_ptr<ICapturerStateCallback> callback)711 void RemoteAudioCapturerSourceInner::RegisterAudioCapturerSourceCallback(
712 std::unique_ptr<ICapturerStateCallback> callback)
713 {
714 AUDIO_ERR_LOG("RegisterAudioCapturerSourceCallback FAILED");
715 }
716
RegisterParameterCallback(IAudioSourceCallback * callback)717 void RemoteAudioCapturerSourceInner::RegisterParameterCallback(IAudioSourceCallback *callback)
718 {
719 AUDIO_INFO_LOG("register params callback");
720 paramCb_ = callback;
721
722 #ifdef FEATURE_DISTRIBUTE_AUDIO
723 std::shared_ptr<IAudioDeviceAdapter> audioAdapter;
724 {
725 std::lock_guard<std::mutex> lock(audioAdapterMutex_);
726 audioAdapter = audioAdapter_;
727 }
728 CHECK_AND_RETURN_LOG(audioAdapter != nullptr, "RegisterParameterCallback: Audio adapter is null.");
729 int32_t ret = audioAdapter->RegExtraParamObserver();
730 CHECK_AND_RETURN_LOG(ret == SUCCESS, "RegisterParameterCallback failed, ret %{public}d.", ret);
731 #endif
732 }
733
OnAudioParamChange(const std::string & adapterName,const AudioParamKey key,const std::string & condition,const std::string & value)734 void RemoteAudioCapturerSourceInner::OnAudioParamChange(const std::string &adapterName, const AudioParamKey key,
735 const std::string &condition, const std::string &value)
736 {
737 AUDIO_INFO_LOG("Audio param change event, key:%{public}d, condition:%{public}s, value:%{public}s",
738 key, condition.c_str(), value.c_str());
739 if (key == AudioParamKey::PARAM_KEY_STATE) {
740 ClearCapture();
741 }
742
743 CHECK_AND_RETURN_LOG(paramCb_ != nullptr, "Sink audio param callback is null.");
744 paramCb_->OnAudioSourceParamChange(adapterName, key, condition, value);
745 }
746
UpdateAppsUid(const int32_t appsUid[PA_MAX_OUTPUTS_PER_SOURCE],const size_t size)747 int32_t RemoteAudioCapturerSourceInner::UpdateAppsUid(const int32_t appsUid[PA_MAX_OUTPUTS_PER_SOURCE],
748 const size_t size)
749 {
750 AUDIO_WARNING_LOG("not supported.");
751 return ERR_NOT_SUPPORTED;
752 }
753
UpdateAppsUid(const std::vector<int32_t> & appsUid)754 int32_t RemoteAudioCapturerSourceInner::UpdateAppsUid(const std::vector<int32_t> &appsUid)
755 {
756 AUDIO_WARNING_LOG("not supported.");
757 return ERR_NOT_SUPPORTED;
758 }
759
GetCaptureId(uint32_t & captureId) const760 int32_t RemoteAudioCapturerSourceInner::GetCaptureId(uint32_t &captureId) const
761 {
762 captureId = GenerateUniqueID(AUDIO_HDI_CAPTURE_ID_BASE, HDI_CAPTURE_OFFSET_REMOTE);
763 return SUCCESS;
764 }
765 } // namespace AudioStandard
766 } // namesapce OHOS
767