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 "audio_hal_log.h"
18 #include "hdf_audio_server_common.h"
19
GetInitCaptureParaAttrs(struct HdfSBuf * data,struct AudioSampleAttributes * attrs)20 int32_t GetInitCaptureParaAttrs(struct HdfSBuf *data, struct AudioSampleAttributes *attrs)
21 {
22 if (data == NULL || attrs == NULL) {
23 return HDF_FAILURE;
24 }
25 uint32_t tempCapturePara = 0;
26 if (!HdfSbufReadUint32(data, &tempCapturePara)) {
27 HDF_LOGE("%{public}s: Capture read tempCapturePara fail", __func__);
28 return HDF_FAILURE;
29 }
30 attrs->type = (enum AudioCategory)tempCapturePara;
31 if (!HdfSbufReadUint32(data, &attrs->period)) {
32 HDF_LOGE("%{public}s: Capture read period fail", __func__);
33 return HDF_FAILURE;
34 }
35 if (!HdfSbufReadUint32(data, &attrs->frameSize)) {
36 HDF_LOGE("%{public}s: Capture read frameSize fail", __func__);
37 return HDF_FAILURE;
38 }
39 if (!HdfSbufReadUint32(data, &attrs->startThreshold)) {
40 HDF_LOGE("%{public}s: Capture read startThreshold fail", __func__);
41 return HDF_FAILURE;
42 }
43 if (!HdfSbufReadUint32(data, &attrs->stopThreshold)) {
44 HDF_LOGE("%{public}s: Capture read stopThreshold fail", __func__);
45 return HDF_FAILURE;
46 }
47 if (!HdfSbufReadUint32(data, &attrs->silenceThreshold)) {
48 HDF_LOGE("%{public}s: Capture read silenceThreshold fail", __func__);
49 return HDF_FAILURE;
50 }
51 if (!HdfSbufReadUint32(data, &tempCapturePara)) {
52 HDF_LOGE("%{public}s: Failed to Get Speed sBuf!", __func__);
53 return HDF_FAILURE;
54 }
55 attrs->isBigEndian = (bool)tempCapturePara;
56 if (!HdfSbufReadUint32(data, &tempCapturePara)) {
57 HDF_LOGE("%{public}s: Failed to Get Speed sBuf!", __func__);
58 return HDF_FAILURE;
59 }
60 attrs->isSignedData = (bool)tempCapturePara;
61 return HDF_SUCCESS;
62 }
63
GetInitCapturePara(struct HdfSBuf * data,struct AudioDeviceDescriptor * devDesc,struct AudioSampleAttributes * attrs)64 int32_t GetInitCapturePara(struct HdfSBuf *data, struct AudioDeviceDescriptor *devDesc,
65 struct AudioSampleAttributes *attrs)
66 {
67 if (data == NULL || devDesc == NULL || attrs == NULL) {
68 return HDF_FAILURE;
69 }
70 uint32_t tempCapturePara = 0;
71 if (!HdfSbufReadUint32(data, &tempCapturePara)) {
72 HDF_LOGE("%{public}s: Failed to Get Speed sBuf!", __func__);
73 return HDF_FAILURE;
74 }
75 attrs->format = (enum AudioFormat)tempCapturePara;
76 if (!HdfSbufReadUint32(data, &attrs->channelCount)) {
77 HDF_LOGE("%{public}s: read channelCount fail", __func__);
78 return HDF_FAILURE;
79 }
80 if (!HdfSbufReadUint32(data, &attrs->sampleRate)) {
81 HDF_LOGE("%{public}s: read sampleRate fail", __func__);
82 return HDF_FAILURE;
83 }
84 if (!HdfSbufReadUint32(data, &tempCapturePara)) {
85 HDF_LOGE("%{public}s: Failed to Get Speed sBuf!", __func__);
86 return HDF_FAILURE;
87 }
88 attrs->interleaved = (bool)tempCapturePara;
89 if (GetInitCaptureParaAttrs(data, attrs) < 0) {
90 return HDF_FAILURE;
91 }
92 if (!HdfSbufReadUint32(data, &devDesc->portId)) {
93 HDF_LOGE("%{public}s: read portId fail", __func__);
94 return HDF_FAILURE;
95 }
96 if (!HdfSbufReadUint32(data, &tempCapturePara)) {
97 HDF_LOGE("%{public}s: read tempCapturePara fail", __func__);
98 return HDF_FAILURE;
99 }
100 devDesc->pins = (enum AudioPortPin)tempCapturePara;
101 devDesc->desc = NULL;
102 return HDF_SUCCESS;
103 }
104
HdiServiceCreatCapture(const struct HdfDeviceIoClient * client,struct HdfSBuf * data,struct HdfSBuf * reply)105 int32_t HdiServiceCreatCapture(const struct HdfDeviceIoClient *client, struct HdfSBuf *data, struct HdfSBuf *reply)
106 {
107 if (client == NULL || data == NULL || reply == NULL) {
108 return AUDIO_HAL_ERR_INVALID_PARAM;
109 }
110 struct AudioAdapter *adapter = NULL;
111 struct AudioDeviceDescriptor devDesc;
112 struct AudioSampleAttributes attrs;
113 struct AudioCapture *capture = NULL;
114 const char *adapterName = NULL;
115 uint32_t capturePid = 0;
116 if ((adapterName = HdfSbufReadString(data)) == NULL) {
117 HDF_LOGE("%{public}s: adapterNameCase Is NULL", __func__);
118 return AUDIO_HAL_ERR_INVALID_PARAM;
119 }
120 if (!HdfSbufReadUint32(data, &capturePid)) {
121 HDF_LOGE("%{public}s: read capturePid fail", __func__);
122 return AUDIO_HAL_ERR_INTERNAL;
123 }
124 HDF_LOGE("%{public}s, capturePid = %{public}u", __func__, capturePid);
125 int32_t ret = GetInitCapturePara(data, &devDesc, &attrs);
126 if (ret < 0) {
127 HDF_LOGE("%{public}s: read Render param failure!", __func__);
128 return AUDIO_HAL_ERR_INTERNAL;
129 }
130 if (AudioAdapterListGetAdapter(adapterName, &adapter)) {
131 HDF_LOGE("%{public}s: AudioAdapterListGetAdapter fail", __func__);
132 return AUDIO_HAL_ERR_INTERNAL;
133 }
134 if (adapter == NULL) {
135 HDF_LOGE("%{public}s: adapter is empty!", __func__);
136 return AUDIO_HAL_ERR_INVALID_PARAM;
137 }
138 const int32_t priority = attrs.type;
139 ret = AudioCreatCaptureCheck(adapterName, priority);
140 if (ret < 0) {
141 HDF_LOGE("%{public}s: AudioCreatRenderCheck: Capture is working can not replace!", __func__);
142 return ret;
143 }
144 ret = adapter->CreateCapture(adapter, &devDesc, &attrs, &capture);
145 if (capture == NULL || ret < 0) {
146 HDF_LOGE("%{public}s: Failed to CreateCapture", __func__);
147 return AUDIO_HAL_ERR_INTERNAL;
148 }
149 if (AudioAddCaptureInfoInAdapter(adapterName, capture, adapter, priority, capturePid)) {
150 HDF_LOGE("%{public}s: AudioAddRenderInfoInAdapter", __func__);
151 adapter->DestroyCapture(adapter, capture);
152 return AUDIO_HAL_ERR_INTERNAL;
153 }
154 return AUDIO_HAL_SUCCESS;
155 }
156
HdiServiceCaptureDestory(const struct HdfDeviceIoClient * client,struct HdfSBuf * data,struct HdfSBuf * reply)157 int32_t HdiServiceCaptureDestory(const struct HdfDeviceIoClient *client, struct HdfSBuf *data, struct HdfSBuf *reply)
158 {
159 if (client == NULL || data == NULL || reply == NULL) {
160 return AUDIO_HAL_ERR_INVALID_PARAM;
161 }
162 struct AudioAdapter *adapter = NULL;
163 struct AudioCapture *capture = NULL;
164 const char *adapterName = NULL;
165 uint32_t pid = 0;
166 if (HdiServiceRenderCaptureReadData(data, &adapterName, &pid) < 0) {
167 return AUDIO_HAL_ERR_INTERNAL;
168 }
169 int32_t ret = AudioAdapterListGetCapture(adapterName, &capture, pid);
170 if (ret < 0) {
171 HDF_LOGE("%{public}s: AudioAdapterListGetAdapter fail", __func__);
172 return ret;
173 }
174 ret = AudioAdapterListGetAdapterCapture(adapterName, &adapter, &capture);
175 if (ret < 0) {
176 HDF_LOGE("%{public}s: AudioAdapterListGetAdapter fail", __func__);
177 return ret;
178 }
179 ret = adapter->DestroyCapture(adapter, capture);
180 if (ret < 0) {
181 HDF_LOGE("%{public}s: DestroyCapture failed!", __func__);
182 return ret;
183 }
184 if (AudioDestroyCaptureInfoInAdapter(adapterName)) {
185 return AUDIO_HAL_ERR_INTERNAL;
186 }
187 return AUDIO_HAL_SUCCESS;
188 }
189
HdiServiceCaptureStart(const struct HdfDeviceIoClient * client,struct HdfSBuf * data,struct HdfSBuf * reply)190 int32_t HdiServiceCaptureStart(const struct HdfDeviceIoClient *client, struct HdfSBuf *data, struct HdfSBuf *reply)
191 {
192 if (client == NULL || data == NULL || reply == NULL) {
193 return AUDIO_HAL_ERR_INVALID_PARAM;
194 }
195 struct AudioCapture *capture = NULL;
196 int ret = AudioAdapterListCheckAndGetCapture(&capture, data);
197 if (ret < 0) {
198 return ret;
199 }
200 return capture->control.Start((AudioHandle)capture);
201 }
202
HdiServiceCaptureStop(const struct HdfDeviceIoClient * client,struct HdfSBuf * data,struct HdfSBuf * reply)203 int32_t HdiServiceCaptureStop(const struct HdfDeviceIoClient *client, struct HdfSBuf *data, struct HdfSBuf *reply)
204 {
205 if (client == NULL || data == NULL || reply == NULL) {
206 return AUDIO_HAL_ERR_INVALID_PARAM;
207 }
208 struct AudioCapture *capture = NULL;
209 int ret = AudioAdapterListCheckAndGetCapture(&capture, data);
210 if (ret < 0) {
211 return ret;
212 }
213 return capture->control.Stop((AudioHandle)capture);
214 }
215
HdiServiceCapturePause(const struct HdfDeviceIoClient * client,struct HdfSBuf * data,struct HdfSBuf * reply)216 int32_t HdiServiceCapturePause(const struct HdfDeviceIoClient *client, struct HdfSBuf *data, struct HdfSBuf *reply)
217 {
218 if (client == NULL || data == NULL || reply == NULL) {
219 return AUDIO_HAL_ERR_INVALID_PARAM;
220 }
221 struct AudioCapture *capture = NULL;
222 int ret = AudioAdapterListCheckAndGetCapture(&capture, data);
223 if (ret < 0) {
224 return ret;
225 }
226 return capture->control.Pause((AudioHandle)capture);
227 }
228
HdiServiceCaptureResume(const struct HdfDeviceIoClient * client,struct HdfSBuf * data,struct HdfSBuf * reply)229 int32_t HdiServiceCaptureResume(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 return capture->control.Resume((AudioHandle)capture);
240 }
241
HdiServiceCaptureFlush(const struct HdfDeviceIoClient * client,struct HdfSBuf * data,struct HdfSBuf * reply)242 int32_t HdiServiceCaptureFlush(const struct HdfDeviceIoClient *client, struct HdfSBuf *data, struct HdfSBuf *reply)
243 {
244 if (client == NULL || data == NULL || reply == NULL) {
245 return AUDIO_HAL_ERR_INVALID_PARAM;
246 }
247 struct AudioCapture *capture = NULL;
248 int ret = AudioAdapterListCheckAndGetCapture(&capture, data);
249 if (ret < 0) {
250 return ret;
251 }
252 return capture->control.Flush((AudioHandle)capture);
253 }
254
HdiServiceCaptureGetFrameSize(const struct HdfDeviceIoClient * client,struct HdfSBuf * data,struct HdfSBuf * reply)255 int32_t HdiServiceCaptureGetFrameSize(const struct HdfDeviceIoClient *client,
256 struct HdfSBuf *data, struct HdfSBuf *reply)
257 {
258 if (client == NULL || data == NULL || reply == NULL) {
259 return AUDIO_HAL_ERR_INVALID_PARAM;
260 }
261 uint64_t size;
262 struct AudioCapture *capture = NULL;
263 int ret = AudioAdapterListCheckAndGetCapture(&capture, data);
264 if (ret < 0) {
265 return ret;
266 }
267 if (capture->attr.GetFrameSize((AudioHandle)capture, &size)) {
268 return AUDIO_HAL_ERR_INTERNAL;
269 }
270 if (!HdfSbufWriteUint64(reply, size)) {
271 return AUDIO_HAL_ERR_INTERNAL;
272 }
273 return AUDIO_HAL_SUCCESS;
274 }
275
HdiServiceCaptureGetFrameCount(const struct HdfDeviceIoClient * client,struct HdfSBuf * data,struct HdfSBuf * reply)276 int32_t HdiServiceCaptureGetFrameCount(const struct HdfDeviceIoClient *client,
277 struct HdfSBuf *data, struct HdfSBuf *reply)
278 {
279 if (client == NULL || data == NULL || reply == NULL) {
280 return AUDIO_HAL_ERR_INVALID_PARAM;
281 }
282 uint64_t count;
283 struct AudioCapture *capture = NULL;
284 int ret = AudioAdapterListCheckAndGetCapture(&capture, data);
285 if (ret < 0) {
286 return ret;
287 }
288 if (capture->attr.GetFrameCount((AudioHandle)capture, &count)) {
289 return AUDIO_HAL_ERR_INTERNAL;
290 }
291 if (!HdfSbufWriteUint64(reply, count)) {
292 return AUDIO_HAL_ERR_INTERNAL;
293 }
294 return AUDIO_HAL_SUCCESS;
295 }
296
HdiServiceCaptureSetSampleAttr(const struct HdfDeviceIoClient * client,struct HdfSBuf * data,struct HdfSBuf * reply)297 int32_t HdiServiceCaptureSetSampleAttr(const struct HdfDeviceIoClient *client,
298 struct HdfSBuf *data, struct HdfSBuf *reply)
299 {
300 if (client == NULL || data == NULL || reply == NULL) {
301 HDF_LOGE("%{public}s: The pointer is null!", __func__);
302 return AUDIO_HAL_ERR_INVALID_PARAM;
303 }
304 int ret;
305 struct AudioSampleAttributes attrs;
306 struct AudioCapture *capture = NULL;
307 ret = AudioAdapterListCheckAndGetCapture(&capture, data);
308 if (ret < 0) {
309 return ret;
310 }
311 if (ReadAudioSapmleAttrbutes(data, &attrs) < 0) {
312 return AUDIO_HAL_ERR_INTERNAL;
313 }
314 return capture->attr.SetSampleAttributes((AudioHandle)capture, &attrs);
315 }
316
HdiServiceCaptureGetSampleAttr(const struct HdfDeviceIoClient * client,struct HdfSBuf * data,struct HdfSBuf * reply)317 int32_t HdiServiceCaptureGetSampleAttr(const struct HdfDeviceIoClient *client,
318 struct HdfSBuf *data, struct HdfSBuf *reply)
319 {
320 if (client == NULL || data == NULL || reply == NULL) {
321 return AUDIO_HAL_ERR_INVALID_PARAM;
322 }
323 struct AudioSampleAttributes attrs;
324 struct AudioCapture *capture = NULL;
325 int ret = AudioAdapterListCheckAndGetCapture(&capture, data);
326 if (ret < 0) {
327 return ret;
328 }
329 ret = capture->attr.GetSampleAttributes((AudioHandle)capture, &attrs);
330 if (ret < 0) {
331 return ret;
332 }
333 if (WriteAudioSampleAttributes(reply, &attrs) < 0) {
334 return AUDIO_HAL_ERR_INTERNAL;
335 }
336 return AUDIO_HAL_SUCCESS;
337 }
338
HdiServiceCaptureGetCurChannelId(const struct HdfDeviceIoClient * client,struct HdfSBuf * data,struct HdfSBuf * reply)339 int32_t HdiServiceCaptureGetCurChannelId(const struct HdfDeviceIoClient *client,
340 struct HdfSBuf *data, struct HdfSBuf *reply)
341 {
342 if (client == NULL || data == NULL || reply == NULL) {
343 return AUDIO_HAL_ERR_INVALID_PARAM;
344 }
345 uint32_t channelId;
346 struct AudioCapture *capture = NULL;
347 int ret = AudioAdapterListCheckAndGetCapture(&capture, data);
348 if (ret < 0) {
349 return ret;
350 }
351 ret = capture->attr.GetCurrentChannelId((AudioHandle)capture, &channelId);
352 if (ret < 0) {
353 return ret;
354 }
355 if (!HdfSbufWriteUint32(reply, channelId)) {
356 return AUDIO_HAL_ERR_INTERNAL;
357 }
358 return AUDIO_HAL_SUCCESS;
359 }
360
HdiServiceCaptureCheckSceneCapability(const struct HdfDeviceIoClient * client,struct HdfSBuf * data,struct HdfSBuf * reply)361 int32_t HdiServiceCaptureCheckSceneCapability(const struct HdfDeviceIoClient *client,
362 struct HdfSBuf *data, struct HdfSBuf *reply)
363 {
364 if (client == NULL || data == NULL || reply == NULL) {
365 return AUDIO_HAL_ERR_INVALID_PARAM;
366 }
367 struct AudioSceneDescriptor scene;
368 bool supported = false;
369 struct AudioCapture *capture = NULL;
370 int ret = AudioAdapterListCheckAndGetCapture(&capture, data);
371 if (ret < 0) {
372 return ret;
373 }
374 if (!HdfSbufReadUint32(data, &scene.scene.id)) {
375 return AUDIO_HAL_ERR_INTERNAL;
376 }
377 uint32_t interimPins = 0;
378 if (!HdfSbufReadUint32(data, &interimPins)) {
379 return AUDIO_HAL_ERR_INTERNAL;
380 }
381 scene.desc.pins = (enum AudioPortPin) interimPins;
382 ret = capture->scene.CheckSceneCapability((AudioHandle)capture, &scene, &supported);
383 if (ret < 0) {
384 return ret;
385 }
386 uint32_t tempSupported = (uint32_t)supported;
387 if (!HdfSbufWriteUint32(reply, tempSupported)) {
388 return AUDIO_HAL_ERR_INTERNAL;
389 }
390 return AUDIO_HAL_SUCCESS;
391 }
392
HdiServiceCaptureSelectScene(const struct HdfDeviceIoClient * client,struct HdfSBuf * data,struct HdfSBuf * reply)393 int32_t HdiServiceCaptureSelectScene(const struct HdfDeviceIoClient *client,
394 struct HdfSBuf *data, struct HdfSBuf *reply)
395 {
396 if (client == NULL || data == NULL || reply == NULL) {
397 return AUDIO_HAL_ERR_INVALID_PARAM;
398 }
399 struct AudioSceneDescriptor scene;
400 struct AudioCapture *capture = NULL;
401 uint32_t tempPins = 0;
402 int ret = AudioAdapterListCheckAndGetCapture(&capture, data);
403 if (ret < 0) {
404 return ret;
405 }
406 if (!HdfSbufReadUint32(data, &scene.scene.id)) {
407 return AUDIO_HAL_ERR_INTERNAL;
408 }
409 if (!HdfSbufReadUint32(data, &tempPins)) {
410 return AUDIO_HAL_ERR_INTERNAL;
411 }
412 scene.desc.pins = (enum AudioPortPin) tempPins;
413 return capture->scene.SelectScene((AudioHandle)capture, &scene);
414 }
415
HdiServiceCaptureGetMute(const struct HdfDeviceIoClient * client,struct HdfSBuf * data,struct HdfSBuf * reply)416 int32_t HdiServiceCaptureGetMute(const struct HdfDeviceIoClient *client,
417 struct HdfSBuf *data, struct HdfSBuf *reply)
418 {
419 if (client == NULL || data == NULL || reply == NULL) {
420 return AUDIO_HAL_ERR_INVALID_PARAM;
421 }
422 int32_t ret;
423 bool mute = false;
424 struct AudioCapture *capture = NULL;
425 ret = AudioAdapterListCheckAndGetCapture(&capture, data);
426 if (ret < 0) {
427 return ret;
428 }
429 ret = capture->volume.GetMute((AudioHandle)capture, &mute);
430 if (ret < 0) {
431 return ret;
432 }
433 uint32_t tempMute = (uint32_t)mute;
434 if (!HdfSbufWriteUint32(reply, tempMute)) {
435 return AUDIO_HAL_ERR_INTERNAL;
436 }
437 return AUDIO_HAL_SUCCESS;
438 }
439
HdiServiceCaptureSetMute(const struct HdfDeviceIoClient * client,struct HdfSBuf * data,struct HdfSBuf * reply)440 int32_t HdiServiceCaptureSetMute(const struct HdfDeviceIoClient *client,
441 struct HdfSBuf *data, struct HdfSBuf *reply)
442 {
443 if (client == NULL || data == NULL || reply == NULL) {
444 return AUDIO_HAL_ERR_INVALID_PARAM;
445 }
446 bool mute = false;
447 struct AudioCapture *capture = NULL;
448 int ret = AudioAdapterListCheckAndGetCapture(&capture, data);
449 if (ret < 0) {
450 return ret;
451 }
452 uint32_t tempMute = 0;
453 if (!HdfSbufReadUint32(data, &tempMute)) {
454 return AUDIO_HAL_ERR_INTERNAL;
455 }
456 mute = (bool)tempMute;
457 return capture->volume.SetMute((AudioHandle)capture, mute);
458 }
459
HdiServiceCaptureSetVolume(const struct HdfDeviceIoClient * client,struct HdfSBuf * data,struct HdfSBuf * reply)460 int32_t HdiServiceCaptureSetVolume(const struct HdfDeviceIoClient *client,
461 struct HdfSBuf *data, struct HdfSBuf *reply)
462 {
463 if (client == NULL || data == NULL || reply == NULL) {
464 return AUDIO_HAL_ERR_INVALID_PARAM;
465 }
466 uint32_t volume = 0;
467 struct AudioCapture *capture = NULL;
468 int ret = AudioAdapterListCheckAndGetCapture(&capture, data);
469 if (ret < 0) {
470 return ret;
471 }
472 if (!HdfSbufReadUint32(data, &volume)) {
473 return AUDIO_HAL_ERR_INTERNAL;
474 }
475 float setVolume = (float)volume / VOLUME_CHANGE;
476 return capture->volume.SetVolume((AudioHandle)capture, setVolume);
477 }
478
HdiServiceCaptureGetVolume(const struct HdfDeviceIoClient * client,struct HdfSBuf * data,struct HdfSBuf * reply)479 int32_t HdiServiceCaptureGetVolume(const struct HdfDeviceIoClient *client,
480 struct HdfSBuf *data, struct HdfSBuf *reply)
481 {
482 if (client == NULL || data == NULL || reply == NULL) {
483 return AUDIO_HAL_ERR_INVALID_PARAM;
484 }
485 float volume;
486 struct AudioCapture *capture = NULL;
487 int ret = AudioAdapterListCheckAndGetCapture(&capture, data);
488 if (ret < 0) {
489 return ret;
490 }
491 ret = capture->volume.GetVolume((AudioHandle)capture, &volume);
492 if (ret < 0) {
493 return ret;
494 }
495 uint32_t tempVolume = (uint32_t)(volume * VOLUME_CHANGE);
496 if (!HdfSbufWriteUint32(reply, tempVolume)) {
497 return AUDIO_HAL_ERR_INTERNAL;
498 }
499 return AUDIO_HAL_SUCCESS;
500 }
501
HdiServiceCaptureGetGainThreshold(const struct HdfDeviceIoClient * client,struct HdfSBuf * data,struct HdfSBuf * reply)502 int32_t HdiServiceCaptureGetGainThreshold(const struct HdfDeviceIoClient *client,
503 struct HdfSBuf *data, struct HdfSBuf *reply)
504 {
505 if (client == NULL || data == NULL || reply == NULL) {
506 return AUDIO_HAL_ERR_INVALID_PARAM;
507 }
508 float min, max;
509 uint32_t tempMin;
510 uint32_t tempMax;
511 struct AudioCapture *capture = NULL;
512 int ret = AudioAdapterListCheckAndGetCapture(&capture, data);
513 if (ret < 0) {
514 return ret;
515 }
516 ret = capture->volume.GetGainThreshold((AudioHandle)capture, &min, &max);
517 if (ret < 0) {
518 return ret;
519 }
520 tempMin = (uint32_t)min;
521 if (!HdfSbufWriteUint32(reply, tempMin)) {
522 return AUDIO_HAL_ERR_INTERNAL;
523 }
524 tempMax = (uint32_t)max;
525 if (!HdfSbufWriteUint32(reply, tempMax)) {
526 return AUDIO_HAL_ERR_INTERNAL;
527 }
528 return AUDIO_HAL_SUCCESS;
529 }
530
HdiServiceCaptureGetGain(const struct HdfDeviceIoClient * client,struct HdfSBuf * data,struct HdfSBuf * reply)531 int32_t HdiServiceCaptureGetGain(const struct HdfDeviceIoClient *client,
532 struct HdfSBuf *data, struct HdfSBuf *reply)
533 {
534 if (client == NULL || data == NULL || reply == NULL) {
535 return AUDIO_HAL_ERR_INVALID_PARAM;
536 }
537 float gain;
538 struct AudioCapture *capture = NULL;
539 int ret = AudioAdapterListCheckAndGetCapture(&capture, data);
540 if (ret < 0) {
541 return ret;
542 }
543 ret = capture->volume.GetGain((AudioHandle)capture, &gain);
544 if (ret < 0) {
545 return ret;
546 }
547 uint32_t tempGain = (uint32_t)gain;
548 if (!HdfSbufWriteUint32(reply, tempGain)) {
549 return AUDIO_HAL_ERR_INTERNAL;
550 }
551 return AUDIO_HAL_SUCCESS;
552 }
553
HdiServiceCaptureSetGain(const struct HdfDeviceIoClient * client,struct HdfSBuf * data,struct HdfSBuf * reply)554 int32_t HdiServiceCaptureSetGain(const struct HdfDeviceIoClient *client,
555 struct HdfSBuf *data, struct HdfSBuf *reply)
556 {
557 if (client == NULL || data == NULL || reply == NULL) {
558 return AUDIO_HAL_ERR_INVALID_PARAM;
559 }
560 uint32_t gain = 0;
561 struct AudioCapture *capture = NULL;
562 int ret = AudioAdapterListCheckAndGetCapture(&capture, data);
563 if (ret < 0) {
564 return ret;
565 }
566 if (!HdfSbufReadUint32(data, &gain)) {
567 return AUDIO_HAL_ERR_INTERNAL;
568 }
569 return capture->volume.SetGain((AudioHandle)capture, (float)gain);
570 }
571
HdiServiceCaptureCaptureFrame(const struct HdfDeviceIoClient * client,struct HdfSBuf * data,struct HdfSBuf * reply)572 int32_t HdiServiceCaptureCaptureFrame(const struct HdfDeviceIoClient *client,
573 struct HdfSBuf *data, struct HdfSBuf *reply)
574 {
575 if (client == NULL || data == NULL || reply == NULL) {
576 return AUDIO_HAL_ERR_INVALID_PARAM;
577 }
578 char *frame = NULL;
579 uint64_t requestBytes = 0;
580 uint64_t replyBytes = 0;
581 struct AudioCapture *capture = NULL;
582 const char *adapterName = NULL;
583 uint32_t pid = 0;
584 uint32_t index = 0;
585 if (HdiServiceRenderCaptureReadData(data, &adapterName, &pid) < 0) {
586 HDF_LOGE("%{public}s: HdiServiceRenderRenderFrame:HdiServiceRenderCaptureReadData fail!", __func__);
587 return AUDIO_HAL_ERR_INTERNAL;
588 }
589 int32_t ret = AudioAdapterFrameGetCapture(adapterName, &capture, pid, &index);
590 if (ret < 0) {
591 HDF_LOGE("%{public}s: AudioAdapterListGetRender fail", __func__);
592 return ret;
593 }
594 if (!HdfSbufReadUint64(data, &requestBytes)) {
595 return AUDIO_HAL_ERR_INTERNAL;
596 }
597 frame = (char *)calloc(1, FRAME_DATA);
598 if (frame == NULL) {
599 return AUDIO_HAL_ERR_MALLOC_FAIL;
600 }
601 AudioSetCaptureBusy(index, true);
602 ret = capture->CaptureFrame((AudioHandle)capture, (void *)frame, requestBytes, &replyBytes);
603 AudioSetCaptureBusy(index, false);
604 if (ret < 0) {
605 AudioMemFree((void **)&frame);
606 return ret;
607 }
608 if (!HdfSbufWriteBuffer(reply, (const void *)frame, (uint32_t)requestBytes)) {
609 AudioMemFree((void **)&frame);
610 return AUDIO_HAL_ERR_INTERNAL;
611 }
612 if (!HdfSbufWriteUint64(reply, replyBytes)) {
613 AudioMemFree((void **)&frame);
614 return AUDIO_HAL_ERR_INTERNAL;
615 }
616 AudioMemFree((void **)&frame);
617 return AUDIO_HAL_SUCCESS;
618 }
619
HdiServiceCaptureGetCapturePosition(const struct HdfDeviceIoClient * client,struct HdfSBuf * data,struct HdfSBuf * reply)620 int32_t HdiServiceCaptureGetCapturePosition(const struct HdfDeviceIoClient *client,
621 struct HdfSBuf *data, struct HdfSBuf *reply)
622 {
623 if (client == NULL || data == NULL || reply == NULL) {
624 return AUDIO_HAL_ERR_INVALID_PARAM;
625 }
626 struct AudioTimeStamp time;
627 uint64_t frames;
628 struct AudioCapture *capture = NULL;
629 int32_t ret = AudioAdapterListCheckAndGetCapture(&capture, data);
630 if (ret < 0) {
631 return ret;
632 }
633 ret = capture->GetCapturePosition((AudioHandle)capture, &frames, &time);
634 if (ret < 0) {
635 HDF_LOGE("%{public}s: GetCapturePosition fail", __func__);
636 return ret;
637 }
638 if (HdiServicePositionWrite(reply, frames, time) < 0) {
639 return AUDIO_HAL_ERR_INTERNAL;
640 }
641 return AUDIO_HAL_SUCCESS;
642 }
643
HdiServiceCaptureSetExtraParams(const struct HdfDeviceIoClient * client,struct HdfSBuf * data,struct HdfSBuf * reply)644 int32_t HdiServiceCaptureSetExtraParams(const struct HdfDeviceIoClient *client,
645 struct HdfSBuf *data, struct HdfSBuf *reply)
646 {
647 HDF_LOGE("%{public}s: enter", __func__);
648 if (client == NULL || data == NULL || reply == NULL) {
649 return AUDIO_HAL_ERR_INVALID_PARAM;
650 }
651 struct AudioCapture *capture = NULL;
652 int ret = AudioAdapterListCheckAndGetCapture(&capture, data);
653 if (ret < 0) {
654 return ret;
655 }
656 const char *keyValueList = NULL;
657 if ((keyValueList = HdfSbufReadString(data)) == NULL) {
658 HDF_LOGE("%{public}s: keyValueList Is NULL", __func__);
659 return AUDIO_HAL_ERR_INVALID_PARAM;
660 }
661 return capture->attr.SetExtraParams((AudioHandle)capture, keyValueList);
662 }
663
HdiServiceCaptureGetExtraParams(const struct HdfDeviceIoClient * client,struct HdfSBuf * data,struct HdfSBuf * reply)664 int32_t HdiServiceCaptureGetExtraParams(const struct HdfDeviceIoClient *client,
665 struct HdfSBuf *data, struct HdfSBuf *reply)
666 {
667 HDF_LOGE("%{public}s: enter", __func__);
668 int32_t ret;
669 if (client == NULL || data == NULL || reply == NULL) {
670 return AUDIO_HAL_ERR_INVALID_PARAM;
671 }
672 struct AudioCapture *capture = NULL;
673 ret = AudioAdapterListCheckAndGetCapture(&capture, data);
674 if (ret < 0) {
675 return ret;
676 }
677 int32_t listLenth = 0;
678 if (!HdfSbufReadInt32(data, &listLenth)) {
679 return AUDIO_HAL_ERR_INTERNAL;
680 }
681 if (listLenth <= 0 || listLenth > STR_MAX - 1) {
682 return AUDIO_HAL_ERR_INTERNAL;
683 }
684 char keyValueList[STR_MAX] = { 0 };
685 ret = capture->attr.GetExtraParams((AudioHandle)capture, keyValueList, listLenth);
686 if (ret < 0) {
687 return ret;
688 }
689 char *keyList = keyValueList;
690 if (!HdfSbufWriteString(reply, keyList)) {
691 return AUDIO_HAL_ERR_INTERNAL;
692 }
693 HDF_LOGE("%{public}s: out", __func__);
694 return AUDIO_HAL_SUCCESS;
695 }
696
HdiServiceCaptureReqMmapBuffer(const struct HdfDeviceIoClient * client,struct HdfSBuf * data,struct HdfSBuf * reply)697 int32_t HdiServiceCaptureReqMmapBuffer(const struct HdfDeviceIoClient *client,
698 struct HdfSBuf *data, struct HdfSBuf *reply)
699 {
700 HDF_LOGE("%{public}s: enter", __func__);
701 if (client == NULL || data == NULL || reply == NULL) {
702 return AUDIO_HAL_ERR_INVALID_PARAM;
703 }
704 struct AudioCapture *capture = NULL;
705 int32_t ret = AudioAdapterListCheckAndGetCapture(&capture, data);
706 if (ret < 0) {
707 return ret;
708 }
709
710 struct AudioMmapBufferDescripter desc;
711 int32_t reqSize = 0;
712 if (!HdfSbufReadInt32(data, &reqSize)) {
713 return AUDIO_HAL_ERR_INTERNAL;
714 }
715 if (HdiServiceReqMmapBuffer(&desc, data) < 0) {
716 return AUDIO_HAL_ERR_INTERNAL;
717 }
718 return capture->attr.ReqMmapBuffer((AudioHandle)capture, reqSize, &desc);
719 }
720
HdiServiceCaptureGetMmapPosition(const struct HdfDeviceIoClient * client,struct HdfSBuf * data,struct HdfSBuf * reply)721 int32_t HdiServiceCaptureGetMmapPosition(const struct HdfDeviceIoClient *client,
722 struct HdfSBuf *data, struct HdfSBuf *reply)
723 {
724 HDF_LOGE("%{public}s: enter", __func__);
725 if (client == NULL || data == NULL || reply == NULL) {
726 return AUDIO_HAL_ERR_INVALID_PARAM;
727 }
728 uint64_t frames;
729 struct AudioTimeStamp time;
730 struct AudioCapture *capture = NULL;
731 int32_t ret = AudioAdapterListCheckAndGetCapture(&capture, data);
732 if (ret < 0) {
733 return ret;
734 }
735
736 ret = capture->attr.GetMmapPosition((AudioHandle)capture, &frames, &time);
737 if (ret < 0) {
738 return ret;
739 }
740 if (HdiServicePositionWrite(reply, frames, time) < 0) {
741 return AUDIO_HAL_ERR_INTERNAL;
742 }
743 HDF_LOGE("%{public}s: out", __func__);
744 return AUDIO_HAL_SUCCESS;
745 }
746
HdiServiceCaptureTurnStandbyMode(const struct HdfDeviceIoClient * client,struct HdfSBuf * data,struct HdfSBuf * reply)747 int32_t HdiServiceCaptureTurnStandbyMode(const struct HdfDeviceIoClient *client,
748 struct HdfSBuf *data, struct HdfSBuf *reply)
749 {
750 if (client == NULL || data == NULL || reply == NULL) {
751 HDF_LOGE("%{public}s: The pointer is null", __func__);
752 return AUDIO_HAL_ERR_INVALID_PARAM;
753 }
754 struct AudioCapture *capture = NULL;
755 int ret = AudioAdapterListCheckAndGetCapture(&capture, data);
756 if (ret < 0) {
757 return ret;
758 }
759 return capture->control.Stop((AudioHandle)capture);
760 }
761
HdiServiceCaptureDevDump(const struct HdfDeviceIoClient * client,struct HdfSBuf * data,struct HdfSBuf * reply)762 int32_t HdiServiceCaptureDevDump(const struct HdfDeviceIoClient *client,
763 struct HdfSBuf *data, struct HdfSBuf *reply)
764 {
765 if (client == NULL || data == NULL || reply == NULL) {
766 HDF_LOGE("%{public}s: parameter Is NULL", __func__);
767 return AUDIO_HAL_ERR_INVALID_PARAM;
768 }
769 struct AudioCapture *capture = NULL;
770 int ret = AudioAdapterListCheckAndGetCapture(&capture, data);
771 if (ret < 0) {
772 return ret;
773 }
774 int32_t range = 0;
775 if (!HdfSbufReadInt32(data, &range)) {
776 return AUDIO_HAL_ERR_INTERNAL;
777 }
778 ret = HdfSbufReadFileDescriptor(data);
779 if (ret < 0) {
780 return AUDIO_HAL_ERR_INTERNAL;
781 }
782 int32_t fd = ret;
783 return capture->control.AudioDevDump((AudioHandle)capture, range, fd);
784 }
785
786