1 /*
2 * Copyright (c) 2024 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15 #include "hdf_audio_server_capture.h"
16 #include "hdf_audio_server_common.h"
17 #include "osal_mem.h"
18
19 namespace OHOS::HDI::Audio_Bluetooth {
GetInitCaptureParaAttrs(struct HdfSBuf * data,struct AudioSampleAttributes * attrs)20 int32_t GetInitCaptureParaAttrs(struct HdfSBuf *data, struct AudioSampleAttributes *attrs)
21 {
22 if (data == nullptr || attrs == nullptr) {
23 return HDF_FAILURE;
24 }
25 uint32_t tempCapturePara = 0;
26 if (!HdfSbufReadUint32(data, &tempCapturePara)) {
27 HDF_LOGE("%{public}s: read tempCapturePara fail", __func__);
28 return HDF_FAILURE;
29 }
30 attrs->type = static_cast<AudioCategory>(tempCapturePara);
31 if (!HdfSbufReadUint32(data, &attrs->period)) {
32 HDF_LOGE("%{public}s: read period fail", __func__);
33 return HDF_FAILURE;
34 }
35 if (!HdfSbufReadUint32(data, &attrs->frameSize)) {
36 HDF_LOGE("%{public}s: read frameSize fail", __func__);
37 return HDF_FAILURE;
38 }
39 if (!HdfSbufReadUint32(data, &attrs->startThreshold)) {
40 HDF_LOGE("%{public}s: read startThreshold fail", __func__);
41 return HDF_FAILURE;
42 }
43 if (!HdfSbufReadUint32(data, &attrs->stopThreshold)) {
44 HDF_LOGE("%{public}s: read stopThreshold fail", __func__);
45 return HDF_FAILURE;
46 }
47 if (!HdfSbufReadUint32(data, &attrs->silenceThreshold)) {
48 HDF_LOGE("%{public}s: read silenceThreshold fail", __func__);
49 return HDF_FAILURE;
50 }
51 if (!HdfSbufReadUint32(data, &tempCapturePara)) {
52 HDF_LOGE("%{public}s: read bool isBigEndian fail", __func__);
53 return HDF_FAILURE;
54 }
55 attrs->isBigEndian = static_cast<bool>(tempCapturePara);
56 return HDF_SUCCESS;
57 }
58
GetInitCapturePara(struct HdfSBuf * data,struct AudioDeviceDescriptor * devDesc,struct AudioSampleAttributes * attrs)59 int32_t GetInitCapturePara(struct HdfSBuf *data, struct AudioDeviceDescriptor *devDesc,
60 struct AudioSampleAttributes *attrs)
61 {
62 if (data == nullptr || devDesc == nullptr || attrs == nullptr) {
63 return HDF_FAILURE;
64 }
65 uint32_t tempCapturePara = 0;
66 if (!HdfSbufReadUint32(data, &tempCapturePara)) {
67 HDF_LOGE("%{public}s: read attrs format fail", __func__);
68 return HDF_FAILURE;
69 }
70 attrs->format = static_cast<AudioFormat>(tempCapturePara);
71 if (!HdfSbufReadUint32(data, &attrs->channelCount)) {
72 HDF_LOGE("%{public}s: read channelCount fail", __func__);
73 return HDF_FAILURE;
74 }
75 if (!HdfSbufReadUint32(data, &attrs->sampleRate)) {
76 HDF_LOGE("%{public}s: read sampleRate fail", __func__);
77 return HDF_FAILURE;
78 }
79 if (!HdfSbufReadUint32(data, &tempCapturePara)) {
80 HDF_LOGE("%{public}s: read attrs interleaved fail", __func__);
81 return HDF_FAILURE;
82 }
83 attrs->interleaved = static_cast<bool>(tempCapturePara);
84 if (GetInitCaptureParaAttrs(data, attrs) < 0) {
85 return HDF_FAILURE;
86 }
87 if (!HdfSbufReadUint32(data, &tempCapturePara)) {
88 HDF_LOGE("%{public}s: read attrs isSignedData fail", __func__);
89 return HDF_FAILURE;
90 }
91 attrs->isSignedData = static_cast<bool>(tempCapturePara);
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 tempRenderPara fail", __func__);
98 return HDF_FAILURE;
99 }
100 devDesc->pins = static_cast<AudioPortPin>(tempCapturePara);
101 devDesc->desc = nullptr;
102 return HDF_SUCCESS;
103 }
104
HdiServiceCreateCapture(const struct HdfDeviceIoClient * client,struct HdfSBuf * data,struct HdfSBuf * reply)105 int32_t HdiServiceCreateCapture(const struct HdfDeviceIoClient *client,
106 struct HdfSBuf *data, struct HdfSBuf *reply)
107 {
108 if (client == nullptr || data == nullptr || reply == nullptr) {
109 return AUDIO_HAL_ERR_INVALID_PARAM;
110 }
111 struct AudioAdapter *adapter = nullptr;
112 struct AudioDeviceDescriptor devDesc;
113 struct AudioSampleAttributes attrs;
114 struct AudioCapture *capture = nullptr;
115 const char *adapterName = nullptr;
116 uint32_t capturePid = 0;
117 if ((adapterName = HdfSbufReadString(data)) == nullptr) {
118 HDF_LOGE("%{public}s: adapterNameCase Is NULL", __func__);
119 return AUDIO_HAL_ERR_INVALID_PARAM;
120 }
121 if (!HdfSbufReadUint32(data, &capturePid)) {
122 return AUDIO_HAL_ERR_INTERNAL;
123 }
124 HDF_LOGE("HdiServiceCreatRender: capturePid = %{public}u", capturePid);
125 int32_t ret = GetInitCapturePara(data, &devDesc, &attrs);
126 if (ret < 0) {
127 HDF_LOGE("%{public}s: GetInitCapturePara fail", __func__);
128 return AUDIO_HAL_ERR_INTERNAL;
129 }
130 if (AudioAdapterListGetAdapter(adapterName, &adapter)) {
131 HDF_LOGE("%{public}s: fail", __func__);
132 return AUDIO_HAL_ERR_INTERNAL;
133 }
134 if (adapter == nullptr) {
135 HDF_LOGE("%{public}s: adapter is NULL!", __func__);
136 return AUDIO_HAL_ERR_INVALID_PARAM;
137 }
138 const int32_t priority = attrs.type;
139 ret = AudioCreateCaptureCheck(adapterName, priority);
140 if (ret < 0) {
141 HDF_LOGE("%{public}s: AudioCreateCaptureCheck: Capture is working can not replace!", __func__);
142 return ret;
143 }
144 ret = adapter->CreateCapture(adapter, &devDesc, &attrs, &capture);
145 if (capture == nullptr || 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: AudioAddCaptureInfoInAdapter", __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,
158 struct HdfSBuf *data, struct HdfSBuf *reply)
159 {
160 if (client == nullptr || data == nullptr || reply == nullptr) {
161 return AUDIO_HAL_ERR_INVALID_PARAM;
162 }
163 struct AudioAdapter *adapter = nullptr;
164 struct AudioCapture *capture = nullptr;
165 const char *adapterName = nullptr;
166 uint32_t pid = 0;
167 if (HdiServiceRenderCaptureReadData(data, &adapterName, &pid) < 0) {
168 return AUDIO_HAL_ERR_INTERNAL;
169 }
170 int32_t ret = AudioAdapterListGetCapture(adapterName, &capture, pid);
171 if (ret < 0) {
172 return ret;
173 }
174 ret = AudioAdapterListGetAdapterCapture(adapterName, &adapter, &capture);
175 if (ret < 0) {
176 return ret;
177 }
178 if (adapter == nullptr || capture == nullptr) {
179 return AUDIO_HAL_ERR_INVALID_PARAM;
180 }
181 HDF_LOGI("%{public}s: DestroyCapture.", __func__);
182 ret = adapter->DestroyCapture(adapter, capture);
183 if (ret < 0) {
184 HDF_LOGE("%{public}s: DestroyCapture failed!", __func__);
185 return ret;
186 }
187 if (AudioDestroyCaptureInfoInAdapter(adapterName)) {
188 return AUDIO_HAL_ERR_INTERNAL;
189 }
190 return AUDIO_HAL_SUCCESS;
191 }
192
HdiServiceCaptureStart(const struct HdfDeviceIoClient * client,struct HdfSBuf * data,struct HdfSBuf * reply)193 int32_t HdiServiceCaptureStart(const struct HdfDeviceIoClient *client, struct HdfSBuf *data, struct HdfSBuf *reply)
194 {
195 if (client == nullptr || data == nullptr || reply == nullptr) {
196 return AUDIO_HAL_ERR_INVALID_PARAM;
197 }
198 struct AudioCapture *capture = nullptr;
199 int ret = AudioAdapterListCheckAndGetCapture(&capture, data);
200 if (ret < 0) {
201 return ret;
202 }
203 return capture->control.Start(static_cast<AudioHandle>(capture));
204 }
205
HdiServiceCaptureStop(const struct HdfDeviceIoClient * client,struct HdfSBuf * data,struct HdfSBuf * reply)206 int32_t HdiServiceCaptureStop(const struct HdfDeviceIoClient *client, struct HdfSBuf *data, struct HdfSBuf *reply)
207 {
208 if (client == nullptr || data == nullptr || reply == nullptr) {
209 return AUDIO_HAL_ERR_INVALID_PARAM;
210 }
211 struct AudioCapture *capture = nullptr;
212 int ret = AudioAdapterListCheckAndGetCapture(&capture, data);
213 if (ret < 0) {
214 return ret;
215 }
216 return capture->control.Stop(static_cast<AudioHandle>(capture));
217 }
218
HdiServiceCapturePause(const struct HdfDeviceIoClient * client,struct HdfSBuf * data,struct HdfSBuf * reply)219 int32_t HdiServiceCapturePause(const struct HdfDeviceIoClient *client,
220 struct HdfSBuf *data, struct HdfSBuf *reply)
221 {
222 if (client == nullptr || data == nullptr || reply == nullptr) {
223 return AUDIO_HAL_ERR_INVALID_PARAM;
224 }
225 HDF_LOGE("%{public}s: enter", __func__);
226 struct AudioCapture *capture = nullptr;
227 int ret = AudioAdapterListCheckAndGetCapture(&capture, data);
228 if (ret < 0) {
229 return ret;
230 }
231 return capture->control.Pause(static_cast<AudioHandle>(capture));
232 }
233
HdiServiceCaptureResume(const struct HdfDeviceIoClient * client,struct HdfSBuf * data,struct HdfSBuf * reply)234 int32_t HdiServiceCaptureResume(const struct HdfDeviceIoClient *client, struct HdfSBuf *data, struct HdfSBuf *reply)
235 {
236 if (client == nullptr || data == nullptr || reply == nullptr) {
237 return AUDIO_HAL_ERR_INVALID_PARAM;
238 }
239 struct AudioCapture *capture = nullptr;
240 int ret = AudioAdapterListCheckAndGetCapture(&capture, data);
241 if (ret < 0) {
242 return ret;
243 }
244 return capture->control.Resume(static_cast<AudioHandle>(capture));
245 }
246
HdiServiceCaptureFlush(const struct HdfDeviceIoClient * client,struct HdfSBuf * data,struct HdfSBuf * reply)247 int32_t HdiServiceCaptureFlush(const struct HdfDeviceIoClient *client, struct HdfSBuf *data, struct HdfSBuf *reply)
248 {
249 if (client == nullptr || data == nullptr || reply == nullptr) {
250 HDF_LOGI("%{public}s: The parameter is empty", __func__);
251 return AUDIO_HAL_ERR_INVALID_PARAM;
252 }
253 struct AudioCapture *capture = nullptr;
254 int ret = AudioAdapterListCheckAndGetCapture(&capture, data);
255 if (ret < 0) {
256 return ret;
257 }
258 return capture->control.Flush(static_cast<AudioHandle>(capture));
259 }
260
HdiServiceCaptureGetMute(const struct HdfDeviceIoClient * client,struct HdfSBuf * data,struct HdfSBuf * reply)261 int32_t HdiServiceCaptureGetMute(const struct HdfDeviceIoClient *client,
262 struct HdfSBuf *data, struct HdfSBuf *reply)
263 {
264 if (client == nullptr || data == nullptr || reply == nullptr) {
265 HDF_LOGI("%{public}s: parameter is empty", __func__);
266 return AUDIO_HAL_ERR_INVALID_PARAM;
267 }
268 bool mute = false;
269 struct AudioCapture *capture = nullptr;
270 int ret = AudioAdapterListCheckAndGetCapture(&capture, data);
271 if (ret < 0) {
272 return ret;
273 }
274 ret = capture->volume.GetMute(static_cast<AudioHandle>(capture), &mute);
275 if (ret < 0) {
276 return ret;
277 }
278 auto tempMute = static_cast<uint32_t>(mute);
279 if (!HdfSbufWriteUint32(reply, tempMute)) {
280 return AUDIO_HAL_ERR_INTERNAL;
281 }
282 return AUDIO_HAL_SUCCESS;
283 }
284
HdiServiceCaptureSetMute(const struct HdfDeviceIoClient * client,struct HdfSBuf * data,struct HdfSBuf * reply)285 int32_t HdiServiceCaptureSetMute(const struct HdfDeviceIoClient *client,
286 struct HdfSBuf *data, struct HdfSBuf *reply)
287 {
288 if (client == nullptr || data == nullptr || reply == nullptr) {
289 return AUDIO_HAL_ERR_INVALID_PARAM;
290 }
291 bool mute = false;
292 struct AudioCapture *capture = nullptr;
293 int ret = AudioAdapterListCheckAndGetCapture(&capture, data);
294 if (ret < 0) {
295 return ret;
296 }
297 uint32_t tempMute = 0;
298 if (!HdfSbufReadUint32(data, &tempMute)) {
299 return AUDIO_HAL_ERR_INTERNAL;
300 }
301 mute = static_cast<bool>(tempMute);
302 return capture->volume.SetMute(static_cast<AudioHandle>(capture), mute);
303 }
304
HdiServiceCaptureCaptureFrame(const struct HdfDeviceIoClient * client,struct HdfSBuf * data,struct HdfSBuf * reply)305 int32_t HdiServiceCaptureCaptureFrame(const struct HdfDeviceIoClient *client,
306 struct HdfSBuf *data, struct HdfSBuf *reply)
307 {
308 if (client == nullptr || data == nullptr || reply == nullptr) {
309 return AUDIO_HAL_ERR_INVALID_PARAM;
310 }
311 char *frame = nullptr;
312 uint64_t requestBytes;
313 uint64_t replyBytes;
314 struct AudioCapture *capture = nullptr;
315 const char *adapterName = nullptr;
316 uint32_t pid;
317 uint32_t index = 0;
318 if (HdiServiceRenderCaptureReadData(data, &adapterName, &pid) < 0) {
319 HDF_LOGE("%{public}s: HdiServiceRenderCaptureReadData fail!", __func__);
320 return AUDIO_HAL_ERR_INTERNAL;
321 }
322 int32_t ret = AudioAdapterFrameGetCapture(adapterName, &capture, pid, &index);
323 if (ret < 0) {
324 HDF_LOGE("%{public}s: AudioAdapterFrameGetCapture fail", __func__);
325 return ret;
326 }
327 if (!HdfSbufReadUint64(data, &requestBytes)) {
328 return AUDIO_HAL_ERR_INTERNAL;
329 }
330 frame = (char *)OsalMemCalloc(FRAME_DATA);
331 if (frame == nullptr) {
332 return AUDIO_HAL_ERR_MALLOC_FAIL;
333 }
334 AudioSetCaptureBusy(index, true);
335 if (capture == nullptr || capture->CaptureFrame == nullptr) {
336 HDF_LOGE("capture or capureFrame in NULL");
337 AudioMemFree(reinterpret_cast<void **>(&frame));
338 return AUDIO_HAL_ERR_INTERNAL;
339 }
340 ret = capture->CaptureFrame(capture, static_cast<void *>(frame), requestBytes, &replyBytes);
341 AudioSetCaptureBusy(index, false);
342 if (ret < 0) {
343 AudioMemFree(reinterpret_cast<void **>(&frame));
344 return ret;
345 }
346 if (!HdfSbufWriteUint64(reply, replyBytes)) {
347 AudioMemFree(reinterpret_cast<void **>(&frame));
348 return AUDIO_HAL_ERR_INTERNAL;
349 }
350 if (!HdfSbufWriteBuffer(reply, static_cast<const void *>(frame), replyBytes)) {
351 AudioMemFree(reinterpret_cast<void **>(&frame));
352 return AUDIO_HAL_ERR_INTERNAL;
353 }
354 AudioMemFree(reinterpret_cast<void **>(&frame));
355 return AUDIO_HAL_SUCCESS;
356 }
357
358 }