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