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