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.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 HdfAudioStartTrace("Hdi:AudioCaptureFrameVdi", 0);
86 struct timeval startTime = AudioDfxSysEventGetTimeStamp();
87 int32_t ret = vdiCapture->CaptureFrame(vdiCapture, frame, frameLen, replyBytes);
88 AudioDfxSysEventError("CaptureFrame", startTime, TIME_THRESHOLD, ret);
89 HdfAudioFinishTrace();
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->syncInfoSize = vdiDesc.syncInfoSize;
523 desc->filePath = strdup(""); // which will be released after send reply
524 if (desc->filePath == NULL) {
525 AUDIO_FUNC_LOGE("strdup fail");
526 return HDF_FAILURE;
527 }
528 if (desc->totalBufferFrames < 0) {
529 // make the totalBufferFrames valid
530 desc->totalBufferFrames *= -1;
531 desc->isShareable = 1;
532 }
533 return HDF_SUCCESS;
534 }
535
AudioCaptureGetMmapPositionVdi(struct IAudioCapture * capture,uint64_t * frames,struct AudioTimeStamp * time)536 int32_t AudioCaptureGetMmapPositionVdi(struct IAudioCapture *capture, uint64_t *frames, struct AudioTimeStamp *time)
537 {
538 CHECK_NULL_PTR_RETURN_VALUE(capture, HDF_ERR_INVALID_PARAM);
539 CHECK_NULL_PTR_RETURN_VALUE(frames, HDF_ERR_INVALID_PARAM);
540 CHECK_NULL_PTR_RETURN_VALUE(time, HDF_ERR_INVALID_PARAM);
541
542 struct AudioTimeStampVdi vdiTime;
543 vdiTime.tvSec = 0;
544 vdiTime.tvNSec = 0;
545
546 struct AudioCaptureInfo *captureInfo = (struct AudioCaptureInfo *)(capture);
547 struct IAudioCaptureVdi *vdiCapture = captureInfo->vdiCapture;
548 CHECK_NULL_PTR_RETURN_VALUE(vdiCapture, HDF_ERR_INVALID_PARAM);
549 CHECK_NULL_PTR_RETURN_VALUE(vdiCapture->GetMmapPosition, HDF_ERR_INVALID_PARAM);
550
551 int32_t ret = vdiCapture->GetMmapPosition(vdiCapture, frames, &vdiTime);
552 if (ret != HDF_SUCCESS) {
553 AUDIO_FUNC_LOGE("audio capture GetMmapPosition fail, ret=%{public}d", ret);
554 return ret;
555 }
556
557 time->tvSec = vdiTime.tvSec;
558 time->tvNSec = vdiTime.tvNSec;
559
560 return HDF_SUCCESS;
561 }
562
AudioCaptureAddAudioEffectVdi(struct IAudioCapture * capture,uint64_t effectid)563 int32_t AudioCaptureAddAudioEffectVdi(struct IAudioCapture *capture, uint64_t effectid)
564 {
565 CHECK_NULL_PTR_RETURN_VALUE(capture, HDF_ERR_INVALID_PARAM);
566
567 struct AudioCaptureInfo *captureInfo = (struct AudioCaptureInfo *)(capture);
568 struct IAudioCaptureVdi *vdiCapture = captureInfo->vdiCapture;
569 CHECK_NULL_PTR_RETURN_VALUE(vdiCapture, HDF_ERR_INVALID_PARAM);
570 CHECK_NULL_PTR_RETURN_VALUE(vdiCapture->AddAudioEffect, HDF_ERR_INVALID_PARAM);
571
572 int32_t ret = vdiCapture->AddAudioEffect(vdiCapture, effectid);
573 if (ret != HDF_SUCCESS) {
574 AUDIO_FUNC_LOGE("audio capture AddAudioEffect fail, ret=%{public}d", ret);
575 return ret;
576 }
577
578 return HDF_SUCCESS;
579 }
580
AudioCaptureRemoveAudioEffectVdi(struct IAudioCapture * capture,uint64_t effectid)581 int32_t AudioCaptureRemoveAudioEffectVdi(struct IAudioCapture *capture, uint64_t effectid)
582 {
583 CHECK_NULL_PTR_RETURN_VALUE(capture, HDF_ERR_INVALID_PARAM);
584
585 struct AudioCaptureInfo *captureInfo = (struct AudioCaptureInfo *)(capture);
586 struct IAudioCaptureVdi *vdiCapture = captureInfo->vdiCapture;
587 CHECK_NULL_PTR_RETURN_VALUE(vdiCapture, HDF_ERR_INVALID_PARAM);
588 CHECK_NULL_PTR_RETURN_VALUE(vdiCapture->RemoveAudioEffect, HDF_ERR_INVALID_PARAM);
589
590 int32_t ret = vdiCapture->RemoveAudioEffect(vdiCapture, effectid);
591 if (ret != HDF_SUCCESS) {
592 AUDIO_FUNC_LOGE("audio capture RemoveAudioEffect fail, ret=%{public}d", ret);
593 return ret;
594 }
595
596 return HDF_SUCCESS;
597 }
598
AudioCaptureGetFrameBufferSizeVdi(struct IAudioCapture * capture,uint64_t * bufferSize)599 int32_t AudioCaptureGetFrameBufferSizeVdi(struct IAudioCapture *capture, uint64_t *bufferSize)
600 {
601 CHECK_NULL_PTR_RETURN_VALUE(capture, HDF_ERR_INVALID_PARAM);
602 CHECK_NULL_PTR_RETURN_VALUE(bufferSize, HDF_ERR_INVALID_PARAM);
603
604 struct AudioCaptureInfo *captureInfo = (struct AudioCaptureInfo *)(capture);
605 struct IAudioCaptureVdi *vdiCapture = captureInfo->vdiCapture;
606 CHECK_NULL_PTR_RETURN_VALUE(vdiCapture, HDF_ERR_INVALID_PARAM);
607 CHECK_NULL_PTR_RETURN_VALUE(vdiCapture->GetFrameBufferSize, HDF_ERR_INVALID_PARAM);
608
609 int32_t ret = vdiCapture->GetFrameBufferSize(vdiCapture, bufferSize);
610 if (ret != HDF_SUCCESS) {
611 AUDIO_FUNC_LOGE("audio capture GetFrameBufferSize fail, ret=%{public}d", ret);
612 return ret;
613 }
614
615 return HDF_SUCCESS;
616 }
617
AudioCaptureStartVdi(struct IAudioCapture * capture)618 int32_t AudioCaptureStartVdi(struct IAudioCapture *capture)
619 {
620 AUDIO_FUNC_LOGI("hdi start enter");
621 CHECK_NULL_PTR_RETURN_VALUE(capture, HDF_ERR_INVALID_PARAM);
622 pthread_rwlock_rdlock(&g_rwVdiCaptureLock);
623 struct AudioCaptureInfo *captureInfo = (struct AudioCaptureInfo *)(capture);
624 struct IAudioCaptureVdi *vdiCapture = captureInfo->vdiCapture;
625 if (vdiCapture == NULL || vdiCapture->Start == NULL) {
626 AUDIO_FUNC_LOGE("invalid param");
627 pthread_rwlock_unlock(&g_rwVdiCaptureLock);
628 return HDF_ERR_INVALID_PARAM;
629 }
630 HdfAudioStartTrace("Hdi:AudioCaptureStartVdi", 0);
631 struct timeval startTime = AudioDfxSysEventGetTimeStamp();
632 int32_t ret = vdiCapture->Start(vdiCapture);
633 AudioDfxSysEventError("Capture Start", startTime, TIME_THRESHOLD, ret);
634 HdfAudioFinishTrace();
635 if (ret != HDF_SUCCESS) {
636 AUDIO_FUNC_LOGE("audio capture Start fail, ret=%{public}d", ret);
637 pthread_rwlock_unlock(&g_rwVdiCaptureLock);
638 return ret;
639 }
640 pthread_rwlock_unlock(&g_rwVdiCaptureLock);
641 return HDF_SUCCESS;
642 }
643
AudioCaptureStopVdi(struct IAudioCapture * capture)644 int32_t AudioCaptureStopVdi(struct IAudioCapture *capture)
645 {
646 AUDIO_FUNC_LOGI("hdi stop enter");
647 CHECK_NULL_PTR_RETURN_VALUE(capture, HDF_ERR_INVALID_PARAM);
648 pthread_rwlock_rdlock(&g_rwVdiCaptureLock);
649 struct AudioCaptureInfo *captureInfo = (struct AudioCaptureInfo *)(capture);
650 struct IAudioCaptureVdi *vdiCapture = captureInfo->vdiCapture;
651 if (vdiCapture == NULL || vdiCapture->Stop == NULL) {
652 AUDIO_FUNC_LOGE("invalid param");
653 pthread_rwlock_unlock(&g_rwVdiCaptureLock);
654 return HDF_ERR_INVALID_PARAM;
655 }
656 HdfAudioStartTrace("Hdi:AudioCaptureStopVdi", 0);
657 struct timeval startTime = AudioDfxSysEventGetTimeStamp();
658 int32_t ret = vdiCapture->Stop(vdiCapture);
659 AudioDfxSysEventError("Capture Stop", startTime, TIME_THRESHOLD, ret);
660 HdfAudioFinishTrace();
661 if (ret != HDF_SUCCESS) {
662 AUDIO_FUNC_LOGE("audio capture Stop fail, ret=%{public}d", ret);
663 pthread_rwlock_unlock(&g_rwVdiCaptureLock);
664 return HDF_ERR_NOT_SUPPORT;
665 }
666 pthread_rwlock_unlock(&g_rwVdiCaptureLock);
667 return HDF_SUCCESS;
668 }
669
AudioCapturePauseVdi(struct IAudioCapture * capture)670 int32_t AudioCapturePauseVdi(struct IAudioCapture *capture)
671 {
672 CHECK_NULL_PTR_RETURN_VALUE(capture, HDF_ERR_INVALID_PARAM);
673 pthread_rwlock_rdlock(&g_rwVdiCaptureLock);
674 struct AudioCaptureInfo *captureInfo = (struct AudioCaptureInfo *)(capture);
675 struct IAudioCaptureVdi *vdiCapture = captureInfo->vdiCapture;
676 if (vdiCapture == NULL || vdiCapture->Pause == NULL) {
677 AUDIO_FUNC_LOGE("invalid param");
678 pthread_rwlock_unlock(&g_rwVdiCaptureLock);
679 return HDF_ERR_INVALID_PARAM;
680 }
681
682 int32_t ret = vdiCapture->Pause(vdiCapture);
683 if (ret != HDF_SUCCESS) {
684 AUDIO_FUNC_LOGE("audio capture Pause fail, ret=%{public}d", ret);
685 pthread_rwlock_unlock(&g_rwVdiCaptureLock);
686 return ret;
687 }
688 pthread_rwlock_unlock(&g_rwVdiCaptureLock);
689 return HDF_SUCCESS;
690 }
691
AudioCaptureResumeVdi(struct IAudioCapture * capture)692 int32_t AudioCaptureResumeVdi(struct IAudioCapture *capture)
693 {
694 CHECK_NULL_PTR_RETURN_VALUE(capture, HDF_ERR_INVALID_PARAM);
695 pthread_rwlock_rdlock(&g_rwVdiCaptureLock);
696 struct AudioCaptureInfo *captureInfo = (struct AudioCaptureInfo *)(capture);
697 struct IAudioCaptureVdi *vdiCapture = captureInfo->vdiCapture;
698 if (vdiCapture == NULL || vdiCapture->Resume == NULL) {
699 AUDIO_FUNC_LOGE("invalid param");
700 pthread_rwlock_unlock(&g_rwVdiCaptureLock);
701 return HDF_ERR_INVALID_PARAM;
702 }
703
704 int32_t ret = vdiCapture->Resume(vdiCapture);
705 if (ret != HDF_SUCCESS) {
706 AUDIO_FUNC_LOGE("audio capture Resume fail, ret=%{public}d", ret);
707 pthread_rwlock_unlock(&g_rwVdiCaptureLock);
708 return ret;
709 }
710 pthread_rwlock_unlock(&g_rwVdiCaptureLock);
711 return HDF_SUCCESS;
712 }
713
AudioCaptureFlushVdi(struct IAudioCapture * capture)714 int32_t AudioCaptureFlushVdi(struct IAudioCapture *capture)
715 {
716 CHECK_NULL_PTR_RETURN_VALUE(capture, HDF_ERR_INVALID_PARAM);
717
718 struct AudioCaptureInfo *captureInfo = (struct AudioCaptureInfo *)(capture);
719 struct IAudioCaptureVdi *vdiCapture = captureInfo->vdiCapture;
720 CHECK_NULL_PTR_RETURN_VALUE(vdiCapture, HDF_ERR_INVALID_PARAM);
721 CHECK_NULL_PTR_RETURN_VALUE(vdiCapture->Flush, HDF_ERR_INVALID_PARAM);
722
723 int32_t ret = vdiCapture->Flush(vdiCapture);
724 if (ret != HDF_SUCCESS) {
725 AUDIO_FUNC_LOGE("audio capture Flush fail, ret=%{public}d", ret);
726 return ret;
727 }
728
729 return HDF_SUCCESS;
730 }
731
AudioCaptureTurnStandbyModeVdi(struct IAudioCapture * capture)732 int32_t AudioCaptureTurnStandbyModeVdi(struct IAudioCapture *capture)
733 {
734 CHECK_NULL_PTR_RETURN_VALUE(capture, HDF_ERR_INVALID_PARAM);
735
736 struct AudioCaptureInfo *captureInfo = (struct AudioCaptureInfo *)(capture);
737 struct IAudioCaptureVdi *vdiCapture = captureInfo->vdiCapture;
738 CHECK_NULL_PTR_RETURN_VALUE(vdiCapture, HDF_ERR_INVALID_PARAM);
739 CHECK_NULL_PTR_RETURN_VALUE(vdiCapture->TurnStandbyMode, HDF_ERR_INVALID_PARAM);
740
741 int32_t ret = vdiCapture->TurnStandbyMode(vdiCapture);
742 if (ret != HDF_SUCCESS) {
743 AUDIO_FUNC_LOGE("audio capture TurnStandbyMode fail, ret=%{public}d", ret);
744 return ret;
745 }
746
747 return HDF_SUCCESS;
748 }
749
AudioCaptureAudioDevDumpVdi(struct IAudioCapture * capture,int32_t range,int32_t fd)750 int32_t AudioCaptureAudioDevDumpVdi(struct IAudioCapture *capture, int32_t range, int32_t fd)
751 {
752 CHECK_NULL_PTR_RETURN_VALUE(capture, HDF_ERR_INVALID_PARAM);
753
754 struct AudioCaptureInfo *captureInfo = (struct AudioCaptureInfo *)(capture);
755 struct IAudioCaptureVdi *vdiCapture = captureInfo->vdiCapture;
756 CHECK_NULL_PTR_RETURN_VALUE(vdiCapture, HDF_ERR_INVALID_PARAM);
757 CHECK_NULL_PTR_RETURN_VALUE(vdiCapture->AudioDevDump, HDF_ERR_INVALID_PARAM);
758
759 int32_t ret = vdiCapture->AudioDevDump(vdiCapture, range, fd);
760 if (ret != HDF_SUCCESS) {
761 AUDIO_FUNC_LOGE("audio capture AudioDevDump fail, ret=%{public}d", ret);
762 return ret;
763 }
764
765 return HDF_SUCCESS;
766 }
767
AudioCaptureIsSupportsPauseAndResumeVdi(struct IAudioCapture * capture,bool * supportPause,bool * supportResume)768 int32_t AudioCaptureIsSupportsPauseAndResumeVdi(struct IAudioCapture *capture, bool *supportPause, bool *supportResume)
769 {
770 CHECK_NULL_PTR_RETURN_VALUE(capture, HDF_ERR_INVALID_PARAM);
771 CHECK_NULL_PTR_RETURN_VALUE(supportPause, HDF_ERR_INVALID_PARAM);
772 CHECK_NULL_PTR_RETURN_VALUE(supportResume, HDF_ERR_INVALID_PARAM);
773
774 struct AudioCaptureInfo *captureInfo = (struct AudioCaptureInfo *)(capture);
775 struct IAudioCaptureVdi *vdiCapture = captureInfo->vdiCapture;
776 CHECK_NULL_PTR_RETURN_VALUE(vdiCapture, HDF_ERR_INVALID_PARAM);
777 CHECK_NULL_PTR_RETURN_VALUE(vdiCapture->IsSupportsPauseAndResume, HDF_ERR_INVALID_PARAM);
778
779 int32_t ret = vdiCapture->IsSupportsPauseAndResume(vdiCapture, supportPause, supportResume);
780 if (ret != HDF_SUCCESS) {
781 AUDIO_FUNC_LOGE("audio capture IsSupportsPauseAndResume fail, ret=%{public}d", ret);
782 return ret;
783 }
784
785 return HDF_SUCCESS;
786 }
787
AudioInitCaptureInstanceVdi(struct IAudioCapture * capture)788 static void AudioInitCaptureInstanceVdi(struct IAudioCapture *capture)
789 {
790 capture->CaptureFrame = AudioCaptureFrameVdi;
791 capture->CaptureFrameEc = AudioCaptureFrameEcVdi;
792 capture->GetCapturePosition = AudioGetCapturePositionVdi;
793 capture->CheckSceneCapability = AudioCaptureCheckSceneCapabilityVdi;
794 capture->SelectScene = AudioCaptureSelectSceneVdi;
795 capture->SetMute = AudioCaptureSetMuteVdi;
796 capture->GetMute = AudioCaptureGetMuteVdi;
797 capture->SetVolume = AudioCaptureSetVolumeVdi;
798 capture->GetVolume = AudioCaptureGetVolumeVdi;
799 capture->GetGainThreshold = AudioCaptureGetGainThresholdVdi;
800 capture->GetGain = AudioCaptureGetGainVdi;
801 capture->SetGain = AudioCaptureSetGainVdi;
802 capture->GetFrameSize = AudioCaptureGetFrameSizeVdi;
803 capture->GetFrameCount = AudioCaptureGetFrameCountVdi;
804 capture->SetSampleAttributes = AudioCaptureSetSampleAttributesVdi;
805 capture->GetSampleAttributes = AudioCaptureGetSampleAttributesVdi;
806 capture->GetCurrentChannelId = AudioCaptureGetCurrentChannelIdVdi;
807 capture->SetExtraParams = AudioCaptureSetExtraParamsVdi;
808 capture->GetExtraParams = AudioCaptureGetExtraParamsVdi;
809 capture->ReqMmapBuffer = AudioCaptureReqMmapBufferVdi;
810 capture->GetMmapPosition = AudioCaptureGetMmapPositionVdi;
811 capture->AddAudioEffect = AudioCaptureAddAudioEffectVdi;
812 capture->RemoveAudioEffect = AudioCaptureRemoveAudioEffectVdi;
813 capture->GetFrameBufferSize = AudioCaptureGetFrameBufferSizeVdi;
814 capture->Start = AudioCaptureStartVdi;
815 capture->Stop = AudioCaptureStopVdi;
816 capture->Pause = AudioCapturePauseVdi;
817 capture->Resume = AudioCaptureResumeVdi;
818 capture->Flush = AudioCaptureFlushVdi;
819 capture->TurnStandbyMode = AudioCaptureTurnStandbyModeVdi;
820 capture->AudioDevDump = AudioCaptureAudioDevDumpVdi;
821 capture->IsSupportsPauseAndResume = AudioCaptureIsSupportsPauseAndResumeVdi;
822 }
823
GetAvailableCaptureId(struct AudioCapturePrivVdi * capturePriv)824 static uint32_t GetAvailableCaptureId(struct AudioCapturePrivVdi *capturePriv)
825 {
826 uint32_t captureId = AUDIO_VDI_STREAM_NUM_MAX;
827 if (capturePriv == NULL) {
828 AUDIO_FUNC_LOGE("Parameter error!");
829 return captureId;
830 }
831
832 if (capturePriv->captureCnt < AUDIO_VDI_STREAM_NUM_MAX) {
833 captureId = capturePriv->captureCnt;
834 capturePriv->captureCnt++;
835 } else {
836 for (uint32_t index = 0; index < AUDIO_VDI_STREAM_NUM_MAX; index++) {
837 if (capturePriv->captureInfos[index] == NULL) {
838 captureId = index;
839 break;
840 }
841 }
842 }
843
844 return captureId;
845 }
846
AudioCreateCaptureByIdVdi(const struct AudioSampleAttributes * attrs,uint32_t * captureId,struct IAudioCaptureVdi * vdiCapture,const struct AudioDeviceDescriptor * desc)847 struct IAudioCapture *AudioCreateCaptureByIdVdi(const struct AudioSampleAttributes *attrs, uint32_t *captureId,
848 struct IAudioCaptureVdi *vdiCapture, const struct AudioDeviceDescriptor *desc)
849 {
850 if (attrs == NULL || captureId == NULL || vdiCapture == NULL || desc == NULL) {
851 AUDIO_FUNC_LOGE("audio capture is null");
852 return NULL;
853 }
854
855 *captureId = AUDIO_VDI_STREAM_NUM_MAX;
856 struct IAudioCapture *capture = NULL;
857 struct AudioCapturePrivVdi *priv = AudioCaptureGetPrivVdi();
858
859 *captureId = GetAvailableCaptureId(priv);
860 if (*captureId >= AUDIO_VDI_STREAM_NUM_MAX) {
861 AUDIO_FUNC_LOGE("audio vdicapture capture capture index fail, captureId=%{public}d", *captureId);
862 return NULL;
863 }
864
865 priv->captureInfos[*captureId] = (struct AudioCaptureInfo *)OsalMemCalloc(sizeof(struct AudioCaptureInfo));
866 if (priv->captureInfos[*captureId] == NULL) {
867 AUDIO_FUNC_LOGE("audio Vdicapture malloc captureInfos fail");
868 return NULL;
869 }
870
871 priv->captureInfos[*captureId]->vdiCapture = vdiCapture;
872 priv->captureInfos[*captureId]->streamType = attrs->type;
873 priv->captureInfos[*captureId]->sampleRate = attrs->sampleRate;
874 priv->captureInfos[*captureId]->channelCount = attrs->channelCount;
875 priv->captureInfos[*captureId]->sourceType = attrs->sourceType;
876 priv->captureInfos[*captureId]->desc.portId = desc->portId;
877 priv->captureInfos[*captureId]->desc.pins = desc->pins;
878 priv->captureInfos[*captureId]->desc.desc = strdup(desc->desc);
879 if (priv->captureInfos[*captureId]->desc.desc == NULL) {
880 AUDIO_FUNC_LOGE("strdup fail, desc->desc = %{public}s", desc->desc);
881 OsalMemFree(priv->captureInfos[*captureId]);
882 priv->captureInfos[*captureId] = NULL;
883 return NULL;
884 }
885 priv->captureInfos[*captureId]->captureId = *captureId;
886 priv->captureInfos[*captureId]->usrCount = 1;
887 capture = &(priv->captureInfos[*captureId]->capture);
888 AudioInitCaptureInstanceVdi(capture);
889
890 AUDIO_FUNC_LOGD("audio create capture success");
891 return capture;
892 };
893
DecreaseCaptureUsrCount(uint32_t captureId)894 uint32_t DecreaseCaptureUsrCount(uint32_t captureId)
895 {
896 uint32_t usrCnt = 0;
897 if (captureId >= AUDIO_VDI_STREAM_NUM_MAX) {
898 AUDIO_FUNC_LOGE("audio check capture index fail, descIndex=%{public}d", captureId);
899 return usrCnt;
900 }
901 struct AudioCapturePrivVdi *priv = AudioCaptureGetPrivVdi();
902 if (priv->captureInfos[captureId] == NULL) {
903 AUDIO_FUNC_LOGE("audio check capture index fail, descIndex=%{public}d", captureId);
904 return usrCnt;
905 }
906
907 priv->captureInfos[captureId]->usrCount--;
908 usrCnt = priv->captureInfos[captureId]->usrCount;
909 return usrCnt;
910 }
911
AudioDestroyCaptureByIdVdi(uint32_t captureId)912 void AudioDestroyCaptureByIdVdi(uint32_t captureId)
913 {
914 if (captureId >= AUDIO_VDI_STREAM_NUM_MAX) {
915 AUDIO_FUNC_LOGE("audio vdiCapture destroy capture index fail, captureId=%{public}d", captureId);
916 return;
917 }
918 struct AudioCapturePrivVdi *priv = AudioCaptureGetPrivVdi();
919 if (priv->captureInfos[captureId] == NULL) {
920 AUDIO_FUNC_LOGE("audio vdiCapture destroy capture index fail, captureId=%{public}d", captureId);
921 return;
922 }
923
924 OsalMemFree((void *)priv->captureInfos[captureId]->desc.desc);
925 priv->captureInfos[captureId]->vdiCapture = NULL;
926 priv->captureInfos[captureId]->desc.desc = NULL;
927 priv->captureInfos[captureId]->desc.portId = UINT_MAX;
928 priv->captureInfos[captureId]->desc.pins = PIN_NONE;
929 StubCollectorRemoveObject(IAUDIOCAPTURE_INTERFACE_DESC, &(priv->captureInfos[captureId]->capture));
930
931 OsalMemFree(priv->captureInfos[captureId]);
932 priv->captureInfos[captureId] = NULL;
933 AUDIO_FUNC_LOGI("audio destroy capture success, captureId = [%{public}u]", captureId);
934 }
935