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