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
AudioCommonDevDescToVdiDevDescVdi(const struct AudioDeviceDescriptor * desc,struct AudioDeviceDescriptorVdi * vdiDesc)28 void AudioCommonDevDescToVdiDevDescVdi(const struct AudioDeviceDescriptor *desc,
29 struct AudioDeviceDescriptorVdi *vdiDesc)
30 {
31 CHECK_NULL_PTR_RETURN(desc);
32 CHECK_NULL_PTR_RETURN(vdiDesc);
33
34 vdiDesc->portId = desc->portId;
35 vdiDesc->pins = (enum AudioPortPinVdi)desc->pins;
36 vdiDesc->desc = strdup(desc->desc); // free by caller
37 }
38
AudioCommonAttrsToVdiAttrsVdi(const struct AudioSampleAttributes * attrs,struct AudioSampleAttributesVdi * vdiAttrs)39 void AudioCommonAttrsToVdiAttrsVdi(const struct AudioSampleAttributes *attrs, struct AudioSampleAttributesVdi *vdiAttrs)
40 {
41 CHECK_NULL_PTR_RETURN(attrs);
42 CHECK_NULL_PTR_RETURN(vdiAttrs);
43
44 vdiAttrs->type = (enum AudioCategoryVdi)attrs->type;
45 vdiAttrs->interleaved = attrs->interleaved;
46 vdiAttrs->format = (enum AudioFormatVdi)attrs->format;
47 vdiAttrs->sampleRate = attrs->sampleRate;
48 vdiAttrs->channelCount = attrs->channelCount;
49 vdiAttrs->period = attrs->period;
50 vdiAttrs->frameSize = attrs->frameSize;
51 vdiAttrs->isBigEndian = attrs->isBigEndian;
52 vdiAttrs->isSignedData = attrs->isSignedData;
53 vdiAttrs->startThreshold = attrs->startThreshold;
54 vdiAttrs->stopThreshold = attrs->stopThreshold;
55 vdiAttrs->silenceThreshold = attrs->silenceThreshold;
56 vdiAttrs->streamId = attrs->streamId;
57 vdiAttrs->sourceType = attrs->sourceType;
58 }
59
AudioCommonPortToVdiPortVdi(const struct AudioPort * port,struct AudioPortVdi * vdiPort)60 int32_t AudioCommonPortToVdiPortVdi(const struct AudioPort *port, struct AudioPortVdi *vdiPort)
61 {
62 CHECK_NULL_PTR_RETURN_VALUE(vdiPort, HDF_ERR_INVALID_PARAM);
63 CHECK_NULL_PTR_RETURN_VALUE(port, HDF_ERR_INVALID_PARAM);
64
65 vdiPort->dir = (enum AudioPortDirectionVdi)port->dir;
66 vdiPort->portId = port->portId;
67 vdiPort->portName = strdup(port->portName); // free by caller
68
69 return HDF_SUCCESS;
70 }
71
AudioFormatsToFormatsVdi(const enum AudioFormatVdi * vdiFormats,uint32_t vdiFormatNum,enum AudioFormat ** formats,uint32_t * formatsLen)72 static int32_t AudioFormatsToFormatsVdi(const enum AudioFormatVdi *vdiFormats, uint32_t vdiFormatNum,
73 enum AudioFormat **formats, uint32_t *formatsLen)
74 {
75 CHECK_NULL_PTR_RETURN_VALUE(vdiFormats, HDF_ERR_INVALID_PARAM);
76 CHECK_NULL_PTR_RETURN_VALUE(formats, HDF_ERR_INVALID_PARAM);
77 CHECK_NULL_PTR_RETURN_VALUE(formatsLen, HDF_ERR_INVALID_PARAM);
78
79 if (vdiFormatNum >= AUDIO_FORMAT_NUM_MAX || vdiFormatNum == 0) {
80 AUDIO_FUNC_LOGE("VdiFormats to formats len fail");
81 return HDF_ERR_INVALID_PARAM;
82 }
83
84 uint32_t size = vdiFormatNum * sizeof(enum AudioFormat);
85 enum AudioFormat *formatTmp = (enum AudioFormat *)OsalMemCalloc(size); // free by caller
86 if (formatTmp == NULL) {
87 AUDIO_FUNC_LOGE("formatTmp malloc fail");
88 return HDF_ERR_MALLOC_FAIL;
89 }
90
91 int32_t ret = memcpy_s((void*)formatTmp, size, (void*)vdiFormats, vdiFormatNum * sizeof(enum AudioFormatVdi));
92 if (ret != HDF_SUCCESS) {
93 OsalMemFree((void *)formatTmp);
94 AUDIO_FUNC_LOGE("format cpy fail=%{public}d", ret);
95 return HDF_FAILURE;
96 }
97
98 *formats = formatTmp;
99 *formatsLen = size;
100 return HDF_SUCCESS;
101 }
102
AudioReleaseSubPortsVdi(struct AudioSubPortCapability ** subPorts,uint32_t * subPortsLen)103 static void AudioReleaseSubPortsVdi(struct AudioSubPortCapability **subPorts, uint32_t *subPortsLen)
104 {
105 struct AudioSubPortCapability *subPortsTmp = NULL;
106
107 CHECK_NULL_PTR_RETURN(subPorts);
108 CHECK_NULL_PTR_RETURN(subPortsLen);
109
110 uint32_t subPortsNum = *subPortsLen / sizeof(struct AudioSubPortCapability);
111 if (subPortsNum >= AUDIO_SUB_PORT_NUM_MAX) {
112 AUDIO_FUNC_LOGE("AudioReleaseSubPortsVdi len fail");
113 return;
114 }
115
116 subPortsTmp = *subPorts;
117 for (uint32_t i = 0; i < subPortsNum; i++) {
118 OsalMemFree((void *)subPortsTmp[i].desc);
119 }
120
121 OsalMemFree((void *)subPortsTmp);
122 subPortsTmp = NULL;
123 }
124
AudioSubPortsToSubPortsVdi(const struct AudioSubPortCapabilityVdi * vdiSubPorts,uint32_t vdiSubPortsNum,struct AudioSubPortCapability ** subPorts,uint32_t * subPortsLen)125 static int32_t AudioSubPortsToSubPortsVdi(const struct AudioSubPortCapabilityVdi *vdiSubPorts, uint32_t vdiSubPortsNum,
126 struct AudioSubPortCapability **subPorts, uint32_t *subPortsLen)
127 {
128 CHECK_NULL_PTR_RETURN_VALUE(vdiSubPorts, HDF_ERR_INVALID_PARAM);
129 CHECK_NULL_PTR_RETURN_VALUE(subPorts, HDF_ERR_INVALID_PARAM);
130 CHECK_NULL_PTR_RETURN_VALUE(subPortsLen, HDF_ERR_INVALID_PARAM);
131
132 if (vdiSubPortsNum >= AUDIO_SUB_PORT_NUM_MAX || vdiSubPortsNum == 0) {
133 AUDIO_FUNC_LOGE("VdiSubPorts to subPorts len fail");
134 return HDF_ERR_INVALID_PARAM;
135 }
136
137 uint32_t size = vdiSubPortsNum * sizeof(struct AudioSubPortCapability);
138 struct AudioSubPortCapability *subPortsTmp = (struct AudioSubPortCapability *)OsalMemCalloc(size);
139 if (subPortsTmp == NULL) {
140 AUDIO_FUNC_LOGE("subPortsTmp malloc fail");
141 return HDF_ERR_MALLOC_FAIL;
142 }
143
144 for (uint32_t i = 0; i < vdiSubPortsNum; i++) {
145 subPortsTmp[i].portId = vdiSubPorts[i].portId;
146 subPortsTmp[i].mask = (enum AudioPortPassthroughMode)vdiSubPorts[i].mask;
147 subPortsTmp[i].desc = strdup(vdiSubPorts[i].desc);
148 }
149
150 *subPorts = subPortsTmp;
151 *subPortsLen = size;
152 return HDF_SUCCESS;
153 }
154
AudioSampleFormatToSampleFormatsVdi(const enum AudioSampleFormatVdi * vdiSampleFormat,uint32_t vdiSupportSampleFormatNum,enum AudioSampleFormat ** sampleFormat,uint32_t * sampleFormatsLen)155 static int32_t AudioSampleFormatToSampleFormatsVdi(const enum AudioSampleFormatVdi *vdiSampleFormat,
156 uint32_t vdiSupportSampleFormatNum, enum AudioSampleFormat **sampleFormat, uint32_t *sampleFormatsLen)
157 {
158 CHECK_NULL_PTR_RETURN_VALUE(vdiSampleFormat, HDF_ERR_INVALID_PARAM);
159 CHECK_NULL_PTR_RETURN_VALUE(sampleFormat, HDF_ERR_INVALID_PARAM);
160 CHECK_NULL_PTR_RETURN_VALUE(sampleFormatsLen, HDF_ERR_INVALID_PARAM);
161
162 if (vdiSupportSampleFormatNum >= AUDIO_SAMPLE_FORMAT_NUM_MAX || vdiSupportSampleFormatNum == 0) {
163 AUDIO_FUNC_LOGE("vdiSampleFormat to sampleFormats len fail");
164 return HDF_ERR_INVALID_PARAM;
165 }
166
167 uint32_t size = vdiSupportSampleFormatNum * sizeof(enum AudioSampleFormat);
168 enum AudioSampleFormat *sampleFormatTmp = (enum AudioSampleFormat *)OsalMemCalloc(size);
169 if (sampleFormatTmp == NULL) {
170 AUDIO_FUNC_LOGE("sampleFormatTmp malloc fail");
171 return HDF_ERR_MALLOC_FAIL;
172 }
173
174 int32_t ret = memcpy_s((void *)sampleFormatTmp, size, (void*)vdiSampleFormat,
175 vdiSupportSampleFormatNum * sizeof(enum AudioSampleFormatVdi));
176 if (ret != HDF_SUCCESS) {
177 OsalMemFree((void *)sampleFormatTmp);
178 AUDIO_FUNC_LOGE("sampleFormatTmp cpy fail=%{public}d", ret);
179 return HDF_FAILURE;
180 }
181
182 *sampleFormat = sampleFormatTmp;
183 *sampleFormatsLen = size;
184 return HDF_SUCCESS;
185 }
186
AudioCommonVdiPortCapToPortCapVdi(const struct AudioPortCapabilityVdi * vdiPortCap,struct AudioPortCapability * portCap)187 void AudioCommonVdiPortCapToPortCapVdi(const struct AudioPortCapabilityVdi *vdiPortCap,
188 struct AudioPortCapability *portCap)
189 {
190 CHECK_NULL_PTR_RETURN(portCap);
191 CHECK_NULL_PTR_RETURN(vdiPortCap);
192
193 portCap->deviceType = vdiPortCap->deviceType;
194 portCap->deviceId = vdiPortCap->deviceId;
195 portCap->hardwareMode = vdiPortCap->hardwareMode;
196 portCap->sampleRateMasks = vdiPortCap->sampleRateMasks;
197 portCap->channelMasks = (enum AudioChannelMask)vdiPortCap->channelMasks;
198 portCap->channelCount = vdiPortCap->channelCount;
199
200 int32_t ret = AudioFormatsToFormatsVdi(vdiPortCap->formats, vdiPortCap->formatNum, &portCap->formats,
201 &portCap->formatsLen);
202 if (ret != HDF_SUCCESS) {
203 AUDIO_FUNC_LOGE("AudioFormatsToFormatsVdi fail");
204 return;
205 }
206
207 ret = AudioSubPortsToSubPortsVdi(vdiPortCap->subPorts, vdiPortCap->subPortsLen,
208 &portCap->subPorts, &portCap->subPortsLen);
209 if (ret != HDF_SUCCESS) {
210 OsalMemFree((void *)portCap->formats);
211 portCap->formats = NULL;
212 AUDIO_FUNC_LOGE("VdiSubPortsToSubPorts fail");
213 return;
214 }
215
216 ret = AudioSampleFormatToSampleFormatsVdi(vdiPortCap->supportSampleFormats, vdiPortCap->supportSampleFormatsLen,
217 &portCap->supportSampleFormats, &portCap->supportSampleFormatsLen);
218 if (ret != HDF_SUCCESS) {
219 OsalMemFree((void *)portCap->formats);
220 AudioReleaseSubPortsVdi(&portCap->subPorts, &portCap->subPortsLen);
221 portCap->formats = NULL;
222 AUDIO_FUNC_LOGE("VdiSampleFormatToSampleFormats fail");
223 return;
224 }
225 }
226
AudioCommonFreeVdiRouteVdi(struct AudioRouteVdi * vdiRoute)227 void AudioCommonFreeVdiRouteVdi(struct AudioRouteVdi *vdiRoute)
228 {
229 CHECK_NULL_PTR_RETURN(vdiRoute);
230
231 if (vdiRoute->sinks != NULL) {
232 if (vdiRoute->sinksLen > AUDIO_ROUTE_NUM_MAX) {
233 AUDIO_FUNC_LOGE("sinksLen para error");
234 return;
235 }
236
237 for (uint32_t i = 0; i < vdiRoute->sinksLen; i++) {
238 if (vdiRoute->sinks[i].type == AUDIO_VDI_PORT_DEVICE_TYPE) {
239 OsalMemFree((void *)vdiRoute->sinks[i].ext.device.desc);
240 }
241 }
242 OsalMemFree((void *)vdiRoute->sinks);
243 }
244
245 if (vdiRoute->sources != NULL) {
246 if (vdiRoute->sourcesLen > AUDIO_ROUTE_NUM_MAX) {
247 AUDIO_FUNC_LOGE("sourcesLen para error");
248 return;
249 }
250
251 for (uint32_t i = 0; i < vdiRoute->sourcesLen; i++) {
252 if (vdiRoute->sources[i].type == AUDIO_VDI_PORT_DEVICE_TYPE) {
253 OsalMemFree((void *)vdiRoute->sources[i].ext.device.desc);
254 }
255 }
256 OsalMemFree((void *)vdiRoute->sources);
257 }
258 }
259
AudioCommonRouteNodeToVdiRouteNodeVdi(struct AudioRouteNode * routeNode,struct AudioRouteNodeVdi * vdiRouteNode)260 static int32_t AudioCommonRouteNodeToVdiRouteNodeVdi(struct AudioRouteNode *routeNode,
261 struct AudioRouteNodeVdi *vdiRouteNode)
262 {
263 vdiRouteNode->portId = routeNode->portId;
264 vdiRouteNode->role = (enum AudioPortRoleVdi)routeNode->role;
265 vdiRouteNode->type = (enum AudioPortTypeVdi)routeNode->type;
266
267 if (routeNode->type == AUDIO_VDI_PORT_DEVICE_TYPE) {
268 vdiRouteNode->ext.device.moduleId = routeNode->ext.device.moduleId;
269 vdiRouteNode->ext.device.type = (enum AudioPortPinVdi)routeNode->ext.device.type;
270 vdiRouteNode->ext.device.desc = strdup(routeNode->ext.device.desc);
271 return HDF_SUCCESS;
272 }
273
274 if (routeNode->type == AUDIO_VDI_PORT_MIX_TYPE) {
275 vdiRouteNode->ext.mix.moduleId = routeNode->ext.mix.moduleId;
276 vdiRouteNode->ext.mix.streamId = routeNode->ext.mix.streamId;
277 return HDF_SUCCESS;
278 }
279
280 if (routeNode->type == AUDIO_VDI_PORT_SESSION_TYPE) {
281 vdiRouteNode->ext.session.sessionType = (enum AudioSessionTypeVdi)routeNode->ext.session.sessionType;
282 return HDF_SUCCESS;
283 }
284
285 AUDIO_FUNC_LOGE("not match route node type");
286 return HDF_FAILURE;
287 }
288
AudioCommonSinkToVdiSinkVdi(const struct AudioRoute * route,struct AudioRouteVdi * vdiRoute)289 static int32_t AudioCommonSinkToVdiSinkVdi(const struct AudioRoute *route, struct AudioRouteVdi *vdiRoute)
290 {
291 struct AudioRouteNodeVdi *nodes = NULL;
292 if (route->sinksLen > AUDIO_ROUTE_NUM_MAX) {
293 AUDIO_FUNC_LOGE("sinksLen para err");
294 return HDF_ERR_INVALID_PARAM;
295 }
296
297 nodes = (struct AudioRouteNodeVdi *)OsalMemCalloc(route->sinksLen * sizeof(struct AudioRouteNodeVdi));
298 if (nodes == NULL) {
299 AUDIO_FUNC_LOGE("nodes null");
300 return HDF_ERR_MALLOC_FAIL;
301 }
302 vdiRoute->sinks = nodes;
303 vdiRoute->sinksLen = route->sinksLen;
304
305 for (uint32_t i = 0; i < vdiRoute->sinksLen; i++) {
306 int32_t ret = AudioCommonRouteNodeToVdiRouteNodeVdi(&route->sinks[i], &vdiRoute->sinks[i]);
307 if (ret != HDF_SUCCESS) {
308 AUDIO_FUNC_LOGE("sink routeNode to vdiRouteNode fail");
309 /* nodes release by AudioCommonFreeVdiRouteVdi */
310 return HDF_FAILURE;
311 }
312 }
313
314 return HDF_SUCCESS;
315 }
316
AudioCommonSourceToVdiSourceVdi(const struct AudioRoute * route,struct AudioRouteVdi * vdiRoute)317 static int32_t AudioCommonSourceToVdiSourceVdi(const struct AudioRoute *route, struct AudioRouteVdi *vdiRoute)
318 {
319 struct AudioRouteNodeVdi *nodes = NULL;
320 if (route->sourcesLen > AUDIO_ROUTE_NUM_MAX) {
321 AUDIO_FUNC_LOGE("sinksLen para err");
322 return HDF_ERR_INVALID_PARAM;
323 }
324
325 nodes = (struct AudioRouteNodeVdi *)OsalMemCalloc(route->sourcesLen * sizeof(struct AudioRouteNodeVdi));
326 if (nodes == NULL) {
327 AUDIO_FUNC_LOGE("nodes null");
328 return HDF_ERR_MALLOC_FAIL;
329 }
330 vdiRoute->sources = nodes;
331 vdiRoute->sourcesLen = route->sourcesLen;
332
333 for (uint32_t i = 0; i < vdiRoute->sourcesLen; i++) {
334 int32_t ret = AudioCommonRouteNodeToVdiRouteNodeVdi(&route->sources[i], &vdiRoute->sources[i]);
335 if (ret != HDF_SUCCESS) {
336 AUDIO_FUNC_LOGE(" source routeNode to vdiRouteNode fail");
337 /* nodes release by AudioCommonFreeVdiRouteVdi */
338 return HDF_FAILURE;
339 }
340 }
341
342 return HDF_SUCCESS;
343 }
344
AudioCommonRouteToVdiRouteVdi(const struct AudioRoute * route,struct AudioRouteVdi * vdiRoute)345 int32_t AudioCommonRouteToVdiRouteVdi(const struct AudioRoute *route, struct AudioRouteVdi *vdiRoute)
346 {
347 int32_t sinkRet = HDF_SUCCESS;
348 int32_t sourcesRet = HDF_SUCCESS;
349
350 CHECK_NULL_PTR_RETURN_VALUE(route, HDF_ERR_INVALID_PARAM);
351 CHECK_NULL_PTR_RETURN_VALUE(vdiRoute, HDF_ERR_INVALID_PARAM);
352
353 if (route->sinks != NULL) {
354 sinkRet = AudioCommonSinkToVdiSinkVdi(route, vdiRoute);
355 if (sinkRet != HDF_SUCCESS) {
356 AUDIO_FUNC_LOGE(" sink routeNode to vdiRouteNode fail");
357 }
358 }
359
360 if (route->sources != NULL) {
361 sourcesRet = AudioCommonSourceToVdiSourceVdi(route, vdiRoute);
362 if (sourcesRet != HDF_SUCCESS) {
363 AUDIO_FUNC_LOGE(" source routeNode to vdiRouteNode fail");
364 return HDF_FAILURE;
365 }
366 }
367
368 if (sinkRet != HDF_SUCCESS || sourcesRet != HDF_SUCCESS) {
369 /* free nodes by sink and source malloc nodes memory */
370 AudioCommonFreeVdiRouteVdi(vdiRoute);
371 return HDF_FAILURE;
372 }
373
374 return HDF_SUCCESS;
375 }
376
AudioCommonSceneToVdiSceneVdi(const struct AudioSceneDescriptor * scene,struct AudioSceneDescriptorVdi * vdiScene)377 int32_t AudioCommonSceneToVdiSceneVdi(const struct AudioSceneDescriptor *scene,
378 struct AudioSceneDescriptorVdi *vdiScene)
379 {
380 CHECK_NULL_PTR_RETURN_VALUE(scene, HDF_ERR_INVALID_PARAM);
381 CHECK_NULL_PTR_RETURN_VALUE(vdiScene, HDF_ERR_INVALID_PARAM);
382
383 vdiScene->scene.id = scene->scene.id;
384 AudioCommonDevDescToVdiDevDescVdi(&scene->desc, &vdiScene->desc);
385
386 return HDF_SUCCESS;
387 }
388
AudioCommonSampleAttrToVdiSampleAttrVdi(const struct AudioSampleAttributes * attrs,struct AudioSampleAttributesVdi * vdiAttrs)389 int32_t AudioCommonSampleAttrToVdiSampleAttrVdi(const struct AudioSampleAttributes *attrs,
390 struct AudioSampleAttributesVdi *vdiAttrs)
391 {
392 CHECK_NULL_PTR_RETURN_VALUE(attrs, HDF_ERR_INVALID_PARAM);
393 CHECK_NULL_PTR_RETURN_VALUE(vdiAttrs, HDF_ERR_INVALID_PARAM);
394
395 vdiAttrs->type = (enum AudioCategoryVdi)attrs->type;
396 vdiAttrs->interleaved = attrs->interleaved;
397 vdiAttrs->format = (enum AudioFormatVdi)attrs->format;
398 vdiAttrs->sampleRate = attrs->sampleRate;
399 vdiAttrs->channelCount = attrs->channelCount;
400 vdiAttrs->period = attrs->period;
401 vdiAttrs->frameSize = attrs->frameSize;
402 vdiAttrs->isBigEndian = attrs->isBigEndian;
403 vdiAttrs->isSignedData = attrs->isSignedData;
404 vdiAttrs->startThreshold = attrs->startThreshold;
405 vdiAttrs->stopThreshold = attrs->stopThreshold;
406 vdiAttrs->silenceThreshold = attrs->silenceThreshold;
407 vdiAttrs->streamId = attrs->streamId;
408 vdiAttrs->sourceType = attrs->sourceType;
409
410 return HDF_SUCCESS;
411 }
412
AudioCommonVdiSampleAttrToSampleAttrVdi(const struct AudioSampleAttributesVdi * vdiAttrs,struct AudioSampleAttributes * attrs)413 int32_t AudioCommonVdiSampleAttrToSampleAttrVdi(const struct AudioSampleAttributesVdi *vdiAttrs,
414 struct AudioSampleAttributes *attrs)
415 {
416 CHECK_NULL_PTR_RETURN_VALUE(attrs, HDF_ERR_INVALID_PARAM);
417 CHECK_NULL_PTR_RETURN_VALUE(vdiAttrs, HDF_ERR_INVALID_PARAM);
418
419 attrs->type = (enum AudioCategory)vdiAttrs->type;
420 attrs->interleaved = vdiAttrs->interleaved;
421 attrs->format = (enum AudioFormat)vdiAttrs->format;
422 attrs->sampleRate = vdiAttrs->sampleRate;
423 attrs->channelCount = vdiAttrs->channelCount;
424 attrs->period = vdiAttrs->period;
425 attrs->frameSize = vdiAttrs->frameSize;
426 attrs->isBigEndian = vdiAttrs->isBigEndian;
427 attrs->isSignedData = vdiAttrs->isSignedData;
428 attrs->startThreshold = vdiAttrs->startThreshold;
429 attrs->stopThreshold = vdiAttrs->stopThreshold;
430 attrs->silenceThreshold = vdiAttrs->silenceThreshold;
431 attrs->streamId = vdiAttrs->streamId;
432
433 return HDF_SUCCESS;
434 }
435