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