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
16 #include "remote_audio_renderer_sink.h"
17
18 #include <chrono>
19 #include <cinttypes>
20 #include <cstdio>
21 #include <cstring>
22 #include <dlfcn.h>
23 #include <list>
24 #include <string>
25 #include <sstream>
26 #include <unistd.h>
27 #include <map>
28 #include "securec.h"
29
30 #include "audio_manager.h"
31
32 #include "audio_errors.h"
33 #include "audio_log.h"
34 #include "audio_utils.h"
35
36 using namespace std;
37
38 namespace OHOS {
39 namespace AudioStandard {
40 namespace {
41 const int32_t HALF_FACTOR = 2;
42 const float DEFAULT_VOLUME_LEVEL = 1.0f;
43 const uint32_t AUDIO_CHANNELCOUNT = 2;
44 const uint32_t AUDIO_SAMPLE_RATE_48K = 48000;
45 const uint32_t DEEP_BUFFER_RENDER_PERIOD_SIZE = 4096;
46 const uint32_t INT_32_MAX = 0x7fffffff;
47 const uint32_t PCM_8_BIT = 8;
48 const uint32_t PCM_16_BIT = 16;
49 const uint32_t REMOTE_OUTPUT_STREAM_ID = 29; // 13 + 2 * 8
50 constexpr int32_t PARAMS_RENDER_STATE_NUM = 2;
51 constexpr int32_t EVENT_DES_SIZE = 60;
52 constexpr int32_t RENDER_STATE_CONTENT_DES_SIZE = 60;
53 #ifdef FEATURE_DISTRIBUTE_AUDIO
54 const uint32_t PARAM_VALUE_LENTH = 20;
55 #endif
56 }
57 class RemoteAudioRendererSinkInner : public RemoteAudioRendererSink {
58 public:
59 explicit RemoteAudioRendererSinkInner(const std::string &deviceNetworkId);
60 ~RemoteAudioRendererSinkInner();
61
62 int32_t Init(IAudioSinkAttr attr) override;
63 bool IsInited(void) override;
64 void DeInit(void) override;
65
66 int32_t Start(void) override;
67 int32_t Stop(void) override;
68 int32_t Flush(void) override;
69 int32_t Reset(void) override;
70 int32_t Pause(void) override;
71 int32_t Resume(void) override;
72
73 int32_t RenderFrame(char &data, uint64_t len, uint64_t &writeLen) override;
74 int32_t SetVolume(float left, float right) override;
75 int32_t GetVolume(float &left, float &right) override;
76 int32_t SetVoiceVolume(float volume) override;
77 int32_t GetTransactionId(uint64_t *transactionId) override;
78 int32_t GetLatency(uint32_t *latency) override;
79 int32_t SetAudioScene(AudioScene audioScene, DeviceType activeDevice) override;
80 int32_t SetOutputRoute(DeviceType deviceType) override;
81 void SetAudioParameter(const AudioParamKey key, const std::string& condition, const std::string& value) override;
82 std::string GetAudioParameter(const AudioParamKey key, const std::string& condition) override;
83 void SetAudioMonoState(bool audioMono) override;
84 void SetAudioBalanceValue(float audioBalance) override;
85 void RegisterParameterCallback(IAudioSinkCallback* callback) override;
86
87 int32_t OpenOutput(DeviceType outputDevice);
88 static int32_t ParamEventCallback(AudioExtParamKey key, const char *condition, const char *value, void *reserved,
89 void *cookie);
90 std::string GetNetworkId();
91 IAudioSinkCallback* GetParamCallback();
92
93 private:
94 IAudioSinkAttr attr_;
95 std::string deviceNetworkId_;
96 std::atomic<bool> rendererInited_ = false;
97 std::atomic<bool> isRenderCreated_ = false;
98 std::atomic<bool> started_ = false;
99 std::atomic<bool> paused_ = false;
100 float leftVolume_ = DEFAULT_VOLUME_LEVEL;
101 float rightVolume_ = DEFAULT_VOLUME_LEVEL;
102 int32_t routeHandle_ = -1;
103 int32_t openSpeaker_ = -1;
104 std::string adapterNameCase_;
105 struct AudioManager *audioManager_;
106 struct AudioAdapter *audioAdapter_ = nullptr;
107 struct AudioRender *audioRender_ = nullptr;
108 struct AudioPort audioPort_;
109 IAudioSinkCallback* callback_ = nullptr;
110 bool paramCallbackRegistered_ = false;
111
112 int32_t GetTargetAdapterPort(struct AudioAdapterDescriptor *descs, int32_t size, const char *networkId);
113 int32_t CreateRender(const struct AudioPort &renderPort);
114 AudioFormat ConverToHdiFormat(AudioSampleFormat format);
115 struct AudioManager *GetAudioManager();
116 #ifdef DEBUG_DUMP_FILE
117 FILE *pfd;
118 #endif // DEBUG_DUMP_FILE
119 };
120
RemoteAudioRendererSinkInner(const std::string & deviceNetworkId)121 RemoteAudioRendererSinkInner::RemoteAudioRendererSinkInner(const std::string &deviceNetworkId)
122 {
123 AUDIO_INFO_LOG("Constract.");
124 attr_ = {};
125 this->deviceNetworkId_ = deviceNetworkId;
126 audioManager_ = GetAudioManager();
127 #ifdef DEBUG_DUMP_FILE
128 pfd = nullptr;
129 #endif // DEBUG_DUMP_FILE
130 }
131
~RemoteAudioRendererSinkInner()132 RemoteAudioRendererSinkInner::~RemoteAudioRendererSinkInner()
133 {
134 if (rendererInited_.load()) {
135 RemoteAudioRendererSinkInner::DeInit();
136 } else {
137 AUDIO_INFO_LOG("RemoteAudioRendererSink has already DeInit.");
138 }
139 }
140
141 std::map<std::string, RemoteAudioRendererSinkInner *> allsinks;
GetInstance(const char * deviceNetworkId)142 RemoteAudioRendererSink *RemoteAudioRendererSink::GetInstance(const char *deviceNetworkId)
143 {
144 AUDIO_INFO_LOG("GetInstance.");
145 RemoteAudioRendererSinkInner *audioRenderer = nullptr;
146 if (deviceNetworkId == nullptr) {
147 return audioRenderer;
148 }
149 // check if it is in our map
150 std::string deviceName = deviceNetworkId;
151 if (allsinks.count(deviceName)) {
152 return allsinks[deviceName];
153 } else {
154 audioRenderer = new(std::nothrow) RemoteAudioRendererSinkInner(deviceName);
155 AUDIO_DEBUG_LOG("new Daudio device sink:[%{public}s]", deviceNetworkId);
156 allsinks[deviceName] = audioRenderer;
157 }
158 CHECK_AND_RETURN_RET_LOG((audioRenderer != nullptr), nullptr, "null audioRenderer!");
159 return audioRenderer;
160 }
161
RegisterParameterCallback(IAudioSinkCallback * callback)162 void RemoteAudioRendererSinkInner::RegisterParameterCallback(IAudioSinkCallback* callback)
163 {
164 AUDIO_INFO_LOG("register params callback");
165 callback_ = callback;
166 if (paramCallbackRegistered_) {
167 return;
168 }
169 #ifdef FEATURE_DISTRIBUTE_AUDIO
170 // register to adapter
171 ParamCallback adapterCallback = &RemoteAudioRendererSinkInner::ParamEventCallback;
172 if (audioAdapter_ == nullptr) {
173 AUDIO_ERR_LOG("RegisterParameterCallback audioAdapter_ is null");
174 return;
175 }
176
177 int32_t ret = audioAdapter_->RegExtraParamObserver(audioAdapter_, adapterCallback, this);
178 if (ret != SUCCESS) {
179 AUDIO_ERR_LOG("RegisterParameterCallback failed, error code: %d", ret);
180 } else {
181 paramCallbackRegistered_ = true;
182 }
183 #endif
184 }
185
SetAudioParameter(const AudioParamKey key,const std::string & condition,const std::string & value)186 void RemoteAudioRendererSinkInner::SetAudioParameter(const AudioParamKey key, const std::string& condition,
187 const std::string& value)
188 {
189 #ifdef FEATURE_DISTRIBUTE_AUDIO
190 AUDIO_INFO_LOG("SetParameter: key %{public}d, condition: %{public}s, value: %{public}s",
191 key, condition.c_str(), value.c_str());
192 enum AudioExtParamKey hdiKey = AudioExtParamKey(key);
193 if (audioAdapter_ == nullptr) {
194 AUDIO_ERR_LOG("SetAudioParameter audioAdapter_ is null");
195 return;
196 }
197 int32_t ret = audioAdapter_->SetExtraParams(audioAdapter_, hdiKey, condition.c_str(), value.c_str());
198 if (ret != SUCCESS) {
199 AUDIO_ERR_LOG("SetAudioParameter failed, error code: %d", ret);
200 }
201 #endif
202 }
203
GetAudioParameter(const AudioParamKey key,const std::string & condition)204 std::string RemoteAudioRendererSinkInner::GetAudioParameter(const AudioParamKey key, const std::string& condition)
205 {
206 #ifdef FEATURE_DISTRIBUTE_AUDIO
207 AUDIO_INFO_LOG("GetParameter: key %{public}d, condition: %{public}s", key,
208 condition.c_str());
209 enum AudioExtParamKey hdiKey = AudioExtParamKey(key);
210 char value[PARAM_VALUE_LENTH];
211 if (audioAdapter_ == nullptr) {
212 AUDIO_ERR_LOG("GetAudioParameter audioAdapter_ is null");
213 return "";
214 }
215 int32_t ret = audioAdapter_->GetExtraParams(audioAdapter_, hdiKey, condition.c_str(), value, PARAM_VALUE_LENTH);
216 if (ret !=SUCCESS) {
217 AUDIO_ERR_LOG("GetAudioParameter failed, error code: %d", ret);
218 return "";
219 }
220 return value;
221 #else
222 return "";
223 #endif
224 }
225
ParamEventCallback(AudioExtParamKey key,const char * condition,const char * value,void * reserved,void * cookie)226 int32_t RemoteAudioRendererSinkInner::ParamEventCallback(AudioExtParamKey key, const char* condition, const char* value,
227 void* reserved, void* cookie)
228 {
229 AUDIO_INFO_LOG("ParamEventCallback:key:%{public}d, condition:%{public}s, value:%{public}s",
230 key, condition, value);
231 RemoteAudioRendererSinkInner* sink = reinterpret_cast<RemoteAudioRendererSinkInner*>(cookie);
232 std::string networkId = sink->GetNetworkId();
233 AudioParamKey audioKey = AudioParamKey(key);
234 // render state change to invalid.
235 if (audioKey == AudioParamKey::RENDER_STATE) {
236 char eventDes[EVENT_DES_SIZE];
237 char contentDes[RENDER_STATE_CONTENT_DES_SIZE];
238 if (sscanf_s(condition, "%[^;];%s", eventDes, EVENT_DES_SIZE, contentDes,
239 RENDER_STATE_CONTENT_DES_SIZE) < PARAMS_RENDER_STATE_NUM) {
240 AUDIO_ERR_LOG("[AudioPolicyServer]: Failed parse condition");
241 return 0;
242 }
243 if (!strcmp(eventDes, "ERR_EVENT")) {
244 AUDIO_DEBUG_LOG("render state invalid, destroy audioRender");
245 if ((sink->audioRender_ != nullptr) && (sink->audioAdapter_ != nullptr)) {
246 sink->audioAdapter_->DestroyRender(sink->audioAdapter_, sink->audioRender_);
247 }
248 sink->audioRender_ = nullptr;
249 sink->isRenderCreated_.store(false);
250 }
251 }
252 IAudioSinkCallback* callback = sink->GetParamCallback();
253 callback->OnAudioParameterChange(networkId, audioKey, condition, value);
254 return 0;
255 }
256
GetNetworkId()257 std::string RemoteAudioRendererSinkInner::GetNetworkId()
258 {
259 return deviceNetworkId_;
260 }
261
GetParamCallback()262 OHOS::AudioStandard::IAudioSinkCallback* RemoteAudioRendererSinkInner::GetParamCallback()
263 {
264 return callback_;
265 }
266
DeInit()267 void RemoteAudioRendererSinkInner::DeInit()
268 {
269 AUDIO_INFO_LOG("DeInit.");
270 started_.store(false);
271 rendererInited_.store(false);
272 if ((audioRender_ != nullptr) && (audioAdapter_ != nullptr)) {
273 audioAdapter_->DestroyRender(audioAdapter_, audioRender_);
274 }
275 audioRender_ = nullptr;
276
277 if ((audioManager_ != nullptr) && (audioAdapter_ != nullptr)) {
278 if (routeHandle_ != -1) {
279 audioAdapter_->ReleaseAudioRoute(audioAdapter_, routeHandle_);
280 }
281 audioManager_->UnloadAdapter(audioManager_, audioAdapter_);
282 }
283 audioAdapter_ = nullptr;
284 audioManager_ = nullptr;
285 #ifdef DEBUG_DUMP_FILE
286 if (pfd) {
287 fclose(pfd);
288 pfd = nullptr;
289 }
290 #endif // DEBUG_DUMP_FILE
291 // remove map recorder.
292 RemoteAudioRendererSinkInner *temp = allsinks[this->deviceNetworkId_];
293 if (temp != nullptr) {
294 delete temp;
295 temp = nullptr;
296 allsinks.erase(this->deviceNetworkId_);
297 }
298 }
299
InitAttrs(struct AudioSampleAttributes & attrs)300 void InitAttrs(struct AudioSampleAttributes &attrs)
301 {
302 /* Initialization of audio parameters for playback */
303 attrs.channelCount = AUDIO_CHANNELCOUNT;
304 attrs.sampleRate = AUDIO_SAMPLE_RATE_48K;
305 attrs.interleaved = 0;
306 attrs.streamId = REMOTE_OUTPUT_STREAM_ID;
307 attrs.type = AUDIO_IN_MEDIA;
308 attrs.period = DEEP_BUFFER_RENDER_PERIOD_SIZE;
309 attrs.isBigEndian = false;
310 attrs.isSignedData = true;
311 attrs.stopThreshold = INT_32_MAX;
312 attrs.silenceThreshold = 0;
313 }
314
GetAudioManager()315 struct AudioManager *RemoteAudioRendererSinkInner::GetAudioManager()
316 {
317 AUDIO_INFO_LOG("Initialize audio proxy manager");
318 #ifdef FEATURE_DISTRIBUTE_AUDIO
319 #ifdef __aarch64__
320 char resolvedPath[100] = "/system/lib64/libdaudio_client.z.so";
321 #else
322 char resolvedPath[100] = "/system/lib/libdaudio_client.z.so";
323 #endif
324 struct AudioManager *(*GetAudioManagerFuncs)() = nullptr;
325
326 void *handle_ = dlopen(resolvedPath, 1);
327 if (handle_ == nullptr) {
328 AUDIO_ERR_LOG("Open so Fail");
329 return nullptr;
330 }
331 AUDIO_INFO_LOG("dlopen successful");
332
333 GetAudioManagerFuncs = (struct AudioManager *(*)())(dlsym(handle_, "GetAudioManagerFuncs"));
334 if (GetAudioManagerFuncs == nullptr) {
335 return nullptr;
336 }
337 AUDIO_INFO_LOG("GetAudioManagerFuncs done");
338
339 struct AudioManager *audioManager = GetAudioManagerFuncs();
340 if (audioManager == nullptr) {
341 return nullptr;
342 }
343 AUDIO_INFO_LOG("daudio manager created");
344 #else
345 struct AudioManager *audioManager = nullptr;
346 #endif // FEATURE_DISTRIBUTE_AUDIO
347 return audioManager;
348 }
349
ConverToHdiFormat(AudioSampleFormat format)350 AudioFormat RemoteAudioRendererSinkInner::ConverToHdiFormat(AudioSampleFormat format)
351 {
352 AudioFormat hdiFormat;
353 switch (format) {
354 case SAMPLE_U8:
355 hdiFormat = AUDIO_FORMAT_TYPE_PCM_8_BIT;
356 break;
357 case SAMPLE_S16LE:
358 hdiFormat = AUDIO_FORMAT_TYPE_PCM_16_BIT;
359 break;
360 case SAMPLE_S24LE:
361 hdiFormat = AUDIO_FORMAT_TYPE_PCM_24_BIT;
362 break;
363 case SAMPLE_S32LE:
364 hdiFormat = AUDIO_FORMAT_TYPE_PCM_32_BIT;
365 break;
366 default:
367 hdiFormat = AUDIO_FORMAT_TYPE_PCM_16_BIT;
368 break;
369 }
370
371 return hdiFormat;
372 }
373
CreateRender(const struct AudioPort & renderPort)374 int32_t RemoteAudioRendererSinkInner::CreateRender(const struct AudioPort &renderPort)
375 {
376 int32_t ret;
377 int64_t start = ClockTime::GetCurNano();
378 struct AudioSampleAttributes param;
379 InitAttrs(param);
380 param.sampleRate = attr_.sampleRate;
381 param.channelCount = attr_.channel;
382 param.format = ConverToHdiFormat(attr_.format);
383 param.frameSize = PCM_16_BIT * param.channelCount / PCM_8_BIT;
384 param.startThreshold = DEEP_BUFFER_RENDER_PERIOD_SIZE / (param.frameSize);
385 AUDIO_INFO_LOG("Create render format: %{public}d", param.format);
386 struct AudioDeviceDescriptor deviceDesc;
387 deviceDesc.portId = renderPort.portId;
388 deviceDesc.pins = PIN_OUT_SPEAKER;
389 deviceDesc.desc = nullptr;
390 ret = audioAdapter_->CreateRender(audioAdapter_, &deviceDesc, ¶m, &audioRender_);
391 if (ret != 0 || audioRender_ == nullptr) {
392 AUDIO_ERR_LOG("AudioDeviceCreateRender failed");
393 return ERR_NOT_STARTED;
394 }
395
396 isRenderCreated_.store(true);
397 int64_t cost = (ClockTime::GetCurNano() - start) / AUDIO_US_PER_SECOND;
398 AUDIO_INFO_LOG("CreateRender cost[%{public}" PRId64 "]ms", cost);
399
400 return 0;
401 }
402
printRemoteAttr(IAudioSinkAttr attr_)403 inline std::string printRemoteAttr(IAudioSinkAttr attr_)
404 {
405 std::stringstream value;
406 value << "adapterName[" << attr_.adapterName << "] openMicSpeaker[" << attr_.openMicSpeaker << "] ";
407 value << "format[" << static_cast<int32_t>(attr_.format) << "] sampleFmt[" << attr_.sampleFmt << "] ";
408 value << "sampleRate[" << attr_.sampleRate << "] channel[" << attr_.channel << "] ";
409 value << "volume[" << attr_.volume << "] filePath[" << attr_.filePath << "] ";
410 value << "deviceNetworkId[" << attr_.deviceNetworkId << "] device_type[" << attr_.deviceType << "]";
411 return value.str();
412 }
413
GetTargetAdapterPort(struct AudioAdapterDescriptor * descs,int32_t size,const char * networkId)414 int32_t RemoteAudioRendererSinkInner::GetTargetAdapterPort(struct AudioAdapterDescriptor *descs, int32_t size,
415 const char *networkId)
416 {
417 int32_t targetIdx = -1;
418 for (int32_t index = 0; index < size; index++) {
419 struct AudioAdapterDescriptor *desc = &descs[index];
420 if (desc == nullptr || desc->adapterName == nullptr) {
421 continue;
422 }
423 if (strcmp(desc->adapterName, networkId)) {
424 AUDIO_INFO_LOG("[%{public}d] is not target adapter", index);
425 continue;
426 }
427 targetIdx = index;
428 for (uint32_t port = 0; port < desc->portNum; port++) {
429 // Only find out the port of out in the sound card
430 if (desc->ports[port].portId == PIN_OUT_SPEAKER) {
431 audioPort_ = desc->ports[port];
432 break;
433 }
434 }
435 }
436 return targetIdx;
437 }
438
IsInited()439 bool RemoteAudioRendererSinkInner::IsInited()
440 {
441 return rendererInited_.load();
442 }
443
Init(IAudioSinkAttr attr)444 int32_t RemoteAudioRendererSinkInner::Init(IAudioSinkAttr attr)
445 {
446 AUDIO_INFO_LOG("RemoteAudioRendererSink: Init start.");
447 attr_ = attr;
448 adapterNameCase_ = attr_.adapterName; // Set sound card information
449 openSpeaker_ = attr_.openMicSpeaker;
450
451 if (audioManager_ == nullptr) {
452 AUDIO_ERR_LOG("Init audio manager Fail");
453 return ERR_NOT_STARTED;
454 }
455
456 int32_t size = 0;
457 struct AudioAdapterDescriptor *descs = nullptr;
458 int32_t ret = audioManager_->GetAllAdapters(audioManager_, &descs, &size);
459 if (size == 0 || descs == nullptr || ret != 0) {
460 AUDIO_ERR_LOG("Get adapters Fail");
461 return ERR_NOT_STARTED;
462 }
463 AUDIO_DEBUG_LOG("Get [%{publid}d]adapters", size);
464 int32_t targetIdx = GetTargetAdapterPort(descs, size, attr_.deviceNetworkId);
465 CHECK_AND_RETURN_RET_LOG((targetIdx >= 0), ERR_NOT_STARTED, "can not find target adapter.");
466
467 struct AudioAdapterDescriptor *desc = &descs[targetIdx];
468
469 if (audioManager_->LoadAdapter(audioManager_, desc, &audioAdapter_) != 0) {
470 AUDIO_ERR_LOG("Load Adapter Fail");
471 return ERR_NOT_STARTED;
472 }
473 if (audioAdapter_ == nullptr) {
474 AUDIO_ERR_LOG("Load audio device failed");
475 return ERR_NOT_STARTED;
476 }
477
478 ret = audioAdapter_->InitAllPorts(audioAdapter_);
479 if (ret != 0) {
480 AUDIO_ERR_LOG("InitAllPorts failed");
481 return ERR_NOT_STARTED;
482 }
483
484 AUDIO_DEBUG_LOG("RemoteAudioRendererSink: Init end.");
485 rendererInited_.store(true);
486
487 #ifdef DEBUG_DUMP_FILE
488 AUDIO_INFO_LOG("dump IAudioSinkAttr:%{public}s", printRemoteAttr(attr_).c_str());
489 std::string fileName = attr_.filePath;
490 std::string filePath = "/data/local/tmp/remote_test_001.pcm";
491 const char *g_audioOutTestFilePath = filePath.c_str();
492 pfd = fopen(g_audioOutTestFilePath, "a+"); // here will not create a file if not exit.
493 AUDIO_ERR_LOG("init dump file[%{public}s]", g_audioOutTestFilePath);
494 if (pfd == nullptr) {
495 AUDIO_ERR_LOG("Error opening remote pcm file[%{public}s]", g_audioOutTestFilePath);
496 }
497 #endif // DEBUG_DUMP_FILE
498
499 return SUCCESS;
500 }
501
RenderFrame(char & data,uint64_t len,uint64_t & writeLen)502 int32_t RemoteAudioRendererSinkInner::RenderFrame(char &data, uint64_t len, uint64_t &writeLen)
503 {
504 int64_t start = ClockTime::GetCurNano();
505 int32_t ret;
506 if (audioRender_ == nullptr) {
507 AUDIO_ERR_LOG("Audio Render Handle is nullptr!");
508 return ERR_INVALID_HANDLE;
509 }
510
511 ret = audioRender_->RenderFrame(audioRender_, static_cast<void*>(&data), len, &writeLen);
512 if (ret != 0) {
513 AUDIO_ERR_LOG("RenderFrame failed ret: %{public}x", ret);
514 return ERR_WRITE_FAILED;
515 }
516 writeLen = len;
517 #ifdef DEBUG_DUMP_FILE
518 if (pfd != nullptr) {
519 size_t writeResult = fwrite((void*)&data, 1, len, pfd);
520 if (writeResult != len) {
521 AUDIO_ERR_LOG("Failed to write the file.");
522 }
523 }
524 #endif // DEBUG_DUMP_FILE
525
526 int64_t cost = (ClockTime::GetCurNano() - start) / AUDIO_US_PER_SECOND;
527 AUDIO_DEBUG_LOG("RenderFrame len[%{public}" PRIu64 "] cost[%{public}" PRId64 "]ms", len, cost);
528 return SUCCESS;
529 }
530
Start(void)531 int32_t RemoteAudioRendererSinkInner::Start(void)
532 {
533 AUDIO_INFO_LOG("Start.");
534 if (!isRenderCreated_.load()) {
535 if (CreateRender(audioPort_) != 0) {
536 AUDIO_ERR_LOG("Create render failed, Audio Port: %{public}d", audioPort_.portId);
537 return ERR_NOT_STARTED;
538 }
539 }
540
541 if (!started_.load()) {
542 int32_t ret = audioRender_->control.Start(reinterpret_cast<AudioHandle>(audioRender_));
543 if (ret) {
544 AUDIO_ERR_LOG("Start failed!");
545 return ERR_NOT_STARTED;
546 }
547 started_.store(true);
548 }
549 return SUCCESS;
550 }
551
SetVolume(float left,float right)552 int32_t RemoteAudioRendererSinkInner::SetVolume(float left, float right)
553 {
554 int32_t ret;
555 float volume;
556
557 if (audioRender_ == nullptr) {
558 AUDIO_ERR_LOG("SetVolume failed audioRender_ null");
559 return ERR_INVALID_HANDLE;
560 }
561
562 leftVolume_ = left;
563 rightVolume_ = right;
564 if ((leftVolume_ == 0) && (rightVolume_ != 0)) {
565 volume = rightVolume_;
566 } else if ((leftVolume_ != 0) && (rightVolume_ == 0)) {
567 volume = leftVolume_;
568 } else {
569 volume = (leftVolume_ + rightVolume_) / HALF_FACTOR;
570 }
571
572 ret = audioRender_->volume.SetVolume(reinterpret_cast<AudioHandle>(audioRender_), volume);
573 if (ret) {
574 AUDIO_ERR_LOG("Set volume failed!");
575 }
576
577 return ret;
578 }
579
GetVolume(float & left,float & right)580 int32_t RemoteAudioRendererSinkInner::GetVolume(float &left, float &right)
581 {
582 left = leftVolume_;
583 right = rightVolume_;
584 return SUCCESS;
585 }
586
GetLatency(uint32_t * latency)587 int32_t RemoteAudioRendererSinkInner::GetLatency(uint32_t *latency)
588 {
589 if (audioRender_ == nullptr) {
590 AUDIO_ERR_LOG("GetLatency failed audio render null");
591 return ERR_INVALID_HANDLE;
592 }
593
594 if (!latency) {
595 AUDIO_ERR_LOG("GetLatency failed latency null");
596 return ERR_INVALID_PARAM;
597 }
598
599 uint32_t hdiLatency = 0;
600 if (audioRender_->GetLatency(audioRender_, &hdiLatency) != 0) {
601 AUDIO_ERR_LOG("GetLatency failed.");
602 return ERR_OPERATION_FAILED;
603 }
604
605 *latency = hdiLatency;
606 return SUCCESS;
607 }
608
GetAudioCategory(AudioScene audioScene)609 static AudioCategory GetAudioCategory(AudioScene audioScene)
610 {
611 AudioCategory audioCategory;
612 switch (audioScene) {
613 case AUDIO_SCENE_DEFAULT:
614 audioCategory = AUDIO_IN_MEDIA;
615 break;
616 case AUDIO_SCENE_RINGING:
617 audioCategory = AUDIO_IN_RINGTONE;
618 break;
619 case AUDIO_SCENE_PHONE_CALL:
620 audioCategory = AUDIO_IN_CALL;
621 break;
622 case AUDIO_SCENE_PHONE_CHAT:
623 audioCategory = AUDIO_IN_COMMUNICATION;
624 break;
625 default:
626 audioCategory = AUDIO_IN_MEDIA;
627 break;
628 }
629 AUDIO_DEBUG_LOG("Audio category returned is: %{public}d", audioCategory);
630
631 return audioCategory;
632 }
633
SetOutputPortPin(DeviceType outputDevice,AudioRouteNode & sink)634 static int32_t SetOutputPortPin(DeviceType outputDevice, AudioRouteNode &sink)
635 {
636 int32_t ret = SUCCESS;
637
638 switch (outputDevice) {
639 case DEVICE_TYPE_SPEAKER:
640 sink.ext.device.type = PIN_OUT_SPEAKER;
641 sink.ext.device.desc = "pin_out_speaker";
642 break;
643 case DEVICE_TYPE_WIRED_HEADSET:
644 sink.ext.device.type = PIN_OUT_HEADSET;
645 sink.ext.device.desc = "pin_out_headset";
646 break;
647 case DEVICE_TYPE_USB_HEADSET:
648 sink.ext.device.type = PIN_OUT_USB_EXT;
649 sink.ext.device.desc = "pin_out_usb_ext";
650 break;
651 default:
652 ret = ERR_NOT_SUPPORTED;
653 break;
654 }
655
656 return ret;
657 }
658
OpenOutput(DeviceType outputDevice)659 int32_t RemoteAudioRendererSinkInner::OpenOutput(DeviceType outputDevice)
660 {
661 AudioRouteNode source = {};
662 AudioRouteNode sink = {};
663
664 int32_t ret = SetOutputPortPin(outputDevice, sink);
665 if (ret != SUCCESS) {
666 AUDIO_ERR_LOG("OpenOutput FAILED: %{public}d", ret);
667 return ret;
668 }
669
670 source.portId = 0;
671 source.role = AUDIO_PORT_SOURCE_ROLE;
672 source.type = AUDIO_PORT_MIX_TYPE;
673 source.ext.mix.moduleId = 0;
674 source.ext.mix.streamId = REMOTE_OUTPUT_STREAM_ID;
675
676 sink.portId = audioPort_.portId;
677 sink.role = AUDIO_PORT_SINK_ROLE;
678 sink.type = AUDIO_PORT_DEVICE_TYPE;
679 sink.ext.device.moduleId = 0;
680
681 AudioRoute route = {
682 .sourcesNum = 1,
683 .sources = &source,
684 .sinksNum = 1,
685 .sinks = &sink,
686 };
687
688 if (audioAdapter_ == nullptr) {
689 AUDIO_ERR_LOG("AudioAdapter object is null.");
690 return ERR_OPERATION_FAILED;
691 }
692
693 ret = audioAdapter_->UpdateAudioRoute(audioAdapter_, &route, &routeHandle_);
694 AUDIO_DEBUG_LOG("UpdateAudioRoute returns: %{public}d", ret);
695 if (ret != 0) {
696 AUDIO_ERR_LOG("UpdateAudioRoute failed");
697 return ERR_OPERATION_FAILED;
698 }
699
700 return SUCCESS;
701 }
702
GetTransactionId(uint64_t * transactionId)703 int32_t RemoteAudioRendererSinkInner::GetTransactionId(uint64_t *transactionId)
704 {
705 (void)transactionId;
706 AUDIO_ERR_LOG("GetTransactionId not supported");
707 return ERR_NOT_SUPPORTED;
708 }
709
SetVoiceVolume(float volume)710 int32_t RemoteAudioRendererSinkInner::SetVoiceVolume(float volume)
711 {
712 (void)volume;
713 AUDIO_ERR_LOG("SetVoiceVolume not supported");
714 return ERR_NOT_SUPPORTED;
715 }
716
SetOutputRoute(DeviceType deviceType)717 int32_t RemoteAudioRendererSinkInner::SetOutputRoute(DeviceType deviceType)
718 {
719 (void)deviceType;
720 AUDIO_ERR_LOG("SetOutputRoute not supported");
721 return ERR_NOT_SUPPORTED;
722 }
723
SetAudioMonoState(bool audioMono)724 void RemoteAudioRendererSinkInner::SetAudioMonoState(bool audioMono)
725 {
726 (void)audioMono;
727 AUDIO_ERR_LOG("SetAudioMonoState not supported");
728 return;
729 }
730
SetAudioBalanceValue(float audioBalance)731 void RemoteAudioRendererSinkInner::SetAudioBalanceValue(float audioBalance)
732 {
733 (void)audioBalance;
734 AUDIO_ERR_LOG("SetAudioBalanceValue not supported");
735 return;
736 }
737
SetAudioScene(AudioScene audioScene,DeviceType activeDevice)738 int32_t RemoteAudioRendererSinkInner::SetAudioScene(AudioScene audioScene, DeviceType activeDevice)
739 {
740 AUDIO_INFO_LOG("SetAudioScene scene: %{public}d, device: %{public}d",
741 audioScene, activeDevice);
742 CHECK_AND_RETURN_RET_LOG(audioScene >= AUDIO_SCENE_DEFAULT && audioScene <= AUDIO_SCENE_PHONE_CHAT,
743 ERR_INVALID_PARAM, "invalid audioScene");
744 if (audioRender_ == nullptr) {
745 AUDIO_ERR_LOG("SetAudioScene failed audio render handle is null!");
746 return ERR_INVALID_HANDLE;
747 }
748
749 int32_t ret = OpenOutput(DEVICE_TYPE_SPEAKER);
750 if (ret < 0) {
751 AUDIO_ERR_LOG("Update route FAILED: %{public}d", ret);
752 }
753 struct AudioSceneDescriptor scene;
754 scene.scene.id = GetAudioCategory(audioScene);
755 scene.desc.pins = PIN_OUT_SPEAKER;
756 if (audioRender_->scene.SelectScene == nullptr) {
757 AUDIO_ERR_LOG("Select scene nullptr");
758 return ERR_OPERATION_FAILED;
759 }
760
761 AUDIO_DEBUG_LOG("SelectScene start");
762 ret = audioRender_->scene.SelectScene((AudioHandle)audioRender_, &scene);
763 AUDIO_DEBUG_LOG("SelectScene over");
764 if (ret < 0) {
765 AUDIO_ERR_LOG("Select scene FAILED: %{public}d", ret);
766 return ERR_OPERATION_FAILED;
767 }
768
769 AUDIO_DEBUG_LOG("Select audio scene SUCCESS: %{public}d", audioScene);
770 return SUCCESS;
771 }
772
Stop(void)773 int32_t RemoteAudioRendererSinkInner::Stop(void)
774 {
775 AUDIO_INFO_LOG("Stop.");
776 if (audioRender_ == nullptr) {
777 AUDIO_ERR_LOG("Stop failed audioRender_ null");
778 return ERR_INVALID_HANDLE;
779 }
780
781 if (started_.load()) {
782 int32_t ret = audioRender_->control.Stop(reinterpret_cast<AudioHandle>(audioRender_));
783 if (ret) {
784 AUDIO_ERR_LOG("Stop failed!");
785 return ERR_OPERATION_FAILED;
786 }
787 started_.store(false);
788 }
789 return SUCCESS;
790 }
791
Pause(void)792 int32_t RemoteAudioRendererSinkInner::Pause(void)
793 {
794 AUDIO_INFO_LOG("Pause.");
795 if (audioRender_ == nullptr) {
796 AUDIO_ERR_LOG("Pause failed audioRender_ null");
797 return ERR_INVALID_HANDLE;
798 }
799
800 if (!started_.load()) {
801 AUDIO_ERR_LOG("Pause invalid state!");
802 return ERR_OPERATION_FAILED;
803 }
804
805 if (!paused_.load()) {
806 int32_t ret = audioRender_->control.Pause(reinterpret_cast<AudioHandle>(audioRender_));
807 if (ret) {
808 AUDIO_ERR_LOG("Pause failed!");
809 return ERR_OPERATION_FAILED;
810 }
811 paused_.store(true);
812 }
813 return SUCCESS;
814 }
815
Resume(void)816 int32_t RemoteAudioRendererSinkInner::Resume(void)
817 {
818 AUDIO_INFO_LOG("Pause.");
819 if (audioRender_ == nullptr) {
820 AUDIO_ERR_LOG("Resume failed audioRender_ null");
821 return ERR_INVALID_HANDLE;
822 }
823
824 if (!started_.load()) {
825 AUDIO_ERR_LOG("Resume invalid state!");
826 return ERR_OPERATION_FAILED;
827 }
828
829 if (paused_.load()) {
830 int32_t ret = audioRender_->control.Resume(reinterpret_cast<AudioHandle>(audioRender_));
831 if (ret) {
832 AUDIO_ERR_LOG("Resume failed!");
833 return ERR_OPERATION_FAILED;
834 }
835 paused_.store(false);
836 }
837 return SUCCESS;
838 }
839
Reset(void)840 int32_t RemoteAudioRendererSinkInner::Reset(void)
841 {
842 AUDIO_INFO_LOG("Reset.");
843 if (!started_.load() || audioRender_ == nullptr) {
844 AUDIO_ERR_LOG("%{public}s remote renderer start state %{public}d.", __func__, started_.load());
845 return ERR_OPERATION_FAILED;
846 }
847
848 int32_t ret = audioRender_->control.Flush(reinterpret_cast<AudioHandle>(audioRender_));
849 if (ret) {
850 AUDIO_ERR_LOG("Reset failed, ret %{public}d.", ret);
851 return ERR_OPERATION_FAILED;
852 }
853 return SUCCESS;
854 }
855
Flush(void)856 int32_t RemoteAudioRendererSinkInner::Flush(void)
857 {
858 AUDIO_INFO_LOG("Flush.");
859 if (!started_.load() || audioRender_ == nullptr) {
860 AUDIO_ERR_LOG("%{public}s remote renderer start state %{public}d.", __func__, started_.load());
861 return ERR_OPERATION_FAILED;
862 }
863
864 int32_t ret = audioRender_->control.Flush(reinterpret_cast<AudioHandle>(audioRender_));
865 if (ret) {
866 AUDIO_ERR_LOG("Flush failed, ret %{public}d.", ret);
867 return ERR_OPERATION_FAILED;
868 }
869 return SUCCESS;
870 }
871 } // namespace AudioStandard
872 } // namespace OHOS
873