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