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