1 /**
2  * Copyright (c) 2022 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 #include "hdi_service_common.h"
16 #include <sys/stat.h>
17 #include "hdf_log.h"
18 #include "osal_mem.h"
19 
20 #define BUFFER_SIZE 16384
21 #define SREREO_CHANNEL 2
22 #define MONO_CHANNEL   1
23 #ifdef SUPPORT_OFFLOAD
24 #define OFFLOAD_AUDIO_WIDTH 32
25 #define OFFLOAD_AUDIO_BIT 8
26 #endif
27 using namespace std;
28 
29 static int g_frameStatus = 1;
30 static int g_writeCompleted = 0;
31 static int g_renderFull = 0;
32 static int g_flushCompleted = 0;
33 namespace OHOS {
34 namespace Audio {
InitAttrs(struct AudioSampleAttributes & attrs)35 int32_t InitAttrs(struct AudioSampleAttributes &attrs)
36 {
37 #ifdef AUDIO_SAMPLE_LOW_BITWIDTH
38     attrs.format = AUDIO_FORMAT_TYPE_PCM_16_BIT;
39     attrs.channelCount = CHANNELCOUNT;
40     attrs.sampleRate = SAMPLERATE;
41     attrs.interleaved = 0;
42     attrs.type = AUDIO_IN_MEDIA;
43     attrs.period = DEEP_BUFFER_RENDER_PERIOD_SIZE;
44     attrs.frameSize = AUDIO_FORMAT_TYPE_PCM_16_BIT * CHANNELCOUNT / MOVE_LEFT_NUM;
45     attrs.isBigEndian = false;
46     attrs.isSignedData = true;
47     attrs.startThreshold = DEEP_BUFFER_RENDER_PERIOD_SIZE / (attrs.format * attrs.channelCount / MOVE_LEFT_NUM);
48     attrs.stopThreshold = INT_32_MAX;
49     attrs.silenceThreshold = BUFFER_LENTH;
50 #else
51     attrs.format = AUDIO_FORMAT_TYPE_PCM_32_BIT;
52     attrs.channelCount = CHANNELCOUNT;
53     attrs.sampleRate = SAMPLERATE;
54     attrs.interleaved = 0;
55     attrs.type = AUDIO_IN_MEDIA;
56     attrs.period = DEEP_BUFFER_RENDER_PERIOD_SIZE;
57     attrs.frameSize = AUDIO_FORMAT_TYPE_PCM_32_BIT * CHANNELCOUNT / MOVE_LEFT_NUM;
58     attrs.isBigEndian = false;
59     attrs.isSignedData = true;
60     attrs.startThreshold = DEEP_BUFFER_RENDER_PERIOD_SIZE / (attrs.format * attrs.channelCount / MOVE_LEFT_NUM);
61     attrs.stopThreshold = INT_32_MAX;
62     attrs.silenceThreshold = BUFFER_LENTH;
63 #endif
64     return HDF_SUCCESS;
65 }
66 
67 #ifdef SUPPORT_OFFLOAD
InitOffloadAttrs(struct AudioSampleAttributes & attrs)68 int32_t InitOffloadAttrs(struct AudioSampleAttributes &attrs)
69 {
70     attrs.format = AUDIO_FORMAT_TYPE_PCM_32_BIT;
71     attrs.channelCount = CHANNELCOUNT;
72     attrs.sampleRate = SAMPLERATE;
73     attrs.interleaved = 0;
74     attrs.type = AUDIO_OFFLOAD;
75     attrs.period = DEEP_BUFFER_RENDER_PERIOD_SIZE;
76     attrs.frameSize = PCM_16_BIT * CHANNELCOUNT / MOVE_LEFT_NUM;
77     attrs.isBigEndian = false;
78     attrs.isSignedData = true;
79     attrs.startThreshold = DEEP_BUFFER_RENDER_PERIOD_SIZE / (PCM_16_BIT * attrs.channelCount / MOVE_LEFT_NUM);
80     attrs.stopThreshold = INT_32_MAX;
81     attrs.silenceThreshold = BUFFER_LENTH;
82     attrs.offloadInfo.sampleRate = SAMPLERATE;
83     attrs.offloadInfo.format = AUDIO_FORMAT_TYPE_PCM_32_BIT;
84     attrs.offloadInfo.bitRate = SAMPLERATE * CHANNELCOUNT * OFFLOAD_AUDIO_WIDTH / OFFLOAD_AUDIO_BIT;
85     attrs.offloadInfo.bitWidth = OFFLOAD_AUDIO_WIDTH;
86     attrs.offloadInfo.channelCount = CHANNELCOUNT;
87     return HDF_SUCCESS;
88 }
89 #endif
90 
InitAttrsUpdate(struct AudioSampleAttributes & attrs,int format,uint32_t channelCount,uint32_t sampleRate,uint32_t silenceThreshold)91 int32_t InitAttrsUpdate(struct AudioSampleAttributes &attrs, int format, uint32_t channelCount,
92     uint32_t sampleRate, uint32_t silenceThreshold)
93 {
94     InitAttrs(attrs);
95     attrs.format = (enum AudioFormat)format;
96     attrs.sampleRate = sampleRate;
97     attrs.channelCount = channelCount;
98     attrs.silenceThreshold = silenceThreshold;
99     return HDF_SUCCESS;
100 }
AudioRenderSetGetSampleAttributes(struct AudioSampleAttributes attrs,struct AudioSampleAttributes & attrsValue,struct IAudioRender * render)101 int32_t AudioRenderSetGetSampleAttributes(struct AudioSampleAttributes attrs, struct AudioSampleAttributes &attrsValue,
102     struct IAudioRender *render)
103 {
104     int32_t ret = -1;
105     if (render == nullptr) {
106         return HDF_ERR_INVALID_PARAM;
107     }
108     ret = render->SetSampleAttributes(render, &attrs);
109     if (ret < 0) {
110         HDF_LOGE("%{public}s: AUDIO_TEST:Set sampleattributes failed\n", __func__);
111         return ret;
112     }
113     ret = render->GetSampleAttributes(render, &attrsValue);
114     if (ret < 0) {
115         HDF_LOGE("%{public}s: AUDIO_TEST:Get sampleattributes failed\n", __func__);
116         return ret;
117     }
118     return HDF_SUCCESS;
119 }
AudioCaptureSetGetSampleAttributes(struct AudioSampleAttributes attrs,struct AudioSampleAttributes & attrsValue,struct IAudioCapture * capture)120 int32_t AudioCaptureSetGetSampleAttributes(struct AudioSampleAttributes attrs, struct AudioSampleAttributes &attrsValue,
121     struct IAudioCapture *capture)
122 {
123     int32_t ret = -1;
124     if (capture == nullptr) {
125         return HDF_ERR_INVALID_PARAM;
126     }
127     ret = capture->SetSampleAttributes(capture, &attrs);
128     if (ret < 0) {
129         HDF_LOGE("%{public}s: AUDIO_TEST:Set sampleattributes failed\n", __func__);
130         return ret;
131     }
132     ret = capture->GetSampleAttributes(capture, &attrsValue);
133     if (ret < 0) {
134         HDF_LOGE("%{public}s: AUDIO_TEST:Get sampleattributes failed\n", __func__);
135         return ret;
136     }
137     return HDF_SUCCESS;
138 }
StringToInt(std::string flag)139 uint32_t StringToInt(std::string flag)
140 {
141     uint32_t temp = flag[0];
142     for (int i = flag.size() - 1; i >= 0; i--) {
143         temp <<= MOVE_LEFT_NUM;
144         temp += flag[i];
145     }
146     return temp;
147 }
148 
InitDevDesc(struct AudioDeviceDescriptor & devDesc,const uint32_t portId,int pins)149 int32_t InitDevDesc(struct AudioDeviceDescriptor &devDesc, const uint32_t portId, int pins)
150 {
151     devDesc.portId = portId;
152     devDesc.pins = (enum AudioPortPin)pins;
153     devDesc.desc = strdup("cardname");
154     return HDF_SUCCESS;
155 }
156 
SwitchAdapter(struct AudioAdapterDescriptor * descs,const std::string & adapterNameCase,int portFlag,struct AudioPort & audioPort,int size)157 int32_t SwitchAdapter(struct AudioAdapterDescriptor *descs, const std::string &adapterNameCase,
158     int portFlag, struct AudioPort &audioPort, int size)
159 {
160     if (descs == nullptr || size > ADAPTER_COUNT) {
161         HDF_LOGE("%{public}s: AUDIO_TEST:parms is invalid\n", __func__);
162         return HDF_FAILURE;
163     }
164 
165     for (int index = 0; index < size; index++) {
166         struct AudioAdapterDescriptor *desc = &descs[index];
167         if (desc == nullptr || desc->adapterName == nullptr) {
168             continue;
169         }
170         if (strcmp(desc->adapterName, adapterNameCase.c_str())) {
171             continue;
172         }
173         for (uint32_t port = 0; port < desc->portsLen; port++) {
174             if (desc->ports[port].dir == portFlag) {
175                 audioPort.dir = desc->ports[port].dir;
176                 audioPort.portId = desc->ports[port].portId;
177                 audioPort.portName = strdup(desc->ports[port].portName);
178                 return index;
179             }
180         }
181     }
182     return HDF_FAILURE;
183 }
184 
PcmFormatToBits(int format)185 uint32_t PcmFormatToBits(int format)
186 {
187     switch (format) {
188         case AUDIO_FORMAT_TYPE_PCM_8_BIT:
189             return PCM_8_BIT;
190         case AUDIO_FORMAT_TYPE_PCM_16_BIT:
191             return PCM_16_BIT;
192         case AUDIO_FORMAT_TYPE_PCM_24_BIT:
193             return PCM_24_BIT;
194         case AUDIO_FORMAT_TYPE_PCM_32_BIT:
195             return PCM_32_BIT;
196         default:
197             return PCM_16_BIT;
198     }
199 }
200 
PcmFramesToBytes(const struct AudioSampleAttributes attrs)201 uint32_t PcmFramesToBytes(const struct AudioSampleAttributes attrs)
202 {
203     if (attrs.channelCount < MONO_CHANNEL || attrs.channelCount > SREREO_CHANNEL) {
204         HDF_LOGE("%{public}s: AUDIO_TEST:channelCount is invalid\n", __func__);
205         return 0;
206     }
207     uint32_t formatBits = PcmFormatToBits(attrs.format);
208     if (formatBits < PCM_8_BIT || formatBits > PCM_32_BIT) {
209         HDF_LOGE("%{public}s: AUDIO_TEST:formatBits is invalid\n", __func__);
210         return 0;
211     }
212     uint32_t ret = FRAME_SIZE * (attrs.channelCount) * (formatBits >> MOVE_RIGHT_NUM);
213     return ret;
214 }
215 
WavHeadAnalysis(struct AudioHeadInfo & wavHeadInfo,FILE * file,struct AudioSampleAttributes & attrs)216 int32_t WavHeadAnalysis(struct AudioHeadInfo &wavHeadInfo, FILE *file, struct AudioSampleAttributes &attrs)
217 {
218     size_t ret = 0;
219     if (file == nullptr) {
220         HDF_LOGE("%{public}s: AUDIO_TEST:params is invalid\n", __func__);
221         return HDF_FAILURE;
222     }
223     ret = fread(&wavHeadInfo, sizeof(wavHeadInfo), 1, file);
224     if (ret != 1) {
225         HDF_LOGE("%{public}s: AUDIO_TEST:fread failed\n", __func__);
226         return HDF_FAILURE;
227     }
228     uint32_t audioRiffId = StringToInt(AUDIO_RIFF);
229     uint32_t audioFileFmt = StringToInt(AUDIO_WAVE);
230     uint32_t audioDataId = StringToInt(AUDIO_DATA);
231     if (wavHeadInfo.testFileRiffId != audioRiffId || wavHeadInfo.testFileFmt != audioFileFmt ||
232         wavHeadInfo.dataId != audioDataId) {
233         HDF_LOGE("%{public}s: AUDIO_TEST:audio file is not wav format\n", __func__);
234         return HDF_FAILURE;
235         }
236     attrs.channelCount = wavHeadInfo.audioChannelNum;
237     attrs.sampleRate = wavHeadInfo.audioSampleRate;
238     switch (wavHeadInfo.audioBitsPerSample) {
239         case PCM_8_BIT: {
240             attrs.format = AUDIO_FORMAT_TYPE_PCM_8_BIT;
241             break;
242         }
243         case PCM_16_BIT: {
244             attrs.format = AUDIO_FORMAT_TYPE_PCM_16_BIT;
245             break;
246         }
247         case PCM_24_BIT: {
248             attrs.format = AUDIO_FORMAT_TYPE_PCM_24_BIT;
249             break;
250         }
251         case PCM_32_BIT: {
252             attrs.format = AUDIO_FORMAT_TYPE_PCM_32_BIT;
253             break;
254         }
255         default:
256             return HDF_FAILURE;
257     }
258     return HDF_SUCCESS;
259 }
260 
TestAudioAdapterDescriptorFree(struct AudioAdapterDescriptor * dataBlock,bool freeSelf)261 static void TestAudioAdapterDescriptorFree(struct AudioAdapterDescriptor *dataBlock, bool freeSelf)
262 {
263     if (dataBlock == NULL) {
264         return;
265     }
266 
267     if (dataBlock->adapterName != NULL) {
268         OsalMemFree(dataBlock->adapterName);
269         dataBlock->adapterName = NULL;
270     }
271 
272     if (dataBlock->ports != NULL) {
273         OsalMemFree(dataBlock->ports);
274         dataBlock->ports = NULL;
275     }
276 
277     if (freeSelf) {
278         OsalMemFree(dataBlock);
279     }
280 }
281 
TestReleaseAdapterDescs(struct AudioAdapterDescriptor ** descs,uint32_t descsLen)282 void TestReleaseAdapterDescs(struct AudioAdapterDescriptor **descs, uint32_t descsLen)
283 {
284     if (descsLen > 0 && descs != nullptr && (*descs) != nullptr) {
285         for (uint32_t i = 0; i < descsLen; i++) {
286             TestAudioAdapterDescriptorFree(&(*descs)[i], false);
287         }
288         OsalMemFree(*descs);
289         *descs = nullptr;
290     }
291 }
GetAdapters(TestAudioManager * manager,struct AudioAdapterDescriptor * & descs,uint32_t & descsLen)292 int32_t GetAdapters(TestAudioManager *manager, struct AudioAdapterDescriptor *&descs, uint32_t &descsLen)
293 {
294     int32_t ret = -1;
295     if (descsLen < AUDIO_ADAPTER_MAX_NUM) {
296         HDF_LOGE("%{public}s: AUDIO_TEST:descsLen is little than AUDIO_ADAPTER_MAX_NUM\n", __func__);
297         return HDF_FAILURE;
298     }
299     descs = reinterpret_cast<struct AudioAdapterDescriptor*>(OsalMemCalloc(
300         sizeof(struct AudioAdapterDescriptor) * (descsLen)));
301     if (descs == NULL) {
302         return HDF_FAILURE;
303     }
304     ret = manager->GetAllAdapters(manager, descs, &descsLen);
305     if (ret < 0) {
306         HDF_LOGE("%{public}s: AUDIO_TEST:GetAllAdapters failed\n", __func__);
307         OsalMemFree(descs);
308         return ret;
309     }
310     return HDF_SUCCESS;
311 }
312 
GetLoadAdapter(TestAudioManager * manager,int portType,const std::string & adapterName,struct IAudioAdapter ** adapter,struct AudioPort & audioPort)313 int32_t GetLoadAdapter(TestAudioManager *manager, int portType,
314     const std::string &adapterName, struct IAudioAdapter **adapter, struct AudioPort &audioPort)
315 {
316     int32_t ret = -1;
317     uint32_t descsLen = AUDIO_ADAPTER_MAX_NUM;
318     struct AudioAdapterDescriptor *desc = nullptr;
319     struct AudioAdapterDescriptor *descs = nullptr;
320     if (manager == nullptr || adapter == nullptr) {
321         HDF_LOGE("%{public}s: AUDIO_TEST:params is invalid\n", __func__);
322         return HDF_ERR_INVALID_PARAM;
323     }
324     ret = GetAdapters(manager, descs, descsLen);
325     if (ret < 0) {
326         return ret;
327     }
328 
329     int index = SwitchAdapter(descs, adapterName, portType, audioPort, descsLen);
330     if (index < 0) {
331         HDF_LOGE("%{public}s: AUDIO_TEST:switch adapter failed\n", __func__);
332         TestReleaseAdapterDescs(&descs, descsLen);
333         return HDF_FAILURE;
334     }
335 
336     desc = &descs[index];
337     if (desc == nullptr) {
338         TestReleaseAdapterDescs(&descs, descsLen);
339         return HDF_ERR_INVALID_PARAM;
340     }
341     ret = manager->LoadAdapter(manager, desc, adapter);
342     if (ret < 0) {
343         HDF_LOGE("%{public}s: AUDIO_TEST:load adapter failed\n", __func__);
344         TestReleaseAdapterDescs(&descs, descsLen);
345         return ret;
346     }
347     if (*adapter == nullptr) {
348         TestReleaseAdapterDescs(&descs, descsLen);
349         return HDF_FAILURE;
350     }
351     TestReleaseAdapterDescs(&descs, descsLen);
352     return HDF_SUCCESS;
353 }
354 
AudioCreateRender(TestAudioManager * manager,int pins,const std::string & adapterName,struct IAudioAdapter ** adapter,struct IAudioRender ** render,unsigned * renderId)355 int32_t AudioCreateRender(TestAudioManager *manager, int pins, const std::string &adapterName,
356     struct IAudioAdapter **adapter, struct IAudioRender **render, unsigned *renderId)
357 {
358     int32_t ret = -1;
359     struct AudioSampleAttributes attrs = {};
360     struct AudioDeviceDescriptor devDesc = {};
361     struct AudioPort audioPort = {};
362     if (adapter == nullptr || render == nullptr || renderId == nullptr) {
363         return HDF_ERR_INVALID_PARAM;
364     }
365     ret = GetLoadAdapter(manager, PORT_OUT, adapterName, adapter, audioPort);
366     if (ret < 0) {
367         if (audioPort.portName != nullptr) {
368             free(audioPort.portName);
369         }
370         return ret;
371     }
372     if (*adapter == nullptr || (*adapter)->CreateRender == nullptr) {
373         free(audioPort.portName);
374         return HDF_FAILURE;
375     }
376     InitAttrs(attrs);
377     InitDevDesc(devDesc, audioPort.portId, pins);
378     ret = (*adapter)->CreateRender(*adapter, &devDesc, &attrs, render, renderId);
379     if (ret < 0 || *render == nullptr) {
380         HDF_LOGE("%{public}s: AUDIO_TEST:Create render failed\n", __func__);
381         manager->UnloadAdapter(manager, adapterName.c_str());
382         IAudioAdapterRelease(*adapter, IS_STUB);
383         free(audioPort.portName);
384         free(devDesc.desc);
385         return ret;
386     }
387     free(audioPort.portName);
388     free(devDesc.desc);
389     return HDF_SUCCESS;
390 }
391 
392 #ifdef SUPPORT_OFFLOAD
AudioOffloadCreateRender(TestAudioManager * manager,int pins,const std::string & adapterName,struct IAudioAdapter ** adapter,struct IAudioRender ** render,unsigned * renderId)393 int32_t AudioOffloadCreateRender(TestAudioManager *manager, int pins, const std::string &adapterName,
394     struct IAudioAdapter **adapter, struct IAudioRender **render, unsigned *renderId)
395 {
396     int32_t ret = -1;
397     struct AudioSampleAttributes attrs = {};
398     struct AudioDeviceDescriptor devDesc = {};
399     struct AudioPort audioPort = {};
400     if (adapter == nullptr || render == nullptr || renderId == nullptr) {
401         return HDF_ERR_INVALID_PARAM;
402     }
403     ret = GetLoadAdapter(manager, PORT_OUT, adapterName, adapter, audioPort);
404     if (ret < 0) {
405         if (audioPort.portName != nullptr) {
406             free(audioPort.portName);
407         }
408         return ret;
409     }
410     if (*adapter == nullptr || (*adapter)->CreateRender == nullptr) {
411         free(audioPort.portName);
412         return HDF_FAILURE;
413     }
414 
415     InitOffloadAttrs(attrs);
416 
417     InitDevDesc(devDesc, audioPort.portId, pins);
418     ret = (*adapter)->CreateRender(*adapter, &devDesc, &attrs, render, renderId);
419     if (ret < 0 || *render == nullptr) {
420         HDF_LOGE("%{public}s: AUDIO_TEST:Create render failed\n", __func__);
421         manager->UnloadAdapter(manager, adapterName.c_str());
422         IAudioAdapterRelease(*adapter, IS_STUB);
423         free(audioPort.portName);
424         free(devDesc.desc);
425         return ret;
426     }
427     free(audioPort.portName);
428     free(devDesc.desc);
429     return HDF_SUCCESS;
430 }
431 #endif
432 
AudioRenderStartAndOneFrame(struct IAudioRender * render)433 int32_t AudioRenderStartAndOneFrame(struct IAudioRender *render)
434 {
435     int32_t ret = -1;
436     char *frame = nullptr;
437     uint64_t numRead = 0;
438     uint64_t replyBytes = 0;
439     if (render == nullptr || render->Start == nullptr || render->RenderFrame == nullptr) {
440         HDF_LOGE("%{public}s: AUDIO_TEST:params is invlaid\n", __func__);
441         return HDF_ERR_INVALID_PARAM;
442     }
443     ret = render->Start(render);
444     if (ret) {
445         return ret;
446     }
447     ret = RenderFramePrepare(AUDIO_FILE, frame, numRead);
448     if (ret < 0) {
449         if (frame != nullptr) {
450             free(frame);
451             frame = nullptr;
452         }
453         return HDF_FAILURE;
454     }
455     ret = render->RenderFrame(render, reinterpret_cast<int8_t *>(frame), numRead, &replyBytes);
456     if (ret < 0) {
457         if (frame != nullptr) {
458             free(frame);
459             frame = nullptr;
460         }
461         HDF_LOGE("%{public}s: AUDIO_TEST:render frame failed\n", __func__);
462         return ret;
463     }
464     free(frame);
465     frame = nullptr;
466     return HDF_SUCCESS;
467 }
468 
AudioCreateCapture(TestAudioManager * manager,int pins,const std::string & adapterName,struct IAudioAdapter ** adapter,struct IAudioCapture ** capture,uint32_t * captureId)469 int32_t AudioCreateCapture(TestAudioManager *manager, int pins, const std::string &adapterName,
470     struct IAudioAdapter **adapter, struct IAudioCapture **capture, uint32_t *captureId)
471 {
472     int32_t ret = -1;
473     struct AudioSampleAttributes attrs = {};
474     struct AudioDeviceDescriptor devDesc = {};
475     struct AudioPort audioPort = {};
476     if (adapter == nullptr || capture == nullptr || captureId == nullptr) {
477         return HDF_ERR_INVALID_PARAM;
478     }
479     ret = GetLoadAdapter(manager, PORT_IN, adapterName, adapter, audioPort);
480     if (ret < 0) {
481         if (audioPort.portName != nullptr) {
482             free(audioPort.portName);
483         }
484         return ret;
485     }
486     if (*adapter == nullptr || (*adapter)->CreateCapture == nullptr) {
487         return HDF_FAILURE;
488     }
489     InitAttrs(attrs);
490 #ifndef AUDIO_SAMPLE_LOW_BITWIDTH
491     attrs.format = AUDIO_FORMAT_TYPE_PCM_16_BIT;
492     attrs.frameSize = AUDIO_FORMAT_TYPE_PCM_16_BIT * CHANNELCOUNT / MOVE_LEFT_NUM;
493     attrs.startThreshold = DEEP_BUFFER_RENDER_PERIOD_SIZE / (attrs.format * attrs.channelCount / MOVE_LEFT_NUM);
494 #endif
495     InitDevDesc(devDesc, audioPort.portId, pins);
496 
497     ret = (*adapter)->CreateCapture(*adapter, &devDesc, &attrs, capture, captureId);
498     if (ret < 0 || *capture == nullptr) {
499         HDF_LOGE("%{public}s: AUDIO_TEST:Create capture failed\n", __func__);
500         manager->UnloadAdapter(manager, adapterName.c_str());
501         IAudioAdapterRelease(*adapter, IS_STUB);
502         free(audioPort.portName);
503         free(devDesc.desc);
504         return ret;
505     }
506     free(audioPort.portName);
507     free(devDesc.desc);
508     return HDF_SUCCESS;
509 }
510 
AudioCaptureStartAndOneFrame(struct IAudioCapture * capture)511 int32_t AudioCaptureStartAndOneFrame(struct IAudioCapture *capture)
512 {
513     int32_t ret = -1;
514     struct AudioSampleAttributes attrs = {};
515     InitAttrs(attrs);
516     attrs.format = AUDIO_FORMAT_TYPE_PCM_16_BIT;
517     attrs.frameSize = AUDIO_FORMAT_TYPE_PCM_16_BIT * CHANNELCOUNT / MOVE_LEFT_NUM;
518     attrs.startThreshold = DEEP_BUFFER_RENDER_PERIOD_SIZE / (attrs.format * attrs.channelCount / MOVE_LEFT_NUM);
519     FILE *file = fopen(AUDIO_CAPTURE_FILE.c_str(), "wb+");
520     if (file == nullptr) {
521         HDF_LOGE("%{public}s: AUDIO_TEST:foen failed\n", __func__);
522         return HDF_FAILURE;
523     }
524     ret = FrameStartCapture(capture, file, attrs);
525     if (ret < 0) {
526         fclose(file);
527         return ret;
528     }
529     (void) fclose(file);
530     return HDF_SUCCESS;
531 }
RenderTryOneFrame(struct IAudioRender * render,int8_t * frame,uint32_t requestBytes,uint64_t * replyBytes)532 static int32_t RenderTryOneFrame(struct IAudioRender *render,
533     int8_t *frame,  uint32_t requestBytes, uint64_t *replyBytes)
534 {
535     int32_t tryNumFrame = 0;
536     int32_t ret;
537 
538     if (render == nullptr || render->RenderFrame == nullptr ||
539         frame == nullptr || replyBytes == nullptr) {
540         HDF_LOGE("%{public}s: AUDIO_TEST:params is invalid\n", __func__);
541         return HDF_FAILURE;
542     }
543     do {
544         ret = render->RenderFrame(render, frame, requestBytes, replyBytes);
545         if (ret == -1) {
546             tryNumFrame++;
547             if (tryNumFrame <= TRY_NUM_FRAME) {
548                 continue;
549             } else {
550                 return ret;
551             }
552         }
553         return ret;
554     } while (true);
555 }
FrameStart(struct AudioHeadInfo wavHeadInfo,struct IAudioRender * render,FILE * file,struct AudioSampleAttributes attrs)556 int32_t FrameStart(struct AudioHeadInfo wavHeadInfo, struct IAudioRender *render, FILE *file,
557     struct AudioSampleAttributes attrs)
558 {
559     uint32_t readSize = 0;
560     size_t numRead = 0;
561     uint64_t replyBytes = 0;
562     if (render == nullptr || render->Start == nullptr || render->RenderFrame == nullptr || file == nullptr) {
563         HDF_LOGE("%{public}s: AUDIO_TEST:params is invalid\n", __func__);
564         return HDF_ERR_INVALID_PARAM;
565     }
566     int32_t ret = render->Start(render);
567     if (ret) {
568         HDF_LOGE("%{public}s: AUDIO_TEST:start failed\n", __func__);
569         return ret;
570     }
571     uint32_t remainingDataSize = wavHeadInfo.dataSize;
572     uint32_t bufferSize = PcmFramesToBytes(attrs);
573     if (bufferSize == 0) {
574         return HDF_FAILURE;
575     }
576     char *frame = nullptr;
577     frame = reinterpret_cast<char *>(calloc(1, bufferSize));
578     if (frame == nullptr) {
579         return HDF_ERR_MALLOC_FAIL;
580     }
581     do {
582         if (g_frameStatus) {
583             readSize = (remainingDataSize) > (bufferSize) ? (bufferSize) : (remainingDataSize);
584             numRead = fread(frame, readSize, 1, file);
585             if (numRead == 0) {
586                 free(frame);
587                 return HDF_FAILURE;
588             }
589             ret = RenderTryOneFrame(render, reinterpret_cast<int8_t *>(frame), readSize, &replyBytes);
590             if (ret < 0) {
591                 free(frame);
592                 return ret;
593             }
594             remainingDataSize -= readSize;
595         }
596     } while (readSize > 0 && remainingDataSize > 0);
597     free(frame);
598     return HDF_SUCCESS;
599 }
600 
FrameStartCapture(struct IAudioCapture * capture,FILE * file,const struct AudioSampleAttributes attrs)601 int32_t FrameStartCapture(struct IAudioCapture *capture, FILE *file, const struct AudioSampleAttributes attrs)
602 {
603     int32_t ret = 0;
604     uint32_t bufferSize = 0;
605     uint32_t replyBytes = 0;
606     uint64_t requestBytes = 0;
607     if (capture == nullptr || capture->Start == nullptr || capture->CaptureFrame == nullptr) {
608         HDF_LOGE("%{public}s: AUDIO_TEST:params is invalid\n", __func__);
609         return HDF_ERR_INVALID_PARAM;
610     }
611     ret = capture->Start(capture);
612     if (ret < 0) {
613         HDF_LOGE("%{public}s: AUDIO_TEST:start failed\n", __func__);
614         return ret;
615     }
616     ret = GetCaptureBufferSize(capture, bufferSize);
617     if (ret < 0 || bufferSize == 0) {
618         HDF_LOGE("%{public}s: AUDIO_TEST:GetCaptureBufferSize failed\n", __func__);
619         return ret;
620     }
621 
622     char *frame = nullptr;
623     frame = reinterpret_cast<char *>(calloc(1, bufferSize));
624     if (frame == nullptr) {
625         return HDF_ERR_MALLOC_FAIL;
626     }
627     requestBytes = bufferSize;
628     replyBytes = bufferSize;
629     ret = capture->CaptureFrame(capture, reinterpret_cast<int8_t *>(frame), &replyBytes, &requestBytes);
630     if (ret < 0) {
631         HDF_LOGE("%{public}s: AUDIO_TEST:CaptureFrame failed\n", __func__);
632         free(frame);
633         return ret;
634     }
635     uint32_t requestByte = static_cast<uint32_t>(replyBytes);
636     (void) fwrite(frame, requestByte, 1, file);
637     free(frame);
638     return HDF_SUCCESS;
639 }
640 
RenderFramePrepare(const std::string & path,char * & frame,uint64_t & readSize)641 int32_t RenderFramePrepare(const std::string &path, char *&frame, uint64_t &readSize)
642 {
643     int32_t ret = -1;
644     size_t numRead = 0;
645     uint32_t bufferSize = 4096;
646     uint32_t remainingDataSize = 0;
647     struct AudioSampleAttributes attrs = {};
648     struct AudioHeadInfo headInfo = {};
649     InitAttrs(attrs);
650     char absPath[PATH_MAX] = {0};
651     if (realpath(path.c_str(), absPath) == nullptr) {
652         HDF_LOGE("%{public}s: AUDIO_TEST:file not exist\n", __func__);
653         return HDF_FAILURE;
654     }
655     FILE *file = fopen(absPath, "rb");
656     if (file == nullptr) {
657         HDF_LOGE("%{public}s: AUDIO_TEST:fopen failed\n", __func__);
658         return HDF_FAILURE;
659     }
660     ret = WavHeadAnalysis(headInfo, file, attrs);
661     if (ret < 0) {
662         fclose(file);
663         return HDF_FAILURE;
664     }
665     frame = reinterpret_cast<char *>(calloc(1, bufferSize));
666     if (frame == nullptr) {
667         fclose(file);
668         return HDF_ERR_MALLOC_FAIL;
669     }
670     remainingDataSize = headInfo.dataSize;
671     readSize = (remainingDataSize) > (bufferSize) ? (bufferSize) : (remainingDataSize);
672     size_t readSizes = static_cast<size_t>(readSize);
673     numRead = fread(frame, readSizes, 1, file);
674     if (numRead < 1) {
675         free(frame);
676         frame = nullptr;
677         fclose(file);
678         return HDF_FAILURE;
679     }
680     (void) fclose(file);
681     return HDF_SUCCESS;
682 }
683 
FrameStatus(int status)684 void FrameStatus(int status)
685 {
686     g_frameStatus = status;
687     return;
688 }
689 
CaptureTryOneFrame(struct IAudioCapture * capture,int8_t * frame,uint32_t * replyBytes,uint64_t * requestBytes)690 static int32_t CaptureTryOneFrame(struct IAudioCapture *capture,
691     int8_t *frame, uint32_t *replyBytes, uint64_t *requestBytes)
692 {
693     int32_t tryNum = 0;
694     int32_t ret;
695 
696     if (capture == nullptr || capture->CaptureFrame == nullptr ||
697         frame == nullptr || replyBytes == nullptr) {
698         return HDF_FAILURE;
699     }
700     do {
701         ret = capture->CaptureFrame(capture, frame, replyBytes, requestBytes);
702         if (ret == HDF_FAILURE) {
703             tryNum++;
704             if (tryNum <= TRY_NUM_FRAME) {
705                 continue;
706             } else {
707                 return ret;
708             }
709         }
710         return ret;
711     } while (true);
712 }
713 
StartRecord(struct IAudioCapture * capture,FILE * file,uint64_t filesize)714 int32_t StartRecord(struct IAudioCapture *capture, FILE *file, uint64_t filesize)
715 {
716     uint32_t replyBytes = BUFFER_LENTH;
717     uint64_t requestBytes = BUFFER_LENTH;
718     uint64_t totalSize = 0;
719     if (capture == nullptr || capture->Start == nullptr ||
720         capture->CaptureFrame == nullptr || file == nullptr) {
721         HDF_LOGE("%{public}s: AUDIO_TEST:param is invalid\n", __func__);
722         return HDF_ERR_INVALID_PARAM;
723     }
724     int32_t ret = capture->Start(capture);
725     if (ret < 0) {
726         HDF_LOGE("%{public}s: AUDIO_TEST:start failed\n", __func__);
727         return ret;
728     }
729     char *frame = reinterpret_cast<char *>(calloc(1, BUFFER_LENTH));
730     if (frame == nullptr) {
731         return HDF_ERR_MALLOC_FAIL;
732     }
733     do {
734         if (g_frameStatus) {
735             ret = CaptureTryOneFrame(capture, reinterpret_cast<int8_t *>(frame), &replyBytes, &requestBytes);
736             if (ret < 0) {
737                 free(frame);
738                 return ret;
739             }
740             uint32_t replyByte = static_cast<uint32_t>(replyBytes);
741             size_t writeRet = fwrite(frame, replyByte, 1, file);
742             if (writeRet == 0) {
743                 free(frame);
744                 return HDF_FAILURE;
745             }
746             totalSize += replyBytes;
747         } else {
748             totalSize += 0;
749         }
750     } while (totalSize <= filesize * MEGABYTE);
751     free(frame);
752     return HDF_SUCCESS;
753 }
754 
StopAudio(struct PrepareAudioPara & audiopara)755 int32_t StopAudio(struct PrepareAudioPara &audiopara)
756 {
757     int32_t ret = -1;
758     if (audiopara.capture != nullptr) {
759         ret = audiopara.capture->Stop(audiopara.capture);
760         HDF_LOGE("%{public}s: AUDIO_TEST:capture stop failed\n", __func__);
761         return ret;
762     }
763     if (audiopara.render != nullptr) {
764         ret = audiopara.render->Stop(audiopara.render);
765         HDF_LOGE("%{public}s: AUDIO_TEST:render stop failed\n", __func__);
766         return ret;
767     }
768     return HDF_SUCCESS;
769 }
770 
ThreadRelease(struct PrepareAudioPara & audiopara)771 int32_t ThreadRelease(struct PrepareAudioPara &audiopara)
772 {
773     int32_t ret = -1;
774     pthread_join(audiopara.tids, &audiopara.result);
775     ret = (intptr_t)audiopara.result;
776     if (ret < 0) {
777         StopAudio(audiopara);
778         return ret;
779     }
780     ret = StopAudio(audiopara);
781     return ret;
782 }
PlayAudioFile(struct PrepareAudioPara & audiopara)783 int32_t PlayAudioFile(struct PrepareAudioPara &audiopara)
784 {
785     int32_t ret = -1;
786     char absPath[PATH_MAX] = {0};
787     if (realpath(audiopara.path, absPath) == nullptr) {
788         HDF_LOGE("%{public}s: AUDIO_TEST:file not exist\n", __func__);
789         return HDF_FAILURE;
790     }
791     FILE *file = fopen(absPath, "rb");
792     if (file == nullptr) {
793         return HDF_FAILURE;
794     }
795     if (WavHeadAnalysis(audiopara.headInfo, file, audiopara.attrs) < 0) {
796         (void)fclose(file);
797         return HDF_FAILURE;
798     }
799     ret = FrameStart(audiopara.headInfo, audiopara.render, file, audiopara.attrs);
800     if (ret != HDF_SUCCESS) {
801         HDF_LOGE("%{public}s: AUDIO_TEST:FrameStart failed\n", __func__);
802         (void)fclose(file);
803         return ret;
804     }
805     (void)fclose(file);
806     return HDF_SUCCESS;
807 }
808 
RecordAudio(struct PrepareAudioPara & audiopara)809 int32_t RecordAudio(struct PrepareAudioPara &audiopara)
810 {
811     int32_t ret = -1;
812     if (audiopara.capture == nullptr) {
813         HDF_LOGE("%{public}s: AUDIO_TEST:param is invalid\n", __func__);
814         return HDF_ERR_INVALID_PARAM;
815     }
816 
817     bool isMute = false;
818     ret = audiopara.capture->SetMute(audiopara.capture, isMute);
819     if (ret < 0) {
820         HDF_LOGE("%{public}s: AUDIO_TEST:SetMute failed\n", __func__);
821         return ret;
822     }
823 
824     FILE *file = fopen(audiopara.path, "wb+");
825     if (file == nullptr) {
826         HDF_LOGE("%{public}s: AUDIO_TEST:fopen failed\n", __func__);
827         return HDF_FAILURE;
828     }
829     ret = StartRecord(audiopara.capture, file, audiopara.fileSize);
830     if (ret < 0) {
831         HDF_LOGE("%{public}s: AUDIO_TEST:StartRecord failed\n", __func__);
832         fclose(file);
833         return ret;
834     }
835     (void) fclose(file);
836     return HDF_SUCCESS;
837 }
InitMmapDesc(const string & path,struct AudioMmapBufferDescriptor & desc,int32_t & reqSize,bool isRender)838 int32_t InitMmapDesc(const string &path, struct AudioMmapBufferDescriptor &desc, int32_t &reqSize, bool isRender)
839 {
840     FILE *fp;
841     if (isRender) {
842         (void)chmod(path.c_str(), S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP | S_IROTH | S_IWOTH);
843         fp = fopen(path.c_str(), "rb+");
844     } else {
845         fp = fopen(path.c_str(), "wb+");
846         (void)chmod(path.c_str(), S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP | S_IROTH | S_IWOTH);
847     }
848     if (fp == nullptr) {
849         HDF_LOGE("%{public}s: AUDIO_TEST:fopen failed\n", __func__);
850         return HDF_FAILURE;
851     }
852     int fd = fileno(fp);
853     if (fd == -1) {
854         fclose(fp);
855         HDF_LOGE("%{public}s: AUDIO_TEST:fd is invalid\n", __func__);
856         return HDF_FAILURE;
857     }
858     if (isRender) {
859         struct AudioHeadInfo wavHeadInfo = {};
860         fseek(fp, 0, SEEK_END);
861         reqSize = ftell(fp);
862         desc.offset = sizeof(wavHeadInfo);
863     } else {
864         reqSize = FILE_CAPTURE_SIZE;
865         ftruncate(fd, FILE_CAPTURE_SIZE);
866         desc.offset = 0;
867     }
868     desc.filePath = strdup(path.c_str());
869     desc.memoryFd = fd;
870     desc.isShareable = 1;
871     desc.transferFrameSize = DEEP_BUFFER_RENDER_PERIOD_SIZE / FRAME_COUNT;
872     (void) fclose(fp);
873     return HDF_SUCCESS;
874 }
875 
PlayMapAudioFile(struct PrepareAudioPara & audiopara)876 int32_t PlayMapAudioFile(struct PrepareAudioPara &audiopara)
877 {
878     int32_t ret = -1;
879     int32_t reqSize = 0;
880     bool isRender = true;
881     FrameStatus(1);
882     struct AudioMmapBufferDescriptor desc = {};
883     if (audiopara.render == nullptr) {
884         return HDF_FAILURE;
885     }
886     ret = InitMmapDesc(audiopara.path, desc, reqSize, isRender);
887     if (ret < 0) {
888         return HDF_FAILURE;
889     }
890     ret = audiopara.render->Start(audiopara.render);
891     if (ret < 0) {
892         HDF_LOGE("%{public}s: AUDIO_TEST:start failed\n", __func__);
893         return ret;
894     }
895     ret = audiopara.render->ReqMmapBuffer(audiopara.render, reqSize, &desc);
896     if (ret == 0) {
897         munmap(desc.memoryAddress, reqSize);
898     }
899     return ret;
900 }
RecordMapAudio(struct PrepareAudioPara & audiopara)901 int32_t RecordMapAudio(struct PrepareAudioPara &audiopara)
902 {
903     int32_t ret = -1;
904     int32_t reqSize = 0;
905     bool isRender = false;
906     struct AudioMmapBufferDescriptor desc = {};
907     if (audiopara.capture == nullptr) {
908         HDF_LOGE("%{public}s: AUDIO_TEST:param is invlaid\n", __func__);
909         return HDF_FAILURE;
910     }
911     ret = InitMmapDesc(audiopara.path, desc, reqSize, isRender);
912     if (ret < 0) {
913         return HDF_FAILURE;
914     }
915     ret = audiopara.capture->Start(audiopara.capture);
916     if (ret < 0) {
917         HDF_LOGE("%{public}s: AUDIO_TEST:start failed\n", __func__);
918         return ret;
919     }
920     ret = audiopara.capture->ReqMmapBuffer(audiopara.capture, reqSize, &desc);
921     if (ret == 0) {
922         munmap(desc.memoryAddress, reqSize);
923     }
924     return ret;
925 }
AudioRenderCallback(struct IAudioCallback * self,AudioCallbackType type,int8_t * reserved,int8_t * cookie)926 int32_t AudioRenderCallback(struct IAudioCallback *self, AudioCallbackType type, int8_t* reserved,
927     int8_t* cookie)
928 {
929     (void)self;
930     (void)reserved;
931     (void)cookie;
932     switch (type) {
933         case AUDIO_NONBLOCK_WRITE_COMPLETED:
934             g_writeCompleted = AUDIO_WRITE_COMPLETED_VALUE;
935             return HDF_SUCCESS;
936         case AUDIO_RENDER_FULL:
937             g_renderFull = AUDIO_RENDER_FULL_VALUE;
938             return HDF_SUCCESS;
939         case AUDIO_FLUSH_COMPLETED:
940             g_flushCompleted = AUDIO_FLUSH_COMPLETED_VALUE;
941             return HDF_SUCCESS;
942         case AUDIO_ERROR_OCCUR:
943             return HDF_FAILURE;
944         case AUDIO_DRAIN_COMPLETED:
945             return HDF_FAILURE;
946         default:
947             return HDF_FAILURE;
948     }
949 }
CheckWriteCompleteValue()950 int32_t CheckWriteCompleteValue()
951 {
952     if (g_writeCompleted == AUDIO_WRITE_COMPLETED_VALUE)
953         return HDF_SUCCESS;
954     else
955         return HDF_FAILURE;
956 }
CheckRenderFullValue()957 int32_t CheckRenderFullValue()
958 {
959     if (g_renderFull == AUDIO_RENDER_FULL_VALUE)
960         return HDF_SUCCESS;
961     else
962         return HDF_FAILURE;
963 }
CheckFlushValue()964 int32_t CheckFlushValue()
965 {
966     if (g_flushCompleted == AUDIO_FLUSH_COMPLETED_VALUE)
967         return HDF_SUCCESS;
968     else
969         return HDF_FAILURE;
970 }
971 
TestAudioSubPortCapabilityFree(struct AudioSubPortCapability * dataBlock,bool freeSelf)972 void TestAudioSubPortCapabilityFree(struct AudioSubPortCapability *dataBlock, bool freeSelf)
973 {
974     if (dataBlock == NULL) {
975         return;
976     }
977 
978     if (dataBlock->desc != NULL) {
979         OsalMemFree(dataBlock->desc);
980         dataBlock->desc = NULL;
981     }
982 
983     if (freeSelf) {
984         OsalMemFree(dataBlock);
985     }
986 }
987 
TestAudioPortCapabilityFree(struct AudioPortCapability * dataBlock,bool freeSelf)988 void TestAudioPortCapabilityFree(struct AudioPortCapability *dataBlock, bool freeSelf)
989 {
990     if (dataBlock == NULL) {
991         return;
992     }
993 
994     if (dataBlock->formatsLen > 0 && dataBlock->formats != NULL) {
995         OsalMemFree(dataBlock->formats);
996     }
997 
998     if (dataBlock->subPortsLen > 0 && dataBlock->subPorts != NULL) {
999         for (uint32_t i = 0; i < dataBlock->subPortsLen; i++) {
1000             TestAudioSubPortCapabilityFree(&dataBlock->subPorts[i], false);
1001         }
1002         OsalMemFree(dataBlock->subPorts);
1003     }
1004 
1005     if (dataBlock->supportSampleFormatsLen > 0 && dataBlock->supportSampleFormats != NULL) {
1006         OsalMemFree(dataBlock->supportSampleFormats);
1007     }
1008 
1009     if (freeSelf) {
1010         OsalMemFree(dataBlock);
1011     }
1012 }
1013 
ReleaseCaptureSource(TestAudioManager * manager,struct IAudioAdapter * & adapter,struct IAudioCapture * & capture,uint32_t captureId)1014 int32_t ReleaseCaptureSource(TestAudioManager *manager, struct IAudioAdapter *&adapter,
1015     struct IAudioCapture *&capture, uint32_t captureId)
1016 {
1017     if (manager == nullptr || adapter == nullptr) {
1018         HDF_LOGE("%{public}s: AUDIO_TEST:param is nullptr\n", __func__);
1019         return HDF_FAILURE;
1020     }
1021     if (manager->UnloadAdapter == nullptr || adapter->DestroyCapture == nullptr) {
1022         HDF_LOGE("%{public}s: AUDIO_TEST:fuction is nullptr\n", __func__);
1023         return HDF_FAILURE;
1024     }
1025     int32_t ret = adapter->DestroyCapture(adapter, captureId);
1026     if (ret != HDF_SUCCESS) {
1027         HDF_LOGE("%{public}s: AUDIO_TEST:DestroyCapture failed\n", __func__);
1028         return HDF_FAILURE;
1029     }
1030     IAudioCaptureRelease(capture, IS_STUB);
1031     capture = nullptr;
1032     ret = manager->UnloadAdapter(manager, ADAPTER_NAME.c_str());
1033     if (ret != HDF_SUCCESS) {
1034         HDF_LOGE("%{public}s: AUDIO_TEST:UnloadAdapter failed\n", __func__);
1035         return HDF_FAILURE;
1036     }
1037     IAudioAdapterRelease(adapter, IS_STUB);
1038     adapter = nullptr;
1039     return HDF_SUCCESS;
1040 }
1041 
ReleaseRenderSource(TestAudioManager * manager,struct IAudioAdapter * & adapter,struct IAudioRender * & render,uint32_t renderId)1042 int32_t ReleaseRenderSource(TestAudioManager *manager, struct IAudioAdapter *&adapter,
1043                             struct IAudioRender *&render, uint32_t renderId)
1044 {
1045     if (manager == nullptr || adapter == nullptr) {
1046         HDF_LOGE("%{public}s: AUDIO_TEST:param is nullptr\n", __func__);
1047         return HDF_FAILURE;
1048     }
1049 
1050     if (manager->UnloadAdapter == nullptr || adapter->DestroyRender == nullptr) {
1051         HDF_LOGE("%{public}s: AUDIO_TEST:fuction is nullptr\n", __func__);
1052         return HDF_FAILURE;
1053     }
1054 
1055     int32_t ret = adapter->DestroyRender(adapter, renderId);
1056     if (ret != HDF_SUCCESS) {
1057         HDF_LOGE("%{public}s: AUDIO_TEST:DestroyRender failed\n", __func__);
1058         return HDF_FAILURE;
1059     }
1060     IAudioRenderRelease(render, IS_STUB);
1061     render = nullptr;
1062     ret = manager->UnloadAdapter(manager, ADAPTER_NAME.c_str());
1063     if (ret != HDF_SUCCESS) {
1064         HDF_LOGE("%{public}s: AUDIO_TEST:UnloadAdapter failed\n", __func__);
1065         return HDF_FAILURE;
1066     }
1067     IAudioAdapterRelease(adapter, IS_STUB);
1068     adapter = nullptr;
1069     return HDF_SUCCESS;
1070 }
1071 
GetCaptureBufferSize(struct IAudioCapture * capture,uint32_t & bufferSize)1072 int32_t GetCaptureBufferSize(struct IAudioCapture *capture, uint32_t &bufferSize)
1073 {
1074     int32_t ret = HDF_SUCCESS;
1075     uint64_t frameSize = 0;
1076     uint64_t frameCount = 0;
1077 
1078     if (capture == nullptr) {
1079         return HDF_ERR_INVALID_PARAM;
1080     }
1081 
1082     ret = capture->GetFrameSize(capture, &frameSize);
1083     if (ret != HDF_SUCCESS) {
1084         return ret;
1085     }
1086 
1087     ret = capture->GetFrameCount(capture, &frameCount);
1088     if (ret != HDF_SUCCESS) {
1089         return ret;
1090     }
1091 
1092     bufferSize = frameCount * frameSize;
1093     if (bufferSize == 0) {
1094         bufferSize = BUFFER_SIZE;
1095     }
1096     return HDF_SUCCESS;
1097 }
1098 }
1099 }
1100