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