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