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