1 /*
2 * Copyright (c) 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 "audio_capture_vdi.h"
17
18 #include <limits.h>
19 #include "osal_mem.h"
20 #include "securec.h"
21 #include <hdf_base.h>
22 #include "audio_uhdf_log.h"
23 #include "audio_common_vdi.h"
24 #include "audio_dfx_vdi.h"
25
26 #define HDF_LOG_TAG HDF_AUDIO_PRIMARY_IMPL
27
28 struct AudioCaptureInfo {
29 struct IAudioCapture capture;
30 struct AudioDeviceDescriptor desc;
31 enum AudioCategory streamType;
32 unsigned int sampleRate;
33 unsigned int channelCount;
34 int sourceType;
35 struct IAudioCaptureVdi *vdiCapture;
36 uint32_t captureId;
37 unsigned int usrCount;
38 };
39
40 struct AudioCapturePrivVdi {
41 struct AudioCaptureInfo *captureInfos[AUDIO_VDI_STREAM_NUM_MAX];
42 uint32_t captureCnt;
43 };
44
45 static struct AudioCapturePrivVdi g_audioCapturePrivVdi;
46
AudioCaptureGetPrivVdi(void)47 static struct AudioCapturePrivVdi *AudioCaptureGetPrivVdi(void)
48 {
49 return &g_audioCapturePrivVdi;
50 }
51
AudioGetVdiCaptureByIdVdi(uint32_t captureId)52 struct IAudioCaptureVdi *AudioGetVdiCaptureByIdVdi(uint32_t captureId)
53 {
54 struct AudioCapturePrivVdi *priv = AudioCaptureGetPrivVdi();
55 if (priv->captureInfos[captureId] == NULL) {
56 AUDIO_FUNC_LOGE("not match capture");
57 return NULL;
58 }
59
60 return priv->captureInfos[captureId]->vdiCapture;
61 }
62
AudioCaptureFrameVdi(struct IAudioCapture *capture, int8_t *frame, uint32_t *frameLen, uint64_t *replyBytes)63 int32_t AudioCaptureFrameVdi(struct IAudioCapture *capture, int8_t *frame, uint32_t *frameLen, uint64_t *replyBytes)
64 {
65 CHECK_NULL_PTR_RETURN_VALUE(capture, HDF_ERR_INVALID_PARAM);
66 CHECK_NULL_PTR_RETURN_VALUE(frame, HDF_ERR_INVALID_PARAM);
67 CHECK_NULL_PTR_RETURN_VALUE(frameLen, HDF_ERR_INVALID_PARAM);
68 CHECK_NULL_PTR_RETURN_VALUE(replyBytes, HDF_ERR_INVALID_PARAM);
69
70 struct AudioCaptureInfo *captureInfo = (struct AudioCaptureInfo *)(capture);
71 struct IAudioCaptureVdi *vdiCapture = captureInfo->vdiCapture;
72 CHECK_NULL_PTR_RETURN_VALUE(vdiCapture, HDF_ERR_INVALID_PARAM);
73 CHECK_NULL_PTR_RETURN_VALUE(vdiCapture->CaptureFrame, HDF_ERR_INVALID_PARAM);
74
75 int32_t id = SetTimer("Hdi:CaptureFrame");
76 HdfAudioStartTrace("Hdi:AudioCaptureFrameVdi", 0);
77 int32_t ret = vdiCapture->CaptureFrame(vdiCapture, frame, frameLen, replyBytes);
78 HdfAudioFinishTrace();
79 CancelTimer(id);
80 if (ret != HDF_SUCCESS) {
81 AUDIO_FUNC_LOGE("audio capture frame fail, ret=%{public}d", ret);
82 return ret;
83 }
84
85 return HDF_SUCCESS;
86 }
87
AudioCaptureFrameEcVdi(struct IAudioCapture *capture, const struct AudioFrameLen *frameLen, struct AudioCaptureFrameInfo *frameInfo)88 int32_t AudioCaptureFrameEcVdi(struct IAudioCapture *capture, const struct AudioFrameLen *frameLen,
89 struct AudioCaptureFrameInfo *frameInfo)
90 {
91 CHECK_NULL_PTR_RETURN_VALUE(capture, HDF_ERR_INVALID_PARAM);
92 CHECK_NULL_PTR_RETURN_VALUE(frameLen, HDF_ERR_INVALID_PARAM);
93 CHECK_NULL_PTR_RETURN_VALUE(frameInfo, HDF_ERR_INVALID_PARAM);
94
95 struct AudioCaptureInfo *captureInfo = (struct AudioCaptureInfo *)(capture);
96 struct IAudioCaptureVdi *vdiCapture = captureInfo->vdiCapture;
97 CHECK_NULL_PTR_RETURN_VALUE(vdiCapture, HDF_ERR_INVALID_PARAM);
98 CHECK_NULL_PTR_RETURN_VALUE(vdiCapture->CaptureFrameEc, HDF_ERR_INVALID_PARAM);
99 struct AudioCaptureFrameInfoVdi frameInfoVdi;
100 (void)memset_s((void *)&frameInfoVdi, sizeof(frameInfoVdi), 0, sizeof(frameInfoVdi));
101 int32_t ret = AudioCommonFrameInfoToVdiFrameInfoVdi(frameLen, &frameInfoVdi);
102 if (ret != HDF_SUCCESS) {
103 AUDIO_FUNC_LOGE("audio capture FrameInfo To VdiFrameInfo fail");
104 return ret;
105 }
106
107 HdfAudioStartTrace("Hdi:AudioCaptureFrameEcVdi", 0);
108 ret = vdiCapture->CaptureFrameEc(vdiCapture, &frameInfoVdi);
109 HdfAudioFinishTrace();
110 if (ret != HDF_SUCCESS) {
111 OsalMemFree((void *)frameInfoVdi.frame);
112 OsalMemFree((void *)frameInfoVdi.frameEc);
113 AUDIO_FUNC_LOGE("audio capture EC frame fail, ret=%{public}d", ret);
114 return ret;
115 }
116
117 ret = AudioCommonVdiFrameInfoToFrameInfoVdi(&frameInfoVdi, frameInfo);
118 if (ret != HDF_SUCCESS) {
119 AUDIO_FUNC_LOGE("audio capture VdiFrameInfo To FrameInfo fail");
120 }
121 OsalMemFree((void *)frameInfoVdi.frame);
122 OsalMemFree((void *)frameInfoVdi.frameEc);
123
124 return ret;
125 }
126
AudioGetCapturePositionVdi(struct IAudioCapture *capture, uint64_t *frames, struct AudioTimeStamp *time)127 int32_t AudioGetCapturePositionVdi(struct IAudioCapture *capture, uint64_t *frames, struct AudioTimeStamp *time)
128 {
129 CHECK_NULL_PTR_RETURN_VALUE(capture, HDF_ERR_INVALID_PARAM);
130 CHECK_NULL_PTR_RETURN_VALUE(frames, HDF_ERR_INVALID_PARAM);
131 CHECK_NULL_PTR_RETURN_VALUE(time, HDF_ERR_INVALID_PARAM);
132
133 struct AudioCaptureInfo *captureInfo = (struct AudioCaptureInfo *)(capture);
134 struct IAudioCaptureVdi *vdiCapture = captureInfo->vdiCapture;
135 CHECK_NULL_PTR_RETURN_VALUE(vdiCapture, HDF_ERR_INVALID_PARAM);
136 CHECK_NULL_PTR_RETURN_VALUE(vdiCapture->GetCapturePosition, HDF_ERR_INVALID_PARAM);
137
138 HdfAudioStartTrace("Hdi:AudioGetCapturePositionVdi", 0);
139 int32_t ret = vdiCapture->GetCapturePosition(vdiCapture, frames, (struct AudioTimeStampVdi *)time);
140 HdfAudioFinishTrace();
141 if (ret != HDF_SUCCESS) {
142 AUDIO_FUNC_LOGE("audio capture get position fail, ret=%{public}d", ret);
143 return ret;
144 }
145
146 return HDF_SUCCESS;
147 }
148
AudioCaptureCheckSceneCapabilityVdi(struct IAudioCapture *capture, const struct AudioSceneDescriptor* scene, bool* supported)149 int32_t AudioCaptureCheckSceneCapabilityVdi(struct IAudioCapture *capture, const struct AudioSceneDescriptor* scene,
150 bool* supported)
151 {
152 CHECK_NULL_PTR_RETURN_VALUE(capture, HDF_ERR_INVALID_PARAM);
153 CHECK_NULL_PTR_RETURN_VALUE(scene, HDF_ERR_INVALID_PARAM);
154 CHECK_NULL_PTR_RETURN_VALUE(supported, HDF_ERR_INVALID_PARAM);
155
156 struct AudioCaptureInfo *captureInfo = (struct AudioCaptureInfo *)(capture);
157 struct IAudioCaptureVdi *vdiCapture = captureInfo->vdiCapture;
158 CHECK_NULL_PTR_RETURN_VALUE(vdiCapture, HDF_ERR_INVALID_PARAM);
159 CHECK_NULL_PTR_RETURN_VALUE(vdiCapture->CheckSceneCapability, HDF_ERR_INVALID_PARAM);
160
161 struct AudioSceneDescriptorVdi vdiScene;
162 (void)memset_s((void *)&vdiScene, sizeof(vdiScene), 0, sizeof(vdiScene));
163 int32_t ret = AudioCommonSceneToVdiSceneVdi(scene, &vdiScene);
164 if (ret != HDF_SUCCESS) {
165 AUDIO_FUNC_LOGE("audio capture scene To vdiScene fail");
166 return HDF_FAILURE;
167 }
168
169 ret = vdiCapture->CheckSceneCapability(vdiCapture, &vdiScene, supported);
170 OsalMemFree((void *)vdiScene.desc.desc);
171 if (ret != HDF_SUCCESS) {
172 AUDIO_FUNC_LOGE("audio capture CheckSceneCapability fail, ret=%{public}d", ret);
173 return ret;
174 }
175
176 return HDF_SUCCESS;
177 }
178
AudioCaptureSelectSceneVdi(struct IAudioCapture *capture, const struct AudioSceneDescriptor* scene)179 int32_t AudioCaptureSelectSceneVdi(struct IAudioCapture *capture, const struct AudioSceneDescriptor* scene)
180 {
181 CHECK_NULL_PTR_RETURN_VALUE(capture, HDF_ERR_INVALID_PARAM);
182 CHECK_NULL_PTR_RETURN_VALUE(scene, HDF_ERR_INVALID_PARAM);
183
184 struct AudioCaptureInfo *captureInfo = (struct AudioCaptureInfo *)(capture);
185 struct IAudioCaptureVdi *vdiCapture = captureInfo->vdiCapture;
186 CHECK_NULL_PTR_RETURN_VALUE(vdiCapture, HDF_ERR_INVALID_PARAM);
187 CHECK_NULL_PTR_RETURN_VALUE(vdiCapture->SelectScene, HDF_ERR_INVALID_PARAM);
188
189 struct AudioSceneDescriptorVdi vdiScene;
190 (void)memset_s((void *)&vdiScene, sizeof(vdiScene), 0, sizeof(vdiScene));
191 int32_t ret = AudioCommonSceneToVdiSceneVdi(scene, &vdiScene);
192 if (ret != HDF_SUCCESS) {
193 AUDIO_FUNC_LOGE("audio vdiAdapter scene To vdiScene fail");
194 return HDF_FAILURE;
195 }
196
197 int32_t id = SetTimer("Hdi:SelectScene");
198 ret = vdiCapture->SelectScene(vdiCapture, &vdiScene);
199 CancelTimer(id);
200 OsalMemFree((void *)vdiScene.desc.desc);
201 if (ret != HDF_SUCCESS) {
202 AUDIO_FUNC_LOGE("audio capture select scene fail, ret=%{public}d", ret);
203 return ret;
204 }
205
206 return HDF_SUCCESS;
207 }
208
AudioCaptureSetMuteVdi(struct IAudioCapture *capture, bool mute)209 int32_t AudioCaptureSetMuteVdi(struct IAudioCapture *capture, bool mute)
210 {
211 CHECK_NULL_PTR_RETURN_VALUE(capture, HDF_ERR_INVALID_PARAM);
212
213 struct AudioCaptureInfo *captureInfo = (struct AudioCaptureInfo *)(capture);
214 struct IAudioCaptureVdi *vdiCapture = captureInfo->vdiCapture;
215 CHECK_NULL_PTR_RETURN_VALUE(vdiCapture, HDF_ERR_INVALID_PARAM);
216 CHECK_NULL_PTR_RETURN_VALUE(vdiCapture->SetMute, HDF_ERR_INVALID_PARAM);
217
218 int32_t ret = vdiCapture->SetMute(vdiCapture, mute);
219 if (ret != HDF_SUCCESS) {
220 AUDIO_FUNC_LOGE("audio capture SetMute fail, ret=%{public}d", ret);
221 return ret;
222 }
223
224 return HDF_SUCCESS;
225 }
226
AudioCaptureGetMuteVdi(struct IAudioCapture *capture, bool *mute)227 int32_t AudioCaptureGetMuteVdi(struct IAudioCapture *capture, bool *mute)
228 {
229 CHECK_NULL_PTR_RETURN_VALUE(capture, HDF_ERR_INVALID_PARAM);
230 CHECK_NULL_PTR_RETURN_VALUE(mute, HDF_ERR_INVALID_PARAM);
231
232 struct AudioCaptureInfo *captureInfo = (struct AudioCaptureInfo *)(capture);
233 struct IAudioCaptureVdi *vdiCapture = captureInfo->vdiCapture;
234 CHECK_NULL_PTR_RETURN_VALUE(vdiCapture, HDF_ERR_INVALID_PARAM);
235 CHECK_NULL_PTR_RETURN_VALUE(vdiCapture->GetMute, HDF_ERR_INVALID_PARAM);
236
237 int32_t ret = vdiCapture->GetMute(vdiCapture, mute);
238 if (ret != HDF_SUCCESS) {
239 AUDIO_FUNC_LOGE("audio capture GetMute fail, ret=%{public}d", ret);
240 return ret;
241 }
242
243 return HDF_SUCCESS;
244 }
245
AudioCaptureSetVolumeVdi(struct IAudioCapture *capture, float volume)246 int32_t AudioCaptureSetVolumeVdi(struct IAudioCapture *capture, float volume)
247 {
248 CHECK_NULL_PTR_RETURN_VALUE(capture, HDF_ERR_INVALID_PARAM);
249
250 struct AudioCaptureInfo *captureInfo = (struct AudioCaptureInfo *)(capture);
251 struct IAudioCaptureVdi *vdiCapture = captureInfo->vdiCapture;
252 CHECK_NULL_PTR_RETURN_VALUE(vdiCapture, HDF_ERR_INVALID_PARAM);
253 CHECK_NULL_PTR_RETURN_VALUE(vdiCapture->SetVolume, HDF_ERR_INVALID_PARAM);
254
255 int32_t ret = vdiCapture->SetVolume(vdiCapture, volume);
256 if (ret != HDF_SUCCESS) {
257 AUDIO_FUNC_LOGE("audio capture SetVolume fail, ret=%{public}d", ret);
258 return ret;
259 }
260
261 return HDF_SUCCESS;
262 }
263
AudioCaptureGetVolumeVdi(struct IAudioCapture *capture, float *volume)264 int32_t AudioCaptureGetVolumeVdi(struct IAudioCapture *capture, float *volume)
265 {
266 CHECK_NULL_PTR_RETURN_VALUE(capture, HDF_ERR_INVALID_PARAM);
267 CHECK_NULL_PTR_RETURN_VALUE(volume, HDF_ERR_INVALID_PARAM);
268
269 struct AudioCaptureInfo *captureInfo = (struct AudioCaptureInfo *)(capture);
270 struct IAudioCaptureVdi *vdiCapture = captureInfo->vdiCapture;
271 CHECK_NULL_PTR_RETURN_VALUE(vdiCapture, HDF_ERR_INVALID_PARAM);
272 CHECK_NULL_PTR_RETURN_VALUE(vdiCapture->GetVolume, HDF_ERR_INVALID_PARAM);
273
274 int32_t ret = vdiCapture->GetVolume(vdiCapture, volume);
275 if (ret != HDF_SUCCESS) {
276 AUDIO_FUNC_LOGE("audio capture GetVolume fail, ret=%{public}d", ret);
277 return ret;
278 }
279
280 return HDF_SUCCESS;
281 }
282
AudioCaptureGetGainThresholdVdi(struct IAudioCapture *capture, float *min, float *max)283 int32_t AudioCaptureGetGainThresholdVdi(struct IAudioCapture *capture, float *min, float *max)
284 {
285 CHECK_NULL_PTR_RETURN_VALUE(capture, HDF_ERR_INVALID_PARAM);
286 CHECK_NULL_PTR_RETURN_VALUE(min, HDF_ERR_INVALID_PARAM);
287 CHECK_NULL_PTR_RETURN_VALUE(max, HDF_ERR_INVALID_PARAM);
288
289 struct AudioCaptureInfo *captureInfo = (struct AudioCaptureInfo *)(capture);
290 struct IAudioCaptureVdi *vdiCapture = captureInfo->vdiCapture;
291 CHECK_NULL_PTR_RETURN_VALUE(vdiCapture, HDF_ERR_INVALID_PARAM);
292 CHECK_NULL_PTR_RETURN_VALUE(vdiCapture->GetGainThreshold, HDF_ERR_INVALID_PARAM);
293
294 int32_t ret = vdiCapture->GetGainThreshold(vdiCapture, min, max);
295 if (ret != HDF_SUCCESS) {
296 AUDIO_FUNC_LOGE("audio capture GetGainThreshold fail, ret=%{public}d", ret);
297 return ret;
298 }
299
300 return HDF_SUCCESS;
301 }
302
AudioCaptureGetGainVdi(struct IAudioCapture *capture, float *gain)303 int32_t AudioCaptureGetGainVdi(struct IAudioCapture *capture, float *gain)
304 {
305 CHECK_NULL_PTR_RETURN_VALUE(capture, HDF_ERR_INVALID_PARAM);
306 CHECK_NULL_PTR_RETURN_VALUE(gain, HDF_ERR_INVALID_PARAM);
307
308 struct AudioCaptureInfo *captureInfo = (struct AudioCaptureInfo *)(capture);
309 struct IAudioCaptureVdi *vdiCapture = captureInfo->vdiCapture;
310 CHECK_NULL_PTR_RETURN_VALUE(vdiCapture, HDF_ERR_INVALID_PARAM);
311 CHECK_NULL_PTR_RETURN_VALUE(vdiCapture->GetGain, HDF_ERR_INVALID_PARAM);
312
313 int32_t ret = vdiCapture->GetGain(vdiCapture, gain);
314 if (ret != HDF_SUCCESS) {
315 AUDIO_FUNC_LOGE("audio capture GetGain fail, ret=%{public}d", ret);
316 return ret;
317 }
318
319 return HDF_SUCCESS;
320 }
321
AudioCaptureSetGainVdi(struct IAudioCapture *capture, float gain)322 int32_t AudioCaptureSetGainVdi(struct IAudioCapture *capture, float gain)
323 {
324 CHECK_NULL_PTR_RETURN_VALUE(capture, HDF_ERR_INVALID_PARAM);
325
326 struct AudioCaptureInfo *captureInfo = (struct AudioCaptureInfo *)(capture);
327 struct IAudioCaptureVdi *vdiCapture = captureInfo->vdiCapture;
328 CHECK_NULL_PTR_RETURN_VALUE(vdiCapture, HDF_ERR_INVALID_PARAM);
329 CHECK_NULL_PTR_RETURN_VALUE(vdiCapture->SetGain, HDF_ERR_INVALID_PARAM);
330
331 int32_t ret = vdiCapture->SetGain(vdiCapture, gain);
332 if (ret != HDF_SUCCESS) {
333 AUDIO_FUNC_LOGE("audio capture SetGain fail, ret=%{public}d", ret);
334 return ret;
335 }
336
337 return HDF_SUCCESS;
338 }
339
AudioCaptureGetFrameSizeVdi(struct IAudioCapture *capture, uint64_t *size)340 int32_t AudioCaptureGetFrameSizeVdi(struct IAudioCapture *capture, uint64_t *size)
341 {
342 CHECK_NULL_PTR_RETURN_VALUE(capture, HDF_ERR_INVALID_PARAM);
343 CHECK_NULL_PTR_RETURN_VALUE(size, HDF_ERR_INVALID_PARAM);
344
345 struct AudioCaptureInfo *captureInfo = (struct AudioCaptureInfo *)(capture);
346 struct IAudioCaptureVdi *vdiCapture = captureInfo->vdiCapture;
347 CHECK_NULL_PTR_RETURN_VALUE(vdiCapture, HDF_ERR_INVALID_PARAM);
348 CHECK_NULL_PTR_RETURN_VALUE(vdiCapture->GetFrameSize, HDF_ERR_INVALID_PARAM);
349
350 int32_t ret = vdiCapture->GetFrameSize(vdiCapture, size);
351 if (ret != HDF_SUCCESS) {
352 AUDIO_FUNC_LOGE("audio capture GetFrameSize fail, ret=%{public}d", ret);
353 return ret;
354 }
355
356 return HDF_SUCCESS;
357 }
358
AudioCaptureGetFrameCountVdi(struct IAudioCapture *capture, uint64_t *count)359 int32_t AudioCaptureGetFrameCountVdi(struct IAudioCapture *capture, uint64_t *count)
360 {
361 CHECK_NULL_PTR_RETURN_VALUE(capture, HDF_ERR_INVALID_PARAM);
362 CHECK_NULL_PTR_RETURN_VALUE(count, HDF_ERR_INVALID_PARAM);
363
364 struct AudioCaptureInfo *captureInfo = (struct AudioCaptureInfo *)(capture);
365 struct IAudioCaptureVdi *vdiCapture = captureInfo->vdiCapture;
366 CHECK_NULL_PTR_RETURN_VALUE(vdiCapture, HDF_ERR_INVALID_PARAM);
367 CHECK_NULL_PTR_RETURN_VALUE(vdiCapture->GetFrameCount, HDF_ERR_INVALID_PARAM);
368
369 int32_t ret = vdiCapture->GetFrameCount(vdiCapture, count);
370 if (ret != HDF_SUCCESS) {
371 AUDIO_FUNC_LOGE("audio capture GetFrameCount fail, ret=%{public}d", ret);
372 return ret;
373 }
374
375 return HDF_SUCCESS;
376 }
377
AudioCaptureSetSampleAttributesVdi(struct IAudioCapture *capture, const struct AudioSampleAttributes *attrs)378 int32_t AudioCaptureSetSampleAttributesVdi(struct IAudioCapture *capture, const struct AudioSampleAttributes *attrs)
379 {
380 CHECK_NULL_PTR_RETURN_VALUE(capture, HDF_ERR_INVALID_PARAM);
381 CHECK_NULL_PTR_RETURN_VALUE(attrs, HDF_ERR_INVALID_PARAM);
382
383 struct AudioCaptureInfo *captureInfo = (struct AudioCaptureInfo *)(capture);
384 struct IAudioCaptureVdi *vdiCapture = captureInfo->vdiCapture;
385 CHECK_NULL_PTR_RETURN_VALUE(vdiCapture, HDF_ERR_INVALID_PARAM);
386 CHECK_NULL_PTR_RETURN_VALUE(vdiCapture->SetSampleAttributes, HDF_ERR_INVALID_PARAM);
387
388 struct AudioSampleAttributesVdi vdiAttrs;
389 (void)memset_s((void *)&vdiAttrs, sizeof(vdiAttrs), 0, sizeof(vdiAttrs));
390 int32_t ret = AudioCommonSampleAttrToVdiSampleAttrVdi(attrs, &vdiAttrs);
391 if (ret != HDF_SUCCESS) {
392 AUDIO_FUNC_LOGE("audio capture SampleAttr to vdisampleAttr fail, ret=%{public}d", ret);
393 return ret;
394 }
395
396 ret = vdiCapture->SetSampleAttributes(vdiCapture, &vdiAttrs);
397 if (ret != HDF_SUCCESS) {
398 AUDIO_FUNC_LOGE("audio capture SetSampleAttributes fail, ret=%{public}d", ret);
399 return ret;
400 }
401
402 return HDF_SUCCESS;
403 }
404
AudioCaptureGetSampleAttributesVdi(struct IAudioCapture *capture, struct AudioSampleAttributes *attrs)405 int32_t AudioCaptureGetSampleAttributesVdi(struct IAudioCapture *capture, struct AudioSampleAttributes *attrs)
406 {
407 CHECK_NULL_PTR_RETURN_VALUE(capture, HDF_ERR_INVALID_PARAM);
408 CHECK_NULL_PTR_RETURN_VALUE(attrs, HDF_ERR_INVALID_PARAM);
409
410 struct AudioCaptureInfo *captureInfo = (struct AudioCaptureInfo *)(capture);
411 struct IAudioCaptureVdi *vdiCapture = captureInfo->vdiCapture;
412 CHECK_NULL_PTR_RETURN_VALUE(vdiCapture, HDF_ERR_INVALID_PARAM);
413 CHECK_NULL_PTR_RETURN_VALUE(vdiCapture->GetSampleAttributes, HDF_ERR_INVALID_PARAM);
414
415 struct AudioSampleAttributesVdi vdiAttrs;
416 (void)memset_s((void *)&vdiAttrs, sizeof(vdiAttrs), 0, sizeof(vdiAttrs));
417 int32_t ret = vdiCapture->GetSampleAttributes(vdiCapture, &vdiAttrs);
418 if (ret != HDF_SUCCESS) {
419 AUDIO_FUNC_LOGE("audio capture GetSampleAttributes fail, ret=%{public}d", ret);
420 return ret;
421 }
422
423 ret = AudioCommonVdiSampleAttrToSampleAttrVdi(&vdiAttrs, attrs);
424 if (ret != HDF_SUCCESS) {
425 AUDIO_FUNC_LOGE("audio capture vdiSampleAttr to SampleAttr fail, ret=%{public}d", ret);
426 return ret;
427 }
428
429 return HDF_SUCCESS;
430 }
431
AudioCaptureGetCurrentChannelIdVdi(struct IAudioCapture *capture, uint32_t *channelId)432 int32_t AudioCaptureGetCurrentChannelIdVdi(struct IAudioCapture *capture, uint32_t *channelId)
433 {
434 CHECK_NULL_PTR_RETURN_VALUE(capture, HDF_ERR_INVALID_PARAM);
435 CHECK_NULL_PTR_RETURN_VALUE(channelId, HDF_ERR_INVALID_PARAM);
436
437 struct AudioCaptureInfo *captureInfo = (struct AudioCaptureInfo *)(capture);
438 struct IAudioCaptureVdi *vdiCapture = captureInfo->vdiCapture;
439 CHECK_NULL_PTR_RETURN_VALUE(vdiCapture, HDF_ERR_INVALID_PARAM);
440 CHECK_NULL_PTR_RETURN_VALUE(vdiCapture->GetCurrentChannelId, HDF_ERR_INVALID_PARAM);
441
442 int32_t ret = vdiCapture->GetCurrentChannelId(vdiCapture, channelId);
443 if (ret != HDF_SUCCESS) {
444 AUDIO_FUNC_LOGE("audio capture GetCurrentChannelId fail, ret=%{public}d", ret);
445 return ret;
446 }
447
448 return HDF_SUCCESS;
449 }
450
AudioCaptureSetExtraParamsVdi(struct IAudioCapture *capture, const char *keyValueList)451 int32_t AudioCaptureSetExtraParamsVdi(struct IAudioCapture *capture, const char *keyValueList)
452 {
453 CHECK_NULL_PTR_RETURN_VALUE(capture, HDF_ERR_INVALID_PARAM);
454 CHECK_NULL_PTR_RETURN_VALUE(keyValueList, HDF_ERR_INVALID_PARAM);
455
456 struct AudioCaptureInfo *captureInfo = (struct AudioCaptureInfo *)(capture);
457 struct IAudioCaptureVdi *vdiCapture = captureInfo->vdiCapture;
458 CHECK_NULL_PTR_RETURN_VALUE(vdiCapture, HDF_ERR_INVALID_PARAM);
459 CHECK_NULL_PTR_RETURN_VALUE(vdiCapture->SetExtraParams, HDF_ERR_INVALID_PARAM);
460
461 int32_t ret = vdiCapture->SetExtraParams(vdiCapture, keyValueList);
462 if (ret != HDF_SUCCESS) {
463 AUDIO_FUNC_LOGE("audio capture SetExtraParams fail, ret=%{public}d", ret);
464 return ret;
465 }
466
467 return HDF_SUCCESS;
468 }
469
AudioCaptureGetExtraParamsVdi(struct IAudioCapture *capture, char *keyValueList, uint32_t keyValueListLen)470 int32_t AudioCaptureGetExtraParamsVdi(struct IAudioCapture *capture, char *keyValueList, uint32_t keyValueListLen)
471 {
472 CHECK_NULL_PTR_RETURN_VALUE(capture, HDF_ERR_INVALID_PARAM);
473 CHECK_NULL_PTR_RETURN_VALUE(keyValueList, HDF_ERR_INVALID_PARAM);
474
475 struct AudioCaptureInfo *captureInfo = (struct AudioCaptureInfo *)(capture);
476 struct IAudioCaptureVdi *vdiCapture = captureInfo->vdiCapture;
477 CHECK_NULL_PTR_RETURN_VALUE(vdiCapture, HDF_ERR_INVALID_PARAM);
478 CHECK_NULL_PTR_RETURN_VALUE(vdiCapture->GetExtraParams, HDF_ERR_INVALID_PARAM);
479
480 int32_t ret = vdiCapture->GetExtraParams(vdiCapture, keyValueList, keyValueListLen);
481 if (ret != HDF_SUCCESS) {
482 AUDIO_FUNC_LOGE("audio capture GetExtraParams fail, ret=%{public}d", ret);
483 return ret;
484 }
485
486 return HDF_SUCCESS;
487 }
488
AudioCaptureReqMmapBufferVdi(struct IAudioCapture *capture, int32_t reqSize, struct AudioMmapBufferDescriptor *desc)489 int32_t AudioCaptureReqMmapBufferVdi(struct IAudioCapture *capture, int32_t reqSize,
490 struct AudioMmapBufferDescriptor *desc)
491 {
492 CHECK_NULL_PTR_RETURN_VALUE(capture, HDF_ERR_INVALID_PARAM);
493 CHECK_NULL_PTR_RETURN_VALUE(desc, HDF_ERR_INVALID_PARAM);
494
495 struct AudioCaptureInfo *captureInfo = (struct AudioCaptureInfo *)(capture);
496 struct IAudioCaptureVdi *vdiCapture = captureInfo->vdiCapture;
497 CHECK_NULL_PTR_RETURN_VALUE(vdiCapture, HDF_ERR_INVALID_PARAM);
498 CHECK_NULL_PTR_RETURN_VALUE(vdiCapture->ReqMmapBuffer, HDF_ERR_INVALID_PARAM);
499
500 struct AudioMmapBufferDescriptorVdi vdiDesc = {0};
501 int32_t ret = vdiCapture->ReqMmapBuffer(vdiCapture, reqSize, &vdiDesc);
502 if (ret != HDF_SUCCESS) {
503 AUDIO_FUNC_LOGE("audio capture ReqMmapBuffer fail, ret=%{pubilc}d", ret);
504 return ret;
505 }
506
507 desc->memoryFd = vdiDesc.memoryFd;
508 desc->totalBufferFrames = vdiDesc.totalBufferFrames;
509 desc->transferFrameSize = vdiDesc.transferFrameSize;
510 desc->isShareable = vdiDesc.isShareable;
511 desc->filePath = strdup(""); // which will be released after send reply
512 if (desc->filePath == NULL) {
513 AUDIO_FUNC_LOGE("strdup fail");
514 return HDF_FAILURE;
515 }
516 if (desc->totalBufferFrames < 0) {
517 // make the totalBufferFrames valid
518 desc->totalBufferFrames *= -1;
519 desc->isShareable = 1;
520 }
521 return HDF_SUCCESS;
522 }
523
AudioCaptureGetMmapPositionVdi(struct IAudioCapture *capture, uint64_t *frames, struct AudioTimeStamp *time)524 int32_t AudioCaptureGetMmapPositionVdi(struct IAudioCapture *capture, uint64_t *frames, struct AudioTimeStamp *time)
525 {
526 CHECK_NULL_PTR_RETURN_VALUE(capture, HDF_ERR_INVALID_PARAM);
527 CHECK_NULL_PTR_RETURN_VALUE(frames, HDF_ERR_INVALID_PARAM);
528 CHECK_NULL_PTR_RETURN_VALUE(time, HDF_ERR_INVALID_PARAM);
529
530 struct AudioTimeStampVdi vdiTime;
531 vdiTime.tvSec = 0;
532 vdiTime.tvNSec = 0;
533
534 struct AudioCaptureInfo *captureInfo = (struct AudioCaptureInfo *)(capture);
535 struct IAudioCaptureVdi *vdiCapture = captureInfo->vdiCapture;
536 CHECK_NULL_PTR_RETURN_VALUE(vdiCapture, HDF_ERR_INVALID_PARAM);
537 CHECK_NULL_PTR_RETURN_VALUE(vdiCapture->GetMmapPosition, HDF_ERR_INVALID_PARAM);
538
539 int32_t ret = vdiCapture->GetMmapPosition(vdiCapture, frames, &vdiTime);
540 if (ret != HDF_SUCCESS) {
541 AUDIO_FUNC_LOGE("audio capture GetMmapPosition fail, ret=%{public}d", ret);
542 return ret;
543 }
544
545 time->tvSec = vdiTime.tvSec;
546 time->tvNSec = vdiTime.tvNSec;
547
548 return HDF_SUCCESS;
549 }
550
AudioCaptureAddAudioEffectVdi(struct IAudioCapture *capture, uint64_t effectid)551 int32_t AudioCaptureAddAudioEffectVdi(struct IAudioCapture *capture, uint64_t effectid)
552 {
553 CHECK_NULL_PTR_RETURN_VALUE(capture, HDF_ERR_INVALID_PARAM);
554
555 struct AudioCaptureInfo *captureInfo = (struct AudioCaptureInfo *)(capture);
556 struct IAudioCaptureVdi *vdiCapture = captureInfo->vdiCapture;
557 CHECK_NULL_PTR_RETURN_VALUE(vdiCapture, HDF_ERR_INVALID_PARAM);
558 CHECK_NULL_PTR_RETURN_VALUE(vdiCapture->AddAudioEffect, HDF_ERR_INVALID_PARAM);
559
560 int32_t ret = vdiCapture->AddAudioEffect(vdiCapture, effectid);
561 if (ret != HDF_SUCCESS) {
562 AUDIO_FUNC_LOGE("audio capture AddAudioEffect fail, ret=%{public}d", ret);
563 return ret;
564 }
565
566 return HDF_SUCCESS;
567 }
568
AudioCaptureRemoveAudioEffectVdi(struct IAudioCapture *capture, uint64_t effectid)569 int32_t AudioCaptureRemoveAudioEffectVdi(struct IAudioCapture *capture, uint64_t effectid)
570 {
571 CHECK_NULL_PTR_RETURN_VALUE(capture, HDF_ERR_INVALID_PARAM);
572
573 struct AudioCaptureInfo *captureInfo = (struct AudioCaptureInfo *)(capture);
574 struct IAudioCaptureVdi *vdiCapture = captureInfo->vdiCapture;
575 CHECK_NULL_PTR_RETURN_VALUE(vdiCapture, HDF_ERR_INVALID_PARAM);
576 CHECK_NULL_PTR_RETURN_VALUE(vdiCapture->RemoveAudioEffect, HDF_ERR_INVALID_PARAM);
577
578 int32_t ret = vdiCapture->RemoveAudioEffect(vdiCapture, effectid);
579 if (ret != HDF_SUCCESS) {
580 AUDIO_FUNC_LOGE("audio capture RemoveAudioEffect fail, ret=%{public}d", ret);
581 return ret;
582 }
583
584 return HDF_SUCCESS;
585 }
586
AudioCaptureGetFrameBufferSizeVdi(struct IAudioCapture *capture, uint64_t *bufferSize)587 int32_t AudioCaptureGetFrameBufferSizeVdi(struct IAudioCapture *capture, uint64_t *bufferSize)
588 {
589 CHECK_NULL_PTR_RETURN_VALUE(capture, HDF_ERR_INVALID_PARAM);
590 CHECK_NULL_PTR_RETURN_VALUE(bufferSize, HDF_ERR_INVALID_PARAM);
591
592 struct AudioCaptureInfo *captureInfo = (struct AudioCaptureInfo *)(capture);
593 struct IAudioCaptureVdi *vdiCapture = captureInfo->vdiCapture;
594 CHECK_NULL_PTR_RETURN_VALUE(vdiCapture, HDF_ERR_INVALID_PARAM);
595 CHECK_NULL_PTR_RETURN_VALUE(vdiCapture->GetFrameBufferSize, HDF_ERR_INVALID_PARAM);
596
597 int32_t ret = vdiCapture->GetFrameBufferSize(vdiCapture, bufferSize);
598 if (ret != HDF_SUCCESS) {
599 AUDIO_FUNC_LOGE("audio capture GetFrameBufferSize fail, ret=%{public}d", ret);
600 return ret;
601 }
602
603 return HDF_SUCCESS;
604 }
605
AudioCaptureStartVdi(struct IAudioCapture *capture)606 int32_t AudioCaptureStartVdi(struct IAudioCapture *capture)
607 {
608 CHECK_NULL_PTR_RETURN_VALUE(capture, HDF_ERR_INVALID_PARAM);
609
610 struct AudioCaptureInfo *captureInfo = (struct AudioCaptureInfo *)(capture);
611 struct IAudioCaptureVdi *vdiCapture = captureInfo->vdiCapture;
612 CHECK_NULL_PTR_RETURN_VALUE(vdiCapture, HDF_ERR_INVALID_PARAM);
613 CHECK_NULL_PTR_RETURN_VALUE(vdiCapture->Start, HDF_ERR_INVALID_PARAM);
614
615 int32_t ret = vdiCapture->Start(vdiCapture);
616 if (ret != HDF_SUCCESS) {
617 AUDIO_FUNC_LOGE("audio capture Start fail, ret=%{public}d", ret);
618 return ret;
619 }
620
621 return HDF_SUCCESS;
622 }
623
AudioCaptureStopVdi(struct IAudioCapture *capture)624 int32_t AudioCaptureStopVdi(struct IAudioCapture *capture)
625 {
626 CHECK_NULL_PTR_RETURN_VALUE(capture, HDF_ERR_INVALID_PARAM);
627
628 struct AudioCaptureInfo *captureInfo = (struct AudioCaptureInfo *)(capture);
629 struct IAudioCaptureVdi *vdiCapture = captureInfo->vdiCapture;
630 CHECK_NULL_PTR_RETURN_VALUE(vdiCapture, HDF_ERR_INVALID_PARAM);
631 CHECK_NULL_PTR_RETURN_VALUE(vdiCapture->Stop, HDF_ERR_INVALID_PARAM);
632
633 int32_t ret = vdiCapture->Stop(vdiCapture);
634 if (ret != HDF_SUCCESS) {
635 AUDIO_FUNC_LOGE("audio capture Stop fail, ret=%{public}d", ret);
636 return HDF_ERR_NOT_SUPPORT;
637 }
638
639 return HDF_SUCCESS;
640 }
641
AudioCapturePauseVdi(struct IAudioCapture *capture)642 int32_t AudioCapturePauseVdi(struct IAudioCapture *capture)
643 {
644 CHECK_NULL_PTR_RETURN_VALUE(capture, HDF_ERR_INVALID_PARAM);
645
646 struct AudioCaptureInfo *captureInfo = (struct AudioCaptureInfo *)(capture);
647 struct IAudioCaptureVdi *vdiCapture = captureInfo->vdiCapture;
648 CHECK_NULL_PTR_RETURN_VALUE(vdiCapture, HDF_ERR_INVALID_PARAM);
649 CHECK_NULL_PTR_RETURN_VALUE(vdiCapture->Pause, HDF_ERR_INVALID_PARAM);
650
651 int32_t ret = vdiCapture->Pause(vdiCapture);
652 if (ret != HDF_SUCCESS) {
653 AUDIO_FUNC_LOGE("audio capture Pause fail, ret=%{public}d", ret);
654 return ret;
655 }
656
657 return HDF_SUCCESS;
658 }
659
AudioCaptureResumeVdi(struct IAudioCapture *capture)660 int32_t AudioCaptureResumeVdi(struct IAudioCapture *capture)
661 {
662 CHECK_NULL_PTR_RETURN_VALUE(capture, HDF_ERR_INVALID_PARAM);
663
664 struct AudioCaptureInfo *captureInfo = (struct AudioCaptureInfo *)(capture);
665 struct IAudioCaptureVdi *vdiCapture = captureInfo->vdiCapture;
666 CHECK_NULL_PTR_RETURN_VALUE(vdiCapture, HDF_ERR_INVALID_PARAM);
667 CHECK_NULL_PTR_RETURN_VALUE(vdiCapture->Resume, HDF_ERR_INVALID_PARAM);
668
669 int32_t ret = vdiCapture->Resume(vdiCapture);
670 if (ret != HDF_SUCCESS) {
671 AUDIO_FUNC_LOGE("audio capture Resume fail, ret=%{public}d", ret);
672 return ret;
673 }
674
675 return HDF_SUCCESS;
676 }
677
AudioCaptureFlushVdi(struct IAudioCapture *capture)678 int32_t AudioCaptureFlushVdi(struct IAudioCapture *capture)
679 {
680 CHECK_NULL_PTR_RETURN_VALUE(capture, HDF_ERR_INVALID_PARAM);
681
682 struct AudioCaptureInfo *captureInfo = (struct AudioCaptureInfo *)(capture);
683 struct IAudioCaptureVdi *vdiCapture = captureInfo->vdiCapture;
684 CHECK_NULL_PTR_RETURN_VALUE(vdiCapture, HDF_ERR_INVALID_PARAM);
685 CHECK_NULL_PTR_RETURN_VALUE(vdiCapture->Flush, HDF_ERR_INVALID_PARAM);
686
687 int32_t ret = vdiCapture->Flush(vdiCapture);
688 if (ret != HDF_SUCCESS) {
689 AUDIO_FUNC_LOGE("audio capture Flush fail, ret=%{public}d", ret);
690 return ret;
691 }
692
693 return HDF_SUCCESS;
694 }
695
AudioCaptureTurnStandbyModeVdi(struct IAudioCapture *capture)696 int32_t AudioCaptureTurnStandbyModeVdi(struct IAudioCapture *capture)
697 {
698 CHECK_NULL_PTR_RETURN_VALUE(capture, HDF_ERR_INVALID_PARAM);
699
700 struct AudioCaptureInfo *captureInfo = (struct AudioCaptureInfo *)(capture);
701 struct IAudioCaptureVdi *vdiCapture = captureInfo->vdiCapture;
702 CHECK_NULL_PTR_RETURN_VALUE(vdiCapture, HDF_ERR_INVALID_PARAM);
703 CHECK_NULL_PTR_RETURN_VALUE(vdiCapture->TurnStandbyMode, HDF_ERR_INVALID_PARAM);
704
705 int32_t ret = vdiCapture->TurnStandbyMode(vdiCapture);
706 if (ret != HDF_SUCCESS) {
707 AUDIO_FUNC_LOGE("audio capture TurnStandbyMode fail, ret=%{public}d", ret);
708 return ret;
709 }
710
711 return HDF_SUCCESS;
712 }
713
AudioCaptureAudioDevDumpVdi(struct IAudioCapture *capture, int32_t range, int32_t fd)714 int32_t AudioCaptureAudioDevDumpVdi(struct IAudioCapture *capture, int32_t range, int32_t fd)
715 {
716 CHECK_NULL_PTR_RETURN_VALUE(capture, HDF_ERR_INVALID_PARAM);
717
718 struct AudioCaptureInfo *captureInfo = (struct AudioCaptureInfo *)(capture);
719 struct IAudioCaptureVdi *vdiCapture = captureInfo->vdiCapture;
720 CHECK_NULL_PTR_RETURN_VALUE(vdiCapture, HDF_ERR_INVALID_PARAM);
721 CHECK_NULL_PTR_RETURN_VALUE(vdiCapture->AudioDevDump, HDF_ERR_INVALID_PARAM);
722
723 int32_t ret = vdiCapture->AudioDevDump(vdiCapture, range, fd);
724 if (ret != HDF_SUCCESS) {
725 AUDIO_FUNC_LOGE("audio capture AudioDevDump fail, ret=%{public}d", ret);
726 return ret;
727 }
728
729 return HDF_SUCCESS;
730 }
731
AudioCaptureIsSupportsPauseAndResumeVdi(struct IAudioCapture *capture, bool *supportPause, bool *supportResume)732 int32_t AudioCaptureIsSupportsPauseAndResumeVdi(struct IAudioCapture *capture, bool *supportPause, bool *supportResume)
733 {
734 CHECK_NULL_PTR_RETURN_VALUE(capture, HDF_ERR_INVALID_PARAM);
735 CHECK_NULL_PTR_RETURN_VALUE(supportPause, HDF_ERR_INVALID_PARAM);
736 CHECK_NULL_PTR_RETURN_VALUE(supportResume, HDF_ERR_INVALID_PARAM);
737
738 struct AudioCaptureInfo *captureInfo = (struct AudioCaptureInfo *)(capture);
739 struct IAudioCaptureVdi *vdiCapture = captureInfo->vdiCapture;
740 CHECK_NULL_PTR_RETURN_VALUE(vdiCapture, HDF_ERR_INVALID_PARAM);
741 CHECK_NULL_PTR_RETURN_VALUE(vdiCapture->IsSupportsPauseAndResume, HDF_ERR_INVALID_PARAM);
742
743 int32_t ret = vdiCapture->IsSupportsPauseAndResume(vdiCapture, supportPause, supportResume);
744 if (ret != HDF_SUCCESS) {
745 AUDIO_FUNC_LOGE("audio capture IsSupportsPauseAndResume fail, ret=%{public}d", ret);
746 return ret;
747 }
748
749 return HDF_SUCCESS;
750 }
751
AudioInitCaptureInstanceVdi(struct IAudioCapture *capture)752 static void AudioInitCaptureInstanceVdi(struct IAudioCapture *capture)
753 {
754 capture->CaptureFrame = AudioCaptureFrameVdi;
755 capture->CaptureFrameEc = AudioCaptureFrameEcVdi;
756 capture->GetCapturePosition = AudioGetCapturePositionVdi;
757 capture->CheckSceneCapability = AudioCaptureCheckSceneCapabilityVdi;
758 capture->SelectScene = AudioCaptureSelectSceneVdi;
759 capture->SetMute = AudioCaptureSetMuteVdi;
760 capture->GetMute = AudioCaptureGetMuteVdi;
761 capture->SetVolume = AudioCaptureSetVolumeVdi;
762 capture->GetVolume = AudioCaptureGetVolumeVdi;
763 capture->GetGainThreshold = AudioCaptureGetGainThresholdVdi;
764 capture->GetGain = AudioCaptureGetGainVdi;
765 capture->SetGain = AudioCaptureSetGainVdi;
766 capture->GetFrameSize = AudioCaptureGetFrameSizeVdi;
767 capture->GetFrameCount = AudioCaptureGetFrameCountVdi;
768 capture->SetSampleAttributes = AudioCaptureSetSampleAttributesVdi;
769 capture->GetSampleAttributes = AudioCaptureGetSampleAttributesVdi;
770 capture->GetCurrentChannelId = AudioCaptureGetCurrentChannelIdVdi;
771 capture->SetExtraParams = AudioCaptureSetExtraParamsVdi;
772 capture->GetExtraParams = AudioCaptureGetExtraParamsVdi;
773 capture->ReqMmapBuffer = AudioCaptureReqMmapBufferVdi;
774 capture->GetMmapPosition = AudioCaptureGetMmapPositionVdi;
775 capture->AddAudioEffect = AudioCaptureAddAudioEffectVdi;
776 capture->RemoveAudioEffect = AudioCaptureRemoveAudioEffectVdi;
777 capture->GetFrameBufferSize = AudioCaptureGetFrameBufferSizeVdi;
778 capture->Start = AudioCaptureStartVdi;
779 capture->Stop = AudioCaptureStopVdi;
780 capture->Pause = AudioCapturePauseVdi;
781 capture->Resume = AudioCaptureResumeVdi;
782 capture->Flush = AudioCaptureFlushVdi;
783 capture->TurnStandbyMode = AudioCaptureTurnStandbyModeVdi;
784 capture->AudioDevDump = AudioCaptureAudioDevDumpVdi;
785 capture->IsSupportsPauseAndResume = AudioCaptureIsSupportsPauseAndResumeVdi;
786 }
787
GetAvailableCaptureId(struct AudioCapturePrivVdi *capturePriv)788 static uint32_t GetAvailableCaptureId(struct AudioCapturePrivVdi *capturePriv)
789 {
790 uint32_t captureId = AUDIO_VDI_STREAM_NUM_MAX;
791 if (capturePriv == NULL) {
792 AUDIO_FUNC_LOGE("Parameter error!");
793 return captureId;
794 }
795
796 if (capturePriv->captureCnt < AUDIO_VDI_STREAM_NUM_MAX) {
797 captureId = capturePriv->captureCnt;
798 capturePriv->captureCnt++;
799 } else {
800 for (uint32_t index = 0; index < AUDIO_VDI_STREAM_NUM_MAX; index++) {
801 if (capturePriv->captureInfos[index] == NULL) {
802 captureId = index;
803 break;
804 }
805 }
806 }
807
808 return captureId;
809 }
810
AudioCreateCaptureByIdVdi(const struct AudioSampleAttributes *attrs, uint32_t *captureId, struct IAudioCaptureVdi *vdiCapture, const struct AudioDeviceDescriptor *desc)811 struct IAudioCapture *AudioCreateCaptureByIdVdi(const struct AudioSampleAttributes *attrs, uint32_t *captureId,
812 struct IAudioCaptureVdi *vdiCapture, const struct AudioDeviceDescriptor *desc)
813 {
814 if (attrs == NULL || captureId == NULL || vdiCapture == NULL || desc == NULL) {
815 AUDIO_FUNC_LOGE("audio capture is null");
816 return NULL;
817 }
818
819 *captureId = AUDIO_VDI_STREAM_NUM_MAX;
820 struct IAudioCapture *capture = NULL;
821 struct AudioCapturePrivVdi *priv = AudioCaptureGetPrivVdi();
822
823 *captureId = GetAvailableCaptureId(priv);
824 if (*captureId >= AUDIO_VDI_STREAM_NUM_MAX) {
825 AUDIO_FUNC_LOGE("audio vdicapture capture capture index fail, captureId=%{public}d", *captureId);
826 return NULL;
827 }
828
829 priv->captureInfos[*captureId] = (struct AudioCaptureInfo *)OsalMemCalloc(sizeof(struct AudioCaptureInfo));
830 if (priv->captureInfos[*captureId] == NULL) {
831 AUDIO_FUNC_LOGE("audio Vdicapture malloc captureInfos fail");
832 return NULL;
833 }
834
835 priv->captureInfos[*captureId]->vdiCapture = vdiCapture;
836 priv->captureInfos[*captureId]->streamType = attrs->type;
837 priv->captureInfos[*captureId]->sampleRate = attrs->sampleRate;
838 priv->captureInfos[*captureId]->channelCount = attrs->channelCount;
839 priv->captureInfos[*captureId]->sourceType = attrs->sourceType;
840 priv->captureInfos[*captureId]->desc.portId = desc->portId;
841 priv->captureInfos[*captureId]->desc.pins = desc->pins;
842 priv->captureInfos[*captureId]->desc.desc = strdup(desc->desc);
843 if (priv->captureInfos[*captureId]->desc.desc == NULL) {
844 AUDIO_FUNC_LOGE("strdup fail, desc->desc = %{public}s", desc->desc);
845 OsalMemFree(priv->captureInfos[*captureId]);
846 priv->captureInfos[*captureId] = NULL;
847 return NULL;
848 }
849 priv->captureInfos[*captureId]->captureId = *captureId;
850 priv->captureInfos[*captureId]->usrCount = 1;
851 capture = &(priv->captureInfos[*captureId]->capture);
852 AudioInitCaptureInstanceVdi(capture);
853
854 AUDIO_FUNC_LOGD("audio create capture success");
855 return capture;
856 };
857
DecreaseCaptureUsrCount(uint32_t captureId)858 uint32_t DecreaseCaptureUsrCount(uint32_t captureId)
859 {
860 uint32_t usrCnt = 0;
861 if (captureId >= AUDIO_VDI_STREAM_NUM_MAX) {
862 AUDIO_FUNC_LOGE("audio check capture index fail, descIndex=%{public}d", captureId);
863 return usrCnt;
864 }
865 struct AudioCapturePrivVdi *priv = AudioCaptureGetPrivVdi();
866 if (priv->captureInfos[captureId] == NULL) {
867 AUDIO_FUNC_LOGE("audio check capture index fail, descIndex=%{public}d", captureId);
868 return usrCnt;
869 }
870
871 priv->captureInfos[captureId]->usrCount--;
872 usrCnt = priv->captureInfos[captureId]->usrCount;
873 return usrCnt;
874 }
875
AudioDestroyCaptureByIdVdi(uint32_t captureId)876 void AudioDestroyCaptureByIdVdi(uint32_t captureId)
877 {
878 if (captureId >= AUDIO_VDI_STREAM_NUM_MAX) {
879 AUDIO_FUNC_LOGE("audio vdiCapture destroy capture index fail, captureId=%{public}d", captureId);
880 return;
881 }
882 struct AudioCapturePrivVdi *priv = AudioCaptureGetPrivVdi();
883 if (priv->captureInfos[captureId] == NULL) {
884 AUDIO_FUNC_LOGE("audio vdiCapture destroy capture index fail, captureId=%{public}d", captureId);
885 return;
886 }
887
888 OsalMemFree((void *)priv->captureInfos[captureId]->desc.desc);
889 priv->captureInfos[captureId]->vdiCapture = NULL;
890 priv->captureInfos[captureId]->desc.desc = NULL;
891 priv->captureInfos[captureId]->desc.portId = UINT_MAX;
892 priv->captureInfos[captureId]->desc.pins = PIN_NONE;
893
894 OsalMemFree(priv->captureInfos[captureId]);
895 priv->captureInfos[captureId] = NULL;
896 }
897