1 /*
2  * Copyright (c) 2023 Huawei Device Co., Ltd.
3  * Licensed under the Apache License, Version 2.0 (the "License");
4  * you may not use this file except in compliance with the License.
5  * You may obtain a copy of the License at
6  *
7  *     http://www.apache.org/licenses/LICENSE-2.0
8  *
9  * Unless required by applicable law or agreed to in writing, software
10  * distributed under the License is distributed on an "AS IS" BASIS,
11  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12  * See the License for the specific language governing permissions and
13  * limitations under the License.
14  */
15 
16 #include "audio_render_vdi.h"
17 
18 #include <string.h>
19 #include <limits.h>
20 #include <hdf_base.h>
21 #include "audio_uhdf_log.h"
22 #include "osal_mem.h"
23 #include "securec.h"
24 #include "audio_common_vdi.h"
25 #include "audio_dfx_vdi.h"
26 
27 #define HDF_LOG_TAG    HDF_AUDIO_PRIMARY_IMPL
28 
29 struct AudioRenderInfo {
30     struct IAudioRender render;
31     struct AudioDeviceDescriptor desc;
32     enum AudioCategory streamType;
33     unsigned int sampleRate;
34     unsigned int channelCount;
35     struct IAudioRenderVdi *vdiRender;
36     uint32_t renderId;
37     unsigned int usrCount;
38     struct IAudioCallback *callback;
39     bool isRegCb;
40     char *adapterName;
41 };
42 
43 struct AudioRenderPrivVdi {
44     struct AudioRenderInfo *renderInfos[AUDIO_VDI_STREAM_NUM_MAX];
45     uint32_t renderCnt;
46 };
47 
48 static struct AudioRenderPrivVdi g_audioRenderPrivVdi;
49 
AudioRenderGetPrivVdi(void)50 static struct AudioRenderPrivVdi *AudioRenderGetPrivVdi(void)
51 {
52     return &g_audioRenderPrivVdi;
53 }
54 
AudioGetVdiRenderByIdVdi(uint32_t renderId)55 struct IAudioRenderVdi *AudioGetVdiRenderByIdVdi(uint32_t renderId)
56 {
57     struct AudioRenderPrivVdi *priv = AudioRenderGetPrivVdi();
58     if (priv->renderInfos[renderId] == NULL) {
59         AUDIO_FUNC_LOGE("not match render");
60         return NULL;
61     }
62 
63     return priv->renderInfos[renderId]->vdiRender;
64 }
65 
AudioGetLatencyVdi(struct IAudioRender *render, uint32_t *ms)66 int32_t AudioGetLatencyVdi(struct IAudioRender *render, uint32_t *ms)
67 {
68     CHECK_NULL_PTR_RETURN_VALUE(render, HDF_ERR_INVALID_PARAM);
69     CHECK_NULL_PTR_RETURN_VALUE(ms, HDF_ERR_INVALID_PARAM);
70 
71     struct AudioRenderInfo *renderInfo = (struct AudioRenderInfo *)render;
72     struct IAudioRenderVdi *vdiRender = renderInfo->vdiRender;
73     CHECK_NULL_PTR_RETURN_VALUE(vdiRender, HDF_ERR_INVALID_PARAM);
74     CHECK_NULL_PTR_RETURN_VALUE(vdiRender->GetLatency, HDF_ERR_INVALID_PARAM);
75 
76     int32_t ret = vdiRender->GetLatency(vdiRender, ms);
77     if (ret != HDF_SUCCESS) {
78         AUDIO_FUNC_LOGE("audio GetLatency fail, ret=%{public}d", ret);
79         return ret;
80     }
81 
82     return HDF_SUCCESS;
83 }
84 
AudioRenderFrameVdi(struct IAudioRender *render, const int8_t *frame, uint32_t frameLen, uint64_t *replyBytes)85 int32_t AudioRenderFrameVdi(struct IAudioRender *render, const int8_t *frame, uint32_t frameLen, uint64_t *replyBytes)
86 {
87     CHECK_NULL_PTR_RETURN_VALUE(render, HDF_ERR_INVALID_PARAM);
88     CHECK_NULL_PTR_RETURN_VALUE(frame, HDF_ERR_INVALID_PARAM);
89     CHECK_NULL_PTR_RETURN_VALUE(replyBytes, HDF_ERR_INVALID_PARAM);
90 
91     struct AudioRenderInfo *renderInfo = (struct AudioRenderInfo *)render;
92     struct IAudioRenderVdi *vdiRender = renderInfo->vdiRender;
93     CHECK_NULL_PTR_RETURN_VALUE(vdiRender, HDF_ERR_INVALID_PARAM);
94     CHECK_NULL_PTR_RETURN_VALUE(vdiRender->RenderFrame, HDF_ERR_INVALID_PARAM);
95 
96     int32_t id = SetTimer("Hdi:RenderFrame");
97     HdfAudioStartTrace("Hdi:AudioRenderFrameVdi", 0);
98     int32_t ret = vdiRender->RenderFrame(vdiRender, frame, frameLen, replyBytes);
99     HdfAudioFinishTrace();
100     CancelTimer(id);
101     if (ret != HDF_SUCCESS) {
102         AUDIO_FUNC_LOGE("audio render frame fail, ret=%{public}d", ret);
103         return ret;
104     }
105 
106     return HDF_SUCCESS;
107 }
108 
AudioGetRenderPositionVdi(struct IAudioRender *render, uint64_t *frames, struct AudioTimeStamp *time)109 int32_t AudioGetRenderPositionVdi(struct IAudioRender *render, uint64_t *frames, struct AudioTimeStamp *time)
110 {
111     CHECK_NULL_PTR_RETURN_VALUE(render, HDF_ERR_INVALID_PARAM);
112     CHECK_NULL_PTR_RETURN_VALUE(frames, HDF_ERR_INVALID_PARAM);
113     CHECK_NULL_PTR_RETURN_VALUE(time, HDF_ERR_INVALID_PARAM);
114 
115     struct AudioRenderInfo *renderInfo = (struct AudioRenderInfo *)render;
116     struct IAudioRenderVdi *vdiRender = renderInfo->vdiRender;
117     CHECK_NULL_PTR_RETURN_VALUE(vdiRender, HDF_ERR_INVALID_PARAM);
118     CHECK_NULL_PTR_RETURN_VALUE(vdiRender->GetRenderPosition, HDF_ERR_INVALID_PARAM);
119 
120     int32_t id = SetTimer("Hdi:GetRenderPosition");
121     HdfAudioStartTrace("Hdi:AudioGetRenderPositionVdi", 0);
122     int32_t ret = vdiRender->GetRenderPosition(vdiRender, frames, (struct AudioTimeStampVdi *)time);
123     HdfAudioFinishTrace();
124     CancelTimer(id);
125     if (ret != HDF_SUCCESS) {
126         AUDIO_FUNC_LOGE("audio render, get position fail, ret=%{public}d", ret);
127         return ret;
128     }
129 
130     return HDF_SUCCESS;
131 }
132 
AudioSetRenderSpeedVdi(struct IAudioRender *render, float speed)133 int32_t AudioSetRenderSpeedVdi(struct IAudioRender *render, float speed)
134 {
135     CHECK_NULL_PTR_RETURN_VALUE(render, HDF_ERR_INVALID_PARAM);
136 
137     struct AudioRenderInfo *renderInfo = (struct AudioRenderInfo *)render;
138     struct IAudioRenderVdi *vdiRender = renderInfo->vdiRender;
139     CHECK_NULL_PTR_RETURN_VALUE(vdiRender, HDF_ERR_INVALID_PARAM);
140     CHECK_NULL_PTR_RETURN_VALUE(vdiRender->SetRenderSpeed, HDF_ERR_INVALID_PARAM);
141 
142     int32_t ret = vdiRender->SetRenderSpeed(vdiRender, speed);
143     if (ret != HDF_SUCCESS) {
144         AUDIO_FUNC_LOGE("audio render SetRenderSpeed fail, ret=%{public}d", ret);
145         return ret;
146     }
147 
148     return HDF_SUCCESS;
149 }
150 
AudioGetRenderSpeedVdi(struct IAudioRender *render, float *speed)151 int32_t AudioGetRenderSpeedVdi(struct IAudioRender *render, float *speed)
152 {
153     CHECK_NULL_PTR_RETURN_VALUE(render, HDF_ERR_INVALID_PARAM);
154     CHECK_NULL_PTR_RETURN_VALUE(speed, HDF_ERR_INVALID_PARAM);
155 
156     struct AudioRenderInfo *renderInfo = (struct AudioRenderInfo *)render;
157     struct IAudioRenderVdi *vdiRender = renderInfo->vdiRender;
158     CHECK_NULL_PTR_RETURN_VALUE(vdiRender, HDF_ERR_INVALID_PARAM);
159     CHECK_NULL_PTR_RETURN_VALUE(vdiRender->GetRenderSpeed, HDF_ERR_INVALID_PARAM);
160 
161     int32_t ret = vdiRender->GetRenderSpeed(vdiRender, speed);
162     if (ret != HDF_SUCCESS) {
163         AUDIO_FUNC_LOGE("audio render GetRenderSpeed fail, ret=%{public}d", ret);
164         return ret;
165     }
166 
167     return HDF_SUCCESS;
168 }
169 
AudioRenderCallbackVdi(enum AudioCallbackTypeVdi type, void *reserved, void *cookie)170 static int32_t AudioRenderCallbackVdi(enum  AudioCallbackTypeVdi type, void *reserved, void *cookie)
171 {
172     CHECK_NULL_PTR_RETURN_VALUE(cookie, HDF_ERR_INVALID_PARAM);
173     struct AudioRenderInfo *renderInfo = (struct AudioRenderInfo *)cookie;
174     struct IAudioCallback *cb = renderInfo->callback;
175     CHECK_NULL_PTR_RETURN_VALUE(cb, HDF_ERR_INVALID_PARAM);
176     int8_t newCookie = 0;
177     int8_t newReserved = 0;
178     int32_t ret = cb->RenderCallback(cb, (enum AudioCallbackType)type, &newReserved, &newCookie);
179     if (ret != HDF_SUCCESS) {
180         AUDIO_FUNC_LOGE("audio render AudioRenderCallbackVdi fail, ret=%{public}d", ret);
181         return HDF_FAILURE;
182     }
183     return HDF_SUCCESS;
184 }
185 
AudioRenderRegCallbackVdi(struct IAudioRender *render, struct IAudioCallback *audioCallback, int8_t cookie)186 int32_t AudioRenderRegCallbackVdi(struct IAudioRender *render, struct IAudioCallback *audioCallback, int8_t cookie)
187 {
188     CHECK_NULL_PTR_RETURN_VALUE(render, HDF_ERR_INVALID_PARAM);
189     CHECK_NULL_PTR_RETURN_VALUE(audioCallback, HDF_ERR_INVALID_PARAM);
190 
191     struct AudioRenderInfo *renderInfo = (struct AudioRenderInfo *)render;
192     struct IAudioRenderVdi *vdiRender = renderInfo->vdiRender;
193     CHECK_NULL_PTR_RETURN_VALUE(vdiRender, HDF_ERR_INVALID_PARAM);
194     CHECK_NULL_PTR_RETURN_VALUE(vdiRender->RegCallback, HDF_ERR_INVALID_PARAM);
195 
196     int32_t ret = vdiRender->RegCallback(vdiRender, AudioRenderCallbackVdi, (void *)renderInfo);
197     if (ret != HDF_SUCCESS) {
198         AUDIO_FUNC_LOGE("audio render regCallback fail, ret=%{public}d", ret);
199         return HDF_FAILURE;
200     }
201     renderInfo->callback = audioCallback;
202     renderInfo->isRegCb = true;
203     return HDF_SUCCESS;
204 }
205 
AudioRenderSetChannelModeVdi(struct IAudioRender *render, enum AudioChannelMode mode)206 int32_t AudioRenderSetChannelModeVdi(struct IAudioRender *render, enum AudioChannelMode mode)
207 {
208     CHECK_NULL_PTR_RETURN_VALUE(render, HDF_ERR_INVALID_PARAM);
209 
210     struct AudioRenderInfo *renderInfo = (struct AudioRenderInfo *)render;
211     struct IAudioRenderVdi *vdiRender = renderInfo->vdiRender;
212     CHECK_NULL_PTR_RETURN_VALUE(vdiRender, HDF_ERR_INVALID_PARAM);
213     CHECK_NULL_PTR_RETURN_VALUE(vdiRender->SetChannelMode, HDF_ERR_INVALID_PARAM);
214 
215     int32_t ret = vdiRender->SetChannelMode(vdiRender, (enum AudioChannelModeVdi)mode);
216     if (ret != HDF_SUCCESS) {
217         AUDIO_FUNC_LOGE("audio SetChannelMode fail, ret=%{public}d", ret);
218         return ret;
219     }
220 
221     return HDF_SUCCESS;
222 }
223 
AudioRenderGetChannelModeVdi(struct IAudioRender *render, enum AudioChannelMode *mode)224 int32_t AudioRenderGetChannelModeVdi(struct IAudioRender *render, enum AudioChannelMode *mode)
225 {
226     CHECK_NULL_PTR_RETURN_VALUE(render, HDF_ERR_INVALID_PARAM);
227     CHECK_NULL_PTR_RETURN_VALUE(mode, HDF_ERR_INVALID_PARAM);
228 
229     struct AudioRenderInfo *renderInfo = (struct AudioRenderInfo *)render;
230     struct IAudioRenderVdi *vdiRender = renderInfo->vdiRender;
231     CHECK_NULL_PTR_RETURN_VALUE(vdiRender, HDF_ERR_INVALID_PARAM);
232     CHECK_NULL_PTR_RETURN_VALUE(vdiRender->GetChannelMode, HDF_ERR_INVALID_PARAM);
233 
234     int32_t ret = vdiRender->GetChannelMode(vdiRender, (enum AudioChannelModeVdi *)mode);
235     if (ret != HDF_SUCCESS) {
236         AUDIO_FUNC_LOGE("audio render GetChannelMode fail, ret=%{public}d", ret);
237         return ret;
238     }
239 
240     return HDF_SUCCESS;
241 }
242 
AudioRenderDrainBufferVdi(struct IAudioRender *render, enum AudioDrainNotifyType *type)243 int32_t AudioRenderDrainBufferVdi(struct IAudioRender *render, enum AudioDrainNotifyType *type)
244 {
245     CHECK_NULL_PTR_RETURN_VALUE(render, HDF_ERR_INVALID_PARAM);
246     CHECK_NULL_PTR_RETURN_VALUE(type, HDF_ERR_INVALID_PARAM);
247 
248     struct AudioRenderInfo *renderInfo = (struct AudioRenderInfo *)render;
249     struct IAudioRenderVdi *vdiRender = renderInfo->vdiRender;
250     CHECK_NULL_PTR_RETURN_VALUE(vdiRender, HDF_ERR_INVALID_PARAM);
251     CHECK_NULL_PTR_RETURN_VALUE(vdiRender->DrainBuffer, HDF_ERR_INVALID_PARAM);
252 
253     int32_t ret = vdiRender->DrainBuffer(vdiRender, (enum AudioDrainNotifyTypeVdi *)type);
254     if (ret != HDF_SUCCESS) {
255         AUDIO_FUNC_LOGE("audio render DrainBuffer fail, ret=%{public}d", ret);
256         return ret;
257     }
258 
259     return HDF_SUCCESS;
260 }
261 
AudioRenderIsSupportsDrainVdi(struct IAudioRender *render, bool *support)262 int32_t AudioRenderIsSupportsDrainVdi(struct IAudioRender *render, bool *support)
263 {
264     CHECK_NULL_PTR_RETURN_VALUE(render, HDF_ERR_INVALID_PARAM);
265     CHECK_NULL_PTR_RETURN_VALUE(support, HDF_ERR_INVALID_PARAM);
266 
267     struct AudioRenderInfo *renderInfo = (struct AudioRenderInfo *)render;
268     struct IAudioRenderVdi *vdiRender = renderInfo->vdiRender;
269     CHECK_NULL_PTR_RETURN_VALUE(vdiRender, HDF_ERR_INVALID_PARAM);
270     CHECK_NULL_PTR_RETURN_VALUE(vdiRender->IsSupportsDrain, HDF_ERR_INVALID_PARAM);
271 
272     int32_t ret = vdiRender->IsSupportsDrain(vdiRender, support);
273     if (ret != HDF_SUCCESS) {
274         AUDIO_FUNC_LOGE("audio render IsSupportsDrain fail, ret=%{public}d", ret);
275         return ret;
276     }
277 
278     return HDF_SUCCESS;
279 }
280 
AudioRenderCheckSceneCapabilityVdi(struct IAudioRender *render, const struct AudioSceneDescriptor *scene, bool *supported)281 int32_t AudioRenderCheckSceneCapabilityVdi(struct IAudioRender *render, const struct AudioSceneDescriptor *scene,
282     bool *supported)
283 {
284     CHECK_NULL_PTR_RETURN_VALUE(render, HDF_ERR_INVALID_PARAM);
285     CHECK_NULL_PTR_RETURN_VALUE(scene, HDF_ERR_INVALID_PARAM);
286     CHECK_NULL_PTR_RETURN_VALUE(supported, HDF_ERR_INVALID_PARAM);
287 
288     struct AudioRenderInfo *renderInfo = (struct AudioRenderInfo *)render;
289     struct IAudioRenderVdi *vdiRender = renderInfo->vdiRender;
290     CHECK_NULL_PTR_RETURN_VALUE(vdiRender, HDF_ERR_INVALID_PARAM);
291     CHECK_NULL_PTR_RETURN_VALUE(vdiRender->CheckSceneCapability, HDF_ERR_INVALID_PARAM);
292 
293     struct AudioSceneDescriptorVdi vdiScene;
294     (void)memset_s((void *)&vdiScene, sizeof(vdiScene), 0, sizeof(vdiScene));
295     int32_t ret = AudioCommonSceneToVdiSceneVdi(scene, &vdiScene);
296     if (ret != HDF_SUCCESS) {
297         AUDIO_FUNC_LOGE("audio render scene To vdiScene fail");
298         return HDF_FAILURE;
299     }
300 
301     ret = vdiRender->CheckSceneCapability(vdiRender, &vdiScene, supported);
302     OsalMemFree((void *)vdiScene.desc.desc);
303     if (ret != HDF_SUCCESS) {
304         AUDIO_FUNC_LOGE("audio render CheckSceneCapability fail, ret=%{public}d", ret);
305         return ret;
306     }
307 
308     return HDF_SUCCESS;
309 }
310 
AudioRenderSelectSceneVdi(struct IAudioRender *render, const struct AudioSceneDescriptor *scene)311 int32_t AudioRenderSelectSceneVdi(struct IAudioRender *render, const struct AudioSceneDescriptor *scene)
312 {
313     CHECK_NULL_PTR_RETURN_VALUE(render, HDF_ERR_INVALID_PARAM);
314     CHECK_NULL_PTR_RETURN_VALUE(scene, HDF_ERR_INVALID_PARAM);
315 
316     struct AudioRenderInfo *renderInfo = (struct AudioRenderInfo *)render;
317     struct IAudioRenderVdi *vdiRender = renderInfo->vdiRender;
318     CHECK_NULL_PTR_RETURN_VALUE(vdiRender, HDF_ERR_INVALID_PARAM);
319     CHECK_NULL_PTR_RETURN_VALUE(vdiRender->SelectScene, HDF_ERR_INVALID_PARAM);
320 
321     AUDIO_FUNC_LOGI("portId = [%{public}u], pin = [%{public}d], desc = [%{public}s]",
322         scene->desc.portId, scene->desc.pins, scene->desc.desc);
323 
324     struct AudioSceneDescriptorVdi vdiScene;
325     (void)memset_s((void *)&vdiScene, sizeof(vdiScene), 0, sizeof(vdiScene));
326     int32_t ret = AudioCommonSceneToVdiSceneVdi(scene, &vdiScene);
327     if (ret != HDF_SUCCESS) {
328         AUDIO_FUNC_LOGE("audio render scene To vdiScene fail");
329         return HDF_FAILURE;
330     }
331 
332     int32_t id = SetTimer("Hdi:SelectScene");
333     ret = vdiRender->SelectScene(vdiRender, &vdiScene);
334     CancelTimer(id);
335     OsalMemFree((void *)vdiScene.desc.desc);
336     if (ret != HDF_SUCCESS) {
337         AUDIO_FUNC_LOGE("audio render select scene fail, ret=%{public}d", ret);
338         return ret;
339     }
340 
341     return HDF_SUCCESS;
342 }
343 
AudioRenderSetMuteVdi(struct IAudioRender *render, bool mute)344 int32_t AudioRenderSetMuteVdi(struct IAudioRender *render, bool mute)
345 {
346     CHECK_NULL_PTR_RETURN_VALUE(render, HDF_ERR_INVALID_PARAM);
347 
348     struct AudioRenderInfo *renderInfo = (struct AudioRenderInfo *)render;
349     struct IAudioRenderVdi *vdiRender = renderInfo->vdiRender;
350     CHECK_NULL_PTR_RETURN_VALUE(vdiRender, HDF_ERR_INVALID_PARAM);
351     CHECK_NULL_PTR_RETURN_VALUE(vdiRender->SetMute, HDF_ERR_INVALID_PARAM);
352 
353     int32_t ret = vdiRender->SetMute(vdiRender, mute);
354     if (ret != HDF_SUCCESS) {
355         AUDIO_FUNC_LOGE("audio render SetMute fail, ret=%{public}d", ret);
356         return ret;
357     }
358 
359     return HDF_SUCCESS;
360 }
361 
AudioRenderGetMuteVdi(struct IAudioRender *render, bool *mute)362 int32_t AudioRenderGetMuteVdi(struct IAudioRender *render, bool *mute)
363 {
364     CHECK_NULL_PTR_RETURN_VALUE(render, HDF_ERR_INVALID_PARAM);
365     CHECK_NULL_PTR_RETURN_VALUE(mute, HDF_ERR_INVALID_PARAM);
366 
367     struct AudioRenderInfo *renderInfo = (struct AudioRenderInfo *)render;
368     struct IAudioRenderVdi *vdiRender = renderInfo->vdiRender;
369     CHECK_NULL_PTR_RETURN_VALUE(vdiRender, HDF_ERR_INVALID_PARAM);
370     CHECK_NULL_PTR_RETURN_VALUE(vdiRender->GetMute, HDF_ERR_INVALID_PARAM);
371 
372     int32_t ret = vdiRender->GetMute(vdiRender, mute);
373     if (ret != HDF_SUCCESS) {
374         AUDIO_FUNC_LOGE("audio render GetMute fail, ret=%{public}d", ret);
375         return ret;
376     }
377 
378     return HDF_SUCCESS;
379 }
380 
AudioRenderSetVolumeVdi(struct IAudioRender *render, float volume)381 int32_t AudioRenderSetVolumeVdi(struct IAudioRender *render, float volume)
382 {
383     CHECK_NULL_PTR_RETURN_VALUE(render, HDF_ERR_INVALID_PARAM);
384 
385     struct AudioRenderInfo *renderInfo = (struct AudioRenderInfo *)render;
386     struct IAudioRenderVdi *vdiRender = renderInfo->vdiRender;
387     CHECK_NULL_PTR_RETURN_VALUE(vdiRender, HDF_ERR_INVALID_PARAM);
388     CHECK_NULL_PTR_RETURN_VALUE(vdiRender->SetVolume, HDF_ERR_INVALID_PARAM);
389 
390     int32_t ret = vdiRender->SetVolume(vdiRender, volume);
391     if (ret != HDF_SUCCESS) {
392         AUDIO_FUNC_LOGE("audio render SetVolume fail, ret=%{public}d", ret);
393         return ret;
394     }
395 
396     return HDF_SUCCESS;
397 }
398 
AudioRenderGetVolumeVdi(struct IAudioRender *render, float *volume)399 int32_t AudioRenderGetVolumeVdi(struct IAudioRender *render, float *volume)
400 {
401     CHECK_NULL_PTR_RETURN_VALUE(render, HDF_ERR_INVALID_PARAM);
402     CHECK_NULL_PTR_RETURN_VALUE(volume, HDF_ERR_INVALID_PARAM);
403 
404     struct AudioRenderInfo *renderInfo = (struct AudioRenderInfo *)render;
405     struct IAudioRenderVdi *vdiRender = renderInfo->vdiRender;
406     CHECK_NULL_PTR_RETURN_VALUE(vdiRender, HDF_ERR_INVALID_PARAM);
407     CHECK_NULL_PTR_RETURN_VALUE(vdiRender->GetVolume, HDF_ERR_INVALID_PARAM);
408 
409     int32_t ret = vdiRender->GetVolume(vdiRender, volume);
410     if (ret != HDF_SUCCESS) {
411         AUDIO_FUNC_LOGE("audio render GetVolume fail, ret=%{public}d", ret);
412         return ret;
413     }
414 
415     return HDF_SUCCESS;
416 }
417 
AudioRenderGetGainThresholdVdi(struct IAudioRender *render, float *min, float *max)418 int32_t AudioRenderGetGainThresholdVdi(struct IAudioRender *render, float *min, float *max)
419 {
420     CHECK_NULL_PTR_RETURN_VALUE(render, HDF_ERR_INVALID_PARAM);
421     CHECK_NULL_PTR_RETURN_VALUE(min, HDF_ERR_INVALID_PARAM);
422     CHECK_NULL_PTR_RETURN_VALUE(max, HDF_ERR_INVALID_PARAM);
423 
424     struct AudioRenderInfo *renderInfo = (struct AudioRenderInfo *)render;
425     struct IAudioRenderVdi *vdiRender = renderInfo->vdiRender;
426     CHECK_NULL_PTR_RETURN_VALUE(vdiRender, HDF_ERR_INVALID_PARAM);
427     CHECK_NULL_PTR_RETURN_VALUE(vdiRender->GetGainThreshold, HDF_ERR_INVALID_PARAM);
428 
429     int32_t ret = vdiRender->GetGainThreshold(vdiRender, min, max);
430     if (ret != HDF_SUCCESS) {
431         AUDIO_FUNC_LOGE("audio render GetGainThreshold fail, ret=%{public}d", ret);
432         return ret;
433     }
434 
435     return HDF_SUCCESS;
436 }
437 
AudioRenderGetGainVdi(struct IAudioRender *render, float *gain)438 int32_t AudioRenderGetGainVdi(struct IAudioRender *render, float *gain)
439 {
440     CHECK_NULL_PTR_RETURN_VALUE(render, HDF_ERR_INVALID_PARAM);
441     CHECK_NULL_PTR_RETURN_VALUE(gain, HDF_ERR_INVALID_PARAM);
442 
443     struct AudioRenderInfo *renderInfo = (struct AudioRenderInfo *)render;
444     struct IAudioRenderVdi *vdiRender = renderInfo->vdiRender;
445     CHECK_NULL_PTR_RETURN_VALUE(vdiRender, HDF_ERR_INVALID_PARAM);
446     CHECK_NULL_PTR_RETURN_VALUE(vdiRender->GetGain, HDF_ERR_INVALID_PARAM);
447 
448     int32_t ret = vdiRender->GetGain(vdiRender, gain);
449     if (ret != HDF_SUCCESS) {
450         AUDIO_FUNC_LOGE("audio render GetGain fail, ret=%{public}d", ret);
451         return ret;
452     }
453 
454     return HDF_SUCCESS;
455 }
456 
AudioRenderSetGainVdi(struct IAudioRender *render, float gain)457 int32_t AudioRenderSetGainVdi(struct IAudioRender *render, float gain)
458 {
459     CHECK_NULL_PTR_RETURN_VALUE(render, HDF_ERR_INVALID_PARAM);
460 
461     struct AudioRenderInfo *renderInfo = (struct AudioRenderInfo *)render;
462     struct IAudioRenderVdi *vdiRender = renderInfo->vdiRender;
463     CHECK_NULL_PTR_RETURN_VALUE(vdiRender, HDF_ERR_INVALID_PARAM);
464     CHECK_NULL_PTR_RETURN_VALUE(vdiRender->SetGain, HDF_ERR_INVALID_PARAM);
465 
466     int32_t ret = vdiRender->SetGain(vdiRender, gain);
467     if (ret != HDF_SUCCESS) {
468         AUDIO_FUNC_LOGE("audio render SetGain fail, ret=%{public}d", ret);
469         return ret;
470     }
471 
472     return HDF_SUCCESS;
473 }
474 
AudioRenderGetFrameSizeVdi(struct IAudioRender *render, uint64_t *size)475 int32_t AudioRenderGetFrameSizeVdi(struct IAudioRender *render, uint64_t *size)
476 {
477     CHECK_NULL_PTR_RETURN_VALUE(render, HDF_ERR_INVALID_PARAM);
478     CHECK_NULL_PTR_RETURN_VALUE(size, HDF_ERR_INVALID_PARAM);
479 
480     struct AudioRenderInfo *renderInfo = (struct AudioRenderInfo *)render;
481     struct IAudioRenderVdi *vdiRender = renderInfo->vdiRender;
482     CHECK_NULL_PTR_RETURN_VALUE(vdiRender, HDF_ERR_INVALID_PARAM);
483     CHECK_NULL_PTR_RETURN_VALUE(vdiRender->GetFrameSize, HDF_ERR_INVALID_PARAM);
484 
485     int32_t ret = vdiRender->GetFrameSize(vdiRender, size);
486     if (ret != HDF_SUCCESS) {
487         AUDIO_FUNC_LOGE("audio render GetFrameSize fail, ret=%{public}d", ret);
488         return ret;
489     }
490 
491     return HDF_SUCCESS;
492 }
493 
AudioRenderGetFrameCountVdi(struct IAudioRender *render, uint64_t *count)494 int32_t AudioRenderGetFrameCountVdi(struct IAudioRender *render, uint64_t *count)
495 {
496     CHECK_NULL_PTR_RETURN_VALUE(render, HDF_ERR_INVALID_PARAM);
497     CHECK_NULL_PTR_RETURN_VALUE(count, HDF_ERR_INVALID_PARAM);
498 
499     struct AudioRenderInfo *renderInfo = (struct AudioRenderInfo *)render;
500     struct IAudioRenderVdi *vdiRender = renderInfo->vdiRender;
501     CHECK_NULL_PTR_RETURN_VALUE(vdiRender, HDF_ERR_INVALID_PARAM);
502     CHECK_NULL_PTR_RETURN_VALUE(vdiRender->GetFrameCount, HDF_ERR_INVALID_PARAM);
503 
504     int32_t ret = vdiRender->GetFrameCount(vdiRender, count);
505     if (ret != HDF_SUCCESS) {
506         AUDIO_FUNC_LOGE("audio render GetFrameCount fail, ret=%{public}d", ret);
507         return ret;
508     }
509 
510     return HDF_SUCCESS;
511 }
512 
AudioRenderSetSampleAttributesVdi(struct IAudioRender *render, const struct AudioSampleAttributes *attrs)513 int32_t AudioRenderSetSampleAttributesVdi(struct IAudioRender *render, const struct AudioSampleAttributes *attrs)
514 {
515     CHECK_NULL_PTR_RETURN_VALUE(render, HDF_ERR_INVALID_PARAM);
516     CHECK_NULL_PTR_RETURN_VALUE(attrs, HDF_ERR_INVALID_PARAM);
517 
518     struct AudioRenderInfo *renderInfo = (struct AudioRenderInfo *)render;
519     struct IAudioRenderVdi *vdiRender = renderInfo->vdiRender;
520     CHECK_NULL_PTR_RETURN_VALUE(vdiRender, HDF_ERR_INVALID_PARAM);
521     CHECK_NULL_PTR_RETURN_VALUE(vdiRender->SetSampleAttributes, HDF_ERR_INVALID_PARAM);
522 
523     struct AudioSampleAttributesVdi vdiAttrs;
524     (void)memset_s((void *)&vdiAttrs, sizeof(vdiAttrs), 0, sizeof(vdiAttrs));
525     int32_t ret = AudioCommonSampleAttrToVdiSampleAttrVdi(attrs, &vdiAttrs);
526     if (ret != HDF_SUCCESS) {
527         AUDIO_FUNC_LOGE("audio render SampleAttr to vdisampleAttr fail, ret=%{public}d", ret);
528         return ret;
529     }
530 
531     ret = vdiRender->SetSampleAttributes(vdiRender, &vdiAttrs);
532     if (ret != HDF_SUCCESS) {
533         AUDIO_FUNC_LOGE("audio render SetSampleAttributes fail, ret=%{public}d", ret);
534         return ret;
535     }
536 
537     return HDF_SUCCESS;
538 }
539 
AudioRenderGetSampleAttributesVdi(struct IAudioRender *render, struct AudioSampleAttributes *attrs)540 int32_t AudioRenderGetSampleAttributesVdi(struct IAudioRender *render, struct AudioSampleAttributes *attrs)
541 {
542     CHECK_NULL_PTR_RETURN_VALUE(render, HDF_ERR_INVALID_PARAM);
543     CHECK_NULL_PTR_RETURN_VALUE(attrs, HDF_ERR_INVALID_PARAM);
544 
545     struct AudioRenderInfo *renderInfo = (struct AudioRenderInfo *)render;
546     struct IAudioRenderVdi *vdiRender = renderInfo->vdiRender;
547     CHECK_NULL_PTR_RETURN_VALUE(vdiRender, HDF_ERR_INVALID_PARAM);
548     CHECK_NULL_PTR_RETURN_VALUE(vdiRender->GetSampleAttributes, HDF_ERR_INVALID_PARAM);
549 
550     struct AudioSampleAttributesVdi vdiAttrs;
551     (void)memset_s((void *)&vdiAttrs, sizeof(vdiAttrs), 0, sizeof(vdiAttrs));
552     int32_t ret = vdiRender->GetSampleAttributes(vdiRender, &vdiAttrs);
553     if (ret != HDF_SUCCESS) {
554         AUDIO_FUNC_LOGE("audio render GetSampleAttributes fail, ret=%{public}d", ret);
555         return ret;
556     }
557 
558     ret = AudioCommonVdiSampleAttrToSampleAttrVdi(&vdiAttrs, attrs);
559     if (ret != HDF_SUCCESS) {
560         AUDIO_FUNC_LOGE("audio render vdiSampleAttr to SampleAttr fail, ret=%{public}d", ret);
561         return ret;
562     }
563 
564     return HDF_SUCCESS;
565 }
566 
AudioRenderGetCurrentChannelIdVdi(struct IAudioRender *render, uint32_t *channelId)567 int32_t AudioRenderGetCurrentChannelIdVdi(struct IAudioRender *render, uint32_t *channelId)
568 {
569     CHECK_NULL_PTR_RETURN_VALUE(render, HDF_ERR_INVALID_PARAM);
570     CHECK_NULL_PTR_RETURN_VALUE(channelId, HDF_ERR_INVALID_PARAM);
571 
572     struct AudioRenderInfo *renderInfo = (struct AudioRenderInfo *)render;
573     struct IAudioRenderVdi *vdiRender = renderInfo->vdiRender;
574     CHECK_NULL_PTR_RETURN_VALUE(vdiRender, HDF_ERR_INVALID_PARAM);
575     CHECK_NULL_PTR_RETURN_VALUE(vdiRender->GetCurrentChannelId, HDF_ERR_INVALID_PARAM);
576 
577     int32_t ret = vdiRender->GetCurrentChannelId(vdiRender, channelId);
578     if (ret != HDF_SUCCESS) {
579         AUDIO_FUNC_LOGE("audio render GetCurrentChannelId fail, ret=%{public}d", ret);
580         return ret;
581     }
582 
583     return HDF_SUCCESS;
584 }
585 
AudioRenderSetExtraParamsVdi(struct IAudioRender *render, const char *keyValueList)586 int32_t AudioRenderSetExtraParamsVdi(struct IAudioRender *render, const char *keyValueList)
587 {
588     CHECK_NULL_PTR_RETURN_VALUE(render, HDF_ERR_INVALID_PARAM);
589     CHECK_NULL_PTR_RETURN_VALUE(keyValueList, HDF_ERR_INVALID_PARAM);
590 
591     struct AudioRenderInfo *renderInfo = (struct AudioRenderInfo *)render;
592     struct IAudioRenderVdi *vdiRender = renderInfo->vdiRender;
593     CHECK_NULL_PTR_RETURN_VALUE(vdiRender, HDF_ERR_INVALID_PARAM);
594     CHECK_NULL_PTR_RETURN_VALUE(vdiRender->SetExtraParams, HDF_ERR_INVALID_PARAM);
595 
596     int32_t ret = vdiRender->SetExtraParams(vdiRender, keyValueList);
597     if (ret != HDF_SUCCESS) {
598         AUDIO_FUNC_LOGE("audio render SetExtraParams fail, ret=%{public}d", ret);
599         return ret;
600     }
601 
602     return HDF_SUCCESS;
603 }
604 
AudioRenderGetExtraParamsVdi(struct IAudioRender *render, char *keyValueList, uint32_t keyValueListLen)605 int32_t AudioRenderGetExtraParamsVdi(struct IAudioRender *render, char *keyValueList, uint32_t keyValueListLen)
606 {
607     CHECK_NULL_PTR_RETURN_VALUE(render, HDF_ERR_INVALID_PARAM);
608     CHECK_NULL_PTR_RETURN_VALUE(keyValueList, HDF_ERR_INVALID_PARAM);
609 
610     struct AudioRenderInfo *renderInfo = (struct AudioRenderInfo *)render;
611     struct IAudioRenderVdi *vdiRender = renderInfo->vdiRender;
612     CHECK_NULL_PTR_RETURN_VALUE(vdiRender, HDF_ERR_INVALID_PARAM);
613     CHECK_NULL_PTR_RETURN_VALUE(vdiRender->GetExtraParams, HDF_ERR_INVALID_PARAM);
614 
615     int32_t ret = vdiRender->GetExtraParams(vdiRender, keyValueList, keyValueListLen);
616     if (ret != HDF_SUCCESS) {
617         AUDIO_FUNC_LOGE("audio render GetExtraParams fail, ret=%{public}d", ret);
618         return ret;
619     }
620 
621     return HDF_SUCCESS;
622 }
623 
AudioRenderReqMmapBufferVdi(struct IAudioRender *render, int32_t reqSize, struct AudioMmapBufferDescriptor *desc)624 int32_t AudioRenderReqMmapBufferVdi(struct IAudioRender *render, int32_t reqSize,
625     struct AudioMmapBufferDescriptor *desc)
626 {
627     CHECK_NULL_PTR_RETURN_VALUE(render, HDF_ERR_INVALID_PARAM);
628     CHECK_NULL_PTR_RETURN_VALUE(desc, HDF_ERR_INVALID_PARAM);
629 
630     struct AudioRenderInfo *renderInfo = (struct AudioRenderInfo *)render;
631     struct IAudioRenderVdi *vdiRender = renderInfo->vdiRender;
632     CHECK_NULL_PTR_RETURN_VALUE(vdiRender, HDF_ERR_INVALID_PARAM);
633     CHECK_NULL_PTR_RETURN_VALUE(vdiRender->ReqMmapBuffer, HDF_ERR_INVALID_PARAM);
634 
635     struct AudioMmapBufferDescriptorVdi vdiDesc = {0};
636     int32_t ret = vdiRender->ReqMmapBuffer(vdiRender, reqSize, &vdiDesc);
637     if (ret != HDF_SUCCESS) {
638         AUDIO_FUNC_LOGE("audio render ReqMmapBuffer fail, ret=%{public}d", ret);
639         return ret;
640     }
641 
642     desc->memoryAddress = NULL;
643     desc->memoryFd = vdiDesc.memoryFd;
644     desc->totalBufferFrames = vdiDesc.totalBufferFrames;
645     desc->transferFrameSize = vdiDesc.transferFrameSize;
646     desc->isShareable = vdiDesc.isShareable;
647     desc->offset = vdiDesc.offset;
648     desc->filePath = strdup("");
649     if (desc->filePath == NULL) {
650         AUDIO_FUNC_LOGE("strdup fail");
651         return HDF_FAILURE;
652     }
653 
654     AUDIO_FUNC_LOGD("%{public}s success", __func__);
655     return HDF_SUCCESS;
656 }
657 
AudioRenderGetMmapPositionVdi(struct IAudioRender *render, uint64_t *frames, struct AudioTimeStamp *time)658 int32_t AudioRenderGetMmapPositionVdi(struct IAudioRender *render, uint64_t *frames, struct AudioTimeStamp *time)
659 {
660     struct AudioTimeStampVdi vdiTime;
661     CHECK_NULL_PTR_RETURN_VALUE(render, HDF_ERR_INVALID_PARAM);
662     CHECK_NULL_PTR_RETURN_VALUE(frames, HDF_ERR_INVALID_PARAM);
663     CHECK_NULL_PTR_RETURN_VALUE(time, HDF_ERR_INVALID_PARAM);
664 
665     vdiTime.tvSec = 0;
666     vdiTime.tvNSec = 0;
667 
668     struct AudioRenderInfo *renderInfo = (struct AudioRenderInfo *)render;
669     struct IAudioRenderVdi *vdiRender = renderInfo->vdiRender;
670     CHECK_NULL_PTR_RETURN_VALUE(vdiRender, HDF_ERR_INVALID_PARAM);
671     CHECK_NULL_PTR_RETURN_VALUE(vdiRender->GetMmapPosition, HDF_ERR_INVALID_PARAM);
672 
673     int32_t ret = vdiRender->GetMmapPosition(vdiRender, frames, &vdiTime);
674     if (ret != HDF_SUCCESS) {
675         AUDIO_FUNC_LOGE("audio render GetMmapPosition fail, ret=%{public}d", ret);
676         return ret;
677     }
678 
679     time->tvSec = vdiTime.tvSec;
680     time->tvNSec = vdiTime.tvNSec;
681     return HDF_SUCCESS;
682 }
683 
AudioRenderAddAudioEffectVdi(struct IAudioRender *render, uint64_t effectid)684 int32_t AudioRenderAddAudioEffectVdi(struct IAudioRender *render, uint64_t effectid)
685 {
686     CHECK_NULL_PTR_RETURN_VALUE(render, HDF_ERR_INVALID_PARAM);
687 
688     struct AudioRenderInfo *renderInfo = (struct AudioRenderInfo *)render;
689     struct IAudioRenderVdi *vdiRender = renderInfo->vdiRender;
690     CHECK_NULL_PTR_RETURN_VALUE(vdiRender, HDF_ERR_INVALID_PARAM);
691     CHECK_NULL_PTR_RETURN_VALUE(vdiRender->AddAudioEffect, HDF_ERR_INVALID_PARAM);
692 
693     return vdiRender->AddAudioEffect(vdiRender, effectid);
694 }
695 
AudioRenderRemoveAudioEffectVdi(struct IAudioRender *render, uint64_t effectid)696 int32_t AudioRenderRemoveAudioEffectVdi(struct IAudioRender *render, uint64_t effectid)
697 {
698     CHECK_NULL_PTR_RETURN_VALUE(render, HDF_ERR_INVALID_PARAM);
699 
700     struct AudioRenderInfo *renderInfo = (struct AudioRenderInfo *)render;
701     struct IAudioRenderVdi *vdiRender = renderInfo->vdiRender;
702     CHECK_NULL_PTR_RETURN_VALUE(vdiRender, HDF_ERR_INVALID_PARAM);
703     CHECK_NULL_PTR_RETURN_VALUE(vdiRender->RemoveAudioEffect, HDF_ERR_INVALID_PARAM);
704 
705     return vdiRender->RemoveAudioEffect(vdiRender, effectid);
706 }
707 
AudioRenderGetFrameBufferSizeVdi(struct IAudioRender *render, uint64_t *bufferSize)708 int32_t AudioRenderGetFrameBufferSizeVdi(struct IAudioRender *render, uint64_t *bufferSize)
709 {
710     CHECK_NULL_PTR_RETURN_VALUE(render, HDF_ERR_INVALID_PARAM);
711     CHECK_NULL_PTR_RETURN_VALUE(bufferSize, HDF_ERR_INVALID_PARAM);
712 
713     struct AudioRenderInfo *renderInfo = (struct AudioRenderInfo *)render;
714     struct IAudioRenderVdi *vdiRender = renderInfo->vdiRender;
715     CHECK_NULL_PTR_RETURN_VALUE(vdiRender, HDF_ERR_INVALID_PARAM);
716     CHECK_NULL_PTR_RETURN_VALUE(vdiRender->GetFrameBufferSize, HDF_ERR_INVALID_PARAM);
717 
718     return vdiRender->GetFrameBufferSize(vdiRender, bufferSize);
719 }
720 
AudioRenderStartVdi(struct IAudioRender *render)721 int32_t AudioRenderStartVdi(struct IAudioRender *render)
722 {
723     CHECK_NULL_PTR_RETURN_VALUE(render, HDF_ERR_INVALID_PARAM);
724 
725     struct AudioRenderInfo *renderInfo = (struct AudioRenderInfo *)render;
726     struct IAudioRenderVdi *vdiRender = renderInfo->vdiRender;
727     CHECK_NULL_PTR_RETURN_VALUE(vdiRender, HDF_ERR_INVALID_PARAM);
728     CHECK_NULL_PTR_RETURN_VALUE(vdiRender->Start, HDF_ERR_INVALID_PARAM);
729 
730     int32_t ret = vdiRender->Start(vdiRender);
731     if (ret != HDF_SUCCESS) {
732         AUDIO_FUNC_LOGE("audio render Start fail, ret=%{public}d", ret);
733         return ret;
734     }
735 
736     return HDF_SUCCESS;
737 }
738 
AudioRenderStopVdi(struct IAudioRender *render)739 int32_t AudioRenderStopVdi(struct IAudioRender *render)
740 {
741     CHECK_NULL_PTR_RETURN_VALUE(render, HDF_ERR_INVALID_PARAM);
742 
743     struct AudioRenderInfo *renderInfo = (struct AudioRenderInfo *)render;
744     struct IAudioRenderVdi *vdiRender = renderInfo->vdiRender;
745     CHECK_NULL_PTR_RETURN_VALUE(vdiRender, HDF_ERR_INVALID_PARAM);
746     CHECK_NULL_PTR_RETURN_VALUE(vdiRender->Stop, HDF_ERR_INVALID_PARAM);
747 
748     int32_t ret = vdiRender->Stop(vdiRender);
749     if (ret != HDF_SUCCESS) {
750         AUDIO_FUNC_LOGE("audio render Stop fail, ret=%{public}d", ret);
751         return ret;
752     }
753 
754     return HDF_SUCCESS;
755 }
756 
AudioRenderPauseVdi(struct IAudioRender *render)757 int32_t AudioRenderPauseVdi(struct IAudioRender *render)
758 {
759     CHECK_NULL_PTR_RETURN_VALUE(render, HDF_ERR_INVALID_PARAM);
760 
761     struct AudioRenderInfo *renderInfo = (struct AudioRenderInfo *)render;
762     struct IAudioRenderVdi *vdiRender = renderInfo->vdiRender;
763     CHECK_NULL_PTR_RETURN_VALUE(vdiRender, HDF_ERR_INVALID_PARAM);
764     CHECK_NULL_PTR_RETURN_VALUE(vdiRender->Pause, HDF_ERR_INVALID_PARAM);
765 
766     int32_t ret = vdiRender->Pause(vdiRender);
767     if (ret != HDF_SUCCESS) {
768         AUDIO_FUNC_LOGE("audio render Pause fail, ret=%{public}d", ret);
769         return ret;
770     }
771 
772     return HDF_SUCCESS;
773 }
774 
AudioRenderResumeVdi(struct IAudioRender *render)775 int32_t AudioRenderResumeVdi(struct IAudioRender *render)
776 {
777     CHECK_NULL_PTR_RETURN_VALUE(render, HDF_ERR_INVALID_PARAM);
778 
779     struct AudioRenderInfo *renderInfo = (struct AudioRenderInfo *)render;
780     struct IAudioRenderVdi *vdiRender = renderInfo->vdiRender;
781     CHECK_NULL_PTR_RETURN_VALUE(vdiRender, HDF_ERR_INVALID_PARAM);
782     CHECK_NULL_PTR_RETURN_VALUE(vdiRender->Resume, HDF_ERR_INVALID_PARAM);
783 
784     int32_t ret = vdiRender->Resume(vdiRender);
785     if (ret != HDF_SUCCESS) {
786         AUDIO_FUNC_LOGE("audio render Resume fail, ret=%{public}d", ret);
787         return ret;
788     }
789 
790     return HDF_SUCCESS;
791 }
792 
AudioRenderFlushVdi(struct IAudioRender *render)793 int32_t AudioRenderFlushVdi(struct IAudioRender *render)
794 {
795     CHECK_NULL_PTR_RETURN_VALUE(render, HDF_ERR_INVALID_PARAM);
796 
797     struct AudioRenderInfo *renderInfo = (struct AudioRenderInfo *)render;
798     struct IAudioRenderVdi *vdiRender = renderInfo->vdiRender;
799     CHECK_NULL_PTR_RETURN_VALUE(vdiRender, HDF_ERR_INVALID_PARAM);
800     CHECK_NULL_PTR_RETURN_VALUE(vdiRender->Flush, HDF_ERR_INVALID_PARAM);
801 
802     int32_t ret = vdiRender->Flush(vdiRender);
803     if (ret != HDF_SUCCESS) {
804         AUDIO_FUNC_LOGE("audio render Flush fail, ret=%{public}d", ret);
805         return ret;
806     }
807 
808     return HDF_SUCCESS;
809 }
810 
AudioRenderTurnStandbyModeVdi(struct IAudioRender *render)811 int32_t AudioRenderTurnStandbyModeVdi(struct IAudioRender *render)
812 {
813     CHECK_NULL_PTR_RETURN_VALUE(render, HDF_ERR_INVALID_PARAM);
814 
815     struct AudioRenderInfo *renderInfo = (struct AudioRenderInfo *)render;
816     struct IAudioRenderVdi *vdiRender = renderInfo->vdiRender;
817     CHECK_NULL_PTR_RETURN_VALUE(vdiRender, HDF_ERR_INVALID_PARAM);
818     CHECK_NULL_PTR_RETURN_VALUE(vdiRender->TurnStandbyMode, HDF_ERR_INVALID_PARAM);
819 
820     int32_t ret = vdiRender->TurnStandbyMode(vdiRender);
821     if (ret != HDF_SUCCESS) {
822         AUDIO_FUNC_LOGE("audio render TurnStandbyMode fail, ret=%{public}d", ret);
823         return ret;
824     }
825 
826     return HDF_SUCCESS;
827 }
828 
AudioRenderAudioDevDumpVdi(struct IAudioRender *render, int32_t range, int32_t fd)829 int32_t AudioRenderAudioDevDumpVdi(struct IAudioRender *render, int32_t range, int32_t fd)
830 {
831     CHECK_NULL_PTR_RETURN_VALUE(render, HDF_ERR_INVALID_PARAM);
832 
833     struct AudioRenderInfo *renderInfo = (struct AudioRenderInfo *)render;
834     struct IAudioRenderVdi *vdiRender = renderInfo->vdiRender;
835     CHECK_NULL_PTR_RETURN_VALUE(vdiRender, HDF_ERR_INVALID_PARAM);
836     CHECK_NULL_PTR_RETURN_VALUE(vdiRender->AudioDevDump, HDF_ERR_INVALID_PARAM);
837 
838     int32_t ret = vdiRender->AudioDevDump(vdiRender, range, fd);
839     if (ret != HDF_SUCCESS) {
840         AUDIO_FUNC_LOGE("audio render AudioDevDump fail, ret=%{public}d", ret);
841         return ret;
842     }
843 
844     return HDF_SUCCESS;
845 }
846 
AudioRenderIsSupportsPauseAndResumeVdi(struct IAudioRender *render, bool *supportPause, bool *supportResume)847 int32_t AudioRenderIsSupportsPauseAndResumeVdi(struct IAudioRender *render, bool *supportPause, bool *supportResume)
848 {
849     CHECK_NULL_PTR_RETURN_VALUE(render, HDF_ERR_INVALID_PARAM);
850     CHECK_NULL_PTR_RETURN_VALUE(supportPause, HDF_ERR_INVALID_PARAM);
851     CHECK_NULL_PTR_RETURN_VALUE(supportResume, HDF_ERR_INVALID_PARAM);
852 
853     struct AudioRenderInfo *renderInfo = (struct AudioRenderInfo *)render;
854     struct IAudioRenderVdi *vdiRender = renderInfo->vdiRender;
855     CHECK_NULL_PTR_RETURN_VALUE(vdiRender, HDF_ERR_INVALID_PARAM);
856     CHECK_NULL_PTR_RETURN_VALUE(vdiRender->IsSupportsPauseAndResume, HDF_ERR_INVALID_PARAM);
857 
858     return vdiRender->IsSupportsPauseAndResume(vdiRender, supportPause, supportResume);
859 }
860 
AudioRenderSetbufferSize(struct IAudioRender *render, uint32_t size)861 int32_t AudioRenderSetbufferSize(struct IAudioRender *render, uint32_t size)
862 {
863     CHECK_NULL_PTR_RETURN_VALUE(render, HDF_ERR_INVALID_PARAM);
864     struct AudioRenderInfo *renderInfo = (struct AudioRenderInfo *)render;
865     struct IAudioRenderVdi *vdiRender = renderInfo->vdiRender;
866     CHECK_NULL_PTR_RETURN_VALUE(vdiRender, HDF_ERR_INVALID_PARAM);
867     return vdiRender->SetBufferSize(vdiRender, size);
868 }
869 
AudioInitRenderInstanceVdi(struct IAudioRender *render)870 static void AudioInitRenderInstanceVdi(struct IAudioRender *render)
871 {
872     render->GetLatency = AudioGetLatencyVdi;
873     render->RenderFrame = AudioRenderFrameVdi;
874     render->GetRenderPosition = AudioGetRenderPositionVdi;
875     render->SetRenderSpeed = AudioSetRenderSpeedVdi;
876     render->GetRenderSpeed = AudioGetRenderSpeedVdi;
877     render->RegCallback = AudioRenderRegCallbackVdi;
878     render->SetChannelMode = AudioRenderSetChannelModeVdi;
879     render->GetChannelMode = AudioRenderGetChannelModeVdi;
880     render->DrainBuffer = AudioRenderDrainBufferVdi;
881     render->IsSupportsDrain = AudioRenderIsSupportsDrainVdi;
882     render->CheckSceneCapability = AudioRenderCheckSceneCapabilityVdi;
883     render->SelectScene = AudioRenderSelectSceneVdi;
884     render->SetMute = AudioRenderSetMuteVdi;
885     render->GetMute = AudioRenderGetMuteVdi;
886     render->SetVolume = AudioRenderSetVolumeVdi;
887     render->GetVolume = AudioRenderGetVolumeVdi;
888     render->GetGainThreshold = AudioRenderGetGainThresholdVdi;
889     render->GetGain = AudioRenderGetGainVdi;
890     render->SetGain = AudioRenderSetGainVdi;
891     render->GetFrameSize = AudioRenderGetFrameSizeVdi;
892     render->GetFrameCount = AudioRenderGetFrameCountVdi;
893     render->SetSampleAttributes = AudioRenderSetSampleAttributesVdi;
894     render->GetSampleAttributes = AudioRenderGetSampleAttributesVdi;
895     render->GetCurrentChannelId = AudioRenderGetCurrentChannelIdVdi;
896     render->SetExtraParams = AudioRenderSetExtraParamsVdi;
897     render->GetExtraParams = AudioRenderGetExtraParamsVdi;
898     render->ReqMmapBuffer = AudioRenderReqMmapBufferVdi;
899     render->GetMmapPosition = AudioRenderGetMmapPositionVdi;
900     render->AddAudioEffect = AudioRenderAddAudioEffectVdi;
901     render->RemoveAudioEffect = AudioRenderRemoveAudioEffectVdi;
902     render->GetFrameBufferSize = AudioRenderGetFrameBufferSizeVdi;
903     render->Start = AudioRenderStartVdi;
904     render->Stop = AudioRenderStopVdi;
905     render->Pause = AudioRenderPauseVdi;
906     render->Resume = AudioRenderResumeVdi;
907     render->Flush = AudioRenderFlushVdi;
908     render->TurnStandbyMode = AudioRenderTurnStandbyModeVdi;
909     render->AudioDevDump = AudioRenderAudioDevDumpVdi;
910     render->IsSupportsPauseAndResume = AudioRenderIsSupportsPauseAndResumeVdi;
911     render->SetBufferSize = AudioRenderSetbufferSize;
912 }
913 
FindRenderCreated(enum AudioPortPin pin, const struct AudioSampleAttributes *attrs, uint32_t *rendrId, const char *adapterName)914 struct IAudioRender *FindRenderCreated(enum AudioPortPin pin, const struct AudioSampleAttributes *attrs,
915     uint32_t *rendrId, const char *adapterName)
916 {
917     if (attrs->type == AUDIO_MMAP_NOIRQ) {
918         AUDIO_FUNC_LOGI("render type is mmap");
919         return NULL;
920     }
921     uint32_t index = 0;
922     struct AudioRenderPrivVdi *renderPriv = AudioRenderGetPrivVdi();
923     if (renderPriv == NULL) {
924         AUDIO_FUNC_LOGE("Parameter error!");
925         return NULL;
926     }
927 
928     if (renderPriv->renderCnt == 0) {
929         AUDIO_FUNC_LOGI("no render created");
930         return NULL;
931     }
932 
933     for (index = 0; index < AUDIO_VDI_STREAM_NUM_MAX; index++) {
934         if ((renderPriv->renderInfos[index] != NULL) &&
935             (attrs->type == AUDIO_IN_MEDIA || attrs->type == AUDIO_MULTI_CHANNEL) &&
936             (renderPriv->renderInfos[index]->streamType == attrs->type) &&
937             (strcmp(renderPriv->renderInfos[index]->adapterName, adapterName) == 0)) {
938             *rendrId = renderPriv->renderInfos[index]->renderId;
939             renderPriv->renderInfos[index]->usrCount++;
940             return &renderPriv->renderInfos[index]->render;
941         }
942         if ((renderPriv->renderInfos[index] != NULL) &&
943             (renderPriv->renderInfos[index]->desc.pins == pin) &&
944             (renderPriv->renderInfos[index]->streamType == attrs->type) &&
945             (renderPriv->renderInfos[index]->sampleRate == attrs->sampleRate) &&
946             (renderPriv->renderInfos[index]->channelCount == attrs->channelCount)) {
947             *rendrId = renderPriv->renderInfos[index]->renderId;
948             renderPriv->renderInfos[index]->usrCount++;
949             return &renderPriv->renderInfos[index]->render;
950         }
951     }
952 
953     return NULL;
954 }
955 
GetAvailableRenderId(struct AudioRenderPrivVdi *renderPriv)956 static uint32_t GetAvailableRenderId(struct AudioRenderPrivVdi *renderPriv)
957 {
958     uint32_t renderId = AUDIO_VDI_STREAM_NUM_MAX;
959     if (renderPriv == NULL) {
960         AUDIO_FUNC_LOGE("Parameter error!");
961         return renderId;
962     }
963 
964     if (renderPriv->renderCnt < AUDIO_VDI_STREAM_NUM_MAX) {
965         renderId = renderPriv->renderCnt;
966         renderPriv->renderCnt++;
967     } else {
968         for (uint32_t index = 0; index < AUDIO_VDI_STREAM_NUM_MAX; index++) {
969             if (renderPriv->renderInfos[index] == NULL) {
970                 renderId = index;
971                 break;
972             }
973         }
974     }
975 
976     return renderId;
977 }
978 
AudioCreateRenderByIdVdi(const struct AudioSampleAttributes *attrs, uint32_t *renderId, struct IAudioRenderVdi *vdiRender, const struct AudioDeviceDescriptor *desc, char *adapterName)979 struct IAudioRender *AudioCreateRenderByIdVdi(const struct AudioSampleAttributes *attrs, uint32_t *renderId,
980     struct IAudioRenderVdi *vdiRender, const struct AudioDeviceDescriptor *desc, char *adapterName)
981 {
982     struct IAudioRender *render = NULL;
983     if (attrs == NULL || renderId == NULL || vdiRender == NULL || desc == NULL) {
984         AUDIO_FUNC_LOGE("audio render is null");
985         return NULL;
986     }
987 
988     *renderId = AUDIO_VDI_STREAM_NUM_MAX;
989     struct AudioRenderPrivVdi *priv = AudioRenderGetPrivVdi();
990 
991     *renderId = GetAvailableRenderId(priv);
992     if (*renderId >= AUDIO_VDI_STREAM_NUM_MAX) {
993         AUDIO_FUNC_LOGE("audio vdiRender create render index fail, renderId=%{public}d", *renderId);
994         return NULL;
995     }
996 
997     priv->renderInfos[*renderId] = (struct AudioRenderInfo *)OsalMemCalloc(sizeof(struct AudioRenderInfo));
998     if (priv->renderInfos[*renderId] == NULL) {
999         AUDIO_FUNC_LOGE("audio VdiRender malloc renderInfos fail");
1000         return NULL;
1001     }
1002 
1003     priv->renderInfos[*renderId]->vdiRender = vdiRender;
1004     priv->renderInfos[*renderId]->streamType = attrs->type;
1005     priv->renderInfos[*renderId]->sampleRate = attrs->sampleRate;
1006     priv->renderInfos[*renderId]->channelCount = attrs->channelCount;
1007     priv->renderInfos[*renderId]->desc.portId = desc->portId;
1008     priv->renderInfos[*renderId]->desc.pins = desc->pins;
1009     priv->renderInfos[*renderId]->desc.desc = strdup(desc->desc);
1010     if (priv->renderInfos[*renderId]->desc.desc == NULL) {
1011         AUDIO_FUNC_LOGE("strdup fail, desc->desc = %{public}s", desc->desc);
1012         OsalMemFree(priv->renderInfos[*renderId]);
1013         priv->renderInfos[*renderId] = NULL;
1014         return NULL;
1015     }
1016     priv->renderInfos[*renderId]->renderId = *renderId;
1017     priv->renderInfos[*renderId]->usrCount = 1;
1018     priv->renderInfos[*renderId]->callback = NULL;
1019     priv->renderInfos[*renderId]->isRegCb = false;
1020     priv->renderInfos[*renderId]->adapterName = strdup(adapterName);
1021     if (priv->renderInfos[*renderId]->adapterName == NULL) {
1022         OsalMemFree(priv->renderInfos[*renderId]->desc.desc);
1023         OsalMemFree(priv->renderInfos[*renderId]);
1024         priv->renderInfos[*renderId] = NULL;
1025         return NULL;
1026     }
1027     render = &(priv->renderInfos[*renderId]->render);
1028     AudioInitRenderInstanceVdi(render);
1029 
1030     AUDIO_FUNC_LOGD("audio create render success");
1031     return render;
1032 }
1033 
DecreaseRenderUsrCount(uint32_t renderId)1034 uint32_t DecreaseRenderUsrCount(uint32_t renderId)
1035 {
1036     uint32_t usrCnt = 0;
1037     if (renderId >= AUDIO_VDI_STREAM_NUM_MAX) {
1038         AUDIO_FUNC_LOGE("audio check render index fail, descIndex=%{public}d", renderId);
1039         return usrCnt;
1040     }
1041     struct AudioRenderPrivVdi *priv = AudioRenderGetPrivVdi();
1042     if (priv->renderInfos[renderId] == NULL) {
1043         AUDIO_FUNC_LOGE("audio check render index fail, descIndex=%{public}d", renderId);
1044         return usrCnt;
1045     }
1046 
1047     priv->renderInfos[renderId]->usrCount--;
1048     usrCnt = priv->renderInfos[renderId]->usrCount;
1049     return usrCnt;
1050 }
1051 
AudioDestroyRenderByIdVdi(uint32_t renderId)1052 void AudioDestroyRenderByIdVdi(uint32_t renderId)
1053 {
1054     if (renderId >= AUDIO_VDI_STREAM_NUM_MAX) {
1055         AUDIO_FUNC_LOGE("audio vdiRender destroy render index fail, descIndex=%{public}d", renderId);
1056         return;
1057     }
1058     struct AudioRenderPrivVdi *priv = AudioRenderGetPrivVdi();
1059     if (priv->renderInfos[renderId] == NULL) {
1060         AUDIO_FUNC_LOGE("audio vdiRender destroy render index fail, descIndex=%{public}d", renderId);
1061         return;
1062     }
1063 
1064     OsalMemFree((void *)priv->renderInfos[renderId]->adapterName);
1065     priv->renderInfos[renderId]->adapterName = NULL;
1066     OsalMemFree((void *)priv->renderInfos[renderId]->desc.desc);
1067     priv->renderInfos[renderId]->vdiRender = NULL;
1068     priv->renderInfos[renderId]->desc.desc = NULL;
1069     priv->renderInfos[renderId]->desc.portId = UINT_MAX;
1070     priv->renderInfos[renderId]->desc.pins = PIN_NONE;
1071     priv->renderInfos[renderId]->callback = NULL;
1072     priv->renderInfos[renderId]->isRegCb = false;
1073     OsalMemFree(priv->renderInfos[renderId]);
1074     priv->renderInfos[renderId] = NULL;
1075 }
1076