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