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