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_vendor.h"
17
18 #include <hdf_base.h>
19 #include <limits.h>
20 #include "audio_common_vendor.h"
21 #include "audio_uhdf_log.h"
22 #include "osal_mem.h"
23 #include "securec.h"
24
25 #define HDF_LOG_TAG HDF_AUDIO_PRIMARY_IMPL
26
27 struct AudioRenderInfo {
28 struct IAudioRender render;
29 struct AudioDeviceDescriptor desc;
30 enum AudioCategory streamType;
31 unsigned int sampleRate;
32 unsigned int channelCount;
33 struct AudioHwiRender *hwiRender;
34 uint32_t renderId;
35 unsigned int usrCount;
36 };
37
38 struct AudioHwiRenderPriv {
39 struct AudioRenderInfo *renderInfos[AUDIO_HW_STREAM_NUM_MAX];
40 uint32_t renderCnt;
41 };
42
43 static struct AudioHwiRenderPriv g_audioHwiRenderPriv;
44
AudioHwiRenderGetPriv(void)45 static struct AudioHwiRenderPriv *AudioHwiRenderGetPriv(void)
46 {
47 return &g_audioHwiRenderPriv;
48 }
49
50
AudioHwiGetHwiRenderById(uint32_t renderId)51 struct AudioHwiRender *AudioHwiGetHwiRenderById(uint32_t renderId)
52 {
53 struct AudioHwiRenderPriv *priv = AudioHwiRenderGetPriv();
54 if (priv->renderInfos[renderId] == NULL) {
55 AUDIO_FUNC_LOGE("not match render");
56 return NULL;
57 }
58
59 return priv->renderInfos[renderId]->hwiRender;
60 }
61
AudioHwiGetLatency(struct IAudioRender * render,uint32_t * ms)62 int32_t AudioHwiGetLatency(struct IAudioRender *render, uint32_t *ms)
63 {
64 CHECK_NULL_PTR_RETURN_VALUE(render, HDF_ERR_INVALID_PARAM);
65 CHECK_NULL_PTR_RETURN_VALUE(ms, HDF_ERR_INVALID_PARAM);
66
67 struct AudioRenderInfo *renderInfo = (struct AudioRenderInfo *)render;
68 struct AudioHwiRender *hwiRender = renderInfo->hwiRender;
69 CHECK_NULL_PTR_RETURN_VALUE(hwiRender, HDF_ERR_INVALID_PARAM);
70 CHECK_NULL_PTR_RETURN_VALUE(hwiRender->GetLatency, HDF_ERR_INVALID_PARAM);
71
72 int32_t ret = hwiRender->GetLatency(hwiRender, ms);
73 if (ret != HDF_SUCCESS) {
74 AUDIO_FUNC_LOGE("audio GetLatency fail, ret=%{public}d", ret);
75 return ret;
76 }
77
78 return HDF_SUCCESS;
79 }
80
AudioHwiRenderFrame(struct IAudioRender * render,const int8_t * frame,uint32_t frameLen,uint64_t * replyBytes)81 int32_t AudioHwiRenderFrame(struct IAudioRender *render, const int8_t *frame, uint32_t frameLen, uint64_t *replyBytes)
82 {
83 CHECK_NULL_PTR_RETURN_VALUE(render, HDF_ERR_INVALID_PARAM);
84 CHECK_NULL_PTR_RETURN_VALUE(frame, HDF_ERR_INVALID_PARAM);
85 CHECK_NULL_PTR_RETURN_VALUE(replyBytes, HDF_ERR_INVALID_PARAM);
86
87 struct AudioRenderInfo *renderInfo = (struct AudioRenderInfo *)render;
88 struct AudioHwiRender *hwiRender = renderInfo->hwiRender;
89 CHECK_NULL_PTR_RETURN_VALUE(hwiRender, HDF_ERR_INVALID_PARAM);
90 CHECK_NULL_PTR_RETURN_VALUE(hwiRender->RenderFrame, HDF_ERR_INVALID_PARAM);
91
92 int32_t ret = hwiRender->RenderFrame(hwiRender, frame, frameLen, replyBytes);
93 if (ret != HDF_SUCCESS) {
94 AUDIO_FUNC_LOGE("audio render frame fail, ret=%{public}d", ret);
95 return ret;
96 }
97
98 return HDF_SUCCESS;
99 }
100
AudioHwiGetRenderPosition(struct IAudioRender * render,uint64_t * frames,struct AudioTimeStamp * time)101 int32_t AudioHwiGetRenderPosition(struct IAudioRender *render, uint64_t *frames, struct AudioTimeStamp *time)
102 {
103 CHECK_NULL_PTR_RETURN_VALUE(render, HDF_ERR_INVALID_PARAM);
104 CHECK_NULL_PTR_RETURN_VALUE(frames, HDF_ERR_INVALID_PARAM);
105 CHECK_NULL_PTR_RETURN_VALUE(time, HDF_ERR_INVALID_PARAM);
106
107 struct AudioRenderInfo *renderInfo = (struct AudioRenderInfo *)render;
108 struct AudioHwiRender *hwiRender = renderInfo->hwiRender;
109 CHECK_NULL_PTR_RETURN_VALUE(hwiRender, HDF_ERR_INVALID_PARAM);
110 CHECK_NULL_PTR_RETURN_VALUE(hwiRender->GetRenderPosition, HDF_ERR_INVALID_PARAM);
111
112 int32_t ret = hwiRender->GetRenderPosition(hwiRender, frames, (struct AudioHwiTimeStamp *)time);
113 if (ret != HDF_SUCCESS) {
114 AUDIO_FUNC_LOGE("audio render, get position fail, ret=%{public}d", ret);
115 }
116
117 return ret;
118 }
119
AudioHwiSetRenderSpeed(struct IAudioRender * render,float speed)120 int32_t AudioHwiSetRenderSpeed(struct IAudioRender *render, float speed)
121 {
122 CHECK_NULL_PTR_RETURN_VALUE(render, HDF_ERR_INVALID_PARAM);
123
124 struct AudioRenderInfo *renderInfo = (struct AudioRenderInfo *)render;
125 struct AudioHwiRender *hwiRender = renderInfo->hwiRender;
126 CHECK_NULL_PTR_RETURN_VALUE(hwiRender, HDF_ERR_INVALID_PARAM);
127 CHECK_NULL_PTR_RETURN_VALUE(hwiRender->SetRenderSpeed, HDF_ERR_INVALID_PARAM);
128
129 int32_t ret = hwiRender->SetRenderSpeed(hwiRender, speed);
130 if (ret != HDF_SUCCESS) {
131 AUDIO_FUNC_LOGE("audio render SetRenderSpeed fail, ret=%{public}d", ret);
132 }
133
134 return ret;
135 }
136
AudioHwiGetRenderSpeed(struct IAudioRender * render,float * speed)137 int32_t AudioHwiGetRenderSpeed(struct IAudioRender *render, float *speed)
138 {
139 CHECK_NULL_PTR_RETURN_VALUE(render, HDF_ERR_INVALID_PARAM);
140 CHECK_NULL_PTR_RETURN_VALUE(speed, HDF_ERR_INVALID_PARAM);
141
142 struct AudioRenderInfo *renderInfo = (struct AudioRenderInfo *)render;
143 struct AudioHwiRender *hwiRender = renderInfo->hwiRender;
144 CHECK_NULL_PTR_RETURN_VALUE(hwiRender, HDF_ERR_INVALID_PARAM);
145 CHECK_NULL_PTR_RETURN_VALUE(hwiRender->GetRenderSpeed, HDF_ERR_INVALID_PARAM);
146
147 int32_t ret = hwiRender->GetRenderSpeed(hwiRender, speed);
148 if (ret != HDF_SUCCESS) {
149 AUDIO_FUNC_LOGE("audio render GetRenderSpeed fail, ret=%{public}d", ret);
150 }
151
152 return ret;
153 }
154
AudioHwiRenderSetChannelMode(struct IAudioRender * render,enum AudioChannelMode mode)155 int32_t AudioHwiRenderSetChannelMode(struct IAudioRender *render, enum AudioChannelMode mode)
156 {
157 CHECK_NULL_PTR_RETURN_VALUE(render, HDF_ERR_INVALID_PARAM);
158
159 struct AudioRenderInfo *renderInfo = (struct AudioRenderInfo *)render;
160 struct AudioHwiRender *hwiRender = renderInfo->hwiRender;
161 CHECK_NULL_PTR_RETURN_VALUE(hwiRender, HDF_ERR_INVALID_PARAM);
162 CHECK_NULL_PTR_RETURN_VALUE(hwiRender->SetChannelMode, HDF_ERR_INVALID_PARAM);
163
164 int32_t ret = hwiRender->SetChannelMode(hwiRender, (enum AudioHwiChannelMode)mode);
165 if (ret != HDF_SUCCESS) {
166 AUDIO_FUNC_LOGE("audio SetChannelMode fail, ret=%{public}d", ret);
167 }
168
169 return ret;
170 }
171
AudioHwiRenderGetChannelMode(struct IAudioRender * render,enum AudioChannelMode * mode)172 int32_t AudioHwiRenderGetChannelMode(struct IAudioRender *render, enum AudioChannelMode *mode)
173 {
174 CHECK_NULL_PTR_RETURN_VALUE(render, HDF_ERR_INVALID_PARAM);
175 CHECK_NULL_PTR_RETURN_VALUE(mode, HDF_ERR_INVALID_PARAM);
176
177 struct AudioRenderInfo *renderInfo = (struct AudioRenderInfo *)render;
178 struct AudioHwiRender *hwiRender = renderInfo->hwiRender;
179 CHECK_NULL_PTR_RETURN_VALUE(hwiRender, HDF_ERR_INVALID_PARAM);
180 CHECK_NULL_PTR_RETURN_VALUE(hwiRender->GetChannelMode, HDF_ERR_INVALID_PARAM);
181
182 int32_t ret = hwiRender->GetChannelMode(hwiRender, (enum AudioHwiChannelMode *)mode);
183 if (ret != HDF_SUCCESS) {
184 AUDIO_FUNC_LOGE("audio render GetChannelMode fail, ret=%{public}d", ret);
185 }
186
187 return ret;
188 }
189
AudioHwiRenderDrainBuffer(struct IAudioRender * render,enum AudioDrainNotifyType * type)190 int32_t AudioHwiRenderDrainBuffer(struct IAudioRender *render, enum AudioDrainNotifyType *type)
191 {
192 CHECK_NULL_PTR_RETURN_VALUE(render, HDF_ERR_INVALID_PARAM);
193 CHECK_NULL_PTR_RETURN_VALUE(type, HDF_ERR_INVALID_PARAM);
194
195 struct AudioRenderInfo *renderInfo = (struct AudioRenderInfo *)render;
196 struct AudioHwiRender *hwiRender = renderInfo->hwiRender;
197 CHECK_NULL_PTR_RETURN_VALUE(hwiRender, HDF_ERR_INVALID_PARAM);
198 CHECK_NULL_PTR_RETURN_VALUE(hwiRender->DrainBuffer, HDF_ERR_INVALID_PARAM);
199
200 int32_t ret = hwiRender->DrainBuffer(hwiRender, (enum AudioHwiDrainNotifyType *)type);
201 if (ret != HDF_SUCCESS) {
202 AUDIO_FUNC_LOGE("audio render DrainBuffer fail, ret=%{public}d", ret);
203 }
204
205 return ret;
206 }
207
AudioHwiRenderIsSupportsDrain(struct IAudioRender * render,bool * support)208 int32_t AudioHwiRenderIsSupportsDrain(struct IAudioRender *render, bool *support)
209 {
210 CHECK_NULL_PTR_RETURN_VALUE(render, HDF_ERR_INVALID_PARAM);
211 CHECK_NULL_PTR_RETURN_VALUE(support, HDF_ERR_INVALID_PARAM);
212
213 struct AudioRenderInfo *renderInfo = (struct AudioRenderInfo *)render;
214 struct AudioHwiRender *hwiRender = renderInfo->hwiRender;
215 CHECK_NULL_PTR_RETURN_VALUE(hwiRender, HDF_ERR_INVALID_PARAM);
216 CHECK_NULL_PTR_RETURN_VALUE(hwiRender->IsSupportsDrain, HDF_ERR_INVALID_PARAM);
217
218 int32_t ret = hwiRender->IsSupportsDrain(hwiRender, support);
219 if (ret != HDF_SUCCESS) {
220 AUDIO_FUNC_LOGE("audio render IsSupportsDrain fail, ret=%{public}d", ret);
221 }
222
223 return ret;
224 }
225
AudioHwiRenderCheckSceneCapability(struct IAudioRender * render,const struct AudioSceneDescriptor * scene,bool * supported)226 int32_t AudioHwiRenderCheckSceneCapability(struct IAudioRender *render, const struct AudioSceneDescriptor *scene,
227 bool *supported)
228 {
229 CHECK_NULL_PTR_RETURN_VALUE(render, HDF_ERR_INVALID_PARAM);
230 CHECK_NULL_PTR_RETURN_VALUE(scene, HDF_ERR_INVALID_PARAM);
231 CHECK_NULL_PTR_RETURN_VALUE(supported, HDF_ERR_INVALID_PARAM);
232
233 struct AudioRenderInfo *renderInfo = (struct AudioRenderInfo *)render;
234 struct AudioHwiRender *hwiRender = renderInfo->hwiRender;
235 CHECK_NULL_PTR_RETURN_VALUE(hwiRender, HDF_ERR_INVALID_PARAM);
236 CHECK_NULL_PTR_RETURN_VALUE(hwiRender->scene.CheckSceneCapability, HDF_ERR_INVALID_PARAM);
237
238 struct AudioHwiSceneDescriptor hwiScene;
239 (void)memset_s((void *)&hwiScene, sizeof(hwiScene), 0, sizeof(hwiScene));
240 int32_t ret = AudioHwiCommonSceneToHwiScene(scene, &hwiScene);
241 if (ret != HDF_SUCCESS) {
242 AUDIO_FUNC_LOGE("audio render scene To hwiScene fail");
243 return HDF_FAILURE;
244 }
245
246 ret = hwiRender->scene.CheckSceneCapability(hwiRender, &hwiScene, supported);
247 OsalMemFree((void *)hwiScene.desc.desc);
248 if (ret != HDF_SUCCESS) {
249 AUDIO_FUNC_LOGE("audio render CheckSceneCapability fail, ret=%{public}d", ret);
250 }
251
252 return ret;
253 }
254
AudioHwiRenderSelectScene(struct IAudioRender * render,const struct AudioSceneDescriptor * scene)255 int32_t AudioHwiRenderSelectScene(struct IAudioRender *render, const struct AudioSceneDescriptor *scene)
256 {
257 CHECK_NULL_PTR_RETURN_VALUE(render, HDF_ERR_INVALID_PARAM);
258 CHECK_NULL_PTR_RETURN_VALUE(scene, HDF_ERR_INVALID_PARAM);
259
260 struct AudioRenderInfo *renderInfo = (struct AudioRenderInfo *)render;
261 struct AudioHwiRender *hwiRender = renderInfo->hwiRender;
262 CHECK_NULL_PTR_RETURN_VALUE(hwiRender, HDF_ERR_INVALID_PARAM);
263 CHECK_NULL_PTR_RETURN_VALUE(hwiRender->scene.SelectScene, HDF_ERR_INVALID_PARAM);
264
265 struct AudioHwiSceneDescriptor hwiScene;
266 (void)memset_s((void *)&hwiScene, sizeof(hwiScene), 0, sizeof(hwiScene));
267 int32_t ret = AudioHwiCommonSceneToHwiScene(scene, &hwiScene);
268 if (ret != HDF_SUCCESS) {
269 AUDIO_FUNC_LOGE("audio render scene To hwiScene fail");
270 return HDF_FAILURE;
271 }
272
273 ret = hwiRender->scene.SelectScene(hwiRender, &hwiScene);
274 OsalMemFree((void *)hwiScene.desc.desc);
275 if (ret != HDF_SUCCESS) {
276 AUDIO_FUNC_LOGE("audio render select scene fail, ret=%{public}d", ret);
277 }
278
279 return ret;
280 }
281
AudioHwiRenderSetMute(struct IAudioRender * render,bool mute)282 int32_t AudioHwiRenderSetMute(struct IAudioRender *render, bool mute)
283 {
284 CHECK_NULL_PTR_RETURN_VALUE(render, HDF_ERR_INVALID_PARAM);
285
286 struct AudioRenderInfo *renderInfo = (struct AudioRenderInfo *)render;
287 struct AudioHwiRender *hwiRender = renderInfo->hwiRender;
288 CHECK_NULL_PTR_RETURN_VALUE(hwiRender, HDF_ERR_INVALID_PARAM);
289 CHECK_NULL_PTR_RETURN_VALUE(hwiRender->volume.SetMute, HDF_ERR_INVALID_PARAM);
290
291 int32_t ret = hwiRender->volume.SetMute(hwiRender, mute);
292 if (ret != HDF_SUCCESS) {
293 AUDIO_FUNC_LOGE("audio render SetMute fail, ret=%{public}d", ret);
294 }
295
296 return ret;
297 }
298
AudioHwiRenderGetMute(struct IAudioRender * render,bool * mute)299 int32_t AudioHwiRenderGetMute(struct IAudioRender *render, bool *mute)
300 {
301 CHECK_NULL_PTR_RETURN_VALUE(render, HDF_ERR_INVALID_PARAM);
302 CHECK_NULL_PTR_RETURN_VALUE(mute, HDF_ERR_INVALID_PARAM);
303
304 struct AudioRenderInfo *renderInfo = (struct AudioRenderInfo *)render;
305 struct AudioHwiRender *hwiRender = renderInfo->hwiRender;
306 CHECK_NULL_PTR_RETURN_VALUE(hwiRender, HDF_ERR_INVALID_PARAM);
307 CHECK_NULL_PTR_RETURN_VALUE(hwiRender->volume.GetMute, HDF_ERR_INVALID_PARAM);
308
309 int32_t ret = hwiRender->volume.GetMute(hwiRender, mute);
310 if (ret != HDF_SUCCESS) {
311 AUDIO_FUNC_LOGE("audio render GetMute fail, ret=%{public}d", ret);
312 }
313
314 return ret;
315 }
316
AudioHwiRenderSetVolume(struct IAudioRender * render,float volume)317 int32_t AudioHwiRenderSetVolume(struct IAudioRender *render, float volume)
318 {
319 CHECK_NULL_PTR_RETURN_VALUE(render, HDF_ERR_INVALID_PARAM);
320
321 struct AudioRenderInfo *renderInfo = (struct AudioRenderInfo *)render;
322 struct AudioHwiRender *hwiRender = renderInfo->hwiRender;
323 CHECK_NULL_PTR_RETURN_VALUE(hwiRender, HDF_ERR_INVALID_PARAM);
324 CHECK_NULL_PTR_RETURN_VALUE(hwiRender->volume.SetVolume, HDF_ERR_INVALID_PARAM);
325
326 int32_t ret = hwiRender->volume.SetVolume(hwiRender, volume);
327 if (ret != HDF_SUCCESS) {
328 AUDIO_FUNC_LOGE("audio render SetVolume fail, ret=%{public}d", ret);
329 }
330
331 return ret;
332 }
333
AudioHwiRenderGetVolume(struct IAudioRender * render,float * volume)334 int32_t AudioHwiRenderGetVolume(struct IAudioRender *render, float *volume)
335 {
336 CHECK_NULL_PTR_RETURN_VALUE(render, HDF_ERR_INVALID_PARAM);
337 CHECK_NULL_PTR_RETURN_VALUE(volume, HDF_ERR_INVALID_PARAM);
338
339 struct AudioRenderInfo *renderInfo = (struct AudioRenderInfo *)render;
340 struct AudioHwiRender *hwiRender = renderInfo->hwiRender;
341 CHECK_NULL_PTR_RETURN_VALUE(hwiRender, HDF_ERR_INVALID_PARAM);
342 CHECK_NULL_PTR_RETURN_VALUE(hwiRender->volume.GetVolume, HDF_ERR_INVALID_PARAM);
343
344 int32_t ret = hwiRender->volume.GetVolume(hwiRender, volume);
345 if (ret != HDF_SUCCESS) {
346 AUDIO_FUNC_LOGE("audio render GetVolume fail, ret=%{public}d", ret);
347 }
348
349 return ret;
350 }
351
AudioHwiRenderGetGainThreshold(struct IAudioRender * render,float * min,float * max)352 int32_t AudioHwiRenderGetGainThreshold(struct IAudioRender *render, float *min, float *max)
353 {
354 CHECK_NULL_PTR_RETURN_VALUE(render, HDF_ERR_INVALID_PARAM);
355 CHECK_NULL_PTR_RETURN_VALUE(min, HDF_ERR_INVALID_PARAM);
356 CHECK_NULL_PTR_RETURN_VALUE(max, HDF_ERR_INVALID_PARAM);
357
358 struct AudioRenderInfo *renderInfo = (struct AudioRenderInfo *)render;
359 struct AudioHwiRender *hwiRender = renderInfo->hwiRender;
360 CHECK_NULL_PTR_RETURN_VALUE(hwiRender, HDF_ERR_INVALID_PARAM);
361 CHECK_NULL_PTR_RETURN_VALUE(hwiRender->volume.GetGainThreshold, HDF_ERR_INVALID_PARAM);
362
363 int32_t ret = hwiRender->volume.GetGainThreshold(hwiRender, min, max);
364 if (ret != HDF_SUCCESS) {
365 AUDIO_FUNC_LOGE("audio render GetGainThreshold fail, ret=%{public}d", ret);
366 }
367
368 return ret;
369 }
370
AudioHwiRenderGetGain(struct IAudioRender * render,float * gain)371 int32_t AudioHwiRenderGetGain(struct IAudioRender *render, float *gain)
372 {
373 CHECK_NULL_PTR_RETURN_VALUE(render, HDF_ERR_INVALID_PARAM);
374 CHECK_NULL_PTR_RETURN_VALUE(gain, HDF_ERR_INVALID_PARAM);
375
376 struct AudioRenderInfo *renderInfo = (struct AudioRenderInfo *)render;
377 struct AudioHwiRender *hwiRender = renderInfo->hwiRender;
378 CHECK_NULL_PTR_RETURN_VALUE(hwiRender, HDF_ERR_INVALID_PARAM);
379 CHECK_NULL_PTR_RETURN_VALUE(hwiRender->volume.GetGain, HDF_ERR_INVALID_PARAM);
380
381 int32_t ret = hwiRender->volume.GetGain(hwiRender, gain);
382 if (ret != HDF_SUCCESS) {
383 AUDIO_FUNC_LOGE("audio render GetGain fail, ret=%{public}d", ret);
384 }
385
386 return ret;
387 }
388
AudioHwiRenderSetGain(struct IAudioRender * render,float gain)389 int32_t AudioHwiRenderSetGain(struct IAudioRender *render, float gain)
390 {
391 CHECK_NULL_PTR_RETURN_VALUE(render, HDF_ERR_INVALID_PARAM);
392
393 struct AudioRenderInfo *renderInfo = (struct AudioRenderInfo *)render;
394 struct AudioHwiRender *hwiRender = renderInfo->hwiRender;
395 CHECK_NULL_PTR_RETURN_VALUE(hwiRender, HDF_ERR_INVALID_PARAM);
396 CHECK_NULL_PTR_RETURN_VALUE(hwiRender->volume.SetGain, HDF_ERR_INVALID_PARAM);
397
398 int32_t ret = hwiRender->volume.SetGain(hwiRender, gain);
399 if (ret != HDF_SUCCESS) {
400 AUDIO_FUNC_LOGE("audio render SetGain fail, ret=%{public}d", ret);
401 }
402
403 return ret;
404 }
405
AudioHwiRenderGetFrameSize(struct IAudioRender * render,uint64_t * size)406 int32_t AudioHwiRenderGetFrameSize(struct IAudioRender *render, uint64_t *size)
407 {
408 CHECK_NULL_PTR_RETURN_VALUE(render, HDF_ERR_INVALID_PARAM);
409 CHECK_NULL_PTR_RETURN_VALUE(size, HDF_ERR_INVALID_PARAM);
410
411 struct AudioRenderInfo *renderInfo = (struct AudioRenderInfo *)render;
412 struct AudioHwiRender *hwiRender = renderInfo->hwiRender;
413 CHECK_NULL_PTR_RETURN_VALUE(hwiRender, HDF_ERR_INVALID_PARAM);
414 CHECK_NULL_PTR_RETURN_VALUE(hwiRender->attr.GetFrameSize, HDF_ERR_INVALID_PARAM);
415
416 int32_t ret = hwiRender->attr.GetFrameSize(hwiRender, size);
417 if (ret != HDF_SUCCESS) {
418 AUDIO_FUNC_LOGE("audio render GetFrameSize fail, ret=%{public}d", ret);
419 }
420
421 return ret;
422 }
423
AudioHwiRenderGetFrameCount(struct IAudioRender * render,uint64_t * count)424 int32_t AudioHwiRenderGetFrameCount(struct IAudioRender *render, uint64_t *count)
425 {
426 CHECK_NULL_PTR_RETURN_VALUE(render, HDF_ERR_INVALID_PARAM);
427 CHECK_NULL_PTR_RETURN_VALUE(count, HDF_ERR_INVALID_PARAM);
428
429 struct AudioRenderInfo *renderInfo = (struct AudioRenderInfo *)render;
430 struct AudioHwiRender *hwiRender = renderInfo->hwiRender;
431 CHECK_NULL_PTR_RETURN_VALUE(hwiRender, HDF_ERR_INVALID_PARAM);
432 CHECK_NULL_PTR_RETURN_VALUE(hwiRender->attr.GetFrameCount, HDF_ERR_INVALID_PARAM);
433
434 int32_t ret = hwiRender->attr.GetFrameCount(hwiRender, count);
435 if (ret != HDF_SUCCESS) {
436 AUDIO_FUNC_LOGE("audio render GetFrameCount fail, ret=%{public}d", ret);
437 }
438
439 return ret;
440 }
441
AudioHwiRenderSetSampleAttributes(struct IAudioRender * render,const struct AudioSampleAttributes * attrs)442 int32_t AudioHwiRenderSetSampleAttributes(struct IAudioRender *render, const struct AudioSampleAttributes *attrs)
443 {
444 CHECK_NULL_PTR_RETURN_VALUE(render, HDF_ERR_INVALID_PARAM);
445 CHECK_NULL_PTR_RETURN_VALUE(attrs, HDF_ERR_INVALID_PARAM);
446
447 struct AudioRenderInfo *renderInfo = (struct AudioRenderInfo *)render;
448 struct AudioHwiRender *hwiRender = renderInfo->hwiRender;
449 CHECK_NULL_PTR_RETURN_VALUE(hwiRender, HDF_ERR_INVALID_PARAM);
450 CHECK_NULL_PTR_RETURN_VALUE(hwiRender->attr.SetSampleAttributes, HDF_ERR_INVALID_PARAM);
451
452 struct AudioHwiSampleAttributes hwiAttrs;
453 (void)memset_s((void *)&hwiAttrs, sizeof(hwiAttrs), 0, sizeof(hwiAttrs));
454 int32_t ret = AudioHwiCommonSampleAttrToHwiSampleAttr(attrs, &hwiAttrs);
455 if (ret != HDF_SUCCESS) {
456 AUDIO_FUNC_LOGE("audio render SampleAttr to hwisampleAttr fail, ret=%{public}d", ret);
457 return ret;
458 }
459
460 ret = hwiRender->attr.SetSampleAttributes(hwiRender, &hwiAttrs);
461 if (ret != HDF_SUCCESS) {
462 AUDIO_FUNC_LOGE("audio render SetSampleAttributes fail, ret=%{public}d", ret);
463 }
464
465 return ret;
466 }
467
AudioHwiRenderGetSampleAttributes(struct IAudioRender * render,struct AudioSampleAttributes * attrs)468 int32_t AudioHwiRenderGetSampleAttributes(struct IAudioRender *render, struct AudioSampleAttributes *attrs)
469 {
470 CHECK_NULL_PTR_RETURN_VALUE(render, HDF_ERR_INVALID_PARAM);
471 CHECK_NULL_PTR_RETURN_VALUE(attrs, HDF_ERR_INVALID_PARAM);
472
473 struct AudioRenderInfo *renderInfo = (struct AudioRenderInfo *)render;
474 struct AudioHwiRender *hwiRender = renderInfo->hwiRender;
475 CHECK_NULL_PTR_RETURN_VALUE(hwiRender, HDF_ERR_INVALID_PARAM);
476 CHECK_NULL_PTR_RETURN_VALUE(hwiRender->attr.GetSampleAttributes, HDF_ERR_INVALID_PARAM);
477
478 struct AudioHwiSampleAttributes hwiAttrs;
479 (void)memset_s((void *)&hwiAttrs, sizeof(hwiAttrs), 0, sizeof(hwiAttrs));
480 int32_t ret = hwiRender->attr.GetSampleAttributes(hwiRender, &hwiAttrs);
481 if (ret != HDF_SUCCESS) {
482 AUDIO_FUNC_LOGE("audio render GetSampleAttributes fail, ret=%{public}d", ret);
483 return ret;
484 }
485
486 ret = AudioHwiCommonHwiSampleAttrToSampleAttr(&hwiAttrs, attrs);
487 if (ret != HDF_SUCCESS) {
488 AUDIO_FUNC_LOGE("audio render hwiSampleAttr to SampleAttr fail, ret=%{public}d", ret);
489 }
490
491 return ret;
492 }
493
AudioHwiRenderGetCurrentChannelId(struct IAudioRender * render,uint32_t * channelId)494 int32_t AudioHwiRenderGetCurrentChannelId(struct IAudioRender *render, uint32_t *channelId)
495 {
496 CHECK_NULL_PTR_RETURN_VALUE(render, HDF_ERR_INVALID_PARAM);
497 CHECK_NULL_PTR_RETURN_VALUE(channelId, HDF_ERR_INVALID_PARAM);
498
499 struct AudioRenderInfo *renderInfo = (struct AudioRenderInfo *)render;
500 struct AudioHwiRender *hwiRender = renderInfo->hwiRender;
501 CHECK_NULL_PTR_RETURN_VALUE(hwiRender, HDF_ERR_INVALID_PARAM);
502 CHECK_NULL_PTR_RETURN_VALUE(hwiRender->attr.GetCurrentChannelId, HDF_ERR_INVALID_PARAM);
503
504 int32_t ret = hwiRender->attr.GetCurrentChannelId(hwiRender, channelId);
505 if (ret != HDF_SUCCESS) {
506 AUDIO_FUNC_LOGE("audio render GetCurrentChannelId fail, ret=%{public}d", ret);
507 }
508
509 return ret;
510 }
511
AudioHwiRenderSetExtraParams(struct IAudioRender * render,const char * keyValueList)512 int32_t AudioHwiRenderSetExtraParams(struct IAudioRender *render, const char *keyValueList)
513 {
514 CHECK_NULL_PTR_RETURN_VALUE(render, HDF_ERR_INVALID_PARAM);
515 CHECK_NULL_PTR_RETURN_VALUE(keyValueList, HDF_ERR_INVALID_PARAM);
516
517 struct AudioRenderInfo *renderInfo = (struct AudioRenderInfo *)render;
518 struct AudioHwiRender *hwiRender = renderInfo->hwiRender;
519 CHECK_NULL_PTR_RETURN_VALUE(hwiRender, HDF_ERR_INVALID_PARAM);
520 CHECK_NULL_PTR_RETURN_VALUE(hwiRender->attr.SetExtraParams, HDF_ERR_INVALID_PARAM);
521
522 int32_t ret = hwiRender->attr.SetExtraParams(hwiRender, keyValueList);
523 if (ret != HDF_SUCCESS) {
524 AUDIO_FUNC_LOGE("audio render SetExtraParams fail, ret=%{public}d", ret);
525 }
526
527 return ret;
528 }
529
AudioHwiRenderGetExtraParams(struct IAudioRender * render,char * keyValueList,uint32_t keyValueListLen)530 int32_t AudioHwiRenderGetExtraParams(struct IAudioRender *render, char *keyValueList, uint32_t keyValueListLen)
531 {
532 CHECK_NULL_PTR_RETURN_VALUE(render, HDF_ERR_INVALID_PARAM);
533 CHECK_NULL_PTR_RETURN_VALUE(keyValueList, HDF_ERR_INVALID_PARAM);
534
535 struct AudioRenderInfo *renderInfo = (struct AudioRenderInfo *)render;
536 struct AudioHwiRender *hwiRender = renderInfo->hwiRender;
537 CHECK_NULL_PTR_RETURN_VALUE(hwiRender, HDF_ERR_INVALID_PARAM);
538 CHECK_NULL_PTR_RETURN_VALUE(hwiRender->attr.GetExtraParams, HDF_ERR_INVALID_PARAM);
539
540 int32_t ret = hwiRender->attr.GetExtraParams(hwiRender, keyValueList, keyValueListLen);
541 if (ret != HDF_SUCCESS) {
542 AUDIO_FUNC_LOGE("audio render GetExtraParams fail, ret=%{public}d", ret);
543 }
544
545 return ret;
546 }
547
AudioHwiRenderReqMmapBuffer(struct IAudioRender * render,int32_t reqSize,struct AudioMmapBufferDescriptor * desc)548 int32_t AudioHwiRenderReqMmapBuffer(struct IAudioRender *render, int32_t reqSize,
549 struct AudioMmapBufferDescriptor *desc)
550 {
551 CHECK_NULL_PTR_RETURN_VALUE(render, HDF_ERR_INVALID_PARAM);
552 CHECK_NULL_PTR_RETURN_VALUE(desc, HDF_ERR_INVALID_PARAM);
553
554 struct AudioRenderInfo *renderInfo = (struct AudioRenderInfo *)render;
555 struct AudioHwiRender *hwiRender = renderInfo->hwiRender;
556 CHECK_NULL_PTR_RETURN_VALUE(hwiRender, HDF_ERR_INVALID_PARAM);
557 CHECK_NULL_PTR_RETURN_VALUE(hwiRender->attr.ReqMmapBuffer, HDF_ERR_INVALID_PARAM);
558
559 struct AudioHwiMmapBufferDescriptor hwiDesc = {0};
560 int32_t ret = hwiRender->attr.ReqMmapBuffer(hwiRender, reqSize, &hwiDesc);
561 if (ret != HDF_SUCCESS) {
562 AUDIO_FUNC_LOGE("audio render ReqMmapBuffer fail, ret=%{public}d", ret);
563 return ret;
564 }
565
566 desc->memoryAddress = NULL;
567 desc->memoryFd = hwiDesc.memoryFd;
568 desc->totalBufferFrames = hwiDesc.totalBufferFrames;
569 desc->transferFrameSize = hwiDesc.transferFrameSize;
570 desc->isShareable = hwiDesc.isShareable;
571 desc->offset = hwiDesc.offset;
572 desc->filePath = strdup("");
573
574 AUDIO_FUNC_LOGI("%{public}s success", __func__);
575 return HDF_SUCCESS;
576 }
577
AudioHwiRenderGetMmapPosition(struct IAudioRender * render,uint64_t * frames,struct AudioTimeStamp * time)578 int32_t AudioHwiRenderGetMmapPosition(struct IAudioRender *render, uint64_t *frames, struct AudioTimeStamp *time)
579 {
580 struct AudioHwiTimeStamp hwiTime;
581 CHECK_NULL_PTR_RETURN_VALUE(render, HDF_ERR_INVALID_PARAM);
582 CHECK_NULL_PTR_RETURN_VALUE(frames, HDF_ERR_INVALID_PARAM);
583 CHECK_NULL_PTR_RETURN_VALUE(time, HDF_ERR_INVALID_PARAM);
584
585 hwiTime.tvSec = 0;
586 hwiTime.tvNSec = 0;
587
588 struct AudioRenderInfo *renderInfo = (struct AudioRenderInfo *)render;
589 struct AudioHwiRender *hwiRender = renderInfo->hwiRender;
590 CHECK_NULL_PTR_RETURN_VALUE(hwiRender, HDF_ERR_INVALID_PARAM);
591 CHECK_NULL_PTR_RETURN_VALUE(hwiRender->attr.GetMmapPosition, HDF_ERR_INVALID_PARAM);
592
593 int32_t ret = hwiRender->attr.GetMmapPosition(hwiRender, frames, &hwiTime);
594 if (ret != HDF_SUCCESS) {
595 AUDIO_FUNC_LOGE("audio render GetMmapPosition fail, ret=%{public}d", ret);
596 return ret;
597 }
598
599 time->tvSec = hwiTime.tvSec;
600 time->tvNSec = hwiTime.tvNSec;
601
602 return HDF_SUCCESS;
603 }
604
AudioHwiRenderAddAudioEffect(struct IAudioRender * render,uint64_t effectid)605 int32_t AudioHwiRenderAddAudioEffect(struct IAudioRender *render, uint64_t effectid)
606 {
607 CHECK_NULL_PTR_RETURN_VALUE(render, HDF_ERR_INVALID_PARAM);
608
609 struct AudioRenderInfo *renderInfo = (struct AudioRenderInfo *)render;
610 struct AudioHwiRender *hwiRender = renderInfo->hwiRender;
611 CHECK_NULL_PTR_RETURN_VALUE(hwiRender, HDF_ERR_INVALID_PARAM);
612 CHECK_NULL_PTR_RETURN_VALUE(hwiRender->attr.AddAudioEffect, HDF_ERR_INVALID_PARAM);
613
614 return hwiRender->attr.AddAudioEffect(hwiRender, effectid);
615 }
616
AudioHwiRenderRemoveAudioEffect(struct IAudioRender * render,uint64_t effectid)617 int32_t AudioHwiRenderRemoveAudioEffect(struct IAudioRender *render, uint64_t effectid)
618 {
619 CHECK_NULL_PTR_RETURN_VALUE(render, HDF_ERR_INVALID_PARAM);
620
621 struct AudioRenderInfo *renderInfo = (struct AudioRenderInfo *)render;
622 struct AudioHwiRender *hwiRender = renderInfo->hwiRender;
623 CHECK_NULL_PTR_RETURN_VALUE(hwiRender, HDF_ERR_INVALID_PARAM);
624 CHECK_NULL_PTR_RETURN_VALUE(hwiRender->attr.RemoveAudioEffect, HDF_ERR_INVALID_PARAM);
625
626 return hwiRender->attr.RemoveAudioEffect(hwiRender, effectid);
627 }
628
AudioHwiRenderGetFrameBufferSize(struct IAudioRender * render,uint64_t * bufferSize)629 int32_t AudioHwiRenderGetFrameBufferSize(struct IAudioRender *render, uint64_t *bufferSize)
630 {
631 CHECK_NULL_PTR_RETURN_VALUE(render, HDF_ERR_INVALID_PARAM);
632 CHECK_NULL_PTR_RETURN_VALUE(bufferSize, HDF_ERR_INVALID_PARAM);
633
634 struct AudioRenderInfo *renderInfo = (struct AudioRenderInfo *)render;
635 struct AudioHwiRender *hwiRender = renderInfo->hwiRender;
636 CHECK_NULL_PTR_RETURN_VALUE(hwiRender, HDF_ERR_INVALID_PARAM);
637 CHECK_NULL_PTR_RETURN_VALUE(hwiRender->attr.GetFrameBufferSize, HDF_ERR_INVALID_PARAM);
638
639 return hwiRender->attr.GetFrameBufferSize(hwiRender, bufferSize);
640 }
641
AudioHwiRenderStart(struct IAudioRender * render)642 int32_t AudioHwiRenderStart(struct IAudioRender *render)
643 {
644 CHECK_NULL_PTR_RETURN_VALUE(render, HDF_ERR_INVALID_PARAM);
645
646 struct AudioRenderInfo *renderInfo = (struct AudioRenderInfo *)render;
647 struct AudioHwiRender *hwiRender = renderInfo->hwiRender;
648 CHECK_NULL_PTR_RETURN_VALUE(hwiRender, HDF_ERR_INVALID_PARAM);
649 CHECK_NULL_PTR_RETURN_VALUE(hwiRender->control.Start, HDF_ERR_INVALID_PARAM);
650
651 int32_t ret = hwiRender->control.Start(hwiRender);
652 if (ret != HDF_SUCCESS) {
653 AUDIO_FUNC_LOGE("audio render Start fail, ret=%{public}d", ret);
654 }
655
656 return ret;
657 }
658
AudioHwiRenderStop(struct IAudioRender * render)659 int32_t AudioHwiRenderStop(struct IAudioRender *render)
660 {
661 CHECK_NULL_PTR_RETURN_VALUE(render, HDF_ERR_INVALID_PARAM);
662
663 struct AudioRenderInfo *renderInfo = (struct AudioRenderInfo *)render;
664 struct AudioHwiRender *hwiRender = renderInfo->hwiRender;
665 CHECK_NULL_PTR_RETURN_VALUE(hwiRender, HDF_ERR_INVALID_PARAM);
666 CHECK_NULL_PTR_RETURN_VALUE(hwiRender->control.Stop, HDF_ERR_INVALID_PARAM);
667
668 int32_t ret = hwiRender->control.Stop(hwiRender);
669 if (ret != HDF_SUCCESS) {
670 AUDIO_FUNC_LOGE("audio render Stop fail, ret=%{public}d", ret);
671 }
672
673 return ret;
674 }
675
AudioHwiRenderPause(struct IAudioRender * render)676 int32_t AudioHwiRenderPause(struct IAudioRender *render)
677 {
678 CHECK_NULL_PTR_RETURN_VALUE(render, HDF_ERR_INVALID_PARAM);
679
680 struct AudioRenderInfo *renderInfo = (struct AudioRenderInfo *)render;
681 struct AudioHwiRender *hwiRender = renderInfo->hwiRender;
682 CHECK_NULL_PTR_RETURN_VALUE(hwiRender, HDF_ERR_INVALID_PARAM);
683 CHECK_NULL_PTR_RETURN_VALUE(hwiRender->control.Pause, HDF_ERR_INVALID_PARAM);
684
685 int32_t ret = hwiRender->control.Pause(hwiRender);
686 if (ret != HDF_SUCCESS) {
687 AUDIO_FUNC_LOGE("audio render Pause fail, ret=%{public}d", ret);
688 }
689
690 return ret;
691 }
692
AudioHwiRenderResume(struct IAudioRender * render)693 int32_t AudioHwiRenderResume(struct IAudioRender *render)
694 {
695 CHECK_NULL_PTR_RETURN_VALUE(render, HDF_ERR_INVALID_PARAM);
696
697 struct AudioRenderInfo *renderInfo = (struct AudioRenderInfo *)render;
698 struct AudioHwiRender *hwiRender = renderInfo->hwiRender;
699 CHECK_NULL_PTR_RETURN_VALUE(hwiRender, HDF_ERR_INVALID_PARAM);
700 CHECK_NULL_PTR_RETURN_VALUE(hwiRender->control.Resume, HDF_ERR_INVALID_PARAM);
701
702 int32_t ret = hwiRender->control.Resume(hwiRender);
703 if (ret != HDF_SUCCESS) {
704 AUDIO_FUNC_LOGE("audio render Resume fail, ret=%{public}d", ret);
705 }
706
707 return ret;
708 }
709
AudioHwiRenderFlush(struct IAudioRender * render)710 int32_t AudioHwiRenderFlush(struct IAudioRender *render)
711 {
712 CHECK_NULL_PTR_RETURN_VALUE(render, HDF_ERR_INVALID_PARAM);
713
714 struct AudioRenderInfo *renderInfo = (struct AudioRenderInfo *)render;
715 struct AudioHwiRender *hwiRender = renderInfo->hwiRender;
716 CHECK_NULL_PTR_RETURN_VALUE(hwiRender, HDF_ERR_INVALID_PARAM);
717 CHECK_NULL_PTR_RETURN_VALUE(hwiRender->control.Flush, HDF_ERR_INVALID_PARAM);
718
719 int32_t ret = hwiRender->control.Flush(hwiRender);
720 if (ret != HDF_SUCCESS) {
721 AUDIO_FUNC_LOGE("audio render Flush fail, ret=%{public}d", ret);
722 }
723
724 return ret;
725 }
726
AudioHwiRenderTurnStandbyMode(struct IAudioRender * render)727 int32_t AudioHwiRenderTurnStandbyMode(struct IAudioRender *render)
728 {
729 CHECK_NULL_PTR_RETURN_VALUE(render, HDF_ERR_INVALID_PARAM);
730
731 struct AudioRenderInfo *renderInfo = (struct AudioRenderInfo *)render;
732 struct AudioHwiRender *hwiRender = renderInfo->hwiRender;
733 CHECK_NULL_PTR_RETURN_VALUE(hwiRender, HDF_ERR_INVALID_PARAM);
734 CHECK_NULL_PTR_RETURN_VALUE(hwiRender->control.TurnStandbyMode, HDF_ERR_INVALID_PARAM);
735
736 int32_t ret = hwiRender->control.TurnStandbyMode(hwiRender);
737 if (ret != HDF_SUCCESS) {
738 AUDIO_FUNC_LOGE("audio render TurnStandbyMode fail, ret=%{public}d", ret);
739 }
740
741 return ret;
742 }
743
AudioHwiRenderAudioDevDump(struct IAudioRender * render,int32_t range,int32_t fd)744 int32_t AudioHwiRenderAudioDevDump(struct IAudioRender *render, int32_t range, int32_t fd)
745 {
746 CHECK_NULL_PTR_RETURN_VALUE(render, HDF_ERR_INVALID_PARAM);
747
748 struct AudioRenderInfo *renderInfo = (struct AudioRenderInfo *)render;
749 struct AudioHwiRender *hwiRender = renderInfo->hwiRender;
750 CHECK_NULL_PTR_RETURN_VALUE(hwiRender, HDF_ERR_INVALID_PARAM);
751 CHECK_NULL_PTR_RETURN_VALUE(hwiRender->control.AudioDevDump, HDF_ERR_INVALID_PARAM);
752
753 int32_t ret = hwiRender->control.AudioDevDump(hwiRender, range, fd);
754 if (ret != HDF_SUCCESS) {
755 AUDIO_FUNC_LOGE("audio render AudioDevDump fail, ret=%{public}d", ret);
756 }
757
758 return ret;
759 }
760
AudioHwiRenderIsSupportsPauseAndResume(struct IAudioRender * render,bool * supportPause,bool * supportResume)761 int32_t AudioHwiRenderIsSupportsPauseAndResume(struct IAudioRender *render, bool *supportPause, bool *supportResume)
762 {
763 CHECK_NULL_PTR_RETURN_VALUE(render, HDF_ERR_INVALID_PARAM);
764 CHECK_NULL_PTR_RETURN_VALUE(supportPause, HDF_ERR_INVALID_PARAM);
765 CHECK_NULL_PTR_RETURN_VALUE(supportResume, HDF_ERR_INVALID_PARAM);
766
767 struct AudioRenderInfo *renderInfo = (struct AudioRenderInfo *)render;
768 struct AudioHwiRender *hwiRender = renderInfo->hwiRender;
769 CHECK_NULL_PTR_RETURN_VALUE(hwiRender, HDF_ERR_INVALID_PARAM);
770 CHECK_NULL_PTR_RETURN_VALUE(hwiRender->control.IsSupportsPauseAndResume, HDF_ERR_INVALID_PARAM);
771
772 return hwiRender->control.IsSupportsPauseAndResume(hwiRender, supportPause, supportResume);
773 }
774
AudioHwiInitRenderInstance(struct IAudioRender * render)775 static void AudioHwiInitRenderInstance(struct IAudioRender *render)
776 {
777 render->GetLatency = AudioHwiGetLatency;
778 render->RenderFrame = AudioHwiRenderFrame;
779 render->GetRenderPosition = AudioHwiGetRenderPosition;
780 render->SetRenderSpeed = AudioHwiSetRenderSpeed;
781 render->GetRenderSpeed = AudioHwiGetRenderSpeed;
782 render->SetChannelMode = AudioHwiRenderSetChannelMode;
783 render->GetChannelMode = AudioHwiRenderGetChannelMode;
784 render->DrainBuffer = AudioHwiRenderDrainBuffer;
785 render->IsSupportsDrain = AudioHwiRenderIsSupportsDrain;
786 render->CheckSceneCapability = AudioHwiRenderCheckSceneCapability;
787 render->SelectScene = AudioHwiRenderSelectScene;
788 render->SetMute = AudioHwiRenderSetMute;
789 render->GetMute = AudioHwiRenderGetMute;
790 render->SetVolume = AudioHwiRenderSetVolume;
791 render->GetVolume = AudioHwiRenderGetVolume;
792 render->GetGainThreshold = AudioHwiRenderGetGainThreshold;
793 render->GetGain = AudioHwiRenderGetGain;
794 render->SetGain = AudioHwiRenderSetGain;
795 render->GetFrameSize = AudioHwiRenderGetFrameSize;
796 render->GetFrameCount = AudioHwiRenderGetFrameCount;
797 render->SetSampleAttributes = AudioHwiRenderSetSampleAttributes;
798 render->GetSampleAttributes = AudioHwiRenderGetSampleAttributes;
799 render->GetCurrentChannelId = AudioHwiRenderGetCurrentChannelId;
800 render->SetExtraParams = AudioHwiRenderSetExtraParams;
801 render->GetExtraParams = AudioHwiRenderGetExtraParams;
802 render->ReqMmapBuffer = AudioHwiRenderReqMmapBuffer;
803 render->GetMmapPosition = AudioHwiRenderGetMmapPosition;
804 render->AddAudioEffect = AudioHwiRenderAddAudioEffect;
805 render->RemoveAudioEffect = AudioHwiRenderRemoveAudioEffect;
806 render->GetFrameBufferSize = AudioHwiRenderGetFrameBufferSize;
807 render->Start = AudioHwiRenderStart;
808 render->Stop = AudioHwiRenderStop;
809 render->Pause = AudioHwiRenderPause;
810 render->Resume = AudioHwiRenderResume;
811 render->Flush = AudioHwiRenderFlush;
812 render->TurnStandbyMode = AudioHwiRenderTurnStandbyMode;
813 render->AudioDevDump = AudioHwiRenderAudioDevDump;
814 render->IsSupportsPauseAndResume = AudioHwiRenderIsSupportsPauseAndResume;
815 }
816
FindRenderCreated(enum AudioPortPin pin,const struct AudioSampleAttributes * attrs,uint32_t * rendrId)817 struct IAudioRender *FindRenderCreated(enum AudioPortPin pin, const struct AudioSampleAttributes *attrs,
818 uint32_t *rendrId)
819 {
820 uint32_t index = 0;
821 struct AudioHwiRenderPriv *renderPriv = AudioHwiRenderGetPriv();
822 if (renderPriv == NULL) {
823 AUDIO_FUNC_LOGE("Parameter error!");
824 return NULL;
825 }
826
827 if (renderPriv->renderCnt == 0) {
828 AUDIO_FUNC_LOGI("no render created");
829 return NULL;
830 }
831
832 for (index = 0; index < AUDIO_HW_STREAM_NUM_MAX; index++) {
833 if ((renderPriv->renderInfos[index] != NULL) &&
834 (renderPriv->renderInfos[index]->desc.pins == pin) &&
835 (renderPriv->renderInfos[index]->streamType == attrs->type) &&
836 (renderPriv->renderInfos[index]->sampleRate == attrs->sampleRate) &&
837 (renderPriv->renderInfos[index]->channelCount == attrs->channelCount)) {
838 *rendrId = renderPriv->renderInfos[index]->renderId;
839 renderPriv->renderInfos[index]->usrCount++;
840 return &renderPriv->renderInfos[index]->render;
841 }
842 }
843
844 return NULL;
845 }
846
GetAvailableRenderId(struct AudioHwiRenderPriv * renderPriv)847 static uint32_t GetAvailableRenderId(struct AudioHwiRenderPriv *renderPriv)
848 {
849 uint32_t renderId = AUDIO_HW_STREAM_NUM_MAX;
850 uint32_t index = 0;
851 if (renderPriv == NULL) {
852 AUDIO_FUNC_LOGE("Parameter error!");
853 return renderId;
854 }
855
856 if (renderPriv->renderCnt < AUDIO_HW_STREAM_NUM_MAX) {
857 renderId = renderPriv->renderCnt;
858 renderPriv->renderCnt++;
859 } else {
860 for (index = 0; index < AUDIO_HW_STREAM_NUM_MAX; index++) {
861 if (renderPriv->renderInfos[index] == NULL) {
862 renderId = index;
863 break;
864 }
865 }
866 }
867
868 return renderId;
869 }
870
AudioHwiCreateRenderById(const struct AudioSampleAttributes * attrs,uint32_t * renderId,struct AudioHwiRender * hwiRender,const struct AudioDeviceDescriptor * desc)871 struct IAudioRender *AudioHwiCreateRenderById(const struct AudioSampleAttributes *attrs, uint32_t *renderId,
872 struct AudioHwiRender *hwiRender, const struct AudioDeviceDescriptor *desc)
873 {
874 struct IAudioRender *render = NULL;
875 if (attrs == NULL || renderId == NULL || hwiRender == NULL || desc == NULL) {
876 AUDIO_FUNC_LOGE("audio render is null");
877 return NULL;
878 }
879
880 *renderId = AUDIO_HW_STREAM_NUM_MAX;
881 struct AudioHwiRenderPriv *priv = AudioHwiRenderGetPriv();
882
883 *renderId = GetAvailableRenderId(priv);
884 if (*renderId >= AUDIO_HW_STREAM_NUM_MAX) {
885 AUDIO_FUNC_LOGE("audio hwiRender create render index fail, renderId=%{public}d", *renderId);
886 return NULL;
887 }
888
889 priv->renderInfos[*renderId] = (struct AudioRenderInfo *)OsalMemCalloc(sizeof(struct AudioRenderInfo));
890 if (priv->renderInfos[*renderId] == NULL) {
891 AUDIO_FUNC_LOGE("audio HwiRender malloc renderInfos fail");
892 return NULL;
893 }
894
895 priv->renderInfos[*renderId]->hwiRender = hwiRender;
896 priv->renderInfos[*renderId]->streamType = attrs->type;
897 priv->renderInfos[*renderId]->sampleRate = attrs->sampleRate;
898 priv->renderInfos[*renderId]->channelCount = attrs->channelCount;
899 priv->renderInfos[*renderId]->desc.portId = desc->portId;
900 priv->renderInfos[*renderId]->desc.pins = desc->pins;
901 priv->renderInfos[*renderId]->desc.desc = strdup(desc->desc);
902 priv->renderInfos[*renderId]->renderId = *renderId;
903 priv->renderInfos[*renderId]->usrCount = 1;
904 render = &(priv->renderInfos[*renderId]->render);
905 AudioHwiInitRenderInstance(render);
906
907 AUDIO_FUNC_LOGI("audio create render success");
908 return render;
909 }
910
DecreaseRenderUsrCount(uint32_t renderId)911 uint32_t DecreaseRenderUsrCount(uint32_t renderId)
912 {
913 uint32_t usrCnt = 0;
914 if (renderId >= AUDIO_HW_STREAM_NUM_MAX) {
915 AUDIO_FUNC_LOGE("audio check render index fail, descIndex=%{public}d", renderId);
916 return usrCnt;
917 }
918 struct AudioHwiRenderPriv *priv = AudioHwiRenderGetPriv();
919 if (priv->renderInfos[renderId] == NULL) {
920 AUDIO_FUNC_LOGE("audio check render index fail, descIndex=%{public}d", renderId);
921 return usrCnt;
922 }
923
924 priv->renderInfos[renderId]->usrCount--;
925 usrCnt = priv->renderInfos[renderId]->usrCount;
926 return usrCnt;
927 }
928
AudioHwiDestroyRenderById(uint32_t renderId)929 void AudioHwiDestroyRenderById(uint32_t renderId)
930 {
931 if (renderId >= AUDIO_HW_STREAM_NUM_MAX) {
932 AUDIO_FUNC_LOGE("audio hwiRender destroy render index fail, descIndex=%{public}d", renderId);
933 return;
934 }
935 struct AudioHwiRenderPriv *priv = AudioHwiRenderGetPriv();
936 if (priv->renderInfos[renderId] == NULL) {
937 AUDIO_FUNC_LOGE("audio hwiRender destroy render index fail, descIndex=%{public}d", renderId);
938 return;
939 }
940
941 OsalMemFree((void *)priv->renderInfos[renderId]->desc.desc);
942 priv->renderInfos[renderId]->hwiRender = NULL;
943 priv->renderInfos[renderId]->desc.desc = NULL;
944 priv->renderInfos[renderId]->desc.portId = UINT_MAX;
945 priv->renderInfos[renderId]->desc.pins = PIN_NONE;
946
947 OsalMemFree(priv->renderInfos[renderId]);
948 priv->renderInfos[renderId] = NULL;
949 }
950