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