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 #ifndef LOG_TAG
16 #define LOG_TAG "OHAudioRenderer"
17 #endif
18 
19 #include "OHAudioRenderer.h"
20 #include "audio_errors.h"
21 
22 using OHOS::AudioStandard::Timestamp;
23 
24 static const int64_t SECOND_TO_NANOSECOND = 1000000000;
25 
convertRenderer(OH_AudioRenderer * renderer)26 static OHOS::AudioStandard::OHAudioRenderer *convertRenderer(OH_AudioRenderer *renderer)
27 {
28     return (OHOS::AudioStandard::OHAudioRenderer*) renderer;
29 }
30 
ConvertError(int32_t err)31 static OH_AudioStream_Result ConvertError(int32_t err)
32 {
33     if (err == OHOS::AudioStandard::SUCCESS) {
34         return AUDIOSTREAM_SUCCESS;
35     } else if (err == OHOS::AudioStandard::ERR_INVALID_PARAM) {
36         return AUDIOSTREAM_ERROR_INVALID_PARAM;
37     } else if (err == OHOS::AudioStandard::ERR_ILLEGAL_STATE) {
38         return AUDIOSTREAM_ERROR_ILLEGAL_STATE;
39     }
40     return AUDIOSTREAM_ERROR_SYSTEM;
41 }
42 
OH_AudioRenderer_Start(OH_AudioRenderer * renderer)43 OH_AudioStream_Result OH_AudioRenderer_Start(OH_AudioRenderer *renderer)
44 {
45     OHOS::AudioStandard::OHAudioRenderer *audioRenderer = convertRenderer(renderer);
46     CHECK_AND_RETURN_RET_LOG(audioRenderer != nullptr, AUDIOSTREAM_ERROR_INVALID_PARAM, "convert renderer failed");
47     if (audioRenderer->Start()) {
48         return AUDIOSTREAM_SUCCESS;
49     } else {
50         return AUDIOSTREAM_ERROR_ILLEGAL_STATE;
51     }
52 }
53 
OH_AudioRenderer_Pause(OH_AudioRenderer * renderer)54 OH_AudioStream_Result OH_AudioRenderer_Pause(OH_AudioRenderer *renderer)
55 {
56     OHOS::AudioStandard::OHAudioRenderer *audioRenderer = convertRenderer(renderer);
57     CHECK_AND_RETURN_RET_LOG(audioRenderer != nullptr, AUDIOSTREAM_ERROR_INVALID_PARAM, "convert renderer failed");
58 
59     if (audioRenderer->Pause()) {
60         return AUDIOSTREAM_SUCCESS;
61     } else {
62         return AUDIOSTREAM_ERROR_ILLEGAL_STATE;
63     }
64 }
65 
OH_AudioRenderer_Stop(OH_AudioRenderer * renderer)66 OH_AudioStream_Result OH_AudioRenderer_Stop(OH_AudioRenderer *renderer)
67 {
68     OHOS::AudioStandard::OHAudioRenderer *audioRenderer = convertRenderer(renderer);
69     CHECK_AND_RETURN_RET_LOG(audioRenderer != nullptr, AUDIOSTREAM_ERROR_INVALID_PARAM, "convert renderer failed");
70 
71     if (audioRenderer->Stop()) {
72         return AUDIOSTREAM_SUCCESS;
73     } else {
74         return AUDIOSTREAM_ERROR_ILLEGAL_STATE;
75     }
76 }
77 
OH_AudioRenderer_Flush(OH_AudioRenderer * renderer)78 OH_AudioStream_Result OH_AudioRenderer_Flush(OH_AudioRenderer *renderer)
79 {
80     OHOS::AudioStandard::OHAudioRenderer *audioRenderer = convertRenderer(renderer);
81     CHECK_AND_RETURN_RET_LOG(audioRenderer != nullptr, AUDIOSTREAM_ERROR_INVALID_PARAM, "convert renderer failed");
82 
83     if (audioRenderer->Flush()) {
84         return AUDIOSTREAM_SUCCESS;
85     } else {
86         return AUDIOSTREAM_ERROR_ILLEGAL_STATE;
87     }
88 }
89 
OH_AudioRenderer_Release(OH_AudioRenderer * renderer)90 OH_AudioStream_Result OH_AudioRenderer_Release(OH_AudioRenderer *renderer)
91 {
92     OHOS::AudioStandard::OHAudioRenderer *audioRenderer = convertRenderer(renderer);
93     CHECK_AND_RETURN_RET_LOG(audioRenderer != nullptr, AUDIOSTREAM_ERROR_INVALID_PARAM, "convert renderer failed");
94 
95     if (audioRenderer->Release()) {
96         delete audioRenderer;
97         audioRenderer = nullptr;
98         return AUDIOSTREAM_SUCCESS;
99     } else {
100         return AUDIOSTREAM_ERROR_ILLEGAL_STATE;
101     }
102 }
103 
OH_AudioRenderer_GetCurrentState(OH_AudioRenderer * renderer,OH_AudioStream_State * state)104 OH_AudioStream_Result OH_AudioRenderer_GetCurrentState(OH_AudioRenderer *renderer, OH_AudioStream_State *state)
105 {
106     OHOS::AudioStandard::OHAudioRenderer *audioRenderer = convertRenderer(renderer);
107     CHECK_AND_RETURN_RET_LOG(audioRenderer != nullptr, AUDIOSTREAM_ERROR_INVALID_PARAM, "convert renderer failed");
108 
109     OHOS::AudioStandard::RendererState rendererState = audioRenderer->GetCurrentState();
110     *state = (OH_AudioStream_State)rendererState;
111     return AUDIOSTREAM_SUCCESS;
112 }
113 
OH_AudioRenderer_GetSamplingRate(OH_AudioRenderer * renderer,int32_t * rate)114 OH_AudioStream_Result OH_AudioRenderer_GetSamplingRate(OH_AudioRenderer *renderer, int32_t *rate)
115 {
116     OHOS::AudioStandard::OHAudioRenderer *audioRenderer = convertRenderer(renderer);
117     CHECK_AND_RETURN_RET_LOG(audioRenderer != nullptr, AUDIOSTREAM_ERROR_INVALID_PARAM, "convert renderer failed");
118 
119     *rate = audioRenderer->GetSamplingRate();
120     return AUDIOSTREAM_SUCCESS;
121 }
122 
OH_AudioRenderer_GetStreamId(OH_AudioRenderer * renderer,uint32_t * streamId)123 OH_AudioStream_Result OH_AudioRenderer_GetStreamId(OH_AudioRenderer *renderer, uint32_t *streamId)
124 {
125     OHOS::AudioStandard::OHAudioRenderer *audioRenderer = convertRenderer(renderer);
126     CHECK_AND_RETURN_RET_LOG(audioRenderer != nullptr, AUDIOSTREAM_ERROR_INVALID_PARAM, "convert renderer failed");
127     audioRenderer->GetStreamId(*streamId);
128     return AUDIOSTREAM_SUCCESS;
129 }
130 
OH_AudioRenderer_GetChannelCount(OH_AudioRenderer * renderer,int32_t * channelCount)131 OH_AudioStream_Result OH_AudioRenderer_GetChannelCount(OH_AudioRenderer *renderer, int32_t *channelCount)
132 {
133     OHOS::AudioStandard::OHAudioRenderer *audioRenderer = convertRenderer(renderer);
134     CHECK_AND_RETURN_RET_LOG(audioRenderer != nullptr, AUDIOSTREAM_ERROR_INVALID_PARAM, "convert renderer failed");
135     *channelCount = audioRenderer->GetChannelCount();
136     return AUDIOSTREAM_SUCCESS;
137 }
138 
OH_AudioRenderer_GetSampleFormat(OH_AudioRenderer * renderer,OH_AudioStream_SampleFormat * sampleFormat)139 OH_AudioStream_Result OH_AudioRenderer_GetSampleFormat(OH_AudioRenderer *renderer,
140     OH_AudioStream_SampleFormat *sampleFormat)
141 {
142     OHOS::AudioStandard::OHAudioRenderer *audioRenderer = convertRenderer(renderer);
143     CHECK_AND_RETURN_RET_LOG(audioRenderer != nullptr, AUDIOSTREAM_ERROR_INVALID_PARAM, "convert renderer failed");
144     *sampleFormat = (OH_AudioStream_SampleFormat)audioRenderer->GetSampleFormat();
145     return AUDIOSTREAM_SUCCESS;
146 }
147 
OH_AudioRenderer_GetLatencyMode(OH_AudioRenderer * renderer,OH_AudioStream_LatencyMode * latencyMode)148 OH_AudioStream_Result OH_AudioRenderer_GetLatencyMode(OH_AudioRenderer *renderer,
149     OH_AudioStream_LatencyMode *latencyMode)
150 {
151     OHOS::AudioStandard::OHAudioRenderer *audioRenderer = convertRenderer(renderer);
152     CHECK_AND_RETURN_RET_LOG(audioRenderer != nullptr, AUDIOSTREAM_ERROR_INVALID_PARAM, "convert renderer failed");
153     OHOS::AudioStandard::AudioRendererInfo rendererInfo;
154     audioRenderer->GetRendererInfo(rendererInfo);
155     *latencyMode = (OH_AudioStream_LatencyMode)rendererInfo.rendererFlags;
156 
157     return AUDIOSTREAM_SUCCESS;
158 }
159 
OH_AudioRenderer_GetRendererInfo(OH_AudioRenderer * renderer,OH_AudioStream_Usage * usage)160 OH_AudioStream_Result OH_AudioRenderer_GetRendererInfo(OH_AudioRenderer *renderer,
161     OH_AudioStream_Usage *usage)
162 {
163     OHOS::AudioStandard::OHAudioRenderer *audioRenderer = convertRenderer(renderer);
164     CHECK_AND_RETURN_RET_LOG(audioRenderer != nullptr, AUDIOSTREAM_ERROR_INVALID_PARAM, "convert renderer failed");
165 
166     OHOS::AudioStandard::AudioRendererInfo rendererInfo;
167     audioRenderer->GetRendererInfo(rendererInfo);
168     *usage = (OH_AudioStream_Usage)rendererInfo.streamUsage;
169     return AUDIOSTREAM_SUCCESS;
170 }
171 
OH_AudioRenderer_GetRendererPrivacy(OH_AudioRenderer * renderer,OH_AudioStream_PrivacyType * privacy)172 OH_AudioStream_Result OH_AudioRenderer_GetRendererPrivacy(OH_AudioRenderer* renderer,
173     OH_AudioStream_PrivacyType* privacy)
174 {
175     OHOS::AudioStandard::OHAudioRenderer *audioRenderer = convertRenderer(renderer);
176     CHECK_AND_RETURN_RET_LOG(audioRenderer != nullptr, AUDIOSTREAM_ERROR_INVALID_PARAM, "convert renderer failed");
177 
178     *privacy = (OH_AudioStream_PrivacyType)audioRenderer->GetRendererPrivacy();
179     return AUDIOSTREAM_SUCCESS;
180 }
181 
OH_AudioRenderer_GetEncodingType(OH_AudioRenderer * renderer,OH_AudioStream_EncodingType * encodingType)182 OH_AudioStream_Result OH_AudioRenderer_GetEncodingType(OH_AudioRenderer *renderer,
183     OH_AudioStream_EncodingType *encodingType)
184 {
185     OHOS::AudioStandard::OHAudioRenderer *audioRenderer = convertRenderer(renderer);
186     CHECK_AND_RETURN_RET_LOG(audioRenderer != nullptr, AUDIOSTREAM_ERROR_INVALID_PARAM, "convert renderer failed");
187     *encodingType = (OH_AudioStream_EncodingType)audioRenderer->GetEncodingType();
188     return AUDIOSTREAM_SUCCESS;
189 }
190 
OH_AudioRenderer_GetFramesWritten(OH_AudioRenderer * renderer,int64_t * frames)191 OH_AudioStream_Result OH_AudioRenderer_GetFramesWritten(OH_AudioRenderer *renderer, int64_t *frames)
192 {
193     OHOS::AudioStandard::OHAudioRenderer *audioRenderer = convertRenderer(renderer);
194     CHECK_AND_RETURN_RET_LOG(audioRenderer != nullptr, AUDIOSTREAM_ERROR_INVALID_PARAM, "convert renderer failed");
195     *frames = audioRenderer->GetFramesWritten();
196     return AUDIOSTREAM_SUCCESS;
197 }
198 
OH_AudioRenderer_GetTimestamp(OH_AudioRenderer * renderer,clockid_t clockId,int64_t * framePosition,int64_t * timestamp)199 OH_AudioStream_Result OH_AudioRenderer_GetTimestamp(OH_AudioRenderer *renderer,
200     clockid_t clockId, int64_t *framePosition, int64_t *timestamp)
201 {
202     OHOS::AudioStandard::OHAudioRenderer *audioRenderer = convertRenderer(renderer);
203     CHECK_AND_RETURN_RET_LOG(audioRenderer != nullptr, AUDIOSTREAM_ERROR_INVALID_PARAM, "convert renderer failed");
204     CHECK_AND_RETURN_RET_LOG(clockId == CLOCK_MONOTONIC, AUDIOSTREAM_ERROR_INVALID_PARAM, "error clockId value");
205     Timestamp stamp;
206     Timestamp::Timestampbase base = Timestamp::Timestampbase::MONOTONIC;
207     bool ret = audioRenderer->GetAudioTime(stamp, base);
208     if (!ret) {
209         AUDIO_ERR_LOG("GetAudioTime error!");
210         return AUDIOSTREAM_ERROR_ILLEGAL_STATE;
211     }
212     *framePosition = stamp.framePosition;
213     *timestamp = stamp.time.tv_sec * SECOND_TO_NANOSECOND + stamp.time.tv_nsec;
214     return AUDIOSTREAM_SUCCESS;
215 }
216 
OH_AudioRenderer_GetFrameSizeInCallback(OH_AudioRenderer * renderer,int32_t * frameSize)217 OH_AudioStream_Result OH_AudioRenderer_GetFrameSizeInCallback(OH_AudioRenderer *renderer, int32_t *frameSize)
218 {
219     OHOS::AudioStandard::OHAudioRenderer *audioRenderer = convertRenderer(renderer);
220     CHECK_AND_RETURN_RET_LOG(audioRenderer != nullptr, AUDIOSTREAM_ERROR_INVALID_PARAM, "convert renderer failed");
221     *frameSize = audioRenderer->GetFrameSizeInCallback();
222     return AUDIOSTREAM_SUCCESS;
223 }
224 
OH_AudioRenderer_GetSpeed(OH_AudioRenderer * renderer,float * speed)225 OH_AudioStream_Result OH_AudioRenderer_GetSpeed(OH_AudioRenderer *renderer, float *speed)
226 {
227     OHOS::AudioStandard::OHAudioRenderer *audioRenderer = convertRenderer(renderer);
228     CHECK_AND_RETURN_RET_LOG(audioRenderer != nullptr, AUDIOSTREAM_ERROR_INVALID_PARAM, "convert renderer failed");
229     *speed = audioRenderer->GetSpeed();
230     return AUDIOSTREAM_SUCCESS;
231 }
232 
OH_AudioRenderer_SetSpeed(OH_AudioRenderer * renderer,float speed)233 OH_AudioStream_Result OH_AudioRenderer_SetSpeed(OH_AudioRenderer *renderer, float speed)
234 {
235     OHOS::AudioStandard::OHAudioRenderer *audioRenderer = convertRenderer(renderer);
236     CHECK_AND_RETURN_RET_LOG(audioRenderer != nullptr, AUDIOSTREAM_ERROR_INVALID_PARAM, "convert renderer failed");
237     audioRenderer->SetSpeed(speed);
238     return AUDIOSTREAM_SUCCESS;
239 }
240 
OH_AudioRenderer_GetUnderflowCount(OH_AudioRenderer * renderer,uint32_t * count)241 OH_AudioStream_Result OH_AudioRenderer_GetUnderflowCount(OH_AudioRenderer* renderer, uint32_t* count)
242 {
243     OHOS::AudioStandard::OHAudioRenderer *audioRenderer = convertRenderer(renderer);
244     CHECK_AND_RETURN_RET_LOG(audioRenderer != nullptr, AUDIOSTREAM_ERROR_INVALID_PARAM, "convert renderer failed");
245     CHECK_AND_RETURN_RET_LOG(count != nullptr, AUDIOSTREAM_ERROR_INVALID_PARAM, "count is nullptr");
246     *count = audioRenderer->GetUnderflowCount();
247     return AUDIOSTREAM_SUCCESS;
248 }
249 
OH_AudioRenderer_SetVolume(OH_AudioRenderer * renderer,float volume)250 OH_AudioStream_Result OH_AudioRenderer_SetVolume(OH_AudioRenderer* renderer, float volume)
251 {
252     OHOS::AudioStandard::OHAudioRenderer *audioRenderer = convertRenderer(renderer);
253     CHECK_AND_RETURN_RET_LOG(audioRenderer != nullptr, AUDIOSTREAM_ERROR_INVALID_PARAM, "convert renderer failed");
254     CHECK_AND_RETURN_RET_LOG(((volume >= 0) && (volume <= 1)), AUDIOSTREAM_ERROR_INVALID_PARAM, "volume set invalid");
255     int32_t err = audioRenderer->SetVolume(volume);
256     return ConvertError(err);
257 }
258 
OH_AudioRenderer_SetVolumeWithRamp(OH_AudioRenderer * renderer,float volume,int32_t durationMs)259 OH_AudioStream_Result OH_AudioRenderer_SetVolumeWithRamp(OH_AudioRenderer *renderer, float volume, int32_t durationMs)
260 {
261     OHOS::AudioStandard::OHAudioRenderer *audioRenderer = convertRenderer(renderer);
262     CHECK_AND_RETURN_RET_LOG(audioRenderer != nullptr, AUDIOSTREAM_ERROR_INVALID_PARAM, "convert renderer failed");
263     CHECK_AND_RETURN_RET_LOG(((volume >= 0) && (volume <= 1)), AUDIOSTREAM_ERROR_INVALID_PARAM, "volume set invalid");
264     int32_t err = audioRenderer->SetVolumeWithRamp(volume, durationMs);
265     return ConvertError(err);
266 }
267 
OH_AudioRenderer_GetVolume(OH_AudioRenderer * renderer,float * volume)268 OH_AudioStream_Result OH_AudioRenderer_GetVolume(OH_AudioRenderer *renderer, float *volume)
269 {
270     OHOS::AudioStandard::OHAudioRenderer *audioRenderer = convertRenderer(renderer);
271     CHECK_AND_RETURN_RET_LOG(audioRenderer != nullptr, AUDIOSTREAM_ERROR_INVALID_PARAM, "convert renderer failed");
272     CHECK_AND_RETURN_RET_LOG(volume != nullptr, AUDIOSTREAM_ERROR_INVALID_PARAM, "volume is nullptr");
273     *volume = audioRenderer->GetVolume();
274     return AUDIOSTREAM_SUCCESS;
275 }
276 
OH_AudioRenderer_SetMarkPosition(OH_AudioRenderer * renderer,uint32_t samplePos,OH_AudioRenderer_OnMarkReachedCallback callback,void * userData)277 OH_AudioStream_Result OH_AudioRenderer_SetMarkPosition(OH_AudioRenderer *renderer, uint32_t samplePos,
278     OH_AudioRenderer_OnMarkReachedCallback callback, void *userData)
279 {
280     OHOS::AudioStandard::OHAudioRenderer *audioRenderer = convertRenderer(renderer);
281     CHECK_AND_RETURN_RET_LOG(audioRenderer != nullptr, AUDIOSTREAM_ERROR_INVALID_PARAM, "convert renderer failed");
282     CHECK_AND_RETURN_RET_LOG(samplePos > 0, AUDIOSTREAM_ERROR_INVALID_PARAM, "framePos set invalid");
283     int32_t err = audioRenderer->SetRendererPositionCallback(callback, samplePos, userData);
284     return ConvertError(err);
285 }
286 
OH_AudioRenderer_CancelMark(OH_AudioRenderer * renderer)287 OH_AudioStream_Result OH_AudioRenderer_CancelMark(OH_AudioRenderer *renderer)
288 {
289     OHOS::AudioStandard::OHAudioRenderer *audioRenderer = convertRenderer(renderer);
290     CHECK_AND_RETURN_RET_LOG(audioRenderer != nullptr, AUDIOSTREAM_ERROR_INVALID_PARAM, "convert renderer failed");
291     audioRenderer->UnsetRendererPositionCallback();
292     return AUDIOSTREAM_SUCCESS;
293 }
294 
OH_AudioRenderer_GetChannelLayout(OH_AudioRenderer * renderer,OH_AudioChannelLayout * channelLayout)295 OH_AudioStream_Result OH_AudioRenderer_GetChannelLayout(OH_AudioRenderer *renderer,
296     OH_AudioChannelLayout *channelLayout)
297 {
298     OHOS::AudioStandard::OHAudioRenderer *audioRenderer = convertRenderer(renderer);
299     CHECK_AND_RETURN_RET_LOG(audioRenderer != nullptr, AUDIOSTREAM_ERROR_INVALID_PARAM, "convert renderer failed");
300     *channelLayout = (OH_AudioChannelLayout)audioRenderer->GetChannelLayout();
301     return AUDIOSTREAM_SUCCESS;
302 }
303 
OH_AudioRenderer_GetEffectMode(OH_AudioRenderer * renderer,OH_AudioStream_AudioEffectMode * effectMode)304 OH_AudioStream_Result OH_AudioRenderer_GetEffectMode(OH_AudioRenderer *renderer,
305     OH_AudioStream_AudioEffectMode *effectMode)
306 {
307     OHOS::AudioStandard::OHAudioRenderer *audioRenderer = convertRenderer(renderer);
308     CHECK_AND_RETURN_RET_LOG(audioRenderer != nullptr, AUDIOSTREAM_ERROR_INVALID_PARAM, "convert renderer failed");
309     *effectMode = (OH_AudioStream_AudioEffectMode)audioRenderer->GetEffectMode();
310     return AUDIOSTREAM_SUCCESS;
311 }
312 
OH_AudioRenderer_SetEffectMode(OH_AudioRenderer * renderer,OH_AudioStream_AudioEffectMode effectMode)313 OH_AudioStream_Result OH_AudioRenderer_SetEffectMode(OH_AudioRenderer *renderer,
314     OH_AudioStream_AudioEffectMode effectMode)
315 {
316     OHOS::AudioStandard::OHAudioRenderer *audioRenderer = convertRenderer(renderer);
317     CHECK_AND_RETURN_RET_LOG(audioRenderer != nullptr, AUDIOSTREAM_ERROR_INVALID_PARAM, "convert renderer failed");
318     audioRenderer->SetEffectMode((OHOS::AudioStandard::AudioEffectMode)effectMode);
319     return AUDIOSTREAM_SUCCESS;
320 }
321 
OH_AudioRenderer_SetSilentModeAndMixWithOthers(OH_AudioRenderer * renderer,bool on)322 OH_AudioStream_Result OH_AudioRenderer_SetSilentModeAndMixWithOthers(
323     OH_AudioRenderer* renderer, bool on)
324 {
325     OHOS::AudioStandard::OHAudioRenderer *audioRenderer = convertRenderer(renderer);
326     CHECK_AND_RETURN_RET_LOG(audioRenderer != nullptr, AUDIOSTREAM_ERROR_INVALID_PARAM, "convert renderer failed");
327     audioRenderer->SetSilentModeAndMixWithOthers(on);
328     return AUDIOSTREAM_SUCCESS;
329 }
330 
OH_AudioRenderer_GetSilentModeAndMixWithOthers(OH_AudioRenderer * renderer,bool * on)331 OH_AudioStream_Result OH_AudioRenderer_GetSilentModeAndMixWithOthers(
332     OH_AudioRenderer* renderer, bool* on)
333 {
334     OHOS::AudioStandard::OHAudioRenderer *audioRenderer = convertRenderer(renderer);
335     CHECK_AND_RETURN_RET_LOG(audioRenderer != nullptr, AUDIOSTREAM_ERROR_INVALID_PARAM, "convert renderer failed");
336     *on = audioRenderer->GetSilentModeAndMixWithOthers();
337     return AUDIOSTREAM_SUCCESS;
338 }
339 
OH_AudioRenderer_SetDefaultOutputDevice(OH_AudioRenderer * renderer,OH_AudioDevice_Type deviceType)340 OH_AudioStream_Result OH_AudioRenderer_SetDefaultOutputDevice(
341     OH_AudioRenderer* renderer, OH_AudioDevice_Type deviceType)
342 {
343     OHOS::AudioStandard::OHAudioRenderer *audioRenderer = convertRenderer(renderer);
344     CHECK_AND_RETURN_RET_LOG(audioRenderer != nullptr, AUDIOSTREAM_ERROR_INVALID_PARAM, "convert renderer failed");
345     bool result = (deviceType == AUDIO_DEVICE_TYPE_EARPIECE || deviceType == AUDIO_DEVICE_TYPE_SPEAKER ||
346         deviceType == AUDIO_DEVICE_TYPE_DEFAULT) ? true : false;
347     CHECK_AND_RETURN_RET_LOG(result != false, AUDIOSTREAM_ERROR_INVALID_PARAM, "deviceType is not valid");
348     int32_t ret = audioRenderer->SetDefaultOutputDevice((OHOS::AudioStandard::DeviceType)deviceType);
349     if (ret == OHOS::AudioStandard::ERR_NOT_SUPPORTED) {
350         AUDIO_ERR_LOG("This audiorenderer can not reset the output device");
351         return AUDIOSTREAM_ERROR_ILLEGAL_STATE;
352     } else if (ret != AUDIOSTREAM_SUCCESS) {
353         AUDIO_ERR_LOG("system error when calling this function");
354         return AUDIOSTREAM_ERROR_SYSTEM;
355     }
356     return AUDIOSTREAM_SUCCESS;
357 }
358 
359 namespace OHOS {
360 namespace AudioStandard {
OHAudioRenderer()361 OHAudioRenderer::OHAudioRenderer()
362 {
363     AUDIO_INFO_LOG("OHAudioRenderer created!");
364 }
365 
~OHAudioRenderer()366 OHAudioRenderer::~OHAudioRenderer()
367 {
368     AUDIO_INFO_LOG("OHAudioRenderer destroyed!");
369 }
370 
Initialize(AudioRendererOptions & rendererOptions)371 bool OHAudioRenderer::Initialize(AudioRendererOptions &rendererOptions)
372 {
373     bool offloadAllowed = true;
374 
375     // unknown stream use music policy as default
376     if (rendererOptions.rendererInfo.streamUsage == STREAM_USAGE_UNKNOWN) {
377         rendererOptions.rendererInfo.streamUsage = STREAM_USAGE_MUSIC;
378         offloadAllowed = false;
379     }
380     std::string cacheDir = "/data/storage/el2/base/temp";
381     audioRenderer_ = AudioRenderer::Create(cacheDir, rendererOptions);
382     if (audioRenderer_ != nullptr) {
383         // if caller do not set usage, do not allow to use offload output
384         audioRenderer_->SetOffloadAllowed(offloadAllowed);
385     }
386 
387     return audioRenderer_ != nullptr;
388 }
389 
Start()390 bool OHAudioRenderer::Start()
391 {
392     if (audioRenderer_ == nullptr) {
393         AUDIO_ERR_LOG("renderer client is nullptr");
394         return false;
395     }
396     return audioRenderer_->Start();
397 }
398 
Pause()399 bool OHAudioRenderer::Pause()
400 {
401     if (audioRenderer_ == nullptr) {
402         AUDIO_ERR_LOG("renderer client is nullptr");
403         return false;
404     }
405     return audioRenderer_->Pause();
406 }
407 
Stop()408 bool OHAudioRenderer::Stop()
409 {
410     if (audioRenderer_ == nullptr) {
411         AUDIO_ERR_LOG("renderer client is nullptr");
412         return false;
413     }
414     return audioRenderer_->Stop();
415 }
416 
Flush()417 bool OHAudioRenderer::Flush()
418 {
419     if (audioRenderer_ == nullptr) {
420         AUDIO_ERR_LOG("renderer client is nullptr");
421         return false;
422     }
423     return audioRenderer_->Flush();
424 }
425 
Release()426 bool OHAudioRenderer::Release()
427 {
428     if (audioRenderer_ == nullptr) {
429         AUDIO_ERR_LOG("renderer client is nullptr");
430         return false;
431     }
432 
433     if (!audioRenderer_->Release()) {
434         return false;
435     }
436     audioRenderer_ = nullptr;
437     audioRendererCallback_ = nullptr;
438     return true;
439 }
440 
GetCurrentState()441 RendererState OHAudioRenderer::GetCurrentState()
442 {
443     CHECK_AND_RETURN_RET_LOG(audioRenderer_ != nullptr, RENDERER_INVALID, "renderer client is nullptr");
444     return audioRenderer_->GetStatus();
445 }
446 
GetStreamId(uint32_t & streamId)447 void OHAudioRenderer::GetStreamId(uint32_t &streamId)
448 {
449     CHECK_AND_RETURN_LOG(audioRenderer_ != nullptr, "renderer client is nullptr");
450     audioRenderer_->GetAudioStreamId(streamId);
451 }
452 
GetChannelCount()453 AudioChannel OHAudioRenderer::GetChannelCount()
454 {
455     CHECK_AND_RETURN_RET_LOG(audioRenderer_ != nullptr, MONO, "renderer client is nullptr");
456     AudioRendererParams params;
457     audioRenderer_->GetParams(params);
458     return params.channelCount;
459 }
460 
GetSamplingRate()461 int32_t OHAudioRenderer::GetSamplingRate()
462 {
463     CHECK_AND_RETURN_RET_LOG(audioRenderer_ != nullptr, MONO, "renderer client is nullptr");
464     AudioRendererParams params;
465     audioRenderer_->GetParams(params);
466     return params.sampleRate;
467 }
468 
GetSampleFormat()469 AudioSampleFormat OHAudioRenderer::GetSampleFormat()
470 {
471     CHECK_AND_RETURN_RET_LOG(audioRenderer_ != nullptr, INVALID_WIDTH, "renderer client is nullptr");
472     AudioRendererParams params;
473     audioRenderer_->GetParams(params);
474     return params.sampleFormat;
475 }
476 
GetRendererInfo(AudioRendererInfo & rendererInfo)477 void OHAudioRenderer::GetRendererInfo(AudioRendererInfo& rendererInfo)
478 {
479     CHECK_AND_RETURN_LOG(audioRenderer_ != nullptr, "renderer client is nullptr");
480     audioRenderer_->GetRendererInfo(rendererInfo);
481 }
482 
GetEncodingType()483 AudioEncodingType OHAudioRenderer::GetEncodingType()
484 {
485     CHECK_AND_RETURN_RET_LOG(audioRenderer_ != nullptr, ENCODING_INVALID, "renderer client is nullptr");
486     AudioRendererParams params;
487     audioRenderer_->GetParams(params);
488     return params.encodingType;
489 }
490 
GetFramesWritten()491 int64_t OHAudioRenderer::GetFramesWritten()
492 {
493     CHECK_AND_RETURN_RET_LOG(audioRenderer_ != nullptr, ERROR, "renderer client is nullptr");
494     return audioRenderer_->GetFramesWritten();
495 }
496 
GetAudioTime(Timestamp & timestamp,Timestamp::Timestampbase base)497 bool OHAudioRenderer::GetAudioTime(Timestamp &timestamp, Timestamp::Timestampbase base)
498 {
499     CHECK_AND_RETURN_RET_LOG(audioRenderer_ != nullptr, false, "renderer client is nullptr");
500     return audioRenderer_->GetAudioPosition(timestamp, base);
501 }
502 
GetFrameSizeInCallback()503 int32_t OHAudioRenderer::GetFrameSizeInCallback()
504 {
505     CHECK_AND_RETURN_RET_LOG(audioRenderer_ != nullptr, ERROR, "renderer client is nullptr");
506     uint32_t frameSize;
507     audioRenderer_->GetFrameCount(frameSize);
508     return static_cast<int32_t>(frameSize);
509 }
510 
GetBufferDesc(BufferDesc & bufDesc) const511 int32_t OHAudioRenderer::GetBufferDesc(BufferDesc &bufDesc) const
512 {
513     CHECK_AND_RETURN_RET_LOG(audioRenderer_ != nullptr, ERROR, "renderer client is nullptr");
514     return audioRenderer_->GetBufferDesc(bufDesc);
515 }
516 
Enqueue(const BufferDesc & bufDesc) const517 int32_t OHAudioRenderer::Enqueue(const BufferDesc &bufDesc) const
518 {
519     CHECK_AND_RETURN_RET_LOG(audioRenderer_ != nullptr, ERROR, "renderer client is nullptr");
520     return audioRenderer_->Enqueue(bufDesc);
521 }
522 
SetSpeed(float speed)523 int32_t OHAudioRenderer::SetSpeed(float speed)
524 {
525     CHECK_AND_RETURN_RET_LOG(audioRenderer_ != nullptr, ERROR, "renderer client is nullptr");
526     return audioRenderer_->SetSpeed(speed);
527 }
528 
GetSpeed()529 float OHAudioRenderer::GetSpeed()
530 {
531     CHECK_AND_RETURN_RET_LOG(audioRenderer_ != nullptr, ERROR, "renderer client is nullptr");
532     return audioRenderer_->GetSpeed();
533 }
534 
SetVolume(float volume) const535 int32_t OHAudioRenderer::SetVolume(float volume) const
536 {
537     CHECK_AND_RETURN_RET_LOG(audioRenderer_ != nullptr, ERROR, "renderer client is nullptr");
538     return audioRenderer_->SetVolume(volume);
539 }
540 
GetVolume() const541 float OHAudioRenderer::GetVolume() const
542 {
543     CHECK_AND_RETURN_RET_LOG(audioRenderer_ != nullptr, ERROR, "renderer client is nullptr");
544     return audioRenderer_->GetVolume();
545 }
546 
SetVolumeWithRamp(float volume,int32_t duration)547 int32_t OHAudioRenderer::SetVolumeWithRamp(float volume, int32_t duration)
548 {
549     CHECK_AND_RETURN_RET_LOG(audioRenderer_ != nullptr, ERROR, "renderer client is nullptr");
550     return audioRenderer_->SetVolumeWithRamp(volume, duration);
551 }
552 
SetRendererPositionCallback(OH_AudioRenderer_OnMarkReachedCallback callback,uint32_t markPosition,void * userData)553 int32_t OHAudioRenderer::SetRendererPositionCallback(OH_AudioRenderer_OnMarkReachedCallback callback,
554     uint32_t markPosition, void *userData)
555 {
556     CHECK_AND_RETURN_RET_LOG(audioRenderer_ != nullptr, ERROR, "renderer client is nullptr");
557     CHECK_AND_RETURN_RET_LOG(callback != nullptr, ERROR, "callback is nullptr");
558     rendererPositionCallback_ = std::make_shared<OHRendererPositionCallback>(callback,
559         reinterpret_cast<OH_AudioRenderer*>(this), userData);
560     return audioRenderer_->SetRendererPositionCallback(markPosition, rendererPositionCallback_);
561 }
562 
UnsetRendererPositionCallback()563 void OHAudioRenderer::UnsetRendererPositionCallback()
564 {
565     CHECK_AND_RETURN_LOG(audioRenderer_ != nullptr, "renderer client is nullptr");
566     audioRenderer_->UnsetRendererPositionCallback();
567 }
568 
OnMarkReached(const int64_t & framePosition)569 void OHRendererPositionCallback::OnMarkReached(const int64_t &framePosition)
570 {
571     CHECK_AND_RETURN_LOG(ohAudioRenderer_ != nullptr, "renderer client is nullptr");
572     CHECK_AND_RETURN_LOG(callback_ != nullptr, "pointer to the function is nullptr");
573     callback_(ohAudioRenderer_, framePosition, userData_);
574 }
575 
GetChannelLayout()576 AudioChannelLayout OHAudioRenderer::GetChannelLayout()
577 {
578     CHECK_AND_RETURN_RET_LOG(audioRenderer_ != nullptr, CH_LAYOUT_UNKNOWN, "renderer client is nullptr");
579     AudioRendererParams params;
580     audioRenderer_->GetParams(params);
581     return params.channelLayout;
582 }
583 
GetRendererPrivacy()584 AudioPrivacyType OHAudioRenderer::GetRendererPrivacy()
585 {
586     CHECK_AND_RETURN_RET_LOG(audioRenderer_ != nullptr, PRIVACY_TYPE_PUBLIC, "renderer client is nullptr for privacy");
587     return audioRenderer_->GetAudioPrivacyType();
588 }
589 
GetEffectMode()590 AudioEffectMode OHAudioRenderer::GetEffectMode()
591 {
592     CHECK_AND_RETURN_RET_LOG(audioRenderer_ != nullptr, EFFECT_NONE, "renderer client is nullptr");
593     return audioRenderer_->GetAudioEffectMode();
594 }
595 
SetEffectMode(AudioEffectMode effectMode)596 int32_t OHAudioRenderer::SetEffectMode(AudioEffectMode effectMode)
597 {
598     CHECK_AND_RETURN_RET_LOG(audioRenderer_ != nullptr, ERROR, "renderer client is nullptr");
599     return audioRenderer_->SetAudioEffectMode(effectMode);
600 }
601 
SetWriteDataCallback(RendererCallback rendererCallbacks,void * userData,void * metadataUserData,AudioEncodingType encodingType)602 void OHAudioRenderer::SetWriteDataCallback(RendererCallback rendererCallbacks, void *userData,
603     void *metadataUserData, AudioEncodingType encodingType)
604 {
605     if (encodingType == ENCODING_AUDIOVIVID && rendererCallbacks.writeDataWithMetadataCallback != nullptr) {
606         std::shared_ptr<AudioRendererWriteCallback> callback = std::make_shared<OHAudioRendererModeCallback>(
607             rendererCallbacks.writeDataWithMetadataCallback, (OH_AudioRenderer*)this, metadataUserData, encodingType);
608         audioRenderer_->SetRendererWriteCallback(callback);
609         AUDIO_INFO_LOG("The write callback function is for AudioVivid type");
610     } else if (encodingType == ENCODING_PCM) {
611         if (writeDataCallbackType_ == WRITE_DATA_CALLBACK_WITH_RESULT &&
612             rendererCallbacks.onWriteDataCallback != nullptr) {
613             std::shared_ptr<AudioRendererWriteCallback> callback = std::make_shared<OHAudioRendererModeCallback>(
614                 rendererCallbacks.onWriteDataCallback, (OH_AudioRenderer*)this, userData, encodingType);
615             audioRenderer_->SetRendererWriteCallback(callback);
616             AUDIO_INFO_LOG("The write callback function is for PCM type with result");
617         }
618 
619         if (writeDataCallbackType_ == WRITE_DATA_CALLBACK_WITHOUT_RESULT &&
620             rendererCallbacks.callbacks.OH_AudioRenderer_OnWriteData != nullptr) {
621             std::shared_ptr<AudioRendererWriteCallback> callback = std::make_shared<OHAudioRendererModeCallback>(
622                 rendererCallbacks.callbacks, (OH_AudioRenderer*)this, userData, encodingType);
623             audioRenderer_->SetRendererWriteCallback(callback);
624             AUDIO_INFO_LOG("The write callback function is for PCM type without result");
625         }
626     } else {
627         AUDIO_WARNING_LOG("The write callback function is not set");
628     }
629 }
630 
SetInterruptCallback(RendererCallback rendererCallbacks,void * userData)631 void OHAudioRenderer::SetInterruptCallback(RendererCallback rendererCallbacks, void *userData)
632 {
633     if (rendererCallbacks.callbacks.OH_AudioRenderer_OnInterruptEvent != nullptr) {
634         audioRendererCallback_ = std::make_shared<OHAudioRendererCallback>(rendererCallbacks.callbacks,
635             (OH_AudioRenderer*)this, userData);
636         audioRenderer_->SetRendererCallback(audioRendererCallback_);
637     } else {
638         AUDIO_WARNING_LOG("The audio renderer interrupt callback function is not set");
639     }
640 }
641 
SetErrorCallback(RendererCallback rendererCallbacks,void * userData)642 void OHAudioRenderer::SetErrorCallback(RendererCallback rendererCallbacks, void *userData)
643 {
644     if (rendererCallbacks.callbacks.OH_AudioRenderer_OnError != nullptr) {
645         std::shared_ptr<AudioRendererPolicyServiceDiedCallback> callback =
646             std::make_shared<OHServiceDiedCallback>(rendererCallbacks.callbacks, (OH_AudioRenderer*)this, userData);
647         int32_t clientPid = getpid();
648         audioRenderer_->RegisterAudioPolicyServerDiedCb(clientPid, callback);
649 
650         std::shared_ptr<AudioRendererErrorCallback> errorCallback = std::make_shared<OHAudioRendererErrorCallback>(
651             rendererCallbacks.callbacks, (OH_AudioRenderer*)this, userData);
652         audioRenderer_->SetAudioRendererErrorCallback(errorCallback);
653     } else {
654         AUDIO_WARNING_LOG("The audio renderer error callback function is not set");
655     }
656 }
657 
SetRendererCallback(RendererCallback rendererCallbacks,void * userData,void * metadataUserData)658 void OHAudioRenderer::SetRendererCallback(RendererCallback rendererCallbacks, void *userData, void *metadataUserData)
659 {
660     CHECK_AND_RETURN_LOG(audioRenderer_ != nullptr, "renderer client is nullptr");
661     audioRenderer_->SetRenderMode(RENDER_MODE_CALLBACK);
662 
663     AudioEncodingType encodingType = GetEncodingType();
664     SetWriteDataCallback(rendererCallbacks, userData, metadataUserData, encodingType);
665     SetInterruptCallback(rendererCallbacks, userData);
666     SetErrorCallback(rendererCallbacks, userData);
667 }
668 
SetRendererOutputDeviceChangeCallback(OH_AudioRenderer_OutputDeviceChangeCallback callback,void * userData)669 void OHAudioRenderer::SetRendererOutputDeviceChangeCallback(OH_AudioRenderer_OutputDeviceChangeCallback callback,
670     void *userData)
671 {
672     CHECK_AND_RETURN_LOG(audioRenderer_ != nullptr, "renderer client is nullptr");
673     CHECK_AND_RETURN_LOG(callback != nullptr, "callback is nullptr");
674     audioRendererDeviceChangeCallbackWithInfo_ =
675         std::make_shared<OHAudioRendererDeviceChangeCallbackWithInfo> (callback,
676         reinterpret_cast<OH_AudioRenderer*>(this), userData);
677     audioRenderer_->RegisterOutputDeviceChangeWithInfoCallback(audioRendererDeviceChangeCallbackWithInfo_);
678 }
679 
SetPreferredFrameSize(int32_t frameSize)680 void OHAudioRenderer::SetPreferredFrameSize(int32_t frameSize)
681 {
682     audioRenderer_->SetPreferredFrameSize(frameSize);
683 }
684 
IsFastRenderer()685 bool OHAudioRenderer::IsFastRenderer()
686 {
687     return audioRenderer_->IsFastRenderer();
688 }
689 
GetUnderflowCount()690 uint32_t OHAudioRenderer::GetUnderflowCount()
691 {
692     CHECK_AND_RETURN_RET_LOG(audioRenderer_ != nullptr, ERROR, "renderer client is nullptr");
693     return audioRenderer_->GetUnderflowCount();
694 }
695 
OnWriteData(size_t length)696 void OHAudioRendererModeCallback::OnWriteData(size_t length)
697 {
698     OHAudioRenderer *audioRenderer = (OHAudioRenderer*)ohAudioRenderer_;
699     CHECK_AND_RETURN_LOG(audioRenderer != nullptr, "renderer client is nullptr");
700     CHECK_AND_RETURN_LOG(((encodingType_ == ENCODING_PCM) && (callbacks_.OH_AudioRenderer_OnWriteData != nullptr)) ||
701         ((encodingType_ == ENCODING_PCM) && (onWriteDataCallback_ != nullptr)) ||
702         ((encodingType_ == ENCODING_AUDIOVIVID) && (writeDataWithMetadataCallback_ != nullptr)),
703         "pointer to the function is nullptr");
704     BufferDesc bufDesc;
705     audioRenderer->GetBufferDesc(bufDesc);
706     if (encodingType_ == ENCODING_AUDIOVIVID && writeDataWithMetadataCallback_ != nullptr) {
707         writeDataWithMetadataCallback_(ohAudioRenderer_, metadataUserData_, (void*)bufDesc.buffer, bufDesc.bufLength,
708             (void*)bufDesc.metaBuffer, bufDesc.metaLength);
709     } else {
710         if (audioRenderer->GetRendererCallbackType() == WRITE_DATA_CALLBACK_WITHOUT_RESULT &&
711             callbacks_.OH_AudioRenderer_OnWriteData != nullptr) {
712             callbacks_.OH_AudioRenderer_OnWriteData(ohAudioRenderer_, userData_,
713                 (void*)bufDesc.buffer, bufDesc.bufLength);
714         }
715         if (audioRenderer->GetRendererCallbackType() == WRITE_DATA_CALLBACK_WITH_RESULT &&
716             onWriteDataCallback_ != nullptr) {
717             OH_AudioData_Callback_Result result = onWriteDataCallback_(ohAudioRenderer_, userData_,
718                 (void*)bufDesc.buffer, bufDesc.bufLength);
719             if (result == AUDIO_DATA_CALLBACK_RESULT_INVALID) {
720                 AUDIO_DEBUG_LOG("Data callback returned invalid, data will not be used.");
721                 bufDesc.dataLength = 0; // Ensure that the invalid data is not used.
722             }
723         }
724     }
725     audioRenderer->Enqueue(bufDesc);
726 }
727 
OnOutputDeviceChange(const DeviceInfo & deviceInfo,const AudioStreamDeviceChangeReason reason)728 void OHAudioRendererDeviceChangeCallback::OnOutputDeviceChange(const DeviceInfo &deviceInfo,
729     const AudioStreamDeviceChangeReason reason)
730 {
731     CHECK_AND_RETURN_LOG(ohAudioRenderer_ != nullptr, "renderer client is nullptr");
732     CHECK_AND_RETURN_LOG(callbacks_.OH_AudioRenderer_OnStreamEvent != nullptr, "pointer to the function is nullptr");
733 
734     OH_AudioStream_Event event =  AUDIOSTREAM_EVENT_ROUTING_CHANGED;
735     callbacks_.OH_AudioRenderer_OnStreamEvent(ohAudioRenderer_, userData_, event);
736 }
737 
OnInterrupt(const InterruptEvent & interruptEvent)738 void OHAudioRendererCallback::OnInterrupt(const InterruptEvent &interruptEvent)
739 {
740     CHECK_AND_RETURN_LOG(ohAudioRenderer_ != nullptr, "renderer client is nullptr");
741     CHECK_AND_RETURN_LOG(callbacks_.OH_AudioRenderer_OnInterruptEvent != nullptr, "pointer to the function is nullptr");
742     OH_AudioInterrupt_ForceType type = (OH_AudioInterrupt_ForceType)(interruptEvent.forceType);
743     OH_AudioInterrupt_Hint hint = OH_AudioInterrupt_Hint(interruptEvent.hintType);
744     callbacks_.OH_AudioRenderer_OnInterruptEvent(ohAudioRenderer_, userData_, type, hint);
745 }
746 
OnAudioPolicyServiceDied()747 void OHServiceDiedCallback::OnAudioPolicyServiceDied()
748 {
749     CHECK_AND_RETURN_LOG(ohAudioRenderer_ != nullptr, "renderer client is nullptr");
750     CHECK_AND_RETURN_LOG(callbacks_.OH_AudioRenderer_OnError != nullptr, "pointer to the function is nullptr");
751     OH_AudioStream_Result error = AUDIOSTREAM_ERROR_SYSTEM;
752     callbacks_.OH_AudioRenderer_OnError(ohAudioRenderer_, userData_, error);
753 }
754 
GetErrorResult(AudioErrors errorCode) const755 OH_AudioStream_Result OHAudioRendererErrorCallback::GetErrorResult(AudioErrors errorCode) const
756 {
757     switch (errorCode) {
758         case ERROR_ILLEGAL_STATE:
759             return AUDIOSTREAM_ERROR_ILLEGAL_STATE;
760         case ERROR_INVALID_PARAM:
761             return AUDIOSTREAM_ERROR_INVALID_PARAM;
762         case ERROR_SYSTEM:
763             return AUDIOSTREAM_ERROR_SYSTEM;
764         default:
765             return AUDIOSTREAM_ERROR_SYSTEM;
766     }
767 }
768 
OnError(AudioErrors errorCode)769 void OHAudioRendererErrorCallback::OnError(AudioErrors errorCode)
770 {
771     CHECK_AND_RETURN_LOG(ohAudioRenderer_ != nullptr && callbacks_.OH_AudioRenderer_OnError != nullptr,
772         "renderer client or error callback funtion is nullptr");
773     OH_AudioStream_Result error = GetErrorResult(errorCode);
774     callbacks_.OH_AudioRenderer_OnError(ohAudioRenderer_, userData_, error);
775 }
776 
OnOutputDeviceChange(const DeviceInfo & deviceInfo,const AudioStreamDeviceChangeReason reason)777 void OHAudioRendererDeviceChangeCallbackWithInfo::OnOutputDeviceChange(const DeviceInfo &deviceInfo,
778     const AudioStreamDeviceChangeReason reason)
779 {
780     CHECK_AND_RETURN_LOG(ohAudioRenderer_ != nullptr, "renderer client is nullptr");
781     CHECK_AND_RETURN_LOG(callback_ != nullptr, "pointer to the function is nullptr");
782 
783     callback_(ohAudioRenderer_, userData_, static_cast<OH_AudioStream_DeviceChangeReason>(reason));
784 }
785 
SetInterruptMode(InterruptMode mode)786 void OHAudioRenderer::SetInterruptMode(InterruptMode mode)
787 {
788     CHECK_AND_RETURN_LOG(audioRenderer_ != nullptr, "renderer client is nullptr");
789     audioRenderer_->SetInterruptMode(mode);
790 }
791 
SetRendererCallbackType(WriteDataCallbackType writeDataCallbackType)792 void OHAudioRenderer::SetRendererCallbackType(WriteDataCallbackType writeDataCallbackType)
793 {
794     writeDataCallbackType_ = writeDataCallbackType;
795 }
796 
GetRendererCallbackType()797 WriteDataCallbackType OHAudioRenderer::GetRendererCallbackType()
798 {
799     return writeDataCallbackType_;
800 }
801 
SetSilentModeAndMixWithOthers(bool on)802 void OHAudioRenderer::SetSilentModeAndMixWithOthers(bool on)
803 {
804     CHECK_AND_RETURN_LOG(audioRenderer_ != nullptr, "renderer client is nullptr");
805     audioRenderer_->SetSilentModeAndMixWithOthers(on);
806 }
807 
GetSilentModeAndMixWithOthers()808 bool OHAudioRenderer::GetSilentModeAndMixWithOthers()
809 {
810     CHECK_AND_RETURN_RET_LOG(audioRenderer_ != nullptr, false, "renderer client is nullptr");
811     return audioRenderer_->GetSilentModeAndMixWithOthers();
812 }
813 
SetDefaultOutputDevice(DeviceType deviceType)814 int32_t OHAudioRenderer::SetDefaultOutputDevice(DeviceType deviceType)
815 {
816     CHECK_AND_RETURN_RET_LOG(audioRenderer_ != nullptr, ERROR, "renderer client is nullptr");
817     return audioRenderer_->SetDefaultOutputDevice(deviceType);
818 }
819 }  // namespace AudioStandard
820 }  // namespace OHOS
821