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