1 /*
2  * Copyright (c) 2021 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 #include <hdf_log.h>
16 #include "audio_internal.h"
17 #include "audio_adapter_info_common.h"
18 #include "audio_bluetooth_manager.h"
19 #include "audio_render.h"
20 namespace OHOS::HDI::Audio_Bluetooth {
21 /* 1 buffer: 8000(8kHz sample rate) * 2(bytes, PCM_16_BIT) * 1(channel) */
22 /* 1 frame: 1024(sample) * 2(bytes, PCM_16_BIT) * 1(channel) */
23 constexpr int FRAME_SIZE = 1024;
24 
PcmBytesToFrames(const struct AudioFrameRenderMode * frameRenderMode,uint64_t bytes,uint32_t * frameCount)25 int32_t PcmBytesToFrames(const struct AudioFrameRenderMode *frameRenderMode, uint64_t bytes, uint32_t *frameCount)
26 {
27     if (frameRenderMode == NULL || frameCount == NULL) {
28         return HDF_FAILURE;
29     }
30     uint32_t formatBits = 0;
31     int32_t ret = FormatToBits(frameRenderMode->attrs.format, &formatBits);
32     if (ret != HDF_SUCCESS) {
33         return ret;
34     }
35     uint32_t frameSize = frameRenderMode->attrs.channelCount * (formatBits >> 3); // Bit to byte >> 3
36     if (frameSize == 0) {
37         return HDF_FAILURE;
38     }
39     *frameCount = (uint32_t)bytes / frameSize;
40     return HDF_SUCCESS;
41 }
42 
AudioRenderStart(AudioHandle handle)43 int32_t AudioRenderStart(AudioHandle handle)
44 {
45     struct AudioHwRender *hwRender = reinterpret_cast<struct AudioHwRender *>(handle);
46     if (hwRender == NULL) {
47         return AUDIO_HAL_ERR_INVALID_PARAM;
48     }
49     if (hwRender->renderParam.frameRenderMode.buffer != NULL) {
50         HDF_LOGE("AudioRender already start!");
51         return AUDIO_HAL_ERR_AO_BUSY; // render is busy now
52     }
53 
54     HDF_LOGI("%s, StartPlaying", __func__);
55 #ifndef A2DP_HDI_SERVICE
56     if (OHOS::Bluetooth::GetPlayingState() == false) {
57         OHOS::Bluetooth::StartPlaying();
58     }
59 #endif
60 
61     char *buffer = static_cast<char *>(calloc(1, FRAME_DATA));
62     if (buffer == NULL) {
63         HDF_LOGE("Calloc Render buffer Fail!");
64         return AUDIO_HAL_ERR_MALLOC_FAIL;
65     }
66     hwRender->renderParam.frameRenderMode.buffer = buffer;
67     return AUDIO_HAL_SUCCESS;
68 }
69 
AudioRenderStop(AudioHandle handle)70 int32_t AudioRenderStop(AudioHandle handle)
71 {
72     HDF_LOGI("AudioRenderStop");
73     struct AudioHwRender *hwRender = reinterpret_cast<struct AudioHwRender *>(handle);
74     if (hwRender == NULL) {
75         return AUDIO_HAL_ERR_INVALID_PARAM;
76     }
77     if (hwRender->renderParam.frameRenderMode.buffer != NULL) {
78         AudioMemFree(reinterpret_cast<void **>(&hwRender->renderParam.frameRenderMode.buffer));
79     } else {
80         HDF_LOGE("Repeat invalid stop operation!");
81         return AUDIO_HAL_ERR_NOT_SUPPORT;
82     }
83 
84     HDF_LOGI("%s, StopPlaying", __func__);
85 #ifndef A2DP_HDI_SERVICE
86     if (OHOS::Bluetooth::GetPlayingState() == true) {
87         OHOS::Bluetooth::StopPlaying();
88     }
89 #else
90     OHOS::Bluetooth::StopPlaying();
91 #endif
92 
93     hwRender->renderParam.renderMode.ctlParam.pause = false;
94     return AUDIO_HAL_SUCCESS;
95 }
96 
AudioRenderPause(AudioHandle handle)97 int32_t AudioRenderPause(AudioHandle handle)
98 {
99     struct AudioHwRender *hwRender = reinterpret_cast<struct AudioHwRender *>(handle);
100     if (hwRender == NULL) {
101         return AUDIO_HAL_ERR_INVALID_PARAM;
102     }
103     if (hwRender->renderParam.frameRenderMode.buffer == NULL) {
104         HDF_LOGE("AudioRender already stop!");
105         return AUDIO_HAL_ERR_INTERNAL;
106     }
107     if (hwRender->renderParam.renderMode.ctlParam.pause) {
108         HDF_LOGE("Audio is already pause!");
109         return AUDIO_HAL_ERR_NOT_SUPPORT;
110     }
111 
112     HDF_LOGI("%s, SuspendPlaying", __func__);
113 #ifndef A2DP_HDI_SERVICE
114     if (OHOS::Bluetooth::GetPlayingState() == true) {
115         OHOS::Bluetooth::SuspendPlaying();
116     }
117 #else
118     OHOS::Bluetooth::SuspendPlaying();
119 #endif
120 
121     hwRender->renderParam.renderMode.ctlParam.pause = true;
122     return AUDIO_HAL_SUCCESS;
123 }
124 
AudioRenderResume(AudioHandle handle)125 int32_t AudioRenderResume(AudioHandle handle)
126 {
127     HDF_LOGI("AudioRenderResume");
128     struct AudioHwRender *hwRender = reinterpret_cast<struct AudioHwRender *>(handle);
129     if (hwRender == NULL) {
130         return AUDIO_HAL_ERR_INVALID_PARAM;
131     }
132     if (!hwRender->renderParam.renderMode.ctlParam.pause) {
133         HDF_LOGE("Audio is already Resume !");
134         return AUDIO_HAL_ERR_NOT_SUPPORT;
135     }
136 
137     HDF_LOGI("%s, StartPlaying", __func__);
138 #ifndef A2DP_HDI_SERVICE
139     if (OHOS::Bluetooth::GetPlayingState() == false) {
140         OHOS::Bluetooth::StartPlaying();
141     }
142 #endif
143 
144     hwRender->renderParam.renderMode.ctlParam.pause = false;
145     return AUDIO_HAL_SUCCESS;
146 }
147 
AudioRenderFlush(AudioHandle handle)148 int32_t AudioRenderFlush(AudioHandle handle)
149 {
150     HDF_LOGI("AudioRenderFlush");
151     struct AudioHwRender *hwRender = reinterpret_cast<struct AudioHwRender *>(handle);
152     if (hwRender == NULL) {
153         return AUDIO_HAL_ERR_INVALID_PARAM;
154     }
155     return AUDIO_HAL_ERR_NOT_SUPPORT;
156 }
157 
AudioRenderGetFrameSize(AudioHandle handle,uint64_t * size)158 int32_t AudioRenderGetFrameSize(AudioHandle handle, uint64_t *size)
159 {
160     struct AudioHwRender *hwRender = reinterpret_cast<struct AudioHwRender *>(handle);
161     const int shift = 3;
162     if (hwRender == NULL || size == NULL) {
163         return AUDIO_HAL_ERR_INVALID_PARAM;
164     }
165     uint32_t channelCount = hwRender->renderParam.frameRenderMode.attrs.channelCount;
166     AudioFormat format = hwRender->renderParam.frameRenderMode.attrs.format;
167     uint32_t formatBits = 0;
168     int32_t ret = FormatToBits(format, &formatBits);
169     if (ret != AUDIO_HAL_SUCCESS) {
170         return ret;
171     }
172     *size = FRAME_SIZE * channelCount * (formatBits >> shift);
173     return AUDIO_HAL_SUCCESS;
174 }
175 
AudioRenderGetFrameCount(AudioHandle handle,uint64_t * count)176 int32_t AudioRenderGetFrameCount(AudioHandle handle, uint64_t *count)
177 {
178     struct AudioHwRender *hwRender = reinterpret_cast<struct AudioHwRender *>(handle);
179     if (hwRender == NULL || count == NULL) {
180         return AUDIO_HAL_ERR_INVALID_PARAM;
181     }
182     *count = hwRender->renderParam.frameRenderMode.frames;
183     return AUDIO_HAL_SUCCESS;
184 }
185 
AudioRenderSetSampleAttributes(AudioHandle handle,const struct AudioSampleAttributes * attrs)186 int32_t AudioRenderSetSampleAttributes(AudioHandle handle, const struct AudioSampleAttributes *attrs)
187 {
188     (void)attrs;
189     return AUDIO_HAL_SUCCESS;
190 }
191 
AudioRenderGetSampleAttributes(AudioHandle handle,struct AudioSampleAttributes * attrs)192 int32_t AudioRenderGetSampleAttributes(AudioHandle handle, struct AudioSampleAttributes *attrs)
193 {
194     struct AudioHwRender *hwRender = reinterpret_cast<struct AudioHwRender *>(handle);
195     if (hwRender == NULL || attrs == NULL) {
196         return AUDIO_HAL_ERR_INVALID_PARAM;
197     }
198     attrs->format = hwRender->renderParam.frameRenderMode.attrs.format;
199     attrs->sampleRate = hwRender->renderParam.frameRenderMode.attrs.sampleRate;
200     attrs->channelCount = hwRender->renderParam.frameRenderMode.attrs.channelCount;
201     attrs->type = hwRender->renderParam.frameRenderMode.attrs.type;
202     attrs->interleaved = hwRender->renderParam.frameRenderMode.attrs.interleaved;
203     attrs->period = hwRender->renderParam.frameRenderMode.attrs.period;
204     attrs->frameSize = hwRender->renderParam.frameRenderMode.attrs.frameSize;
205     attrs->isBigEndian = hwRender->renderParam.frameRenderMode.attrs.isBigEndian;
206     attrs->isSignedData = hwRender->renderParam.frameRenderMode.attrs.isSignedData;
207     attrs->startThreshold = hwRender->renderParam.frameRenderMode.attrs.startThreshold;
208     attrs->stopThreshold = hwRender->renderParam.frameRenderMode.attrs.stopThreshold;
209     attrs->silenceThreshold = hwRender->renderParam.frameRenderMode.attrs.silenceThreshold;
210     return AUDIO_HAL_SUCCESS;
211 }
212 
AudioRenderGetCurrentChannelId(AudioHandle handle,uint32_t * channelId)213 int32_t AudioRenderGetCurrentChannelId(AudioHandle handle, uint32_t *channelId)
214 {
215     HDF_LOGI("AudioRenderGetCurrentChannelId");
216     struct AudioHwRender *hwRender = reinterpret_cast<struct AudioHwRender *>(handle);
217     if (hwRender == NULL || channelId == NULL) {
218         return AUDIO_HAL_ERR_INVALID_PARAM;
219     }
220     *channelId = hwRender->renderParam.frameRenderMode.attrs.channelCount;
221     return AUDIO_HAL_SUCCESS;
222 }
223 
AudioRenderCheckSceneCapability(AudioHandle handle,const struct AudioSceneDescriptor * scene,bool * supported)224 int32_t AudioRenderCheckSceneCapability(AudioHandle handle, const struct AudioSceneDescriptor *scene,
225                                         bool *supported)
226 {
227     (void)scene;
228     (void)supported;
229     HDF_LOGI("AudioRenderCheckSceneCapability");
230     return AUDIO_HAL_SUCCESS;
231 }
232 
AudioRenderSelectScene(AudioHandle handle,const struct AudioSceneDescriptor * scene)233 int32_t AudioRenderSelectScene(AudioHandle handle, const struct AudioSceneDescriptor *scene)
234 {
235     (void)scene;
236     return AUDIO_HAL_SUCCESS;
237 }
238 
AudioRenderSetMute(AudioHandle handle,bool mute)239 int32_t AudioRenderSetMute(AudioHandle handle, bool mute)
240 {
241     (void)mute;
242     return AUDIO_HAL_SUCCESS;
243 }
244 
AudioRenderGetMute(AudioHandle handle,bool * mute)245 int32_t AudioRenderGetMute(AudioHandle handle, bool *mute)
246 {
247     (void)mute;
248     return AUDIO_HAL_SUCCESS;
249 }
250 
AudioRenderSetVolume(AudioHandle handle,float volume)251 int32_t AudioRenderSetVolume(AudioHandle handle, float volume)
252 {
253     (void)volume;
254     return AUDIO_HAL_SUCCESS;
255 }
256 
AudioRenderGetVolume(AudioHandle handle,float * volume)257 int32_t AudioRenderGetVolume(AudioHandle handle, float *volume)
258 {
259     (void)volume;
260     return AUDIO_HAL_SUCCESS;
261 }
262 
AudioRenderGetGainThreshold(AudioHandle handle,float * min,float * max)263 int32_t AudioRenderGetGainThreshold(AudioHandle handle, float *min, float *max)
264 {
265     (void)min;
266     (void)max;
267     HDF_LOGI("AudioRenderGetGainThreshold");
268     return AUDIO_HAL_SUCCESS;
269 }
270 
AudioRenderGetGain(AudioHandle handle,float * gain)271 int32_t AudioRenderGetGain(AudioHandle handle, float *gain)
272 {
273     (void)gain;
274     HDF_LOGI("AudioRenderGetGain");
275     return AUDIO_HAL_SUCCESS;
276 }
277 
AudioRenderSetGain(AudioHandle handle,float gain)278 int32_t AudioRenderSetGain(AudioHandle handle, float gain)
279 {
280     (void)gain;
281     HDF_LOGI("AudioRenderSetGain");
282     return AUDIO_HAL_SUCCESS;
283 }
284 
AudioRenderGetLatency(struct AudioRender * render,uint32_t * ms)285 int32_t AudioRenderGetLatency(struct AudioRender *render, uint32_t *ms)
286 {
287     struct AudioHwRender *impl = reinterpret_cast<struct AudioHwRender *>(render);
288     if (impl == NULL || ms == NULL) {
289         return AUDIO_HAL_ERR_INVALID_PARAM;
290     }
291     uint32_t byteRate = impl->renderParam.frameRenderMode.byteRate;
292     uint32_t periodSize = impl->renderParam.frameRenderMode.periodSize;
293     uint32_t periodCount = impl->renderParam.frameRenderMode.periodCount;
294     if (byteRate == 0) {
295         return AUDIO_HAL_ERR_INTERNAL;
296     }
297     uint32_t periodMs = (periodCount * periodSize * 1000) / byteRate;
298     *ms = periodMs;
299 #ifdef A2DP_HDI_SERVICE
300     uint32_t latency = 0;
301     OHOS::Bluetooth::GetLatency(latency);
302     *ms = latency;
303 #endif
304     return AUDIO_HAL_SUCCESS;
305 }
306 
AudioRenderRenderFramSplit(struct AudioHwRender * hwRender)307 int32_t AudioRenderRenderFramSplit(struct AudioHwRender *hwRender)
308 {
309     return HDF_SUCCESS;
310 }
311 
AudioRenderRenderFrame(struct AudioRender * render,const void * frame,uint64_t requestBytes,uint64_t * replyBytes)312 int32_t AudioRenderRenderFrame(struct AudioRender *render, const void *frame,
313                                uint64_t requestBytes, uint64_t *replyBytes)
314 {
315     HDF_LOGD("AudioRenderRenderFrame");
316     struct AudioHwRender *hwRender = reinterpret_cast<struct AudioHwRender *>(render);
317     if (hwRender == NULL || frame == NULL || replyBytes == NULL ||
318         hwRender->renderParam.frameRenderMode.buffer == NULL) {
319         HDF_LOGE("Render Frame Paras is NULL!");
320         return AUDIO_HAL_ERR_INVALID_PARAM;
321     }
322     if (FRAME_DATA < requestBytes) {
323         HDF_LOGE("Out of FRAME_DATA size!");
324         return AUDIO_HAL_ERR_INTERNAL;
325     }
326     int32_t ret = memcpy_s(hwRender->renderParam.frameRenderMode.buffer, FRAME_DATA, frame, (uint32_t)requestBytes);
327     if (ret != EOK) {
328         HDF_LOGE("memcpy_s fail");
329         return AUDIO_HAL_ERR_INTERNAL;
330     }
331     hwRender->renderParam.frameRenderMode.bufferSize = requestBytes;
332     uint32_t frameCount = 0;
333     ret = PcmBytesToFrames(&hwRender->renderParam.frameRenderMode, requestBytes, &frameCount);
334     if (ret != AUDIO_HAL_SUCCESS) {
335         return ret;
336     }
337     hwRender->renderParam.frameRenderMode.bufferFrameSize = (uint64_t)frameCount;
338     if (AudioRenderRenderFramSplit(hwRender) < 0) {
339         return AUDIO_HAL_ERR_INTERNAL;
340     }
341     *replyBytes = requestBytes;
342     hwRender->renderParam.frameRenderMode.frames += hwRender->renderParam.frameRenderMode.bufferFrameSize;
343     if (hwRender->renderParam.frameRenderMode.attrs.sampleRate == 0) {
344         HDF_LOGE("Divisor cannot be zero!");
345         return AUDIO_HAL_ERR_INTERNAL;
346     }
347     if (TimeToAudioTimeStamp(hwRender->renderParam.frameRenderMode.bufferFrameSize,
348         &hwRender->renderParam.frameRenderMode.time,
349         hwRender->renderParam.frameRenderMode.attrs.sampleRate) == HDF_FAILURE) {
350         HDF_LOGE("Frame is NULL");
351         return AUDIO_HAL_ERR_INTERNAL;
352     }
353 
354     LOGV("%s, WriteFrame", __func__);
355     const uint8_t *data = reinterpret_cast<const uint8_t *>(frame);
356     AudioSampleAttributes *attrs = &hwRender->renderParam.frameRenderMode.attrs;
357     return OHOS::Bluetooth::WriteFrame(data, static_cast<uint32_t>(requestBytes), attrs);
358 }
359 
AudioRenderGetRenderPosition(struct AudioRender * render,uint64_t * frames,struct AudioTimeStamp * time)360 int32_t AudioRenderGetRenderPosition(struct AudioRender *render, uint64_t *frames, struct AudioTimeStamp *time)
361 {
362     struct AudioHwRender *impl = reinterpret_cast<struct AudioHwRender *>(render);
363     if (impl == NULL || frames == NULL || time == NULL) {
364         return AUDIO_HAL_ERR_INVALID_PARAM;
365     }
366     *frames = impl->renderParam.frameRenderMode.frames;
367     *time = impl->renderParam.frameRenderMode.time;
368     return AUDIO_HAL_SUCCESS;
369 }
370 
AudioRenderSetRenderSpeed(struct AudioRender * render,float speed)371 int32_t AudioRenderSetRenderSpeed(struct AudioRender *render, float speed)
372 {
373     (void)speed;
374     HDF_LOGI("AudioRenderSetRenderSpeed");
375     struct AudioHwRender *hwRender = reinterpret_cast<struct AudioHwRender *>(render);
376     if (hwRender == NULL) {
377         return AUDIO_HAL_ERR_INVALID_PARAM;
378     }
379     return AUDIO_HAL_ERR_NOT_SUPPORT;
380 }
381 
AudioRenderGetRenderSpeed(struct AudioRender * render,float * speed)382 int32_t AudioRenderGetRenderSpeed(struct AudioRender *render, float *speed)
383 {
384     HDF_LOGI("AudioRenderGetRenderSpeed");
385     struct AudioHwRender *hwRender = reinterpret_cast<struct AudioHwRender *>(render);
386     if (hwRender == NULL || speed == NULL) {
387         return AUDIO_HAL_ERR_INVALID_PARAM;
388     }
389     return AUDIO_HAL_ERR_NOT_SUPPORT;
390 }
391 
AudioRenderSetChannelMode(struct AudioRender * render,AudioChannelMode mode)392 int32_t AudioRenderSetChannelMode(struct AudioRender *render, AudioChannelMode mode)
393 {
394     (void)render;
395     HDF_LOGI("AudioRenderSetChannelMode");
396     return AUDIO_HAL_SUCCESS;
397 }
398 
AudioRenderGetChannelMode(struct AudioRender * render,AudioChannelMode * mode)399 int32_t AudioRenderGetChannelMode(struct AudioRender *render, AudioChannelMode *mode)
400 {
401     (void)render;
402     HDF_LOGI("AudioRenderGetChannelMode");
403     return AUDIO_HAL_SUCCESS;
404 }
405 
SetValue(struct ExtraParams mExtraParams,struct AudioHwRender * render)406 int32_t SetValue(struct ExtraParams mExtraParams, struct AudioHwRender *render)
407 {
408     if (render == NULL) {
409         return HDF_FAILURE;
410     }
411     if (mExtraParams.route != -1) {
412         render->renderParam.renderMode.hwInfo.pathroute = (PathRoute)mExtraParams.route;
413     }
414     if (mExtraParams.format != -1) {
415         render->renderParam.frameRenderMode.attrs.format = (AudioFormat)mExtraParams.format;
416     }
417     if (mExtraParams.channels != 0) {
418         render->renderParam.frameRenderMode.attrs.channelCount = mExtraParams.channels;
419     }
420     if (mExtraParams.flag) {
421         render->renderParam.frameRenderMode.frames = mExtraParams.frames;
422     }
423     if (mExtraParams.sampleRate != 0) {
424         render->renderParam.frameRenderMode.attrs.sampleRate = mExtraParams.sampleRate;
425     }
426 #ifdef A2DP_HDI_SERVICE
427     if (mExtraParams.audioStreamCtl == 1) {
428         HDF_LOGI("SetValue, try to suspendPlaying=1");
429         OHOS::Bluetooth::SuspendPlayingFromParam();
430     } else if (mExtraParams.audioStreamCtl == 0) {
431         HDF_LOGI("SetValue, try to suspendPlaying=0");
432         OHOS::Bluetooth::UnBlockStart();
433     }
434 #endif
435     return HDF_SUCCESS;
436 }
437 
AudioRenderSetExtraParams(AudioHandle handle,const char * keyValueList)438 int32_t AudioRenderSetExtraParams(AudioHandle handle, const char *keyValueList)
439 {
440     struct AudioHwRender *render = reinterpret_cast<struct AudioHwRender *>(handle);
441     if (render == NULL || keyValueList == NULL) {
442         return AUDIO_HAL_ERR_INVALID_PARAM;
443     }
444     int32_t count = 0;
445     int32_t sumOk = 0;
446     struct ExtraParams mExtraParams;
447     if (AudioSetExtraParams(keyValueList, &count, &mExtraParams, &sumOk) < 0) {
448         return AUDIO_HAL_ERR_INTERNAL;
449     }
450     if (count != 0 && sumOk == count) {
451         SetValue(mExtraParams, render);
452         return AUDIO_HAL_SUCCESS;
453     } else {
454         return AUDIO_HAL_ERR_INTERNAL;
455     }
456 }
457 
AudioRenderGetExtraParams(AudioHandle handle,char * keyValueList,int32_t listLenth)458 int32_t AudioRenderGetExtraParams(AudioHandle handle, char *keyValueList, int32_t listLenth)
459 {
460     struct AudioHwRender *render = reinterpret_cast<struct AudioHwRender *>(handle);
461     if (render == NULL || keyValueList == NULL || listLenth <= 0) {
462         return AUDIO_HAL_ERR_INVALID_PARAM;
463     }
464     int32_t bufferSize = strlen(ROUTE_SAMPLE) + strlen(FORMAT_SAMPLE) + strlen(CHANNELS_SAMPLE)
465                     + strlen(FRAME_COUNT_SAMPLE) + strlen(SAMPLING_RATE_SAMPLE) + 1;
466     if (listLenth < bufferSize) {
467         return AUDIO_HAL_ERR_INTERNAL;
468     }
469     int32_t ret = AddElementToList(keyValueList, listLenth, AUDIO_ATTR_PARAM_ROUTE,
470         &render->renderParam.renderMode.hwInfo.pathroute);
471     if (ret < 0) {
472         return AUDIO_HAL_ERR_INTERNAL;
473     }
474     ret = AddElementToList(keyValueList, listLenth, AUDIO_ATTR_PARAM_FORMAT,
475         &render->renderParam.frameRenderMode.attrs.format);
476     if (ret < 0) {
477         return AUDIO_HAL_ERR_INTERNAL;
478     }
479     ret = AddElementToList(keyValueList, listLenth, AUDIO_ATTR_PARAM_CHANNELS,
480         &render->renderParam.frameRenderMode.attrs.channelCount);
481     if (ret < 0) {
482         return AUDIO_HAL_ERR_INTERNAL;
483     }
484     ret = AddElementToList(keyValueList, listLenth, AUDIO_ATTR_PARAM_FRAME_COUNT,
485         &render->renderParam.frameRenderMode.frames);
486     if (ret < 0) {
487         return AUDIO_HAL_ERR_INTERNAL;
488     }
489     ret = AddElementToList(keyValueList, listLenth, AUDIO_ATTR_PARAM_SAMPLING_RATE,
490         &render->renderParam.frameRenderMode.attrs.sampleRate);
491     if (ret < 0) {
492         return AUDIO_HAL_ERR_INTERNAL;
493     }
494     return AUDIO_HAL_SUCCESS;
495 }
496 
AudioRenderReqMmapBuffer(AudioHandle handle,int32_t reqSize,struct AudioMmapBufferDescriptor * desc)497 int32_t AudioRenderReqMmapBuffer(AudioHandle handle, int32_t reqSize, struct AudioMmapBufferDescriptor *desc)
498 {
499     (void)desc;
500     HDF_LOGI("AudioRenderReqMmapBuffer Success!");
501     return AUDIO_HAL_SUCCESS;
502 }
503 
AudioRenderGetMmapPosition(AudioHandle handle,uint64_t * frames,struct AudioTimeStamp * time)504 int32_t AudioRenderGetMmapPosition(AudioHandle handle, uint64_t *frames, struct AudioTimeStamp *time)
505 {
506     struct AudioHwRender *render = reinterpret_cast<struct AudioHwRender *>(handle);
507     if (render == NULL || frames == NULL || time == NULL) {
508         return AUDIO_HAL_ERR_INVALID_PARAM;
509     }
510     *frames = render->renderParam.frameRenderMode.frames;
511     render->renderParam.frameRenderMode.time.tvSec = (int64_t)render->renderParam.frameRenderMode.frames /
512                                        (int64_t)render->renderParam.frameRenderMode.attrs.sampleRate;
513     int64_t lastBufFrames = render->renderParam.frameRenderMode.frames %
514                         ((int64_t)render->renderParam.frameRenderMode.attrs.sampleRate);
515     render->renderParam.frameRenderMode.time.tvNSec =
516         (lastBufFrames * SEC_TO_NSEC) / ((int64_t)render->renderParam.frameRenderMode.attrs.sampleRate);
517     *time = render->renderParam.frameRenderMode.time;
518     return AUDIO_HAL_SUCCESS;
519 }
520 
AudioRenderTurnStandbyMode(AudioHandle handle)521 int32_t AudioRenderTurnStandbyMode(AudioHandle handle)
522 {
523     struct AudioHwRender *render = reinterpret_cast<struct AudioHwRender *>(handle);
524     if (render == NULL) {
525         return AUDIO_HAL_ERR_INVALID_PARAM;
526     }
527     int32_t ret = AudioRenderStop((AudioHandle)render);
528     if (ret < 0) {
529         return AUDIO_HAL_ERR_INTERNAL;
530     }
531     return AUDIO_HAL_SUCCESS;
532 }
533 
AudioRenderAudioDevDump(AudioHandle handle,int32_t range,int32_t fd)534 int32_t AudioRenderAudioDevDump(AudioHandle handle, int32_t range, int32_t fd)
535 {
536     struct AudioHwRender *render = reinterpret_cast<struct AudioHwRender *>(handle);
537     if (render == NULL) {
538         return AUDIO_HAL_ERR_INVALID_PARAM;
539     }
540     dprintf(fd, "%s%d\n", "Number of errors: ", render->errorLog.totalErrors);
541     if (range < RANGE_MIN - 1 || range > RANGE_MAX) {
542         dprintf(fd, "%s\n", "Out of range, invalid output");
543         return AUDIO_HAL_SUCCESS;
544     }
545     uint32_t mSize = render->errorLog.iter;
546     if (range < RANGE_MIN) {
547         dprintf(fd, "%-5s  %-10s  %s\n", "count", "errorCode", "Time");
548         for (uint32_t i = 0; i < mSize; i++) {
549             dprintf(fd, FORMAT_TWO, render->errorLog.errorDump[i].count + 1,
550                     render->errorLog.errorDump[i].errorCode,
551                     render->errorLog.errorDump[i].currentTime);
552         }
553     } else {
554         dprintf(fd, "%-5s  %-10s  %-20s  %-15s  %s\n", "count", "errorCode", "frames", "fail reason", "Time");
555         for (uint32_t i = 0; i < mSize; i++) {
556             dprintf(fd, FORMAT_ONE, render->errorLog.errorDump[i].count + 1,
557                     render->errorLog.errorDump[i].errorCode,
558                     render->errorLog.errorDump[i].frames,
559                     render->errorLog.errorDump[i].reason,
560                     render->errorLog.errorDump[i].currentTime);
561         }
562     }
563     return AUDIO_HAL_SUCCESS;
564 }
CallbackProcessing(AudioHandle handle,AudioCallbackType callBackType)565 int32_t CallbackProcessing(AudioHandle handle, AudioCallbackType callBackType)
566 {
567     struct AudioHwRender *render = reinterpret_cast<struct AudioHwRender *>(handle);
568     if (render == NULL) {
569         HDF_LOGI("Unregistered callback.\n");
570         return HDF_FAILURE;
571     }
572     if (render->renderParam.frameRenderMode.callback == NULL) {
573         return HDF_FAILURE;
574     }
575     bool isCallBack = true;
576     switch (callBackType) {
577         case AUDIO_NONBLOCK_WRITE_COMPLETED:
578         case AUDIO_DRAIN_COMPLETED:
579         case AUDIO_FLUSH_COMPLETED:
580         case AUDIO_RENDER_FULL:
581         case AUDIO_ERROR_OCCUR:
582             isCallBack = true;
583             break;
584         default:
585             isCallBack = false;
586             break;
587     }
588     if (!isCallBack) {
589         HDF_LOGI("No callback processing is required.\n");
590         return HDF_ERR_NOT_SUPPORT;
591     }
592     render->renderParam.frameRenderMode.callback(callBackType, NULL, render->renderParam.frameRenderMode.cookie);
593     return HDF_SUCCESS;
594 }
595 
AudioRenderRegCallback(struct AudioRender * render,RenderCallback callback,void * cookie)596 int32_t AudioRenderRegCallback(struct AudioRender *render, RenderCallback callback, void *cookie)
597 {
598     struct AudioHwRender *pRender = reinterpret_cast<struct AudioHwRender *>(render);
599     if (pRender == NULL) {
600         return AUDIO_HAL_ERR_INVALID_PARAM;
601     }
602     pRender->renderParam.frameRenderMode.callback = callback;
603     pRender->renderParam.frameRenderMode.cookie = cookie;
604     return AUDIO_HAL_SUCCESS;
605 }
606 
AudioRenderDrainBuffer(struct AudioRender * render,AudioDrainNotifyType * type)607 int32_t AudioRenderDrainBuffer(struct AudioRender *render, AudioDrainNotifyType *type)
608 {
609     struct AudioHwRender *pRender = reinterpret_cast<struct AudioHwRender *>(render);
610     if (pRender == NULL || type == NULL) {
611         return AUDIO_HAL_ERR_INVALID_PARAM;
612     }
613     return AUDIO_HAL_ERR_NOT_SUPPORT;
614 }
615 }