1 /*
2 * Copyright (c) 2021-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 "hdf_audio_server_capture.h"
17 #include "osal_mem.h"
18 #include "audio_uhdf_log.h"
19 #include "hdf_audio_server_common.h"
20
21 #define HDF_LOG_TAG HDF_AUDIO_HAL_STUB
22 #define INTERNEL_INPUT_STEAM_ID 1
23
GetInitCaptureParaAttrs(struct HdfSBuf * data,struct AudioSampleAttributes * attrs)24 static int32_t GetInitCaptureParaAttrs(struct HdfSBuf *data, struct AudioSampleAttributes *attrs)
25 {
26 if (data == NULL || attrs == NULL) {
27 return HDF_FAILURE;
28 }
29 uint32_t tempCapturePara = 0;
30 if (!HdfSbufReadUint32(data, &tempCapturePara)) {
31 AUDIO_FUNC_LOGE("Capture read tempCapturePara fail");
32 return HDF_FAILURE;
33 }
34 attrs->type = (enum AudioCategory)tempCapturePara;
35 if (!HdfSbufReadUint32(data, &attrs->period)) {
36 AUDIO_FUNC_LOGE("Capture read period fail");
37 return HDF_FAILURE;
38 }
39 if (!HdfSbufReadUint32(data, &attrs->frameSize)) {
40 AUDIO_FUNC_LOGE("Capture read frameSize fail");
41 return HDF_FAILURE;
42 }
43 if (!HdfSbufReadUint32(data, &attrs->startThreshold)) {
44 AUDIO_FUNC_LOGE("Capture read startThreshold fail");
45 return HDF_FAILURE;
46 }
47 if (!HdfSbufReadUint32(data, &attrs->stopThreshold)) {
48 AUDIO_FUNC_LOGE("Capture read stopThreshold fail");
49 return HDF_FAILURE;
50 }
51 if (!HdfSbufReadUint32(data, &attrs->silenceThreshold)) {
52 AUDIO_FUNC_LOGE("Capture read silenceThreshold fail");
53 return HDF_FAILURE;
54 }
55 if (!HdfSbufReadUint32(data, &tempCapturePara)) {
56 AUDIO_FUNC_LOGE("Failed to Get Speed sBuf!");
57 return HDF_FAILURE;
58 }
59 attrs->isBigEndian = (bool)tempCapturePara;
60 if (!HdfSbufReadUint32(data, &tempCapturePara)) {
61 AUDIO_FUNC_LOGE("Failed to Get Speed sBuf!");
62 return HDF_FAILURE;
63 }
64 attrs->isSignedData = (bool)tempCapturePara;
65
66 if (!HdfSbufReadInt32(data, &attrs->streamId)) {
67 AUDIO_FUNC_LOGE("read streamId fail");
68 return HDF_FAILURE;
69 }
70
71 return HDF_SUCCESS;
72 }
73
GetInitCapturePara(struct HdfSBuf * data,struct AudioDeviceDescriptor * devDesc,struct AudioSampleAttributes * attrs)74 static int32_t GetInitCapturePara(struct HdfSBuf *data, struct AudioDeviceDescriptor *devDesc,
75 struct AudioSampleAttributes *attrs)
76 {
77 if (data == NULL || devDesc == NULL || attrs == NULL) {
78 return HDF_FAILURE;
79 }
80 uint32_t tempCapturePara = 0;
81 if (!HdfSbufReadUint32(data, &tempCapturePara)) {
82 AUDIO_FUNC_LOGE("Failed to Get Speed sBuf!");
83 return HDF_FAILURE;
84 }
85 attrs->format = (enum AudioFormat)tempCapturePara;
86 if (!HdfSbufReadUint32(data, &attrs->channelCount)) {
87 AUDIO_FUNC_LOGE("read channelCount fail");
88 return HDF_FAILURE;
89 }
90 if (!HdfSbufReadUint32(data, &attrs->sampleRate)) {
91 AUDIO_FUNC_LOGE("read sampleRate fail");
92 return HDF_FAILURE;
93 }
94 if (!HdfSbufReadUint32(data, &tempCapturePara)) {
95 AUDIO_FUNC_LOGE("Failed to Get Speed sBuf!");
96 return HDF_FAILURE;
97 }
98 attrs->interleaved = (bool)tempCapturePara;
99 if (GetInitCaptureParaAttrs(data, attrs) < 0) {
100 return HDF_FAILURE;
101 }
102 if (!HdfSbufReadUint32(data, &devDesc->portId)) {
103 AUDIO_FUNC_LOGE("read portId fail");
104 return HDF_FAILURE;
105 }
106 if (!HdfSbufReadUint32(data, &tempCapturePara)) {
107 AUDIO_FUNC_LOGE("read tempCapturePara fail");
108 return HDF_FAILURE;
109 }
110 devDesc->pins = (enum AudioPortPin)tempCapturePara;
111 devDesc->desc = NULL;
112 return HDF_SUCCESS;
113 }
114
HdiServiceCreatCapture(const struct HdfDeviceIoClient * client,struct HdfSBuf * data,struct HdfSBuf * reply)115 int32_t HdiServiceCreatCapture(const struct HdfDeviceIoClient *client, struct HdfSBuf *data, struct HdfSBuf *reply)
116 {
117 if (client == NULL || data == NULL || reply == NULL) {
118 AUDIO_FUNC_LOGE("client or data or reply is null!");
119 return AUDIO_HAL_ERR_INVALID_PARAM;
120 }
121 struct AudioAdapter *adapter = NULL;
122 struct AudioDeviceDescriptor devDesc;
123 struct AudioSampleAttributes attrs;
124 struct AudioCapture *capture = NULL;
125 const char *adapterName = NULL;
126 uint32_t capturePid = 0;
127 if ((adapterName = HdfSbufReadString(data)) == NULL) {
128 AUDIO_FUNC_LOGE("adapterNameCase Is NULL");
129 return AUDIO_HAL_ERR_INVALID_PARAM;
130 }
131 if (!HdfSbufReadUint32(data, &capturePid)) {
132 AUDIO_FUNC_LOGE("read capturePid fail");
133 return AUDIO_HAL_ERR_INTERNAL;
134 }
135 AUDIO_FUNC_LOGD("capturePid = %{public}u", capturePid);
136 int32_t ret = GetInitCapturePara(data, &devDesc, &attrs);
137 if (ret < 0) {
138 return AUDIO_HAL_ERR_INTERNAL;
139 }
140 if (AudioAdapterListGetAdapter(adapterName, &adapter) < 0) {
141 AUDIO_FUNC_LOGE("AudioAdapterListGetAdapter fail");
142 return AUDIO_HAL_ERR_INTERNAL;
143 }
144 if (adapter == NULL) {
145 AUDIO_FUNC_LOGE("adapter is empty!");
146 return AUDIO_HAL_ERR_INVALID_PARAM;
147 }
148 const int32_t priority = attrs.type;
149 ret = AudioCreatCaptureCheck(adapterName, priority);
150 if (ret < 0) {
151 return ret;
152 }
153
154 attrs.streamId = INTERNEL_INPUT_STEAM_ID;
155 if (adapter->CreateCapture == NULL) {
156 AUDIO_FUNC_LOGE("CreateCapture is NULL");
157 return AUDIO_HAL_ERR_INTERNAL;
158 }
159 ret = adapter->CreateCapture(adapter, &devDesc, &attrs, &capture);
160 if (capture == NULL || ret < 0) {
161 AUDIO_FUNC_LOGE("Failed to CreateCapture");
162 return AUDIO_HAL_ERR_INTERNAL;
163 }
164 if (AudioAddCaptureInfoInAdapter(adapterName, capture, adapter, priority, capturePid)) {
165 AUDIO_FUNC_LOGE("AudioAddRenderInfoInAdapter");
166 adapter->DestroyCapture(adapter, capture);
167 return AUDIO_HAL_ERR_INTERNAL;
168 }
169 return AUDIO_HAL_SUCCESS;
170 }
171
HdiServiceCaptureDestory(const struct HdfDeviceIoClient * client,struct HdfSBuf * data,struct HdfSBuf * reply)172 int32_t HdiServiceCaptureDestory(const struct HdfDeviceIoClient *client, struct HdfSBuf *data, struct HdfSBuf *reply)
173 {
174 if (client == NULL || data == NULL || reply == NULL) {
175 AUDIO_FUNC_LOGE("client or data or reply is null!");
176 return AUDIO_HAL_ERR_INVALID_PARAM;
177 }
178 struct AudioAdapter *adapter = NULL;
179 struct AudioCapture *capture = NULL;
180 const char *adapterName = NULL;
181 uint32_t pid = 0;
182 if (HdiServiceRenderCaptureReadData(data, &adapterName, &pid) < 0) {
183 return AUDIO_HAL_ERR_INTERNAL;
184 }
185 int32_t ret = AudioAdapterListGetCapture(adapterName, &capture, pid);
186 if (ret < 0) {
187 AUDIO_FUNC_LOGE("AudioAdapterListGetCapture failed ret = %{public}d", ret);
188 return ret;
189 }
190 ret = AudioAdapterListGetAdapterCapture(adapterName, &adapter, &capture);
191 if (ret < 0) {
192 AUDIO_FUNC_LOGE("AudioAdapterListGetAdapterCapture failed ret = %{public}d", ret);
193 return ret;
194 }
195 if (adapter == NULL || adapter->DestroyCapture == NULL) {
196 AUDIO_FUNC_LOGE("adapter or DestroyCapture is NULL");
197 return AUDIO_HAL_ERR_INTERNAL;
198 }
199 ret = adapter->DestroyCapture(adapter, capture);
200 if (ret < 0) {
201 AUDIO_FUNC_LOGE("DestroyCapture failed!");
202 return ret;
203 }
204 if (AudioDestroyCaptureInfoInAdapter(adapterName) < 0) {
205 return AUDIO_HAL_ERR_INTERNAL;
206 }
207 return AUDIO_HAL_SUCCESS;
208 }
209
HdiServiceCaptureStart(const struct HdfDeviceIoClient * client,struct HdfSBuf * data,struct HdfSBuf * reply)210 int32_t HdiServiceCaptureStart(const struct HdfDeviceIoClient *client, struct HdfSBuf *data, struct HdfSBuf *reply)
211 {
212 if (client == NULL || data == NULL || reply == NULL) {
213 AUDIO_FUNC_LOGE("client or data or repoly is null!");
214 return AUDIO_HAL_ERR_INVALID_PARAM;
215 }
216 struct AudioCapture *capture = NULL;
217 int ret = AudioAdapterListCheckAndGetCapture(&capture, data);
218 if (ret < 0) {
219 AUDIO_FUNC_LOGE("AudioAdapterListCheckAndGetCapture failed ret = %{public}d", ret);
220 return ret;
221 }
222 if (capture == NULL || capture->control.Start == NULL) {
223 AUDIO_FUNC_LOGE("capture or Start is NULL");
224 return AUDIO_HAL_ERR_INTERNAL;
225 }
226 return capture->control.Start((AudioHandle)capture);
227 }
228
HdiServiceCaptureStop(const struct HdfDeviceIoClient * client,struct HdfSBuf * data,struct HdfSBuf * reply)229 int32_t HdiServiceCaptureStop(const struct HdfDeviceIoClient *client, struct HdfSBuf *data, struct HdfSBuf *reply)
230 {
231 if (client == NULL || data == NULL || reply == NULL) {
232 return AUDIO_HAL_ERR_INVALID_PARAM;
233 }
234 struct AudioCapture *capture = NULL;
235 int ret = AudioAdapterListCheckAndGetCapture(&capture, data);
236 if (ret < 0) {
237 return ret;
238 }
239 if (capture == NULL || capture->control.Stop == NULL) {
240 AUDIO_FUNC_LOGE("capture or Stop is NULL");
241 return AUDIO_HAL_ERR_INTERNAL;
242 }
243 return capture->control.Stop((AudioHandle)capture);
244 }
245
HdiServiceCapturePause(const struct HdfDeviceIoClient * client,struct HdfSBuf * data,struct HdfSBuf * reply)246 int32_t HdiServiceCapturePause(const struct HdfDeviceIoClient *client, struct HdfSBuf *data, struct HdfSBuf *reply)
247 {
248 if (client == NULL || data == NULL || reply == NULL) {
249 return AUDIO_HAL_ERR_INVALID_PARAM;
250 }
251 struct AudioCapture *capture = NULL;
252 int ret = AudioAdapterListCheckAndGetCapture(&capture, data);
253 if (ret < 0) {
254 return ret;
255 }
256 if (capture == NULL || capture->control.Pause == NULL) {
257 AUDIO_FUNC_LOGE("capture or Pause is NULL");
258 return AUDIO_HAL_ERR_INTERNAL;
259 }
260 return capture->control.Pause((AudioHandle)capture);
261 }
262
HdiServiceCaptureResume(const struct HdfDeviceIoClient * client,struct HdfSBuf * data,struct HdfSBuf * reply)263 int32_t HdiServiceCaptureResume(const struct HdfDeviceIoClient *client, struct HdfSBuf *data, struct HdfSBuf *reply)
264 {
265 if (client == NULL || data == NULL || reply == NULL) {
266 return AUDIO_HAL_ERR_INVALID_PARAM;
267 }
268 struct AudioCapture *capture = NULL;
269 int ret = AudioAdapterListCheckAndGetCapture(&capture, data);
270 if (ret < 0) {
271 return ret;
272 }
273 if (capture == NULL || capture->control.Resume == NULL) {
274 AUDIO_FUNC_LOGE("capture or Resume is NULL");
275 return AUDIO_HAL_ERR_INTERNAL;
276 }
277 return capture->control.Resume((AudioHandle)capture);
278 }
279
HdiServiceCaptureFlush(const struct HdfDeviceIoClient * client,struct HdfSBuf * data,struct HdfSBuf * reply)280 int32_t HdiServiceCaptureFlush(const struct HdfDeviceIoClient *client, struct HdfSBuf *data, struct HdfSBuf *reply)
281 {
282 if (client == NULL || data == NULL || reply == NULL) {
283 return AUDIO_HAL_ERR_INVALID_PARAM;
284 }
285 struct AudioCapture *capture = NULL;
286 int ret = AudioAdapterListCheckAndGetCapture(&capture, data);
287 if (ret < 0) {
288 return ret;
289 }
290 if (capture == NULL || capture->control.Flush == NULL) {
291 AUDIO_FUNC_LOGE("capture or Flush is NULL");
292 return AUDIO_HAL_ERR_INTERNAL;
293 }
294 return capture->control.Flush((AudioHandle)capture);
295 }
296
HdiServiceCaptureGetFrameSize(const struct HdfDeviceIoClient * client,struct HdfSBuf * data,struct HdfSBuf * reply)297 int32_t HdiServiceCaptureGetFrameSize(const struct HdfDeviceIoClient *client,
298 struct HdfSBuf *data, struct HdfSBuf *reply)
299 {
300 if (client == NULL || data == NULL || reply == NULL) {
301 return AUDIO_HAL_ERR_INVALID_PARAM;
302 }
303 uint64_t size;
304 struct AudioCapture *capture = NULL;
305 int ret = AudioAdapterListCheckAndGetCapture(&capture, data);
306 if (ret < 0) {
307 return ret;
308 }
309 if (capture == NULL || capture->attr.GetFrameSize == NULL) {
310 AUDIO_FUNC_LOGE("capture or GetFrameSize is NULL");
311 return AUDIO_HAL_ERR_INTERNAL;
312 }
313 if (capture->attr.GetFrameSize((AudioHandle)capture, &size)) {
314 return AUDIO_HAL_ERR_INTERNAL;
315 }
316 if (!HdfSbufWriteUint64(reply, size)) {
317 return AUDIO_HAL_ERR_INTERNAL;
318 }
319 return AUDIO_HAL_SUCCESS;
320 }
321
HdiServiceCaptureGetFrameCount(const struct HdfDeviceIoClient * client,struct HdfSBuf * data,struct HdfSBuf * reply)322 int32_t HdiServiceCaptureGetFrameCount(const struct HdfDeviceIoClient *client,
323 struct HdfSBuf *data, struct HdfSBuf *reply)
324 {
325 if (client == NULL || data == NULL || reply == NULL) {
326 return AUDIO_HAL_ERR_INVALID_PARAM;
327 }
328 uint64_t count;
329 struct AudioCapture *capture = NULL;
330 int ret = AudioAdapterListCheckAndGetCapture(&capture, data);
331 if (ret < 0) {
332 return ret;
333 }
334 if (capture == NULL || capture->attr.GetFrameCount == NULL) {
335 AUDIO_FUNC_LOGE("capture or GetFrameCount is NULL");
336 return AUDIO_HAL_ERR_INTERNAL;
337 }
338 if (capture->attr.GetFrameCount((AudioHandle)capture, &count)) {
339 return AUDIO_HAL_ERR_INTERNAL;
340 }
341 if (!HdfSbufWriteUint64(reply, count)) {
342 AUDIO_FUNC_LOGE("write count failed!");
343 return AUDIO_HAL_ERR_INTERNAL;
344 }
345 return AUDIO_HAL_SUCCESS;
346 }
347
HdiServiceCaptureSetSampleAttr(const struct HdfDeviceIoClient * client,struct HdfSBuf * data,struct HdfSBuf * reply)348 int32_t HdiServiceCaptureSetSampleAttr(const struct HdfDeviceIoClient *client,
349 struct HdfSBuf *data, struct HdfSBuf *reply)
350 {
351 if (client == NULL || data == NULL || reply == NULL) {
352 AUDIO_FUNC_LOGE("The pointer is null!");
353 return AUDIO_HAL_ERR_INVALID_PARAM;
354 }
355 int ret;
356 struct AudioSampleAttributes attrs;
357 struct AudioCapture *capture = NULL;
358 ret = AudioAdapterListCheckAndGetCapture(&capture, data);
359 if (ret < 0) {
360 return ret;
361 }
362 if (ReadAudioSapmleAttrbutes(data, &attrs) < 0) {
363 return AUDIO_HAL_ERR_INTERNAL;
364 }
365 if (capture == NULL || capture->attr.SetSampleAttributes == NULL) {
366 AUDIO_FUNC_LOGE("capture or SetSampleAttributes is NULL");
367 return AUDIO_HAL_ERR_INTERNAL;
368 }
369 return capture->attr.SetSampleAttributes((AudioHandle)capture, &attrs);
370 }
371
HdiServiceCaptureGetSampleAttr(const struct HdfDeviceIoClient * client,struct HdfSBuf * data,struct HdfSBuf * reply)372 int32_t HdiServiceCaptureGetSampleAttr(const struct HdfDeviceIoClient *client,
373 struct HdfSBuf *data, struct HdfSBuf *reply)
374 {
375 if (client == NULL || data == NULL || reply == NULL) {
376 return AUDIO_HAL_ERR_INVALID_PARAM;
377 }
378 struct AudioSampleAttributes attrs;
379 struct AudioCapture *capture = NULL;
380 int ret = AudioAdapterListCheckAndGetCapture(&capture, data);
381 if (ret < 0) {
382 return ret;
383 }
384 if (capture == NULL || capture->attr.GetSampleAttributes == NULL) {
385 AUDIO_FUNC_LOGE("capture or GetSampleAttributes is NULL");
386 return AUDIO_HAL_ERR_INTERNAL;
387 }
388 ret = capture->attr.GetSampleAttributes((AudioHandle)capture, &attrs);
389 if (ret < 0) {
390 return ret;
391 }
392 if (WriteAudioSampleAttributes(reply, &attrs) < 0) {
393 return AUDIO_HAL_ERR_INTERNAL;
394 }
395 return AUDIO_HAL_SUCCESS;
396 }
397
HdiServiceCaptureGetCurChannelId(const struct HdfDeviceIoClient * client,struct HdfSBuf * data,struct HdfSBuf * reply)398 int32_t HdiServiceCaptureGetCurChannelId(const struct HdfDeviceIoClient *client,
399 struct HdfSBuf *data, struct HdfSBuf *reply)
400 {
401 if (client == NULL || data == NULL || reply == NULL) {
402 return AUDIO_HAL_ERR_INVALID_PARAM;
403 }
404 uint32_t channelId;
405 struct AudioCapture *capture = NULL;
406 int ret = AudioAdapterListCheckAndGetCapture(&capture, data);
407 if (ret < 0) {
408 return ret;
409 }
410 if (capture == NULL || capture->attr.GetCurrentChannelId == NULL) {
411 AUDIO_FUNC_LOGE("capture or GetCurrentChannelId is NULL");
412 return AUDIO_HAL_ERR_INTERNAL;
413 }
414 ret = capture->attr.GetCurrentChannelId((AudioHandle)capture, &channelId);
415 if (ret < 0) {
416 return ret;
417 }
418 if (!HdfSbufWriteUint32(reply, channelId)) {
419 return AUDIO_HAL_ERR_INTERNAL;
420 }
421 return AUDIO_HAL_SUCCESS;
422 }
423
HdiServiceCaptureCheckSceneCapability(const struct HdfDeviceIoClient * client,struct HdfSBuf * data,struct HdfSBuf * reply)424 int32_t HdiServiceCaptureCheckSceneCapability(const struct HdfDeviceIoClient *client,
425 struct HdfSBuf *data, struct HdfSBuf *reply)
426 {
427 if (client == NULL || data == NULL || reply == NULL) {
428 AUDIO_FUNC_LOGE("client or data or reply is null!");
429 return AUDIO_HAL_ERR_INVALID_PARAM;
430 }
431 struct AudioSceneDescriptor scene;
432 bool supported = false;
433 struct AudioCapture *capture = NULL;
434 int ret = AudioAdapterListCheckAndGetCapture(&capture, data);
435 if (ret < 0) {
436 return ret;
437 }
438 if (!HdfSbufReadUint32(data, &scene.scene.id)) {
439 return AUDIO_HAL_ERR_INTERNAL;
440 }
441 uint32_t interimPins = 0;
442 if (!HdfSbufReadUint32(data, &interimPins)) {
443 return AUDIO_HAL_ERR_INTERNAL;
444 }
445 scene.desc.pins = (enum AudioPortPin) interimPins;
446 if (capture == NULL || capture->scene.CheckSceneCapability == NULL) {
447 AUDIO_FUNC_LOGE("capture or CheckSceneCapability is NULL");
448 return AUDIO_HAL_ERR_INTERNAL;
449 }
450 ret = capture->scene.CheckSceneCapability((AudioHandle)capture, &scene, &supported);
451 if (ret < 0) {
452 return ret;
453 }
454 uint32_t tempSupported = (uint32_t)supported;
455 if (!HdfSbufWriteUint32(reply, tempSupported)) {
456 return AUDIO_HAL_ERR_INTERNAL;
457 }
458 return AUDIO_HAL_SUCCESS;
459 }
460
HdiServiceCaptureSelectScene(const struct HdfDeviceIoClient * client,struct HdfSBuf * data,struct HdfSBuf * reply)461 int32_t HdiServiceCaptureSelectScene(const struct HdfDeviceIoClient *client,
462 struct HdfSBuf *data, struct HdfSBuf *reply)
463 {
464 if (client == NULL || data == NULL || reply == NULL) {
465 return AUDIO_HAL_ERR_INVALID_PARAM;
466 }
467 struct AudioSceneDescriptor scene;
468 struct AudioCapture *capture = NULL;
469 uint32_t tempPins = 0;
470 int ret = AudioAdapterListCheckAndGetCapture(&capture, data);
471 if (ret < 0) {
472 return ret;
473 }
474 if (!HdfSbufReadUint32(data, &scene.scene.id)) {
475 return AUDIO_HAL_ERR_INTERNAL;
476 }
477 if (!HdfSbufReadUint32(data, &tempPins)) {
478 return AUDIO_HAL_ERR_INTERNAL;
479 }
480 scene.desc.pins = (enum AudioPortPin) tempPins;
481 if (capture == NULL || capture->scene.SelectScene == NULL) {
482 AUDIO_FUNC_LOGE("capture or SelectScene is NULL");
483 return AUDIO_HAL_ERR_INTERNAL;
484 }
485 return capture->scene.SelectScene((AudioHandle)capture, &scene);
486 }
487
HdiServiceCaptureGetMute(const struct HdfDeviceIoClient * client,struct HdfSBuf * data,struct HdfSBuf * reply)488 int32_t HdiServiceCaptureGetMute(const struct HdfDeviceIoClient *client,
489 struct HdfSBuf *data, struct HdfSBuf *reply)
490 {
491 if (client == NULL || data == NULL || reply == NULL) {
492 AUDIO_FUNC_LOGE("client or data or reply is null!");
493 return AUDIO_HAL_ERR_INVALID_PARAM;
494 }
495 int32_t ret;
496 bool mute = false;
497 struct AudioCapture *capture = NULL;
498 ret = AudioAdapterListCheckAndGetCapture(&capture, data);
499 if (ret < 0) {
500 return ret;
501 }
502 if (capture == NULL || capture->volume.GetMute == NULL) {
503 AUDIO_FUNC_LOGE("capture or GetMute is NULL");
504 return AUDIO_HAL_ERR_INTERNAL;
505 }
506 ret = capture->volume.GetMute((AudioHandle)capture, &mute);
507 if (ret < 0) {
508 AUDIO_FUNC_LOGE("getmute failed! ret = %{public}d", ret);
509 return ret;
510 }
511 uint32_t tempMute = (uint32_t)mute;
512 if (!HdfSbufWriteUint32(reply, tempMute)) {
513 return AUDIO_HAL_ERR_INTERNAL;
514 }
515 return AUDIO_HAL_SUCCESS;
516 }
517
HdiServiceCaptureSetMute(const struct HdfDeviceIoClient * client,struct HdfSBuf * data,struct HdfSBuf * reply)518 int32_t HdiServiceCaptureSetMute(const struct HdfDeviceIoClient *client,
519 struct HdfSBuf *data, struct HdfSBuf *reply)
520 {
521 if (client == NULL || data == NULL || reply == NULL) {
522 AUDIO_FUNC_LOGE("client or data or reply is null!");
523 return AUDIO_HAL_ERR_INVALID_PARAM;
524 }
525 bool mute = false;
526 struct AudioCapture *capture = NULL;
527 int ret = AudioAdapterListCheckAndGetCapture(&capture, data);
528 if (ret < 0) {
529 return ret;
530 }
531 uint32_t tempMute = 0;
532 if (!HdfSbufReadUint32(data, &tempMute)) {
533 return AUDIO_HAL_ERR_INTERNAL;
534 }
535 mute = (bool)tempMute;
536 if (capture == NULL || capture->volume.SetMute == NULL) {
537 AUDIO_FUNC_LOGE("capture or SetMute is NULL");
538 return AUDIO_HAL_ERR_INTERNAL;
539 }
540 return capture->volume.SetMute((AudioHandle)capture, mute);
541 }
542
HdiServiceCaptureSetVolume(const struct HdfDeviceIoClient * client,struct HdfSBuf * data,struct HdfSBuf * reply)543 int32_t HdiServiceCaptureSetVolume(const struct HdfDeviceIoClient *client,
544 struct HdfSBuf *data, struct HdfSBuf *reply)
545 {
546 if (client == NULL || data == NULL || reply == NULL) {
547 AUDIO_FUNC_LOGE("client or data or reply is null!");
548 return AUDIO_HAL_ERR_INVALID_PARAM;
549 }
550 uint32_t volume = 0;
551 struct AudioCapture *capture = NULL;
552 int ret = AudioAdapterListCheckAndGetCapture(&capture, data);
553 if (ret < 0) {
554 return ret;
555 }
556 if (!HdfSbufReadUint32(data, &volume)) {
557 return AUDIO_HAL_ERR_INTERNAL;
558 }
559 float setVolume = (float)volume / VOLUME_CHANGE;
560 if (capture == NULL || capture->volume.SetVolume == NULL) {
561 AUDIO_FUNC_LOGE("capture or SetVolume is NULL");
562 return AUDIO_HAL_ERR_INTERNAL;
563 }
564 return capture->volume.SetVolume((AudioHandle)capture, setVolume);
565 }
566
HdiServiceCaptureGetVolume(const struct HdfDeviceIoClient * client,struct HdfSBuf * data,struct HdfSBuf * reply)567 int32_t HdiServiceCaptureGetVolume(const struct HdfDeviceIoClient *client,
568 struct HdfSBuf *data, struct HdfSBuf *reply)
569 {
570 if (client == NULL || data == NULL || reply == NULL) {
571 AUDIO_FUNC_LOGE("client or data or reply is null!");
572 return AUDIO_HAL_ERR_INVALID_PARAM;
573 }
574 float volume;
575 struct AudioCapture *capture = NULL;
576 int ret = AudioAdapterListCheckAndGetCapture(&capture, data);
577 if (ret < 0) {
578 return ret;
579 }
580 if (capture == NULL || capture->volume.GetVolume == NULL) {
581 AUDIO_FUNC_LOGE("capture or GetVolume is NULL");
582 return AUDIO_HAL_ERR_INTERNAL;
583 }
584 ret = capture->volume.GetVolume((AudioHandle)capture, &volume);
585 if (ret < 0) {
586 return ret;
587 }
588 uint32_t tempVolume = (uint32_t)(volume * VOLUME_CHANGE);
589 if (!HdfSbufWriteUint32(reply, tempVolume)) {
590 return AUDIO_HAL_ERR_INTERNAL;
591 }
592 return AUDIO_HAL_SUCCESS;
593 }
594
HdiServiceCaptureGetGainThreshold(const struct HdfDeviceIoClient * client,struct HdfSBuf * data,struct HdfSBuf * reply)595 int32_t HdiServiceCaptureGetGainThreshold(const struct HdfDeviceIoClient *client,
596 struct HdfSBuf *data, struct HdfSBuf *reply)
597 {
598 if (client == NULL || data == NULL || reply == NULL) {
599 AUDIO_FUNC_LOGE("client or data or reply is null!");
600 return AUDIO_HAL_ERR_INVALID_PARAM;
601 }
602 float min, max;
603 uint32_t tempMin;
604 uint32_t tempMax;
605 struct AudioCapture *capture = NULL;
606 int ret = AudioAdapterListCheckAndGetCapture(&capture, data);
607 if (ret < 0) {
608 return ret;
609 }
610 if (capture == NULL || capture->volume.GetGainThreshold == NULL) {
611 AUDIO_FUNC_LOGE("capture or GetGainThreshold is NULL");
612 return AUDIO_HAL_ERR_INTERNAL;
613 }
614 ret = capture->volume.GetGainThreshold((AudioHandle)capture, &min, &max);
615 if (ret < 0) {
616 AUDIO_FUNC_LOGE("GetGainThreshold failed! ret = %{public}d", ret);
617 return ret;
618 }
619 tempMin = (uint32_t)min;
620 if (!HdfSbufWriteUint32(reply, tempMin)) {
621 return AUDIO_HAL_ERR_INTERNAL;
622 }
623 tempMax = (uint32_t)max;
624 if (!HdfSbufWriteUint32(reply, tempMax)) {
625 return AUDIO_HAL_ERR_INTERNAL;
626 }
627 return AUDIO_HAL_SUCCESS;
628 }
629
HdiServiceCaptureGetGain(const struct HdfDeviceIoClient * client,struct HdfSBuf * data,struct HdfSBuf * reply)630 int32_t HdiServiceCaptureGetGain(const struct HdfDeviceIoClient *client,
631 struct HdfSBuf *data, struct HdfSBuf *reply)
632 {
633 if (client == NULL || data == NULL || reply == NULL) {
634 return AUDIO_HAL_ERR_INVALID_PARAM;
635 }
636 float gain;
637 struct AudioCapture *capture = NULL;
638 int ret = AudioAdapterListCheckAndGetCapture(&capture, data);
639 if (ret < 0) {
640 return ret;
641 }
642 if (capture == NULL || capture->volume.GetGain == NULL) {
643 AUDIO_FUNC_LOGE("capture or GetGain is NULL");
644 return AUDIO_HAL_ERR_INTERNAL;
645 }
646 ret = capture->volume.GetGain((AudioHandle)capture, &gain);
647 if (ret < 0) {
648 AUDIO_FUNC_LOGE("GetGain failed! ret = %{public}d", ret);
649 return ret;
650 }
651 uint32_t tempGain = (uint32_t)gain;
652 if (!HdfSbufWriteUint32(reply, tempGain)) {
653 return AUDIO_HAL_ERR_INTERNAL;
654 }
655 return AUDIO_HAL_SUCCESS;
656 }
657
HdiServiceCaptureSetGain(const struct HdfDeviceIoClient * client,struct HdfSBuf * data,struct HdfSBuf * reply)658 int32_t HdiServiceCaptureSetGain(const struct HdfDeviceIoClient *client,
659 struct HdfSBuf *data, struct HdfSBuf *reply)
660 {
661 if (client == NULL || data == NULL || reply == NULL) {
662 return AUDIO_HAL_ERR_INVALID_PARAM;
663 }
664 uint32_t gain = 0;
665 struct AudioCapture *capture = NULL;
666 int ret = AudioAdapterListCheckAndGetCapture(&capture, data);
667 if (ret < 0) {
668 return ret;
669 }
670 if (!HdfSbufReadUint32(data, &gain)) {
671 return AUDIO_HAL_ERR_INTERNAL;
672 }
673 if (capture == NULL || capture->volume.SetGain == NULL) {
674 AUDIO_FUNC_LOGE("capture or SetGain is NULL");
675 return AUDIO_HAL_ERR_INTERNAL;
676 }
677 return capture->volume.SetGain((AudioHandle)capture, (float)gain);
678 }
679
HdiServiceCaptureCaptureFrame(const struct HdfDeviceIoClient * client,struct HdfSBuf * data,struct HdfSBuf * reply)680 int32_t HdiServiceCaptureCaptureFrame(const struct HdfDeviceIoClient *client,
681 struct HdfSBuf *data, struct HdfSBuf *reply)
682 {
683 if (client == NULL || data == NULL || reply == NULL) {
684 return AUDIO_HAL_ERR_INVALID_PARAM;
685 }
686 char *frame = NULL;
687 uint64_t requestBytes = 0;
688 uint64_t replyBytes = 0;
689 struct AudioCapture *capture = NULL;
690 const char *adapterName = NULL;
691 uint32_t pid = 0;
692 uint32_t index = 0;
693 if (HdiServiceRenderCaptureReadData(data, &adapterName, &pid) < 0) {
694 AUDIO_FUNC_LOGE("HdiServiceRenderRenderFrame:HdiServiceRenderCaptureReadData fail!");
695 return AUDIO_HAL_ERR_INTERNAL;
696 }
697 int32_t ret = AudioAdapterFrameGetCapture(adapterName, &capture, pid, &index);
698 if (ret < 0) {
699 AUDIO_FUNC_LOGE("AudioAdapterListGetRender fail");
700 return ret;
701 }
702 if (!HdfSbufReadUint64(data, &requestBytes)) {
703 return AUDIO_HAL_ERR_INTERNAL;
704 }
705 frame = (char *)OsalMemCalloc(FRAME_DATA);
706 if (frame == NULL) {
707 return AUDIO_HAL_ERR_MALLOC_FAIL;
708 }
709 AudioSetCaptureBusy(index, true);
710 if (capture == NULL || capture->CaptureFrame == NULL) {
711 AUDIO_FUNC_LOGE("capture or CaptureFrame is NULL");
712 return AUDIO_HAL_ERR_INTERNAL;
713 }
714 ret = capture->CaptureFrame((AudioHandle)capture, (void *)frame, requestBytes, &replyBytes);
715 AudioSetCaptureBusy(index, false);
716 if (ret < 0) {
717 AudioMemFree((void **)&frame);
718 return ret;
719 }
720 if (!HdfSbufWriteBuffer(reply, (const void *)frame, (uint32_t)requestBytes)) {
721 AudioMemFree((void **)&frame);
722 return AUDIO_HAL_ERR_INTERNAL;
723 }
724 if (!HdfSbufWriteUint64(reply, replyBytes)) {
725 AudioMemFree((void **)&frame);
726 return AUDIO_HAL_ERR_INTERNAL;
727 }
728 AudioMemFree((void **)&frame);
729 return AUDIO_HAL_SUCCESS;
730 }
731
HdiServiceCaptureGetCapturePosition(const struct HdfDeviceIoClient * client,struct HdfSBuf * data,struct HdfSBuf * reply)732 int32_t HdiServiceCaptureGetCapturePosition(const struct HdfDeviceIoClient *client,
733 struct HdfSBuf *data, struct HdfSBuf *reply)
734 {
735 if (client == NULL || data == NULL || reply == NULL) {
736 return AUDIO_HAL_ERR_INVALID_PARAM;
737 }
738 struct AudioTimeStamp time;
739 uint64_t frames;
740 struct AudioCapture *capture = NULL;
741 int32_t ret = AudioAdapterListCheckAndGetCapture(&capture, data);
742 if (ret < 0) {
743 return ret;
744 }
745 if (capture == NULL || capture->GetCapturePosition == NULL) {
746 AUDIO_FUNC_LOGE("capture or GetCapturePosition is NULL");
747 return AUDIO_HAL_ERR_INTERNAL;
748 }
749 ret = capture->GetCapturePosition((AudioHandle)capture, &frames, &time);
750 if (ret < 0) {
751 AUDIO_FUNC_LOGE("GetCapturePosition fail");
752 return ret;
753 }
754 if (HdiServicePositionWrite(reply, frames, time) < 0) {
755 return AUDIO_HAL_ERR_INTERNAL;
756 }
757 return AUDIO_HAL_SUCCESS;
758 }
759
HdiServiceCaptureSetExtraParams(const struct HdfDeviceIoClient * client,struct HdfSBuf * data,struct HdfSBuf * reply)760 int32_t HdiServiceCaptureSetExtraParams(const struct HdfDeviceIoClient *client,
761 struct HdfSBuf *data, struct HdfSBuf *reply)
762 {
763 if (client == NULL || data == NULL || reply == NULL) {
764 return AUDIO_HAL_ERR_INVALID_PARAM;
765 }
766 struct AudioCapture *capture = NULL;
767 int ret = AudioAdapterListCheckAndGetCapture(&capture, data);
768 if (ret < 0) {
769 return ret;
770 }
771 const char *keyValueList = NULL;
772 if ((keyValueList = HdfSbufReadString(data)) == NULL) {
773 AUDIO_FUNC_LOGE("keyValueList Is NULL");
774 return AUDIO_HAL_ERR_INVALID_PARAM;
775 }
776 if (capture == NULL || capture->attr.SetExtraParams == NULL) {
777 AUDIO_FUNC_LOGE("capture or SetExtraParams is NULL");
778 return AUDIO_HAL_ERR_INTERNAL;
779 }
780 return capture->attr.SetExtraParams((AudioHandle)capture, keyValueList);
781 }
782
HdiServiceCaptureGetExtraParams(const struct HdfDeviceIoClient * client,struct HdfSBuf * data,struct HdfSBuf * reply)783 int32_t HdiServiceCaptureGetExtraParams(const struct HdfDeviceIoClient *client,
784 struct HdfSBuf *data, struct HdfSBuf *reply)
785 {
786 int32_t ret;
787 if (client == NULL || data == NULL || reply == NULL) {
788 return AUDIO_HAL_ERR_INVALID_PARAM;
789 }
790 struct AudioCapture *capture = NULL;
791 ret = AudioAdapterListCheckAndGetCapture(&capture, data);
792 if (ret < 0) {
793 return ret;
794 }
795 int32_t listLenth = 0;
796 if (!HdfSbufReadInt32(data, &listLenth)) {
797 return AUDIO_HAL_ERR_INTERNAL;
798 }
799 if (listLenth <= 0 || listLenth > STR_MAX - 1) {
800 return AUDIO_HAL_ERR_INTERNAL;
801 }
802 char keyValueList[STR_MAX] = { 0 };
803 if (capture == NULL || capture->attr.GetExtraParams == NULL) {
804 AUDIO_FUNC_LOGE("capture or GetExtraParams is NULL");
805 return AUDIO_HAL_ERR_INTERNAL;
806 }
807 ret = capture->attr.GetExtraParams((AudioHandle)capture, keyValueList, listLenth);
808 if (ret < 0) {
809 AUDIO_FUNC_LOGE("GetExtraParams failed! ret = %{public}d", ret);
810 return ret;
811 }
812 char *keyList = keyValueList;
813 if (!HdfSbufWriteString(reply, keyList)) {
814 return AUDIO_HAL_ERR_INTERNAL;
815 }
816 return AUDIO_HAL_SUCCESS;
817 }
818
HdiServiceCaptureReqMmapBuffer(const struct HdfDeviceIoClient * client,struct HdfSBuf * data,struct HdfSBuf * reply)819 int32_t HdiServiceCaptureReqMmapBuffer(const struct HdfDeviceIoClient *client,
820 struct HdfSBuf *data, struct HdfSBuf *reply)
821 {
822 if (client == NULL || data == NULL || reply == NULL) {
823 return AUDIO_HAL_ERR_INVALID_PARAM;
824 }
825 struct AudioCapture *capture = NULL;
826 int32_t ret = AudioAdapterListCheckAndGetCapture(&capture, data);
827 if (ret < 0) {
828 return ret;
829 }
830
831 struct AudioMmapBufferDescriptor desc;
832 int32_t reqSize = 0;
833 if (!HdfSbufReadInt32(data, &reqSize)) {
834 return AUDIO_HAL_ERR_INTERNAL;
835 }
836 if (HdiServiceReqMmapBuffer(&desc, data) < 0) {
837 return AUDIO_HAL_ERR_INTERNAL;
838 }
839 if (capture == NULL || capture->attr.ReqMmapBuffer == NULL) {
840 AUDIO_FUNC_LOGE("capture or ReqMmapBuffer is NULL");
841 return AUDIO_HAL_ERR_INTERNAL;
842 }
843 ret = capture->attr.ReqMmapBuffer((AudioHandle)capture, reqSize, &desc);
844 if (ret < 0) {
845 AUDIO_FUNC_LOGE("ReqMmapBuffer fail");
846 return ret;
847 }
848
849 if (!HdfSbufWriteFileDescriptor(reply, desc.memoryFd)) {
850 AUDIO_FUNC_LOGE("memoryFd write fail");
851 return AUDIO_HAL_ERR_INTERNAL;
852 }
853
854 if (!HdfSbufWriteInt32(reply, desc.totalBufferFrames)) {
855 AUDIO_FUNC_LOGE("totalBufferFrames write fail");
856 return AUDIO_HAL_ERR_INTERNAL;
857 }
858
859 if (!HdfSbufWriteInt32(reply, desc.transferFrameSize)) {
860 AUDIO_FUNC_LOGE("transferFrameSize write fail");
861 return AUDIO_HAL_ERR_INTERNAL;
862 }
863
864 if (!HdfSbufWriteInt32(reply, desc.isShareable)) {
865 AUDIO_FUNC_LOGE("isShareable write fail");
866 return AUDIO_HAL_ERR_INTERNAL;
867 }
868
869 if (!HdfSbufWriteUint32(reply, desc.offset)) {
870 AUDIO_FUNC_LOGE("offset write fail");
871 return AUDIO_HAL_ERR_INTERNAL;
872 }
873 return AUDIO_HAL_SUCCESS;
874 }
875
HdiServiceCaptureGetMmapPosition(const struct HdfDeviceIoClient * client,struct HdfSBuf * data,struct HdfSBuf * reply)876 int32_t HdiServiceCaptureGetMmapPosition(const struct HdfDeviceIoClient *client,
877 struct HdfSBuf *data, struct HdfSBuf *reply)
878 {
879 if (client == NULL || data == NULL || reply == NULL) {
880 return AUDIO_HAL_ERR_INVALID_PARAM;
881 }
882 uint64_t frames;
883 struct AudioTimeStamp time;
884 struct AudioCapture *capture = NULL;
885 int32_t ret = AudioAdapterListCheckAndGetCapture(&capture, data);
886 if (ret < 0) {
887 return ret;
888 }
889
890 if (capture == NULL || capture->attr.GetMmapPosition == NULL) {
891 AUDIO_FUNC_LOGE("capture or GetMmapPosition is NULL");
892 return AUDIO_HAL_ERR_INTERNAL;
893 }
894 ret = capture->attr.GetMmapPosition((AudioHandle)capture, &frames, &time);
895 if (ret < 0) {
896 AUDIO_FUNC_LOGE("GetMmapPosition failed! ret = %{public}d", ret);
897 return ret;
898 }
899 if (HdiServicePositionWrite(reply, frames, time) < 0) {
900 return AUDIO_HAL_ERR_INTERNAL;
901 }
902 return AUDIO_HAL_SUCCESS;
903 }
904
HdiServiceCaptureAddEffect(const struct HdfDeviceIoClient * client,struct HdfSBuf * data,struct HdfSBuf * reply)905 int32_t HdiServiceCaptureAddEffect(const struct HdfDeviceIoClient *client,
906 struct HdfSBuf *data, struct HdfSBuf *reply)
907 {
908 (void)client;
909 (void)reply;
910 uint64_t effectid = 0;
911 struct AudioCapture *capture = NULL;
912 if (data == NULL) {
913 return AUDIO_HAL_ERR_INVALID_PARAM;
914 }
915
916 int32_t ret = AudioAdapterListCheckAndGetCapture(&capture, data);
917 if (ret < 0 || capture == NULL) {
918 AUDIO_FUNC_LOGE("capture is null or ret = %{public}d", ret);
919 return ret;
920 }
921
922 if (!HdfSbufReadUint64(data, &effectid)) {
923 AUDIO_FUNC_LOGE("SbufReadUint64 failed ");
924 return HDF_FAILURE;
925 }
926
927 if (capture->attr.AddAudioEffect == NULL) {
928 AUDIO_FUNC_LOGE("capture or GetMmapPosition is NULL");
929 return AUDIO_HAL_ERR_INTERNAL;
930 }
931 return capture->attr.AddAudioEffect((AudioHandle)capture, effectid);
932 }
933
HdiServiceCaptureRemoveEffect(const struct HdfDeviceIoClient * client,struct HdfSBuf * data,struct HdfSBuf * reply)934 int32_t HdiServiceCaptureRemoveEffect(const struct HdfDeviceIoClient *client,
935 struct HdfSBuf *data, struct HdfSBuf *reply)
936 {
937 (void)client;
938 (void)reply;
939 uint64_t effectid = 0;
940 if (data == NULL) {
941 return AUDIO_HAL_ERR_INVALID_PARAM;
942 }
943
944 struct AudioCapture *capture = NULL;
945 int32_t ret = AudioAdapterListCheckAndGetCapture(&capture, data);
946 if (ret < 0 || capture == NULL) {
947 AUDIO_FUNC_LOGE("capture is NULL or ret = %{public}d", ret);
948 return ret;
949 }
950
951 if (!HdfSbufReadUint64(data, &effectid)) {
952 AUDIO_FUNC_LOGE("HdfSbufReadUint64 failed.");
953 return HDF_FAILURE;
954 }
955
956 if (capture->attr.RemoveAudioEffect == NULL) {
957 AUDIO_FUNC_LOGE("capture or GetMmapPosition is NULL");
958 return AUDIO_HAL_ERR_INTERNAL;
959 }
960 return capture->attr.RemoveAudioEffect((AudioHandle)capture, effectid);
961 }
962
HdiServiceCaptureTurnStandbyMode(const struct HdfDeviceIoClient * client,struct HdfSBuf * data,struct HdfSBuf * reply)963 int32_t HdiServiceCaptureTurnStandbyMode(const struct HdfDeviceIoClient *client,
964 struct HdfSBuf *data, struct HdfSBuf *reply)
965 {
966 if (client == NULL || data == NULL || reply == NULL) {
967 AUDIO_FUNC_LOGE("The pointer is null");
968 return AUDIO_HAL_ERR_INVALID_PARAM;
969 }
970 struct AudioCapture *capture = NULL;
971 int ret = AudioAdapterListCheckAndGetCapture(&capture, data);
972 if (ret < 0) {
973 return ret;
974 }
975 if (capture == NULL || capture->control.Stop == NULL) {
976 AUDIO_FUNC_LOGE("capture or Stop is NULL");
977 return AUDIO_HAL_ERR_INTERNAL;
978 }
979 return capture->control.Stop((AudioHandle)capture);
980 }
981
HdiServiceCaptureDevDump(const struct HdfDeviceIoClient * client,struct HdfSBuf * data,struct HdfSBuf * reply)982 int32_t HdiServiceCaptureDevDump(const struct HdfDeviceIoClient *client,
983 struct HdfSBuf *data, struct HdfSBuf *reply)
984 {
985 if (client == NULL || data == NULL || reply == NULL) {
986 AUDIO_FUNC_LOGE("parameter Is NULL");
987 return AUDIO_HAL_ERR_INVALID_PARAM;
988 }
989 struct AudioCapture *capture = NULL;
990 int ret = AudioAdapterListCheckAndGetCapture(&capture, data);
991 if (ret < 0) {
992 return ret;
993 }
994 int32_t range = 0;
995 if (!HdfSbufReadInt32(data, &range)) {
996 return AUDIO_HAL_ERR_INTERNAL;
997 }
998 ret = HdfSbufReadFileDescriptor(data);
999 if (ret < 0) {
1000 return AUDIO_HAL_ERR_INTERNAL;
1001 }
1002 int32_t fd = ret;
1003 if (capture == NULL || capture->control.AudioDevDump == NULL) {
1004 AUDIO_FUNC_LOGE("capture or AudioDevDump is NULL");
1005 return AUDIO_HAL_ERR_INTERNAL;
1006 }
1007 return capture->control.AudioDevDump((AudioHandle)capture, range, fd);
1008 }
1009
1010