1 /*
2 * Copyright (c) 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_fast_audio_renderer_sink.h"
17
18 #include <cinttypes>
19 #include <dlfcn.h>
20 #include <map>
21 #include <sstream>
22 #include "securec.h"
23
24 #include "audio_errors.h"
25 #include "audio_log.h"
26 #include "audio_utils.h"
27 #include "audio_info.h"
28 #include "audio_manager.h"
29 #include "ashmem.h"
30 #include "i_audio_renderer_sink.h"
31 #include "fast_audio_renderer_sink.h"
32
33 namespace OHOS {
34 namespace AudioStandard {
35 namespace {
36 const int32_t HALF_FACTOR = 2;
37 const uint32_t AUDIO_CHANNELCOUNT = 2;
38 const uint32_t AUDIO_SAMPLE_RATE_48K = 48000;
39 const uint32_t DEEP_BUFFER_RENDER_PERIOD_SIZE = 3840;
40 const uint32_t INT_32_MAX = 0x7fffffff;
41 const uint32_t PCM_8_BIT = 8;
42 const uint32_t PCM_16_BIT = 16;
43 const uint32_t PCM_24_BIT = 24;
44 const uint32_t PCM_32_BIT = 32;
45 const uint32_t REMOTE_FAST_OUTPUT_STREAM_ID = 37; // 13 + 3 * 8
46 const int64_t SECOND_TO_NANOSECOND = 1000000000;
47 const int32_t INVALID_FD = -1;
48 }
49 class RemoteFastAudioRendererSinkInner : public RemoteFastAudioRendererSink {
50 public:
51 explicit RemoteFastAudioRendererSinkInner(const std::string &deviceNetworkId);
52 ~RemoteFastAudioRendererSinkInner();
53
54 int32_t Init(IAudioSinkAttr attr) override;
55 bool IsInited(void) override;
56 void DeInit(void) override;
57
58 int32_t Start(void) override;
59 int32_t Stop(void) override;
60 int32_t Flush(void) override;
61 int32_t Reset(void) override;
62 int32_t Pause(void) override;
63 int32_t Resume(void) override;
64
65 int32_t RenderFrame(char &data, uint64_t len, uint64_t &writeLen) override;
66 int32_t SetVolume(float left, float right) override;
67 int32_t GetVolume(float &left, float &right) override;
68 int32_t SetVoiceVolume(float volume) override;
69 int32_t GetTransactionId(uint64_t *transactionId) override;
70 int32_t GetLatency(uint32_t *latency) override;
71 int32_t SetAudioScene(AudioScene audioScene, DeviceType activeDevice) override;
72 int32_t SetOutputRoute(DeviceType deviceType) override;
73 void SetAudioParameter(const AudioParamKey key, const std::string& condition, const std::string& value) override;
74 std::string GetAudioParameter(const AudioParamKey key, const std::string& condition) override;
75 void SetAudioMonoState(bool audioMono) override;
76 void SetAudioBalanceValue(float audioBalance) override;
77 void RegisterParameterCallback(IAudioSinkCallback* callback) override;
78
79 int32_t GetMmapBufferInfo(int &fd, uint32_t &totalSizeInframe, uint32_t &spanSizeInframe,
80 uint32_t &byteSizePerFrame) override;
81 int32_t GetMmapHandlePosition(uint64_t &frames, int64_t &timeSec, int64_t &timeNanoSec) override;
82
83 std::string GetNetworkId();
84 IAudioSinkCallback* GetParamCallback();
85
86 private:
87 int32_t InitAudioManager();
88 int32_t GetTargetAdapterPort(struct AudioAdapterDescriptor *descs, int32_t size, const char *networkId);
89 int32_t CreateRender(const struct AudioPort &renderPort);
90 void InitAttrs(struct AudioSampleAttributes &attrs);
91 AudioFormat ConverToHdiFormat(AudioSampleFormat format);
92 int32_t PrepareMmapBuffer();
93 uint32_t PcmFormatToBits(AudioSampleFormat format);
94
95 private:
96 std::atomic<bool> rendererInited_ = false;
97 std::atomic<bool> isRenderCreated_ = false;
98
99 std::atomic<bool> started_ = false;
100 std::atomic<bool> paused_ = false;
101 std::atomic<bool> paramCallbackRegistered_ = false;
102 float leftVolume_ = 0;
103 float rightVolume_ = 0;
104 struct AudioManager *audioManager_ = nullptr;
105 struct AudioAdapter *audioAdapter_ = nullptr;
106 struct AudioRender *audioRender_ = nullptr;
107 IAudioSinkCallback *callback_ = nullptr;
108 struct AudioPort audioPort_;
109 IAudioSinkAttr attr_ = {};
110 std::string deviceNetworkId_;
111
112 uint32_t bufferTotalFrameSize_ = 0;
113 int32_t bufferFd_ = INVALID_FD;
114 uint32_t frameSizeInByte_ = 1;
115 uint32_t eachReadFrameSize_ = 0;
116
117 #ifdef DEBUG_DIRECT_USE_HDI
118 sptr<Ashmem> ashmemSink_ = nullptr;
119 size_t bufferSize_ = 0;
120 #endif
121 };
122
123 std::map<std::string, RemoteFastAudioRendererSinkInner *> allRFSinks;
GetInstance(const std::string & deviceNetworkId)124 IMmapAudioRendererSink *RemoteFastAudioRendererSink::GetInstance(const std::string &deviceNetworkId)
125 {
126 AUDIO_INFO_LOG("GetInstance.");
127 RemoteFastAudioRendererSinkInner *audioRenderer = nullptr;
128 // check if it is in our map
129 if (allRFSinks.count(deviceNetworkId)) {
130 return allRFSinks[deviceNetworkId];
131 } else {
132 audioRenderer = new(std::nothrow) RemoteFastAudioRendererSinkInner(deviceNetworkId);
133 AUDIO_DEBUG_LOG("new Daudio device sink:[%{public}s]", deviceNetworkId.c_str());
134 allRFSinks[deviceNetworkId] = audioRenderer;
135 }
136 CHECK_AND_RETURN_RET_LOG((audioRenderer != nullptr), nullptr, "null audioRenderer!");
137 return audioRenderer;
138 }
139
RemoteFastAudioRendererSinkInner(const std::string & deviceNetworkId)140 RemoteFastAudioRendererSinkInner::RemoteFastAudioRendererSinkInner(const std::string &deviceNetworkId)
141 : deviceNetworkId_(deviceNetworkId)
142 {
143 AUDIO_INFO_LOG("RemoteFastAudioRendererSinkInner Constract.");
144 }
145
~RemoteFastAudioRendererSinkInner()146 RemoteFastAudioRendererSinkInner::~RemoteFastAudioRendererSinkInner()
147 {
148 if (rendererInited_.load()) {
149 RemoteFastAudioRendererSinkInner::DeInit();
150 }
151 AUDIO_INFO_LOG("RemoteFastAudioRendererSink end.");
152 }
153
IsInited()154 bool RemoteFastAudioRendererSinkInner::IsInited()
155 {
156 return rendererInited_.load();
157 }
158
DeInit()159 void RemoteFastAudioRendererSinkInner::DeInit()
160 {
161 AUDIO_INFO_LOG("DeInit.");
162 started_.store(false);
163 rendererInited_.store(false);
164 #ifdef DEBUG_DIRECT_USE_HDI
165 if (ashmemSink_ != nullptr) {
166 ashmemSink_->UnmapAshmem();
167 ashmemSink_->CloseAshmem();
168 ashmemSink_ = nullptr;
169 AUDIO_INFO_LOG("%{public}s: UnInit sink ashmem OK,", __func__);
170 }
171 #endif // DEBUG_DIRECT_USE_HDI
172 if (bufferFd_ != INVALID_FD) {
173 close(bufferFd_);
174 bufferFd_ = INVALID_FD;
175 }
176 if ((audioRender_ != nullptr) && (audioAdapter_ != nullptr)) {
177 audioAdapter_->DestroyRender(audioAdapter_, audioRender_);
178 audioRender_ = nullptr;
179 }
180
181 if ((audioManager_ != nullptr) && (audioAdapter_ != nullptr)) {
182 audioManager_->UnloadAdapter(audioManager_, audioAdapter_);
183 }
184 audioAdapter_ = nullptr;
185 audioManager_ = nullptr;
186 // remove map recorder.
187 RemoteFastAudioRendererSinkInner *temp = allRFSinks[this->deviceNetworkId_];
188 if (temp != nullptr) {
189 delete temp;
190 temp = nullptr;
191 allRFSinks.erase(this->deviceNetworkId_);
192 }
193 }
194
Init(IAudioSinkAttr attr)195 int32_t RemoteFastAudioRendererSinkInner::Init(IAudioSinkAttr attr)
196 {
197 AUDIO_INFO_LOG("Init start.");
198 attr_ = attr;
199
200 int32_t ret = InitAudioManager();
201 if (ret != SUCCESS) {
202 AUDIO_ERR_LOG("Init audio manager Fail, ret: %{public}d.", ret);
203 return ERR_INVALID_HANDLE;
204 }
205
206 int32_t size = 0;
207 struct AudioAdapterDescriptor *descs = nullptr;
208 ret = audioManager_->GetAllAdapters(audioManager_, &descs, &size);
209 if (size == 0 || descs == nullptr || ret != SUCCESS) {
210 AUDIO_ERR_LOG("Get adapters Fail, ret: %{public}d.", ret);
211 return ERR_INVALID_HANDLE;
212 }
213 AUDIO_DEBUG_LOG("Get [%{publid}d]adapters", size);
214 int32_t targetIdx = GetTargetAdapterPort(descs, size, attr_.deviceNetworkId);
215 CHECK_AND_RETURN_RET_LOG((targetIdx >= 0), ERR_INVALID_INDEX, "can not find target adapter.");
216
217 struct AudioAdapterDescriptor *desc = &descs[targetIdx];
218
219 if (audioManager_->LoadAdapter(audioManager_, desc, &audioAdapter_) != SUCCESS ||
220 audioAdapter_ == nullptr) {
221 AUDIO_ERR_LOG("Load adapter failed, ret: %{public}d.", ret);
222 return ERR_INVALID_HANDLE;
223 }
224
225 ret = audioAdapter_->InitAllPorts(audioAdapter_);
226 if (ret != SUCCESS) {
227 AUDIO_ERR_LOG("InitAllPorts failed, ret: %{public}d.", ret);
228 return ERR_NOT_STARTED;
229 }
230
231 if (CreateRender(audioPort_) != SUCCESS) {
232 AUDIO_ERR_LOG("Create render failed, audio port: %{public}d", audioPort_.portId);
233 return ERR_NOT_STARTED;
234 }
235
236 AUDIO_DEBUG_LOG("RemoteAudioRendererSink: Init end.");
237 rendererInited_.store(true);
238 return SUCCESS;
239 }
240
InitAudioManager()241 int32_t RemoteFastAudioRendererSinkInner::InitAudioManager()
242 {
243 AUDIO_INFO_LOG("Initialize audio proxy manager");
244 #ifdef __aarch64__
245 char resolvedPath[100] = "/system/lib64/libdaudio_client.z.so";
246 #else
247 char resolvedPath[100] = "/system/lib/libdaudio_client.z.so";
248 #endif
249 struct AudioManager *(*GetAudioManagerFuncs)() = nullptr;
250
251 void *handle = dlopen(resolvedPath, RTLD_LAZY);
252 if (handle == nullptr) {
253 AUDIO_ERR_LOG("Open so Fail");
254 return ERR_INVALID_HANDLE;
255 }
256 AUDIO_DEBUG_LOG("dlopen successful");
257
258 GetAudioManagerFuncs = reinterpret_cast<struct AudioManager *(*)()>(dlsym(handle, "GetAudioManagerFuncs"));
259 if (GetAudioManagerFuncs == nullptr) {
260 AUDIO_ERR_LOG("dlsym GetAudioManagerFuncs fail.");
261 return ERR_INVALID_HANDLE;
262 }
263 AUDIO_DEBUG_LOG("dlsym GetAudioManagerFuncs done");
264 audioManager_ = GetAudioManagerFuncs();
265 CHECK_AND_RETURN_RET_LOG((audioManager_ != nullptr), ERR_INVALID_HANDLE, "Init daudio manager fail!");
266 AUDIO_DEBUG_LOG("Get daudio manager ok");
267 return SUCCESS;
268 }
269
GetTargetAdapterPort(struct AudioAdapterDescriptor * descs,int32_t size,const char * networkId)270 int32_t RemoteFastAudioRendererSinkInner::GetTargetAdapterPort(struct AudioAdapterDescriptor *descs, int32_t size,
271 const char *networkId)
272 {
273 return 0;
274 }
275
RegisterParameterCallback(IAudioSinkCallback * callback)276 void RemoteFastAudioRendererSinkInner::RegisterParameterCallback(IAudioSinkCallback* callback)
277 {
278 AUDIO_INFO_LOG("register params callback");
279 callback_ = callback;
280 if (paramCallbackRegistered_.load()) {
281 return;
282 }
283 paramCallbackRegistered_.store(true);
284 }
285
SetAudioParameter(const AudioParamKey key,const std::string & condition,const std::string & value)286 void RemoteFastAudioRendererSinkInner::SetAudioParameter(const AudioParamKey key, const std::string& condition,
287 const std::string& value)
288 {
289 AUDIO_INFO_LOG("SetAudioParameter not support.");
290 }
291
GetAudioParameter(const AudioParamKey key,const std::string & condition)292 std::string RemoteFastAudioRendererSinkInner::GetAudioParameter(const AudioParamKey key, const std::string& condition)
293 {
294 AUDIO_INFO_LOG("GetAudioParameter not support.");
295 return "";
296 }
297
GetNetworkId()298 std::string RemoteFastAudioRendererSinkInner::GetNetworkId()
299 {
300 return deviceNetworkId_;
301 }
302
GetParamCallback()303 OHOS::AudioStandard::IAudioSinkCallback* RemoteFastAudioRendererSinkInner::GetParamCallback()
304 {
305 return callback_;
306 }
307
CreateRender(const struct AudioPort & renderPort)308 int32_t RemoteFastAudioRendererSinkInner::CreateRender(const struct AudioPort &renderPort)
309 {
310 int64_t start = ClockTime::GetCurNano();
311 struct AudioSampleAttributes param;
312 InitAttrs(param);
313 param.sampleRate = attr_.sampleRate;
314 param.channelCount = attr_.channel;
315 param.format = ConverToHdiFormat(attr_.format);
316 param.frameSize = PCM_16_BIT * param.channelCount / PCM_8_BIT;
317 param.startThreshold = DEEP_BUFFER_RENDER_PERIOD_SIZE / (param.frameSize);
318 AUDIO_INFO_LOG("Create render format: %{public}d", param.format);
319 struct AudioDeviceDescriptor deviceDesc;
320 deviceDesc.portId = renderPort.portId;
321 deviceDesc.pins = PIN_OUT_SPEAKER;
322 deviceDesc.desc = nullptr;
323 int32_t ret = audioAdapter_->CreateRender(audioAdapter_, &deviceDesc, ¶m, &audioRender_);
324 if (ret != SUCCESS || audioRender_ == nullptr) {
325 AUDIO_ERR_LOG("AudioDeviceCreateRender failed");
326 return ERR_NOT_STARTED;
327 }
328 if (param.type == AUDIO_MMAP_NOIRQ) {
329 PrepareMmapBuffer();
330 }
331 isRenderCreated_.store(true);
332 int64_t cost = (ClockTime::GetCurNano() - start) / AUDIO_US_PER_SECOND;
333 AUDIO_DEBUG_LOG("CreateRender cost[%{public}" PRId64 "]ms", cost);
334 return SUCCESS;
335 }
336
PrepareMmapBuffer()337 int32_t RemoteFastAudioRendererSinkInner::PrepareMmapBuffer()
338 {
339 CHECK_AND_RETURN_RET_LOG((audioRender_ != nullptr), ERR_INVALID_HANDLE,
340 "%{public}s: audio render is null.", __func__);
341
342 int32_t totalBifferInMs = 40; // 5 * (6 + 2 * (1)) = 40ms, the buffer size, not latency.
343 frameSizeInByte_ = PcmFormatToBits(attr_.format) * attr_.channel / PCM_8_BIT;
344 int32_t reqBufferFrameSize = totalBifferInMs * (attr_.sampleRate / 1000);
345
346 struct AudioMmapBufferDescriptor desc = {0};
347 int32_t ret = audioRender_->attr.ReqMmapBuffer((AudioHandle)audioRender_, reqBufferFrameSize, &desc);
348 CHECK_AND_RETURN_RET_LOG((ret == SUCCESS), ERR_OPERATION_FAILED,
349 "%{public}s require mmap buffer failed, ret:%{public}d.", __func__, ret);
350
351 AUDIO_INFO_LOG("AudioMmapBufferDescriptor memoryAddress[%{private}p] memoryFd[%{public}d] totalBufferFrames"
352 "[%{public}d] transferFrameSize[%{public}d] isShareable[%{public}d] offset[%{public}d]", desc.memoryAddress,
353 desc.memoryFd, desc.totalBufferFrames, desc.transferFrameSize, desc.isShareable, desc.offset);
354
355 bufferFd_ = desc.memoryFd; // fcntl(fd, 1030,3) after dup?
356 int32_t periodFrameMaxSize = 1920000; // 192khz * 10s
357 if (desc.totalBufferFrames < 0 || desc.transferFrameSize < 0 || desc.transferFrameSize > periodFrameMaxSize) {
358 AUDIO_ERR_LOG("ReqMmapBuffer invalid values: totalBufferFrames[%{public}d] transferFrameSize[%{public}d]",
359 desc.totalBufferFrames, desc.transferFrameSize);
360 return ERR_OPERATION_FAILED;
361 }
362 bufferTotalFrameSize_ = desc.totalBufferFrames; // 1440 ~ 3840
363 eachReadFrameSize_ = desc.transferFrameSize; // 240
364
365 if (frameSizeInByte_ > ULLONG_MAX / bufferTotalFrameSize_) {
366 AUDIO_ERR_LOG("BufferSize will overflow!");
367 return ERR_OPERATION_FAILED;
368 }
369
370 #ifdef DEBUG_DIRECT_USE_HDI
371 bufferSize_ = bufferTotalFrameSize_ * frameSizeInByte_;
372 ashmemSink_ = new Ashmem(bufferFd_, bufferSize_);
373 AUDIO_INFO_LOG("%{public}s create ashmem sink OK, ashmemLen %{public}zu.", __func__, bufferSize_);
374 if (!(ashmemSink_->MapReadAndWriteAshmem())) {
375 AUDIO_ERR_LOG("%{public}s map ashmem sink failed.", __func__);
376 return ERR_OPERATION_FAILED;
377 }
378 #endif // DEBUG_DIRECT_USE_HDI
379 return SUCCESS;
380 }
381
GetMmapBufferInfo(int & fd,uint32_t & totalSizeInframe,uint32_t & spanSizeInframe,uint32_t & byteSizePerFrame)382 int32_t RemoteFastAudioRendererSinkInner::GetMmapBufferInfo(int &fd, uint32_t &totalSizeInframe,
383 uint32_t &spanSizeInframe, uint32_t &byteSizePerFrame)
384 {
385 if (bufferFd_ == INVALID_FD) {
386 AUDIO_ERR_LOG("buffer fd has been released!");
387 return ERR_INVALID_HANDLE;
388 }
389 fd = bufferFd_;
390 totalSizeInframe = bufferTotalFrameSize_;
391 spanSizeInframe = eachReadFrameSize_;
392 byteSizePerFrame = PcmFormatToBits(attr_.format) * attr_.channel / PCM_8_BIT;
393 return SUCCESS;
394 }
395
GetMmapHandlePosition(uint64_t & frames,int64_t & timeSec,int64_t & timeNanoSec)396 int32_t RemoteFastAudioRendererSinkInner::GetMmapHandlePosition(uint64_t &frames, int64_t &timeSec,
397 int64_t &timeNanoSec)
398 {
399 if (audioRender_ == nullptr) {
400 AUDIO_ERR_LOG("Audio render is null!");
401 return ERR_INVALID_HANDLE;
402 }
403
404 struct AudioTimeStamp timestamp = {};
405 int32_t ret = audioRender_->attr.GetMmapPosition((AudioHandle)audioRender_, &frames, ×tamp);
406 if (ret != 0) {
407 AUDIO_ERR_LOG("Hdi GetMmapPosition filed, ret:%{public}d!", ret);
408 return ERR_OPERATION_FAILED;
409 }
410
411 int64_t maxSec = 9223372036; // (9223372036 + 1) * 10^9 > INT64_MAX, seconds should not bigger than it.
412 if (timestamp.tvSec < 0 || timestamp.tvSec > maxSec || timestamp.tvNSec < 0 ||
413 timestamp.tvNSec > SECOND_TO_NANOSECOND) {
414 AUDIO_ERR_LOG("Hdi GetMmapPosition get invaild second:%{public}" PRId64 " or nanosecond:%{public}" PRId64 " !",
415 timestamp.tvSec, timestamp.tvNSec);
416 return ERR_OPERATION_FAILED;
417 }
418 timeSec = timestamp.tvSec;
419 timeNanoSec = timestamp.tvNSec;
420
421 return SUCCESS;
422 }
423
PcmFormatToBits(AudioSampleFormat format)424 uint32_t RemoteFastAudioRendererSinkInner::PcmFormatToBits(AudioSampleFormat format)
425 {
426 switch (format) {
427 case SAMPLE_U8:
428 return PCM_8_BIT;
429 case SAMPLE_S16LE:
430 return PCM_16_BIT;
431 case SAMPLE_S24LE:
432 return PCM_24_BIT;
433 case SAMPLE_S32LE:
434 return PCM_32_BIT;
435 case SAMPLE_F32LE:
436 return PCM_32_BIT;
437 default:
438 return PCM_24_BIT;
439 }
440 }
441
ConverToHdiFormat(AudioSampleFormat format)442 AudioFormat RemoteFastAudioRendererSinkInner::ConverToHdiFormat(AudioSampleFormat format)
443 {
444 AudioFormat hdiFormat;
445 switch (format) {
446 case SAMPLE_U8:
447 hdiFormat = AUDIO_FORMAT_TYPE_PCM_8_BIT;
448 break;
449 case SAMPLE_S16LE:
450 hdiFormat = AUDIO_FORMAT_TYPE_PCM_16_BIT;
451 break;
452 case SAMPLE_S24LE:
453 hdiFormat = AUDIO_FORMAT_TYPE_PCM_24_BIT;
454 break;
455 case SAMPLE_S32LE:
456 hdiFormat = AUDIO_FORMAT_TYPE_PCM_32_BIT;
457 break;
458 default:
459 hdiFormat = AUDIO_FORMAT_TYPE_PCM_16_BIT;
460 break;
461 }
462
463 return hdiFormat;
464 }
465
InitAttrs(struct AudioSampleAttributes & attrs)466 void RemoteFastAudioRendererSinkInner::InitAttrs(struct AudioSampleAttributes &attrs)
467 {
468 /* Initialization of audio parameters for playback */
469 attrs.channelCount = AUDIO_CHANNELCOUNT;
470 attrs.sampleRate = AUDIO_SAMPLE_RATE_48K;
471 attrs.interleaved = 0;
472 attrs.streamId = REMOTE_FAST_OUTPUT_STREAM_ID;
473 attrs.type = AUDIO_MMAP_NOIRQ;
474 attrs.period = DEEP_BUFFER_RENDER_PERIOD_SIZE;
475 attrs.isBigEndian = false;
476 attrs.isSignedData = true;
477 attrs.stopThreshold = INT_32_MAX;
478 attrs.silenceThreshold = 0;
479 }
480
printRemoteAttr(IAudioSinkAttr attr_)481 inline std::string printRemoteAttr(IAudioSinkAttr attr_)
482 {
483 std::stringstream value;
484 value << "adapterName[" << attr_.adapterName << "] openMicSpeaker[" << attr_.openMicSpeaker << "] ";
485 value << "format[" << static_cast<int32_t>(attr_.format) << "] sampleFmt[" << attr_.sampleFmt << "] ";
486 value << "sampleRate[" << attr_.sampleRate << "] channel[" << attr_.channel << "] ";
487 value << "volume[" << attr_.volume << "] filePath[" << attr_.filePath << "] ";
488 value << "deviceNetworkId[" << attr_.deviceNetworkId << "] device_type[" << attr_.deviceType << "]";
489 return value.str();
490 }
491
Start(void)492 int32_t RemoteFastAudioRendererSinkInner::Start(void)
493 {
494 AUDIO_INFO_LOG("Start.");
495 if (!isRenderCreated_.load()) {
496 if (CreateRender(audioPort_) != 0) {
497 AUDIO_ERR_LOG("Create render failed, Audio Port: %{public}d", audioPort_.portId);
498 return ERR_NOT_STARTED;
499 }
500 }
501
502 if (!started_.load()) {
503 int32_t ret = audioRender_->control.Start(reinterpret_cast<AudioHandle>(audioRender_));
504 if (ret != SUCCESS) {
505 AUDIO_ERR_LOG("Start failed!");
506 return ERR_NOT_STARTED;
507 }
508 started_.store(true);
509 }
510 AUDIO_INFO_LOG("Start Ok.");
511 return SUCCESS;
512 }
513
RenderFrame(char & data,uint64_t len,uint64_t & writeLen)514 int32_t RemoteFastAudioRendererSinkInner::RenderFrame(char &data, uint64_t len, uint64_t &writeLen)
515 {
516 AUDIO_DEBUG_LOG("RenderFrame is not supported.");
517 return SUCCESS;
518 }
519
SetVolume(float left,float right)520 int32_t RemoteFastAudioRendererSinkInner::SetVolume(float left, float right)
521 {
522 if (audioRender_ == nullptr) {
523 AUDIO_ERR_LOG("RemoteFastAudioRendererSink::SetVolume failed audioRender_ null");
524 return ERR_INVALID_HANDLE;
525 }
526
527 float volume;
528 leftVolume_ = left;
529 rightVolume_ = right;
530 if ((leftVolume_ == 0) && (rightVolume_ != 0)) {
531 volume = rightVolume_;
532 } else if ((leftVolume_ != 0) && (rightVolume_ == 0)) {
533 volume = leftVolume_;
534 } else {
535 volume = (leftVolume_ + rightVolume_) / HALF_FACTOR;
536 }
537
538 int32_t ret = audioRender_->volume.SetVolume(reinterpret_cast<AudioHandle>(audioRender_), volume);
539 if (ret) {
540 AUDIO_ERR_LOG("Set volume failed!");
541 }
542 return ret;
543 }
544
GetVolume(float & left,float & right)545 int32_t RemoteFastAudioRendererSinkInner::GetVolume(float &left, float &right)
546 {
547 left = leftVolume_;
548 right = rightVolume_;
549 return SUCCESS;
550 }
551
GetLatency(uint32_t * latency)552 int32_t RemoteFastAudioRendererSinkInner::GetLatency(uint32_t *latency)
553 {
554 if (audioRender_ == nullptr) {
555 AUDIO_ERR_LOG("GetLatency failed audio render null");
556 return ERR_INVALID_HANDLE;
557 }
558
559 if (!latency) {
560 AUDIO_ERR_LOG("GetLatency failed latency null");
561 return ERR_INVALID_PARAM;
562 }
563
564 uint32_t hdiLatency = 0;
565 if (audioRender_->GetLatency(audioRender_, &hdiLatency) != 0) {
566 AUDIO_ERR_LOG("GetLatency failed.");
567 return ERR_OPERATION_FAILED;
568 }
569
570 *latency = hdiLatency;
571 return SUCCESS;
572 }
573
GetTransactionId(uint64_t * transactionId)574 int32_t RemoteFastAudioRendererSinkInner::GetTransactionId(uint64_t *transactionId)
575 {
576 (void)transactionId;
577 AUDIO_ERR_LOG("GetTransactionId not supported");
578 return ERR_NOT_SUPPORTED;
579 }
580
SetVoiceVolume(float volume)581 int32_t RemoteFastAudioRendererSinkInner::SetVoiceVolume(float volume)
582 {
583 (void)volume;
584 AUDIO_ERR_LOG("SetVoiceVolume not supported");
585 return ERR_NOT_SUPPORTED;
586 }
587
SetOutputRoute(DeviceType deviceType)588 int32_t RemoteFastAudioRendererSinkInner::SetOutputRoute(DeviceType deviceType)
589 {
590 (void)deviceType;
591 AUDIO_ERR_LOG("SetOutputRoute not supported");
592 return ERR_NOT_SUPPORTED;
593 }
594
SetAudioMonoState(bool audioMono)595 void RemoteFastAudioRendererSinkInner::SetAudioMonoState(bool audioMono)
596 {
597 (void)audioMono;
598 AUDIO_ERR_LOG("SetAudioMonoState not supported");
599 return;
600 }
601
SetAudioBalanceValue(float audioBalance)602 void RemoteFastAudioRendererSinkInner::SetAudioBalanceValue(float audioBalance)
603 {
604 (void)audioBalance;
605 AUDIO_ERR_LOG("SetAudioBalanceValue not supported");
606 return;
607 }
608
SetAudioScene(AudioScene audioScene,DeviceType activeDevice)609 int32_t RemoteFastAudioRendererSinkInner::SetAudioScene(AudioScene audioScene, DeviceType activeDevice)
610 {
611 AUDIO_INFO_LOG("SetAudioScene not supported");
612 return SUCCESS;
613 }
614
Stop(void)615 int32_t RemoteFastAudioRendererSinkInner::Stop(void)
616 {
617 AUDIO_INFO_LOG("Stop.");
618 if (audioRender_ == nullptr) {
619 AUDIO_ERR_LOG("Stop failed audioRender_ null");
620 return ERR_INVALID_HANDLE;
621 }
622
623 if (started_.load()) {
624 int32_t ret = audioRender_->control.Stop(reinterpret_cast<AudioHandle>(audioRender_));
625 if (ret) {
626 AUDIO_ERR_LOG("Stop failed!");
627 return ERR_OPERATION_FAILED;
628 }
629 started_.store(false);
630 }
631 AUDIO_DEBUG_LOG("Stop ok.");
632 return SUCCESS;
633 }
634
Pause(void)635 int32_t RemoteFastAudioRendererSinkInner::Pause(void)
636 {
637 AUDIO_INFO_LOG("Pause.");
638 if (audioRender_ == nullptr) {
639 AUDIO_ERR_LOG("Pause failed audioRender_ null");
640 return ERR_INVALID_HANDLE;
641 }
642
643 if (!started_.load()) {
644 AUDIO_ERR_LOG("Pause invalid state!");
645 return ERR_OPERATION_FAILED;
646 }
647
648 if (!paused_.load()) {
649 int32_t ret = audioRender_->control.Pause(reinterpret_cast<AudioHandle>(audioRender_));
650 if (ret) {
651 AUDIO_ERR_LOG("Pause failed!");
652 return ERR_OPERATION_FAILED;
653 }
654 paused_.store(true);
655 }
656 return SUCCESS;
657 }
658
Resume(void)659 int32_t RemoteFastAudioRendererSinkInner::Resume(void)
660 {
661 AUDIO_INFO_LOG("Pause.");
662 if (audioRender_ == nullptr) {
663 AUDIO_ERR_LOG("Resume failed audioRender_ null");
664 return ERR_INVALID_HANDLE;
665 }
666
667 if (!started_.load()) {
668 AUDIO_ERR_LOG("Resume invalid state!");
669 return ERR_OPERATION_FAILED;
670 }
671
672 if (paused_.load()) {
673 int32_t ret = audioRender_->control.Resume(reinterpret_cast<AudioHandle>(audioRender_));
674 if (ret) {
675 AUDIO_ERR_LOG("Resume failed!");
676 return ERR_OPERATION_FAILED;
677 }
678 paused_.store(false);
679 }
680 return SUCCESS;
681 }
682
Reset(void)683 int32_t RemoteFastAudioRendererSinkInner::Reset(void)
684 {
685 AUDIO_INFO_LOG("Reset.");
686 if (!started_.load() || audioRender_ == nullptr) {
687 AUDIO_ERR_LOG("%{public}s remote renderer start state %{public}d.", __func__, started_.load());
688 return ERR_OPERATION_FAILED;
689 }
690
691 int32_t ret = audioRender_->control.Flush(reinterpret_cast<AudioHandle>(audioRender_));
692 if (ret) {
693 AUDIO_ERR_LOG("Reset failed, ret %{public}d.", ret);
694 return ERR_OPERATION_FAILED;
695 }
696 return SUCCESS;
697 }
698
Flush(void)699 int32_t RemoteFastAudioRendererSinkInner::Flush(void)
700 {
701 AUDIO_INFO_LOG("Flush.");
702 if (!started_.load() || audioRender_ == nullptr) {
703 AUDIO_ERR_LOG("%{public}s remote renderer start state %{public}d.", __func__, started_.load());
704 return ERR_OPERATION_FAILED;
705 }
706
707 int32_t ret = audioRender_->control.Flush(reinterpret_cast<AudioHandle>(audioRender_));
708 if (ret) {
709 AUDIO_ERR_LOG("Flush failed, ret %{public}d.", ret);
710 return ERR_OPERATION_FAILED;
711 }
712 return SUCCESS;
713 }
714 } // namespace AudioStandard
715 } // namespace OHOS