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 #include "audio_common_vdi.h"
16 
17 #include "osal_mem.h"
18 #include "securec.h"
19 #include <hdf_base.h>
20 #include "audio_uhdf_log.h"
21 
22 #define HDF_LOG_TAG    HDF_AUDIO_PRIMARY_IMPL
23 #define AUDIO_FORMAT_NUM_MAX 15
24 #define AUDIO_ROUTE_NUM_MAX 2
25 #define AUDIO_SAMPLE_FORMAT_NUM_MAX 30
26 #define AUDIO_SUB_PORT_NUM_MAX 10
27 #define AUDIO_FRAME_LEN_MAX (100 * 1024 * 1024)
28 
AudioCommonDevDescToVdiDevDescVdi(const struct AudioDeviceDescriptor *desc, struct AudioDeviceDescriptorVdi *vdiDesc)29 int32_t AudioCommonDevDescToVdiDevDescVdi(const struct AudioDeviceDescriptor *desc,
30     struct AudioDeviceDescriptorVdi *vdiDesc)
31 {
32     CHECK_NULL_PTR_RETURN_VALUE(desc, HDF_FAILURE);
33     CHECK_NULL_PTR_RETURN_VALUE(vdiDesc, HDF_FAILURE);
34 
35     vdiDesc->portId = desc->portId;
36     vdiDesc->pins = (enum AudioPortPinVdi)desc->pins;
37     vdiDesc->desc = strdup(desc->desc); // free by caller
38     if (vdiDesc->desc == NULL) {
39         AUDIO_FUNC_LOGE("strdup fail, desc->desc = %{public}s", desc->desc);
40         return HDF_FAILURE;
41     }
42     return HDF_SUCCESS;
43 }
44 
AudioCommonAttrsToVdiAttrsVdi(const struct AudioSampleAttributes *attrs, struct AudioSampleAttributesVdi *vdiAttrs)45 void AudioCommonAttrsToVdiAttrsVdi(const struct AudioSampleAttributes *attrs, struct AudioSampleAttributesVdi *vdiAttrs)
46 {
47     CHECK_NULL_PTR_RETURN(attrs);
48     CHECK_NULL_PTR_RETURN(vdiAttrs);
49     AUDIO_FUNC_LOGI("render or capture type is %{public}d", attrs->type);
50     vdiAttrs->type = (enum AudioCategoryVdi)attrs->type;
51     vdiAttrs->interleaved = attrs->interleaved;
52     vdiAttrs->format = (enum AudioFormatVdi)attrs->format;
53     vdiAttrs->sampleRate = attrs->sampleRate;
54     vdiAttrs->channelCount = attrs->channelCount;
55     vdiAttrs->channelLayout = attrs->channelLayout;
56     vdiAttrs->period = attrs->period;
57     vdiAttrs->frameSize = attrs->frameSize;
58     vdiAttrs->isBigEndian = attrs->isBigEndian;
59     vdiAttrs->isSignedData = attrs->isSignedData;
60     vdiAttrs->startThreshold = attrs->startThreshold;
61     vdiAttrs->stopThreshold = attrs->stopThreshold;
62     vdiAttrs->silenceThreshold = attrs->silenceThreshold;
63     vdiAttrs->streamId = attrs->streamId;
64     vdiAttrs->sourceType = attrs->sourceType;
65     if (vdiAttrs->type == AUDIO_VDI_OFFLOAD) {
66         vdiAttrs->offloadInfo.sampleRate = attrs->offloadInfo.sampleRate;
67         vdiAttrs->offloadInfo.channelCount = attrs->offloadInfo.channelCount;
68         vdiAttrs->offloadInfo.channelLayout = attrs->offloadInfo.channelLayout;
69         vdiAttrs->offloadInfo.bitRate = attrs->offloadInfo.bitRate;
70         vdiAttrs->offloadInfo.bitWidth = attrs->offloadInfo.bitWidth;
71         vdiAttrs->offloadInfo.format = (enum AudioFormatVdi)attrs->offloadInfo.format;
72         vdiAttrs->offloadInfo.offloadBufferSize = attrs->offloadInfo.offloadBufferSize;
73         vdiAttrs->offloadInfo.duration = attrs->offloadInfo.duration;
74     }
75     vdiAttrs->ecSampleAttributes.ecInterleaved = attrs->ecSampleAttributes.ecInterleaved;
76     vdiAttrs->ecSampleAttributes.ecFormat = (enum AudioFormatVdi)attrs->ecSampleAttributes.ecFormat;
77     vdiAttrs->ecSampleAttributes.ecSampleRate = attrs->ecSampleAttributes.ecSampleRate;
78     vdiAttrs->ecSampleAttributes.ecChannelCount = attrs->ecSampleAttributes.ecChannelCount;
79     vdiAttrs->ecSampleAttributes.ecChannelLayout = attrs->ecSampleAttributes.ecChannelLayout;
80     vdiAttrs->ecSampleAttributes.ecPeriod = attrs->ecSampleAttributes.ecPeriod;
81     vdiAttrs->ecSampleAttributes.ecFrameSize = attrs->ecSampleAttributes.ecFrameSize;
82     vdiAttrs->ecSampleAttributes.ecIsBigEndian = attrs->ecSampleAttributes.ecIsBigEndian;
83     vdiAttrs->ecSampleAttributes.ecIsSignedData = attrs->ecSampleAttributes.ecIsSignedData;
84     vdiAttrs->ecSampleAttributes.ecStartThreshold = attrs->ecSampleAttributes.ecStartThreshold;
85     vdiAttrs->ecSampleAttributes.ecStopThreshold = attrs->ecSampleAttributes.ecStopThreshold;
86     vdiAttrs->ecSampleAttributes.ecSilenceThreshold = attrs->ecSampleAttributes.ecSilenceThreshold;
87 }
88 
AudioCommonPortToVdiPortVdi(const struct AudioPort *port, struct AudioPortVdi *vdiPort)89 int32_t AudioCommonPortToVdiPortVdi(const struct AudioPort *port, struct AudioPortVdi *vdiPort)
90 {
91     CHECK_NULL_PTR_RETURN_VALUE(vdiPort, HDF_ERR_INVALID_PARAM);
92     CHECK_NULL_PTR_RETURN_VALUE(port, HDF_ERR_INVALID_PARAM);
93 
94     vdiPort->dir = (enum AudioPortDirectionVdi)port->dir;
95     vdiPort->portId = port->portId;
96     vdiPort->portName = strdup(port->portName); // free by caller
97     if (vdiPort->portName == NULL) {
98         AUDIO_FUNC_LOGE("strdup fail, port->portName = %{public}s", port->portName);
99         return HDF_FAILURE;
100     }
101 
102     return HDF_SUCCESS;
103 }
104 
AudioFormatsToFormatsVdi(const enum AudioFormatVdi *vdiFormats, uint32_t vdiFormatNum, enum AudioFormat **formats, uint32_t *formatsLen)105 static int32_t AudioFormatsToFormatsVdi(const enum AudioFormatVdi *vdiFormats, uint32_t vdiFormatNum,
106     enum AudioFormat **formats, uint32_t *formatsLen)
107 {
108     CHECK_NULL_PTR_RETURN_VALUE(vdiFormats, HDF_ERR_INVALID_PARAM);
109     CHECK_NULL_PTR_RETURN_VALUE(formats, HDF_ERR_INVALID_PARAM);
110     CHECK_NULL_PTR_RETURN_VALUE(formatsLen, HDF_ERR_INVALID_PARAM);
111 
112     if (vdiFormatNum >= AUDIO_FORMAT_NUM_MAX || vdiFormatNum == 0) {
113         AUDIO_FUNC_LOGE("VdiFormats to formats len fail");
114         return HDF_ERR_INVALID_PARAM;
115     }
116 
117     uint32_t size = vdiFormatNum * sizeof(enum AudioFormat);
118     enum AudioFormat *formatTmp = (enum AudioFormat *)OsalMemCalloc(size);  // free by caller
119     if (formatTmp == NULL) {
120         AUDIO_FUNC_LOGE("formatTmp malloc fail");
121         return HDF_ERR_MALLOC_FAIL;
122     }
123 
124     int32_t ret = memcpy_s((void*)formatTmp, size, (void*)vdiFormats, vdiFormatNum * sizeof(enum AudioFormatVdi));
125     if (ret != HDF_SUCCESS) {
126         OsalMemFree((void *)formatTmp);
127         AUDIO_FUNC_LOGE("format cpy fail=%{public}d", ret);
128         return HDF_FAILURE;
129     }
130 
131     *formats = formatTmp;
132     *formatsLen = size;
133     return HDF_SUCCESS;
134 }
135 
AudioReleaseSubPortsVdi(struct AudioSubPortCapability **subPorts, uint32_t *subPortsLen)136 static void AudioReleaseSubPortsVdi(struct AudioSubPortCapability **subPorts, uint32_t *subPortsLen)
137 {
138     struct AudioSubPortCapability *subPortsTmp = NULL;
139 
140     CHECK_NULL_PTR_RETURN(subPorts);
141     CHECK_NULL_PTR_RETURN(subPortsLen);
142 
143     uint32_t subPortsNum = *subPortsLen / sizeof(struct AudioSubPortCapability);
144     if (subPortsNum >= AUDIO_SUB_PORT_NUM_MAX) {
145         AUDIO_FUNC_LOGE("AudioReleaseSubPortsVdi len fail");
146         return;
147     }
148 
149     subPortsTmp = *subPorts;
150     for (uint32_t i = 0; i < subPortsNum; i++) {
151         OsalMemFree((void *)subPortsTmp[i].desc);
152     }
153 
154     OsalMemFree((void *)subPortsTmp);
155     subPortsTmp = NULL;
156 }
157 
AudioSubPortsToSubPortsVdi(const struct AudioSubPortCapabilityVdi *vdiSubPorts, uint32_t vdiSubPortsNum, struct AudioSubPortCapability **subPorts, uint32_t *subPortsLen)158 static int32_t AudioSubPortsToSubPortsVdi(const struct AudioSubPortCapabilityVdi *vdiSubPorts, uint32_t vdiSubPortsNum,
159     struct AudioSubPortCapability **subPorts, uint32_t *subPortsLen)
160 {
161     CHECK_NULL_PTR_RETURN_VALUE(vdiSubPorts, HDF_ERR_INVALID_PARAM);
162     CHECK_NULL_PTR_RETURN_VALUE(subPorts, HDF_ERR_INVALID_PARAM);
163     CHECK_NULL_PTR_RETURN_VALUE(subPortsLen, HDF_ERR_INVALID_PARAM);
164 
165     if (vdiSubPortsNum >= AUDIO_SUB_PORT_NUM_MAX || vdiSubPortsNum == 0) {
166         AUDIO_FUNC_LOGE("VdiSubPorts to subPorts len fail");
167         return HDF_ERR_INVALID_PARAM;
168     }
169 
170     uint32_t size = vdiSubPortsNum * sizeof(struct AudioSubPortCapability);
171     struct AudioSubPortCapability *subPortsTmp = (struct AudioSubPortCapability *)OsalMemCalloc(size);
172     if (subPortsTmp == NULL) {
173         AUDIO_FUNC_LOGE("subPortsTmp malloc fail");
174         return HDF_ERR_MALLOC_FAIL;
175     }
176 
177     for (uint32_t i = 0; i < vdiSubPortsNum; i++) {
178         subPortsTmp[i].portId = vdiSubPorts[i].portId;
179         subPortsTmp[i].mask = (enum AudioPortPassthroughMode)vdiSubPorts[i].mask;
180         subPortsTmp[i].desc = strdup(vdiSubPorts[i].desc);
181         if (subPortsTmp[i].desc == NULL) {
182             *subPorts = subPortsTmp;
183             *subPortsLen = size;
184             AUDIO_FUNC_LOGE("strdup fail, vdiSubPorts[%{public}d].desc = %{public}s", i, vdiSubPorts[i].desc);
185             return HDF_FAILURE;
186         }
187     }
188 
189     *subPorts = subPortsTmp;
190     *subPortsLen = size;
191     return HDF_SUCCESS;
192 }
193 
AudioSampleFormatToSampleFormatsVdi(const enum AudioSampleFormatVdi *vdiSampleFormat, uint32_t vdiSupportSampleFormatNum, enum AudioSampleFormat **sampleFormat, uint32_t *sampleFormatsLen)194 static int32_t AudioSampleFormatToSampleFormatsVdi(const enum AudioSampleFormatVdi *vdiSampleFormat,
195     uint32_t vdiSupportSampleFormatNum, enum AudioSampleFormat **sampleFormat, uint32_t *sampleFormatsLen)
196 {
197     CHECK_NULL_PTR_RETURN_VALUE(vdiSampleFormat, HDF_ERR_INVALID_PARAM);
198     CHECK_NULL_PTR_RETURN_VALUE(sampleFormat, HDF_ERR_INVALID_PARAM);
199     CHECK_NULL_PTR_RETURN_VALUE(sampleFormatsLen, HDF_ERR_INVALID_PARAM);
200 
201     if (vdiSupportSampleFormatNum >= AUDIO_SAMPLE_FORMAT_NUM_MAX || vdiSupportSampleFormatNum == 0) {
202         AUDIO_FUNC_LOGE("vdiSampleFormat to sampleFormats len fail");
203         return HDF_ERR_INVALID_PARAM;
204     }
205 
206     uint32_t size = vdiSupportSampleFormatNum * sizeof(enum AudioSampleFormat);
207     enum AudioSampleFormat *sampleFormatTmp = (enum AudioSampleFormat *)OsalMemCalloc(size);
208     if (sampleFormatTmp == NULL) {
209         AUDIO_FUNC_LOGE("sampleFormatTmp malloc fail");
210         return HDF_ERR_MALLOC_FAIL;
211     }
212 
213     int32_t ret = memcpy_s((void *)sampleFormatTmp, size, (void*)vdiSampleFormat,
214         vdiSupportSampleFormatNum * sizeof(enum AudioSampleFormatVdi));
215     if (ret != HDF_SUCCESS) {
216         OsalMemFree((void *)sampleFormatTmp);
217         AUDIO_FUNC_LOGE("sampleFormatTmp cpy fail=%{public}d", ret);
218         return HDF_FAILURE;
219     }
220 
221     *sampleFormat = sampleFormatTmp;
222     *sampleFormatsLen = size;
223     return HDF_SUCCESS;
224 }
225 
AudioCommonVdiPortCapToPortCapVdi(const struct AudioPortCapabilityVdi *vdiPortCap, struct AudioPortCapability *portCap)226 void AudioCommonVdiPortCapToPortCapVdi(const struct AudioPortCapabilityVdi *vdiPortCap,
227     struct AudioPortCapability *portCap)
228 {
229     CHECK_NULL_PTR_RETURN(portCap);
230     CHECK_NULL_PTR_RETURN(vdiPortCap);
231 
232     portCap->deviceType = vdiPortCap->deviceType;
233     portCap->deviceId = vdiPortCap->deviceId;
234     portCap->hardwareMode = vdiPortCap->hardwareMode;
235     portCap->sampleRateMasks = vdiPortCap->sampleRateMasks;
236     portCap->channelMasks = (enum AudioChannelMask)vdiPortCap->channelMasks;
237     portCap->channelCount = vdiPortCap->channelCount;
238 
239     int32_t ret = AudioFormatsToFormatsVdi(vdiPortCap->formats, vdiPortCap->formatNum, &portCap->formats,
240         &portCap->formatsLen);
241     if (ret != HDF_SUCCESS) {
242         AUDIO_FUNC_LOGE("AudioFormatsToFormatsVdi fail");
243         return;
244     }
245 
246     ret = AudioSubPortsToSubPortsVdi(vdiPortCap->subPorts, vdiPortCap->subPortsLen,
247         &portCap->subPorts, &portCap->subPortsLen);
248     if (ret != HDF_SUCCESS) {
249         OsalMemFree((void *)portCap->formats);
250         AudioReleaseSubPortsVdi(&portCap->subPorts, &portCap->subPortsLen);
251         portCap->formats = NULL;
252         AUDIO_FUNC_LOGE("VdiSubPortsToSubPorts fail");
253         return;
254     }
255 
256     ret = AudioSampleFormatToSampleFormatsVdi(vdiPortCap->supportSampleFormats, vdiPortCap->supportSampleFormatsLen,
257         &portCap->supportSampleFormats, &portCap->supportSampleFormatsLen);
258     if (ret != HDF_SUCCESS) {
259         OsalMemFree((void *)portCap->formats);
260         AudioReleaseSubPortsVdi(&portCap->subPorts, &portCap->subPortsLen);
261         portCap->formats = NULL;
262         AUDIO_FUNC_LOGE("VdiSampleFormatToSampleFormats fail");
263         return;
264     }
265 }
266 
AudioCommonFreeVdiRouteVdi(struct AudioRouteVdi *vdiRoute)267 void AudioCommonFreeVdiRouteVdi(struct AudioRouteVdi *vdiRoute)
268 {
269     CHECK_NULL_PTR_RETURN(vdiRoute);
270 
271     if (vdiRoute->sinks != NULL) {
272         if (vdiRoute->sinksLen > AUDIO_ROUTE_NUM_MAX) {
273             AUDIO_FUNC_LOGE("sinksLen para error");
274             return;
275         }
276 
277         for (uint32_t i = 0; i < vdiRoute->sinksLen; i++) {
278             if (vdiRoute->sinks[i].type == AUDIO_VDI_PORT_DEVICE_TYPE) {
279                 OsalMemFree((void *)vdiRoute->sinks[i].ext.device.desc);
280             }
281         }
282         OsalMemFree((void *)vdiRoute->sinks);
283     }
284 
285     if (vdiRoute->sources != NULL) {
286         if (vdiRoute->sourcesLen > AUDIO_ROUTE_NUM_MAX) {
287             AUDIO_FUNC_LOGE("sourcesLen para error");
288             return;
289         }
290 
291         for (uint32_t i = 0; i < vdiRoute->sourcesLen; i++) {
292             if (vdiRoute->sources[i].type == AUDIO_VDI_PORT_DEVICE_TYPE) {
293                 OsalMemFree((void *)vdiRoute->sources[i].ext.device.desc);
294             }
295         }
296         OsalMemFree((void *)vdiRoute->sources);
297     }
298 }
299 
AudioCommonRouteNodeToVdiRouteNodeVdi(struct AudioRouteNode *routeNode, struct AudioRouteNodeVdi *vdiRouteNode)300 static int32_t AudioCommonRouteNodeToVdiRouteNodeVdi(struct AudioRouteNode *routeNode,
301     struct AudioRouteNodeVdi *vdiRouteNode)
302 {
303     vdiRouteNode->portId = routeNode->portId;
304     vdiRouteNode->role = (enum AudioPortRoleVdi)routeNode->role;
305     vdiRouteNode->type = (enum AudioPortTypeVdi)routeNode->type;
306 
307     if (routeNode->type == AUDIO_VDI_PORT_DEVICE_TYPE) {
308         vdiRouteNode->ext.device.moduleId = routeNode->ext.device.moduleId;
309         vdiRouteNode->ext.device.type = (enum AudioPortPinVdi)routeNode->ext.device.type;
310         vdiRouteNode->ext.device.desc = strdup(routeNode->ext.device.desc);
311         if (vdiRouteNode->ext.device.desc == NULL) {
312             AUDIO_FUNC_LOGE("strdup fail, routeNode->ext.device.desc = %{public}s", routeNode->ext.device.desc);
313             return HDF_FAILURE;
314         }
315         return HDF_SUCCESS;
316     }
317 
318     if (routeNode->type == AUDIO_VDI_PORT_MIX_TYPE) {
319         vdiRouteNode->ext.mix.moduleId = routeNode->ext.mix.moduleId;
320         vdiRouteNode->ext.mix.streamId = routeNode->ext.mix.streamId;
321         vdiRouteNode->ext.mix.source = routeNode->ext.mix.source;
322         return HDF_SUCCESS;
323     }
324 
325     if (routeNode->type == AUDIO_VDI_PORT_SESSION_TYPE) {
326         vdiRouteNode->ext.session.sessionType = (enum AudioSessionTypeVdi)routeNode->ext.session.sessionType;
327         return HDF_SUCCESS;
328     }
329 
330     AUDIO_FUNC_LOGE("not match route node type");
331     return HDF_FAILURE;
332 }
333 
AudioCommonSinkToVdiSinkVdi(const struct AudioRoute *route, struct AudioRouteVdi *vdiRoute)334 static int32_t AudioCommonSinkToVdiSinkVdi(const struct AudioRoute *route, struct AudioRouteVdi *vdiRoute)
335 {
336     struct AudioRouteNodeVdi *nodes = NULL;
337     if (route->sinksLen > AUDIO_ROUTE_NUM_MAX) {
338         AUDIO_FUNC_LOGE("sinksLen para err");
339         return HDF_ERR_INVALID_PARAM;
340     }
341 
342     nodes = (struct AudioRouteNodeVdi *)OsalMemCalloc(route->sinksLen * sizeof(struct AudioRouteNodeVdi));
343     if (nodes == NULL) {
344         AUDIO_FUNC_LOGE("nodes null");
345         return HDF_ERR_MALLOC_FAIL;
346     }
347     vdiRoute->sinks = nodes;
348     vdiRoute->sinksLen = route->sinksLen;
349 
350     for (uint32_t i = 0; i < vdiRoute->sinksLen; i++) {
351         int32_t ret = AudioCommonRouteNodeToVdiRouteNodeVdi(&route->sinks[i], &vdiRoute->sinks[i]);
352         if (ret != HDF_SUCCESS) {
353             AUDIO_FUNC_LOGE("sink routeNode to vdiRouteNode fail");
354             /* nodes release by AudioCommonFreeVdiRouteVdi */
355             return HDF_FAILURE;
356         }
357     }
358 
359     return HDF_SUCCESS;
360 }
361 
AudioCommonSourceToVdiSourceVdi(const struct AudioRoute *route, struct AudioRouteVdi *vdiRoute)362 static int32_t AudioCommonSourceToVdiSourceVdi(const struct AudioRoute *route, struct AudioRouteVdi *vdiRoute)
363 {
364     struct AudioRouteNodeVdi *nodes = NULL;
365     if (route->sourcesLen > AUDIO_ROUTE_NUM_MAX) {
366         AUDIO_FUNC_LOGE("sinksLen para err");
367         return HDF_ERR_INVALID_PARAM;
368     }
369 
370     nodes = (struct AudioRouteNodeVdi *)OsalMemCalloc(route->sourcesLen * sizeof(struct AudioRouteNodeVdi));
371     if (nodes == NULL) {
372         AUDIO_FUNC_LOGE("nodes null");
373         return HDF_ERR_MALLOC_FAIL;
374     }
375     vdiRoute->sources = nodes;
376     vdiRoute->sourcesLen = route->sourcesLen;
377 
378     for (uint32_t i = 0; i < vdiRoute->sourcesLen; i++) {
379         int32_t ret = AudioCommonRouteNodeToVdiRouteNodeVdi(&route->sources[i], &vdiRoute->sources[i]);
380         if (ret != HDF_SUCCESS) {
381             AUDIO_FUNC_LOGE(" source routeNode to vdiRouteNode fail");
382             /* nodes release by AudioCommonFreeVdiRouteVdi */
383             return HDF_FAILURE;
384         }
385     }
386 
387     return HDF_SUCCESS;
388 }
389 
AudioCommonRouteToVdiRouteVdi(const struct AudioRoute *route, struct AudioRouteVdi *vdiRoute)390 int32_t AudioCommonRouteToVdiRouteVdi(const struct AudioRoute *route, struct AudioRouteVdi *vdiRoute)
391 {
392     int32_t sinkRet = HDF_SUCCESS;
393     int32_t sourcesRet = HDF_SUCCESS;
394 
395     CHECK_NULL_PTR_RETURN_VALUE(route, HDF_ERR_INVALID_PARAM);
396     CHECK_NULL_PTR_RETURN_VALUE(vdiRoute, HDF_ERR_INVALID_PARAM);
397 
398     if (route->sinks != NULL && route->sinksLen > 0) {
399         sinkRet = AudioCommonSinkToVdiSinkVdi(route, vdiRoute);
400         if (sinkRet != HDF_SUCCESS) {
401             AUDIO_FUNC_LOGE(" sink routeNode to vdiRouteNode fail");
402         }
403     }
404 
405     if (route->sources != NULL && route->sourcesLen > 0) {
406         sourcesRet = AudioCommonSourceToVdiSourceVdi(route, vdiRoute);
407         if (sourcesRet != HDF_SUCCESS) {
408             AUDIO_FUNC_LOGE(" source routeNode to vdiRouteNode fail");
409             return HDF_FAILURE;
410         }
411     }
412 
413     if (sinkRet != HDF_SUCCESS || sourcesRet != HDF_SUCCESS) {
414         /* free nodes by sink and source malloc nodes memory */
415         AudioCommonFreeVdiRouteVdi(vdiRoute);
416         return HDF_FAILURE;
417     }
418 
419     return HDF_SUCCESS;
420 }
421 
AudioCommonSceneToVdiSceneVdi(const struct AudioSceneDescriptor *scene, struct AudioSceneDescriptorVdi *vdiScene)422 int32_t AudioCommonSceneToVdiSceneVdi(const struct AudioSceneDescriptor *scene,
423     struct AudioSceneDescriptorVdi *vdiScene)
424 {
425     CHECK_NULL_PTR_RETURN_VALUE(scene, HDF_ERR_INVALID_PARAM);
426     CHECK_NULL_PTR_RETURN_VALUE(vdiScene, HDF_ERR_INVALID_PARAM);
427 
428     vdiScene->scene.id = scene->scene.id;
429     return AudioCommonDevDescToVdiDevDescVdi(&scene->desc, &vdiScene->desc);
430 }
431 
AudioCommonSampleAttrToVdiSampleAttrVdi(const struct AudioSampleAttributes *attrs, struct AudioSampleAttributesVdi *vdiAttrs)432 int32_t AudioCommonSampleAttrToVdiSampleAttrVdi(const struct AudioSampleAttributes *attrs,
433     struct AudioSampleAttributesVdi *vdiAttrs)
434 {
435     CHECK_NULL_PTR_RETURN_VALUE(attrs, HDF_ERR_INVALID_PARAM);
436     CHECK_NULL_PTR_RETURN_VALUE(vdiAttrs, HDF_ERR_INVALID_PARAM);
437 
438     vdiAttrs->type = (enum AudioCategoryVdi)attrs->type;
439     vdiAttrs->interleaved = attrs->interleaved;
440     vdiAttrs->format = (enum AudioFormatVdi)attrs->format;
441     vdiAttrs->sampleRate = attrs->sampleRate;
442     vdiAttrs->channelCount = attrs->channelCount;
443     vdiAttrs->channelLayout = attrs->channelLayout;
444     vdiAttrs->period = attrs->period;
445     vdiAttrs->frameSize = attrs->frameSize;
446     vdiAttrs->isBigEndian = attrs->isBigEndian;
447     vdiAttrs->isSignedData = attrs->isSignedData;
448     vdiAttrs->startThreshold = attrs->startThreshold;
449     vdiAttrs->stopThreshold = attrs->stopThreshold;
450     vdiAttrs->silenceThreshold = attrs->silenceThreshold;
451     vdiAttrs->streamId = attrs->streamId;
452     vdiAttrs->sourceType = attrs->sourceType;
453     if (vdiAttrs->type == AUDIO_VDI_OFFLOAD) {
454         vdiAttrs->offloadInfo.sampleRate = attrs->offloadInfo.sampleRate;
455         vdiAttrs->offloadInfo.channelCount = attrs->offloadInfo.channelCount;
456         vdiAttrs->offloadInfo.channelLayout = attrs->offloadInfo.channelLayout;
457         vdiAttrs->offloadInfo.bitRate = attrs->offloadInfo.bitRate;
458         vdiAttrs->offloadInfo.bitWidth = attrs->offloadInfo.bitWidth;
459         vdiAttrs->offloadInfo.format = (enum AudioFormatVdi)attrs->offloadInfo.format;
460         vdiAttrs->offloadInfo.offloadBufferSize = attrs->offloadInfo.offloadBufferSize;
461         vdiAttrs->offloadInfo.duration = attrs->offloadInfo.duration;
462     }
463     return HDF_SUCCESS;
464 }
465 
AudioCommonVdiSampleAttrToSampleAttrVdi(const struct AudioSampleAttributesVdi *vdiAttrs, struct AudioSampleAttributes *attrs)466 int32_t AudioCommonVdiSampleAttrToSampleAttrVdi(const struct AudioSampleAttributesVdi *vdiAttrs,
467     struct AudioSampleAttributes *attrs)
468 {
469     CHECK_NULL_PTR_RETURN_VALUE(attrs, HDF_ERR_INVALID_PARAM);
470     CHECK_NULL_PTR_RETURN_VALUE(vdiAttrs, HDF_ERR_INVALID_PARAM);
471 
472     attrs->type = (enum AudioCategory)vdiAttrs->type;
473     attrs->interleaved = vdiAttrs->interleaved;
474     attrs->format = (enum AudioFormat)vdiAttrs->format;
475     attrs->sampleRate = vdiAttrs->sampleRate;
476     attrs->channelCount = vdiAttrs->channelCount;
477     attrs->period = vdiAttrs->period;
478     attrs->frameSize = vdiAttrs->frameSize;
479     attrs->isBigEndian = vdiAttrs->isBigEndian;
480     attrs->isSignedData = vdiAttrs->isSignedData;
481     attrs->startThreshold = vdiAttrs->startThreshold;
482     attrs->stopThreshold = vdiAttrs->stopThreshold;
483     attrs->silenceThreshold = vdiAttrs->silenceThreshold;
484     attrs->streamId = vdiAttrs->streamId;
485 
486     return HDF_SUCCESS;
487 }
488 
AudioCommonFrameInfoToVdiFrameInfoVdi(const struct AudioFrameLen *frameLen, struct AudioCaptureFrameInfoVdi *frameInfoVdi)489 int32_t AudioCommonFrameInfoToVdiFrameInfoVdi(const struct AudioFrameLen *frameLen,
490     struct AudioCaptureFrameInfoVdi *frameInfoVdi)
491 {
492     CHECK_NULL_PTR_RETURN_VALUE(frameLen, HDF_ERR_INVALID_PARAM);
493     CHECK_NULL_PTR_RETURN_VALUE(frameInfoVdi, HDF_ERR_INVALID_PARAM);
494 
495     if (frameLen->frameLen <= 0 || frameLen->frameEcLen <= 0) {
496         AUDIO_FUNC_LOGE("frameLen len err");
497         return HDF_ERR_INVALID_PARAM;
498     }
499     frameInfoVdi->frameLen = frameLen->frameLen;
500     frameInfoVdi->frameEcLen = frameLen->frameEcLen;
501     frameInfoVdi->frame = (int8_t*)OsalMemCalloc(sizeof(int8_t) * (frameLen->frameLen));
502     if (frameInfoVdi->frame == NULL) {
503         AUDIO_FUNC_LOGE("frameInfoVdi->frame null");
504         return HDF_ERR_MALLOC_FAIL;
505     }
506     frameInfoVdi->frameEc = (int8_t*)OsalMemCalloc(sizeof(int8_t) * (frameLen->frameEcLen));
507     if (frameInfoVdi->frameEc == NULL) {
508         OsalMemFree((void *)frameInfoVdi->frame);
509         AUDIO_FUNC_LOGE("frameInfoVdi->frameEc null");
510         return HDF_ERR_MALLOC_FAIL;
511     }
512 
513     return HDF_SUCCESS;
514 }
515 
AudioCommonVdiFrameInfoToFrameInfoVdi(struct AudioCaptureFrameInfoVdi *frameInfoVdi, struct AudioCaptureFrameInfo *frameInfo)516 int32_t AudioCommonVdiFrameInfoToFrameInfoVdi(struct AudioCaptureFrameInfoVdi *frameInfoVdi,
517     struct AudioCaptureFrameInfo *frameInfo)
518 {
519     CHECK_NULL_PTR_RETURN_VALUE(frameInfo, HDF_ERR_INVALID_PARAM);
520     CHECK_NULL_PTR_RETURN_VALUE(frameInfoVdi, HDF_ERR_INVALID_PARAM);
521 
522     if (frameInfoVdi->frameLen <= 0 || frameInfoVdi->frameEcLen <= 0 ||
523         frameInfoVdi->frameLen > AUDIO_FRAME_LEN_MAX || frameInfoVdi->frameEcLen > AUDIO_FRAME_LEN_MAX) {
524         AUDIO_FUNC_LOGE("frameLen len err");
525         return HDF_ERR_INVALID_PARAM;
526     }
527     frameInfo->frameLen = frameInfoVdi->frameLen;
528     frameInfo->frameEcLen = frameInfoVdi->frameEcLen;
529     frameInfo->frame = (int8_t*)OsalMemCalloc(sizeof(int8_t) * (frameInfo->frameLen));
530     if (frameInfo->frame == NULL) {
531         frameInfo->frameLen = 0;
532         AUDIO_FUNC_LOGE("frameInfo->frame null");
533         return HDF_ERR_MALLOC_FAIL;
534     }
535     int32_t ret = memcpy_s(frameInfo->frame, (size_t)frameInfo->frameLen, frameInfoVdi->frame,
536         (size_t)frameInfoVdi->frameLen);
537     if (ret != HDF_SUCCESS) {
538         AUDIO_FUNC_LOGE("memcpy_s frame fail");
539         return HDF_FAILURE;
540     }
541 
542     frameInfo->frameEc = (int8_t*)OsalMemCalloc(sizeof(int8_t) * (frameInfo->frameEcLen));
543     if (frameInfo->frameEc == NULL) {
544         frameInfo->frameLen = 0;
545         frameInfo->frameEcLen = 0;
546         OsalMemFree((void *)frameInfo->frame);
547         AUDIO_FUNC_LOGE("frameInfo->frameEc null");
548         return HDF_ERR_MALLOC_FAIL;
549     }
550     ret = memcpy_s(frameInfo->frameEc, (size_t)frameInfo->frameEcLen, frameInfoVdi->frameEc,
551         (size_t)frameInfoVdi->frameEcLen);
552     if (ret != HDF_SUCCESS) {
553         AUDIO_FUNC_LOGE("memcpy_s frameEc fail");
554         return HDF_FAILURE;
555     }
556     frameInfo->replyBytes = frameInfoVdi->replyBytes;
557     frameInfo->replyBytesEc = frameInfoVdi->replyBytesEc;
558 
559     return HDF_SUCCESS;
560 }