1 /*
2 * Copyright (c) 2024-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
16 #include "multimedia_audio_renderer_impl.h"
17 #include "cj_lambda.h"
18 #include "audio_errors.h"
19 #include "audio_interrupt_info.h"
20 #include "audio_renderer_log.h"
21 #include "multimedia_audio_common.h"
22 #include "multimedia_audio_error.h"
23 #include "timestamp.h"
24
25 namespace OHOS {
26 namespace AudioStandard {
27 extern "C" {
28
MMAAudioRendererImpl()29 MMAAudioRendererImpl::MMAAudioRendererImpl() {}
30
~MMAAudioRendererImpl()31 MMAAudioRendererImpl::~MMAAudioRendererImpl()
32 {
33 if (audioRenderer_ != nullptr) {
34 audioRenderer_.reset();
35 }
36 }
37
CreateAudioRenderer(CAudioRendererOptions options)38 int32_t MMAAudioRendererImpl::CreateAudioRenderer(CAudioRendererOptions options)
39 {
40 AudioRendererOptions rendererOptions{};
41 Convert2AudioRendererOptions(rendererOptions, options);
42 audioRenderer_ = AudioRenderer::CreateRenderer(rendererOptions);
43 if (audioRenderer_ == nullptr) {
44 AUDIO_ERR_LOG("Create AudioRenderer failed.");
45 return ERR_INVALID_INSTANCE_CODE;
46 }
47 if (callback_ == nullptr) {
48 callback_ = std::make_shared<CjAudioRendererCallback>();
49 }
50 int ret = audioRenderer_->SetRendererCallback(callback_);
51 if (ret != SUCCESS_CODE) {
52 AUDIO_ERR_LOG("SetRendererCallback failed.");
53 return CJ_ERR_SYSTEM;
54 }
55 return SUCCESS_CODE;
56 }
57
GetState()58 int32_t MMAAudioRendererImpl::GetState()
59 {
60 if (audioRenderer_ == nullptr) {
61 return CJ_ERR_INVALID_RETURN_VALUE;
62 }
63 return audioRenderer_->GetStatus();
64 }
65
GetAudioTime(int32_t * errorCode)66 int64_t MMAAudioRendererImpl::GetAudioTime(int32_t *errorCode)
67 {
68 Timestamp timestamp{};
69 if (audioRenderer_ == nullptr) {
70 *errorCode = CJ_ERR_SYSTEM;
71 return CJ_ERR_INVALID_RETURN_VALUE;
72 }
73 bool ret = audioRenderer_->GetAudioTime(timestamp, Timestamp::Timestampbase::MONOTONIC);
74 if (!ret) {
75 AUDIO_ERR_LOG("Get audioTime failed.");
76 *errorCode = CJ_ERR_INVALID_VALUE;
77 return CJ_ERR_INVALID_RETURN_VALUE;
78 }
79 const uint64_t secToNanosecond = 1000000000;
80 uint64_t time =
81 static_cast<uint64_t>(timestamp.time.tv_nsec) + static_cast<uint64_t>(timestamp.time.tv_sec) * secToNanosecond;
82 return static_cast<int64_t>(time);
83 }
84
GetBufferSize(int32_t * errorCode)85 uint32_t MMAAudioRendererImpl::GetBufferSize(int32_t *errorCode)
86 {
87 size_t bufferSize = 0;
88 if (audioRenderer_ == nullptr) {
89 *errorCode = CJ_ERR_SYSTEM;
90 return CJ_ERR_INVALID_RETURN_VALUE;
91 }
92 int32_t ret = audioRenderer_->GetBufferSize(bufferSize);
93 if (ret != SUCCESS_CODE) {
94 AUDIO_ERR_LOG("Get bufferSize failed.");
95 *errorCode = CJ_ERR_INVALID_VALUE;
96 return CJ_ERR_INVALID_RETURN_VALUE;
97 }
98 return bufferSize;
99 }
100
Flush()101 int32_t MMAAudioRendererImpl::Flush()
102 {
103 if (audioRenderer_ == nullptr) {
104 return CJ_ERR_SYSTEM;
105 }
106 bool isSuccess = audioRenderer_->Flush();
107 if (!isSuccess) {
108 AUDIO_ERR_LOG("AudioRenderer flush failed.");
109 return CJ_ERR_ILLEGAL_STATE;
110 }
111 return SUCCESS_CODE;
112 }
113
Drain()114 int32_t MMAAudioRendererImpl::Drain()
115 {
116 if (audioRenderer_ == nullptr) {
117 return CJ_ERR_SYSTEM;
118 }
119 bool isSuccess = audioRenderer_->Drain();
120 if (!isSuccess) {
121 AUDIO_ERR_LOG("AudioRenderer drain failed.");
122 return CJ_ERR_SYSTEM;
123 }
124 return SUCCESS_CODE;
125 }
126
Pause()127 int32_t MMAAudioRendererImpl::Pause()
128 {
129 if (audioRenderer_ == nullptr) {
130 return CJ_ERR_SYSTEM;
131 }
132 bool isSuccess = audioRenderer_->Pause();
133 if (!isSuccess) {
134 AUDIO_ERR_LOG("AudioRenderer pause failed.");
135 return CJ_ERR_SYSTEM;
136 }
137 return SUCCESS_CODE;
138 }
139
GetCurrentOutputDevices(int32_t * errorCode)140 CArrDeviceDescriptor MMAAudioRendererImpl::GetCurrentOutputDevices(int32_t *errorCode)
141 {
142 if (audioRenderer_ == nullptr) {
143 *errorCode = CJ_ERR_SYSTEM;
144 return CArrDeviceDescriptor();
145 }
146 AudioDeviceDescriptor deviceInfo(AudioDeviceDescriptor::DEVICE_INFO);
147 int32_t ret = audioRenderer_->GetCurrentOutputDevices(deviceInfo);
148 if (ret != SUCCESS_CODE) {
149 AUDIO_ERR_LOG("GetCurrentOutputDevices failure!");
150 *errorCode = CJ_ERR_SYSTEM;
151 return CArrDeviceDescriptor();
152 }
153 CArrDeviceDescriptor devices{};
154 Convert2CArrDeviceDescriptorByDeviceInfo(devices, deviceInfo, errorCode);
155 if (*errorCode != SUCCESS_CODE) {
156 FreeCArrDeviceDescriptor(devices);
157 return CArrDeviceDescriptor();
158 }
159 return devices;
160 }
161
GetSpeed(int32_t * errorCode)162 double MMAAudioRendererImpl::GetSpeed(int32_t *errorCode)
163 {
164 if (audioRenderer_ == nullptr) {
165 *errorCode = CJ_ERR_SYSTEM;
166 return CJ_ERR_INVALID_RETURN_DOUBLE_VALUE;
167 }
168 return audioRenderer_->GetSpeed();
169 }
170
GetSilentModeAndMixWithOthers(int32_t * errorCode)171 bool MMAAudioRendererImpl::GetSilentModeAndMixWithOthers(int32_t *errorCode)
172 {
173 if (audioRenderer_ == nullptr) {
174 *errorCode = CJ_ERR_SYSTEM;
175 return false;
176 }
177 bool on = audioRenderer_->GetSilentModeAndMixWithOthers();
178 if (!on) {
179 AUDIO_ERR_LOG("AudioRenderer GetSilentModeAndMixWithOthers failed.");
180 }
181 return on;
182 }
183
GetVolume(int32_t * errorCode)184 double MMAAudioRendererImpl::GetVolume(int32_t *errorCode)
185 {
186 if (audioRenderer_ == nullptr) {
187 *errorCode = CJ_ERR_SYSTEM;
188 return CJ_ERR_INVALID_RETURN_DOUBLE_VALUE;
189 }
190 return audioRenderer_->GetVolume();
191 }
192
GetUnderflowCount(int32_t * errorCode)193 uint32_t MMAAudioRendererImpl::GetUnderflowCount(int32_t *errorCode)
194 {
195 if (audioRenderer_ == nullptr) {
196 *errorCode = CJ_ERR_SYSTEM;
197 return CJ_ERR_INVALID_RETURN_VALUE;
198 }
199 return audioRenderer_->GetUnderflowCount();
200 }
201
SetVolumeWithRamp(double volume,int32_t duration,int32_t * errorCode)202 void MMAAudioRendererImpl::SetVolumeWithRamp(double volume, int32_t duration, int32_t *errorCode)
203 {
204 if (audioRenderer_ == nullptr) {
205 *errorCode = CJ_ERR_SYSTEM;
206 return;
207 }
208 if (volume < MIN_VOLUME_IN_DOUBLE || volume > MAX_VOLUME_IN_DOUBLE) {
209 *errorCode = CJ_ERR_UNSUPPORTED;
210 return;
211 }
212 int32_t ret = audioRenderer_->SetVolumeWithRamp(static_cast<float>(volume), duration);
213 if (ret == ERR_ILLEGAL_STATE) {
214 *errorCode = CJ_ERR_ILLEGAL_STATE;
215 }
216 }
217
SetSpeed(double speed,int32_t * errorCode)218 void MMAAudioRendererImpl::SetSpeed(double speed, int32_t *errorCode)
219 {
220 if (audioRenderer_ == nullptr) {
221 *errorCode = CJ_ERR_SYSTEM;
222 return;
223 }
224 if (speed < MIN_STREAM_SPEED_LEVEL || speed > MAX_STREAM_SPEED_LEVEL) {
225 *errorCode = CJ_ERR_UNSUPPORTED;
226 return;
227 }
228 int32_t ret = audioRenderer_->SetSpeed(static_cast<float>(speed));
229 if (ret == ERR_ILLEGAL_STATE) {
230 *errorCode = CJ_ERR_ILLEGAL_STATE;
231 }
232 }
233
SetVolume(double volume,int32_t * errorCode)234 void MMAAudioRendererImpl::SetVolume(double volume, int32_t *errorCode)
235 {
236 if (audioRenderer_ == nullptr) {
237 *errorCode = CJ_ERR_SYSTEM;
238 return;
239 }
240 if (volume < MIN_VOLUME_IN_DOUBLE || volume > MAX_VOLUME_IN_DOUBLE) {
241 *errorCode = CJ_ERR_UNSUPPORTED;
242 return;
243 }
244 int32_t ret = audioRenderer_->SetVolume(static_cast<float>(volume));
245 if (ret != SUCCESS_CODE) {
246 *errorCode = CJ_ERR_SYSTEM;
247 }
248 }
249
SetSilentModeAndMixWithOthers(bool on,int32_t * errorCode)250 void MMAAudioRendererImpl::SetSilentModeAndMixWithOthers(bool on, int32_t *errorCode)
251 {
252 if (audioRenderer_ == nullptr) {
253 *errorCode = CJ_ERR_SYSTEM;
254 return;
255 }
256 audioRenderer_->SetSilentModeAndMixWithOthers(on);
257 }
258
SetInterruptMode(int32_t mode,int32_t * errorCode)259 void MMAAudioRendererImpl::SetInterruptMode(int32_t mode, int32_t *errorCode)
260 {
261 if (audioRenderer_ == nullptr) {
262 *errorCode = CJ_ERR_SYSTEM;
263 return;
264 }
265 audioRenderer_->SetInterruptMode(static_cast<InterruptMode>(mode));
266 }
267
SetChannelBlendMode(int32_t mode,int32_t * errorCode)268 void MMAAudioRendererImpl::SetChannelBlendMode(int32_t mode, int32_t *errorCode)
269 {
270 if (audioRenderer_ == nullptr) {
271 *errorCode = CJ_ERR_SYSTEM;
272 return;
273 }
274 int32_t ret = audioRenderer_->SetChannelBlendMode(static_cast<ChannelBlendMode>(mode));
275 if (ret == ERR_ILLEGAL_STATE) {
276 *errorCode = CJ_ERR_ILLEGAL_STATE;
277 }
278 }
279
RegisterOutputDeviceCallback(int32_t callbackType,void (* callback)(),int32_t * errorCode)280 void MMAAudioRendererImpl::RegisterOutputDeviceCallback(int32_t callbackType, void (*callback)(), int32_t *errorCode)
281 {
282 if (callbackType == AudioRendererCallbackType::AR_OUTPUT_DEVICE_CHANGE) {
283 auto func = CJLambda::Create(reinterpret_cast<void (*)(CArrDeviceDescriptor)>(callback));
284 if (func == nullptr) {
285 AUDIO_ERR_LOG("Register OUTPUT_DEVICE_CHANGE event failure!");
286 *errorCode = CJ_ERR_SYSTEM;
287 return;
288 }
289 if (rendererDeviceChangeCallback_ != nullptr) {
290 AUDIO_ERR_LOG("OutputDeviceChangeCallback already subscribed!");
291 return;
292 }
293 rendererDeviceChangeCallback_ = std::make_shared<CjAudioRendererOutputDeviceChangeCallback>();
294 rendererDeviceChangeCallback_->RegisterFunc(func);
295 int ret = audioRenderer_->RegisterOutputDeviceChangeWithInfoCallback(rendererDeviceChangeCallback_);
296 if (ret != SUCCESS_CODE) {
297 AUDIO_ERR_LOG("SetOutputDeviceChangeCallback failure!");
298 *errorCode = CJ_ERR_SYSTEM;
299 }
300 }
301 if (callbackType == AudioRendererCallbackType::AR_OUTPUT_DEVICE_CHANGE_WITH_INFO) {
302 auto func = CJLambda::Create(reinterpret_cast<void (*)(CAudioStreamDeviceChangeInfo)>(callback));
303 if (func == nullptr) {
304 AUDIO_ERR_LOG("Register OUTPUT_DEVICE_CHANGE_WITH_INFO event failure!");
305 *errorCode = CJ_ERR_SYSTEM;
306 return;
307 }
308 if (rendererOutputDeviceChangeWithInfoCallback_ != nullptr) {
309 AUDIO_ERR_LOG("OutputDeviceChangeWithInfoCallback already subscribed!");
310 return;
311 }
312 rendererOutputDeviceChangeWithInfoCallback_ =
313 std::make_shared<CjAudioRendererOutputDeviceChangeWithInfoCallback>();
314 rendererOutputDeviceChangeWithInfoCallback_->RegisterFunc(func);
315 int ret =
316 audioRenderer_->RegisterOutputDeviceChangeWithInfoCallback(rendererOutputDeviceChangeWithInfoCallback_);
317 if (ret != SUCCESS_CODE) {
318 AUDIO_ERR_LOG("SetOutputDeviceChangeWithInfoCallback failure!");
319 *errorCode = CJ_ERR_SYSTEM;
320 }
321 }
322 }
323
RegisterCallback(int32_t callbackType,void (* callback)(),int32_t * errorCode)324 void MMAAudioRendererImpl::RegisterCallback(int32_t callbackType, void (*callback)(), int32_t *errorCode)
325 {
326 if (audioRenderer_ == nullptr) {
327 *errorCode = CJ_ERR_SYSTEM;
328 return;
329 }
330 if (callbackType == AudioRendererCallbackType::AR_AUDIO_INTERRUPT) {
331 auto func = CJLambda::Create(reinterpret_cast<void (*)(CInterruptEvent)>(callback));
332 if (func == nullptr) {
333 AUDIO_ERR_LOG("Register AUDIO_INTERRUPT event failure!");
334 *errorCode = CJ_ERR_SYSTEM;
335 return;
336 }
337 callback_->RegisterInterruptFunc(func);
338 }
339 if (callbackType == AudioRendererCallbackType::AR_WRITE_DATA) {
340 auto func = CJLambda::Create(reinterpret_cast<int32_t (*)(CArrUI8)>(callback));
341 if (func == nullptr) {
342 AUDIO_ERR_LOG("Register WRITE_DATA event failure!");
343 *errorCode = CJ_ERR_SYSTEM;
344 return;
345 }
346 rendererWriteDataCallback_ = std::make_shared<CjAudioRendererWriteCallback>();
347 rendererWriteDataCallback_->RegisterFunc(func, audioRenderer_);
348 audioRenderer_->SetRenderMode(RENDER_MODE_CALLBACK);
349 int32_t ret = audioRenderer_->SetRendererWriteCallback(rendererWriteDataCallback_);
350 if (ret != SUCCESS_CODE) {
351 AUDIO_ERR_LOG("SetWriteDataCallback failure!");
352 *errorCode = CJ_ERR_SYSTEM;
353 }
354 }
355 if (callbackType == AudioRendererCallbackType::AR_STATE_CHANGE) {
356 auto func = CJLambda::Create(reinterpret_cast<void (*)(int32_t)>(callback));
357 if (func == nullptr) {
358 AUDIO_ERR_LOG("Register STATE_CHANGE event failure!");
359 *errorCode = CJ_ERR_SYSTEM;
360 return;
361 }
362 callback_->RegisterFunc(func);
363 }
364 RegisterOutputDeviceCallback(callbackType, callback, errorCode);
365 }
366
RegisterCallbackWithFrame(int32_t callbackType,void (* callback)(),int64_t frame,int32_t * errorCode)367 void MMAAudioRendererImpl::RegisterCallbackWithFrame(int32_t callbackType, void (*callback)(), int64_t frame,
368 int32_t *errorCode)
369 {
370 if (audioRenderer_ == nullptr) {
371 *errorCode = CJ_ERR_SYSTEM;
372 return;
373 }
374 if (callbackType == AudioRendererCallbackType::AR_MARK_REACH) {
375 auto func = CJLambda::Create(reinterpret_cast<void (*)(int64_t)>(callback));
376 if (func == nullptr) {
377 AUDIO_ERR_LOG("Register MARK_REACH event failure!");
378 *errorCode = CJ_ERR_SYSTEM;
379 return;
380 }
381 if (frame <= 0) {
382 AUDIO_ERR_LOG("mark position not supported!");
383 *errorCode = CJ_ERR_INVALID_PARAM;
384 return;
385 }
386 positionCb_ = std::make_shared<CjRendererPositionCallback>();
387 positionCb_->RegisterFunc(func);
388 int32_t ret = audioRenderer_->SetRendererPositionCallback(frame, positionCb_);
389 if (ret != SUCCESS_CODE) {
390 AUDIO_ERR_LOG("SetRendererPositionCallback failure!");
391 *errorCode = CJ_ERR_SYSTEM;
392 }
393 }
394 if (callbackType == AudioRendererCallbackType::AR_PERIOD_REACH) {
395 auto func = CJLambda::Create(reinterpret_cast<void (*)(int64_t)>(callback));
396 if (func == nullptr) {
397 AUDIO_ERR_LOG("Register PERIOD_REACH event failure!");
398 *errorCode = CJ_ERR_SYSTEM;
399 return;
400 }
401 if (frame <= 0) {
402 AUDIO_ERR_LOG("framecount not supported!");
403 *errorCode = CJ_ERR_INVALID_PARAM;
404 return;
405 }
406 if (periodPositionCb_ != nullptr) {
407 AUDIO_ERR_LOG("PERIOD_REACH already subscribed!");
408 return;
409 }
410 periodPositionCb_ = std::make_shared<CjRendererPeriodPositionCallback>();
411 periodPositionCb_->RegisterFunc(func);
412 int32_t ret = audioRenderer_->SetRendererPeriodPositionCallback(frame, periodPositionCb_);
413 if (ret != SUCCESS_CODE) {
414 AUDIO_ERR_LOG("SetRendererPeriodPositionCallback failure!");
415 *errorCode = CJ_ERR_SYSTEM;
416 }
417 }
418 }
419
GetAudioEffectMode(int32_t * errorCode)420 int32_t MMAAudioRendererImpl::GetAudioEffectMode(int32_t *errorCode)
421 {
422 if (audioRenderer_ == nullptr) {
423 *errorCode = CJ_ERR_SYSTEM;
424 return CJ_ERR_INVALID_VALUE;
425 }
426 return audioRenderer_->GetAudioEffectMode();
427 }
428
SetAudioEffectMode(int32_t mode,int32_t * errorCode)429 void MMAAudioRendererImpl::SetAudioEffectMode(int32_t mode, int32_t *errorCode)
430 {
431 if (audioRenderer_ == nullptr) {
432 *errorCode = CJ_ERR_SYSTEM;
433 return;
434 }
435 auto ret = audioRenderer_->SetAudioEffectMode(static_cast<AudioEffectMode>(mode));
436 if (ret != SUCCESS_CODE) {
437 AUDIO_ERR_LOG("Get SetAudioEffectMode failed.");
438 *errorCode = CJ_ERR_INVALID_VALUE;
439 }
440 }
441
GetMinStreamVolume(int32_t * errorCode)442 double MMAAudioRendererImpl::GetMinStreamVolume(int32_t *errorCode)
443 {
444 if (audioRenderer_ == nullptr) {
445 *errorCode = CJ_ERR_SYSTEM;
446 return CJ_ERR_INVALID_RETURN_DOUBLE_VALUE;
447 }
448 return audioRenderer_->GetMinStreamVolume();
449 }
450
GetMaxStreamVolume(int32_t * errorCode)451 double MMAAudioRendererImpl::GetMaxStreamVolume(int32_t *errorCode)
452 {
453 if (audioRenderer_ == nullptr) {
454 *errorCode = CJ_ERR_SYSTEM;
455 return CJ_ERR_INVALID_RETURN_DOUBLE_VALUE;
456 }
457 return audioRenderer_->GetMaxStreamVolume();
458 }
459
Release(int32_t * errorCode)460 void MMAAudioRendererImpl::Release(int32_t *errorCode)
461 {
462 if (audioRenderer_ == nullptr) {
463 *errorCode = CJ_ERR_SYSTEM;
464 return;
465 }
466 bool isSuccess = audioRenderer_->Release();
467 if (!isSuccess) {
468 AUDIO_ERR_LOG("AudioRenderer Release failed!");
469 }
470 }
471
GetStreamId(int32_t * errorCode)472 uint32_t MMAAudioRendererImpl::GetStreamId(int32_t *errorCode)
473 {
474 if (audioRenderer_ == nullptr) {
475 *errorCode = CJ_ERR_SYSTEM;
476 return CJ_ERR_INVALID_RETURN_VALUE;
477 }
478 uint32_t sessionId = 0;
479 auto ret = audioRenderer_->GetAudioStreamId(sessionId);
480 if (ret != SUCCESS_CODE) {
481 AUDIO_ERR_LOG("Get StreamId failed.");
482 *errorCode = CJ_ERR_INVALID_VALUE;
483 }
484 return sessionId;
485 }
486
Stop(int32_t * errorCode)487 void MMAAudioRendererImpl::Stop(int32_t *errorCode)
488 {
489 if (audioRenderer_ == nullptr) {
490 *errorCode = CJ_ERR_SYSTEM;
491 return;
492 }
493 bool isSuccess = audioRenderer_->Stop();
494 if (!isSuccess) {
495 AUDIO_ERR_LOG("AudioRenderer Stop failed.");
496 }
497 }
498
Start(int32_t * errorCode)499 void MMAAudioRendererImpl::Start(int32_t *errorCode)
500 {
501 if (audioRenderer_ == nullptr) {
502 *errorCode = CJ_ERR_SYSTEM;
503 return;
504 }
505 bool isSuccess = audioRenderer_->Start();
506 if (!isSuccess) {
507 AUDIO_ERR_LOG("AudioRenderer Start failed.");
508 }
509 }
510
GetStreamInfo(int32_t * errorCode)511 CAudioStreamInfo MMAAudioRendererImpl::GetStreamInfo(int32_t *errorCode)
512 {
513 if (audioRenderer_ == nullptr) {
514 *errorCode = CJ_ERR_SYSTEM;
515 return CAudioStreamInfo();
516 }
517 AudioStreamInfo streamInfo{};
518 auto ret = audioRenderer_->GetStreamInfo(streamInfo);
519 if (ret != SUCCESS_CODE) {
520 AUDIO_ERR_LOG("Get StreamInfo failed.");
521 *errorCode = CJ_ERR_INVALID_VALUE;
522 return CAudioStreamInfo();
523 }
524 CAudioStreamInfo cInfo{};
525 Convert2CAudioStreamInfo(cInfo, streamInfo);
526 return cInfo;
527 }
528
GetRendererInfo(int32_t * errorCode)529 CAudioRendererInfo MMAAudioRendererImpl::GetRendererInfo(int32_t *errorCode)
530 {
531 if (audioRenderer_ == nullptr) {
532 *errorCode = CJ_ERR_SYSTEM;
533 return CAudioRendererInfo();
534 }
535 AudioRendererInfo rendererInfo{};
536 auto ret = audioRenderer_->GetRendererInfo(rendererInfo);
537 if (ret != SUCCESS_CODE) {
538 AUDIO_ERR_LOG("Get RendererInfo failed.");
539 *errorCode = CJ_ERR_INVALID_VALUE;
540 return CAudioRendererInfo();
541 }
542 CAudioRendererInfo cInfo{};
543 Convert2AudioRendererInfo(cInfo, rendererInfo);
544 return cInfo;
545 }
546 }
547 } // namespace AudioStandard
548 } // namespace OHO
549