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