1 /*
2 * Copyright (c) 2022 HiSilicon (Shanghai) Technologies CO., LIMITED.
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 <stdlib.h>
16 #include <stdio.h>
17 #include <string.h>
18 #include <unistd.h>
19 #include <sys/types.h>
20 #include <sys/stat.h>
21 #include <sys/ioctl.h>
22 #include <fcntl.h>
23 #include <pthread.h>
24 #include <errno.h>
25 #include <signal.h>
26 #include <limits.h>
27 #include "sample_comm.h"
28 #include "acodec.h"
29 #include "audio_aac_adp.h"
30 #include "audio_dl_adp.h"
31 #include "hi_resampler_api.h"
32 #if defined(HI_VQE_USE_STATIC_MODULE_REGISTER)
33 #include "hi_vqe_register_api.h"
34 #endif
35 #include "sdk.h"
36
37 static PAYLOAD_TYPE_E gs_enPayloadType = PT_AAC;
38 static HI_BOOL gs_bAioReSample = HI_FALSE;
39 static HI_BOOL gs_bUserGetMode = HI_FALSE;
40 static HI_BOOL gs_bAoVolumeCtrl = HI_FALSE;
41 static AUDIO_SAMPLE_RATE_E g_in_sample_rate = AUDIO_SAMPLE_RATE_BUTT;
42 static AUDIO_SAMPLE_RATE_E g_out_sample_rate = AUDIO_SAMPLE_RATE_BUTT;
43 /* 0: close, 1: record, 2:reserved, 3:talkv2 */
44 static HI_U32 g_ai_vqe_type = 1;
45 static HI_BOOL g_sample_audio_exit = HI_FALSE;
46
47 static AI_RECORDVQE_CONFIG_S g_ai_record_vqe_attr;
48 static AI_TALKVQEV2_CONFIG_S g_ai_talkv2_vqe_attr;
49
50 #define SAMPLE_DBG(s32Ret) \
51 do { \
52 printf("s32Ret = %#x, fuc:%s, line:%d\n", s32Ret, __FUNCTION__, __LINE__); \
53 } while (0)
54
55 /* function : PT Number to String */
SAMPLE_AUDIO_Pt2Str(PAYLOAD_TYPE_E enType)56 static char *SAMPLE_AUDIO_Pt2Str(PAYLOAD_TYPE_E enType)
57 {
58 if (enType == PT_G711A) {
59 return "g711a";
60 } else if (enType == PT_G711U) {
61 return "g711u";
62 } else if (enType == PT_ADPCMA) {
63 return "adpcm";
64 } else if (enType == PT_G726) {
65 return "g726";
66 } else if (enType == PT_LPCM) {
67 return "pcm";
68 } else if (enType == PT_AAC) {
69 return "aac";
70 } else if (enType == PT_MP3) {
71 return "mp3";
72 } else {
73 return "data";
74 }
75 }
76
SAMPLE_AUDIO_Getchar(HI_VOID)77 static HI_S32 SAMPLE_AUDIO_Getchar(HI_VOID)
78 {
79 int c;
80
81 if (g_sample_audio_exit == HI_TRUE) {
82 SAMPLE_COMM_AUDIO_DestroyAllTrd();
83 SAMPLE_COMM_SYS_Exit();
84 printf("\033[0;31mprogram exit abnormally!\033[0;39m\n");
85 return -1;
86 }
87
88 c = getchar();
89
90 if (g_sample_audio_exit == HI_TRUE) {
91 SAMPLE_COMM_AUDIO_DestroyAllTrd();
92 SAMPLE_COMM_SYS_Exit();
93 printf("\033[0;31mprogram exit abnormally!\033[0;39m\n");
94 return -1;
95 }
96
97 return c;
98 }
99
100 /* function : Add dynamic load path */
101 #ifndef HI_VQE_USE_STATIC_MODULE_REGISTER
SAMPLE_AUDIO_AddLibPath(HI_VOID)102 static HI_VOID SAMPLE_AUDIO_AddLibPath(HI_VOID)
103 {
104 HI_S32 s32Ret;
105 HI_CHAR aszLibPath[FILE_NAME_LEN] = {0};
106 #if defined(__HuaweiLite__) && (!defined(__OHOS__))
107 s32Ret = snprintf_s(aszLibPath, FILE_NAME_LEN, FILE_NAME_LEN - 1, "/sharefs/");
108 if (s32Ret <= EOK) {
109 printf("\n snprintf_s fail! ret = 0x%x", s32Ret);
110 return;
111 }
112 #else
113 #endif
114 s32Ret = Audio_Dlpath(aszLibPath);
115 if (s32Ret != HI_SUCCESS) {
116 printf("%s: add lib path %s failed\n", __FUNCTION__, aszLibPath);
117 }
118 return;
119 }
120 #endif
121
SAMPLE_AUDIO_OpenAencFile(AENC_CHN AeChn,PAYLOAD_TYPE_E enType)122 static FILE *SAMPLE_AUDIO_OpenAencFile(AENC_CHN AeChn, PAYLOAD_TYPE_E enType)
123 {
124 FILE *pfd = NULL;
125 HI_CHAR aszFileName[FILE_NAME_LEN] = {0};
126 HI_S32 s32Ret;
127 /* create file for save stream */
128 #if defined(__HuaweiLite__) && (!defined(__OHOS__))
129 s32Ret = snprintf_s(aszFileName, FILE_NAME_LEN, FILE_NAME_LEN - 1, "/sharefs/audio_chn%d.%s", AeChn,
130 SAMPLE_AUDIO_Pt2Str(enType));
131 if (s32Ret <= EOK) {
132 printf("\n snprintf_s fail! ret = 0x%x", s32Ret);
133 return NULL;
134 }
135 #else
136 s32Ret = snprintf_s(aszFileName, FILE_NAME_LEN, FILE_NAME_LEN - 1,
137 "audio_chn%d.%s", AeChn, SAMPLE_AUDIO_Pt2Str(enType));
138 if (s32Ret <= EOK) {
139 printf("\n snprintf_s fail! ret = 0x%x", s32Ret);
140 return NULL;
141 }
142 #endif
143 pfd = fopen(aszFileName, "w+");
144 if (pfd == NULL) {
145 printf("%s: open file %s failed\n", __FUNCTION__, aszFileName);
146 return NULL;
147 }
148 printf("open stream file:\"%s\" for aenc ok\n", aszFileName);
149 return pfd;
150 }
151
SAMPLE_AUDIO_OpenAdecFile(ADEC_CHN AdChn,PAYLOAD_TYPE_E enType)152 static FILE *SAMPLE_AUDIO_OpenAdecFile(ADEC_CHN AdChn, PAYLOAD_TYPE_E enType)
153 {
154 FILE *pfd = NULL;
155 HI_CHAR aszFileName[FILE_NAME_LEN] = {0};
156 HI_S32 s32Ret;
157 #if (!defined(__HuaweiLite__)) || defined(__OHOS__)
158 HI_CHAR path[PATH_MAX] = {0};
159 #endif
160
161 /* create file for save stream */
162 #if defined(__HuaweiLite__) && (!defined(__OHOS__))
163 s32Ret = snprintf_s(aszFileName, FILE_NAME_LEN, FILE_NAME_LEN - 1, "/sharefs/audio_chn%d.%s", AdChn,
164 SAMPLE_AUDIO_Pt2Str(enType));
165 if (s32Ret <= EOK) {
166 printf("\n snprintf_s fail! ret = 0x%x", s32Ret);
167 return NULL;
168 }
169 #else
170 s32Ret = snprintf_s(aszFileName, FILE_NAME_LEN, FILE_NAME_LEN - 1,
171 "audio_chn%d.%s", AdChn, SAMPLE_AUDIO_Pt2Str(enType));
172 if (s32Ret <= EOK) {
173 printf("\n snprintf_s fail! ret = 0x%x", s32Ret);
174 return NULL;
175 }
176 #endif
177
178 #if (!defined(__HuaweiLite__)) || defined(__OHOS__)
179 if (realpath(aszFileName, path) == NULL) {
180 printf("[func]:%s [line]:%d [info]:%s\n", __FUNCTION__, __LINE__, "adec file name realpath fail");
181 return NULL;
182 }
183
184 pfd = fopen(path, "rb");
185 if (pfd == NULL) {
186 printf("%s: open file %s failed\n", __FUNCTION__, aszFileName);
187 return NULL;
188 }
189 #else
190 pfd = fopen(aszFileName, "rb");
191 if (pfd == NULL) {
192 printf("%s: open file %s failed\n", __FUNCTION__, aszFileName);
193 return NULL;
194 }
195 #endif
196
197 printf("open stream file:\"%s\" for adec ok\n", aszFileName);
198 return pfd;
199 }
200
sample_audio_adec_ao_init_param(AIO_ATTR_S * attr)201 static hi_void sample_audio_adec_ao_init_param(AIO_ATTR_S *attr)
202 {
203 attr->enSamplerate = AUDIO_SAMPLE_RATE_48000;
204 attr->u32FrmNum = FPS_30;
205 attr->enBitwidth = AUDIO_BIT_WIDTH_16;
206 attr->enWorkmode = AIO_MODE_I2S_MASTER;
207 attr->enSoundmode = AUDIO_SOUND_MODE_MONO; // AUDIO_SOUND_MODE_STEREO;
208 attr->u32ChnCnt = 1; /* 2: chn num */
209 attr->u32ClkSel = 1;
210 attr->enI2sType = AIO_I2STYPE_INNERCODEC;
211 attr->u32PtNumPerFrm = AACLC_SAMPLES_PER_FRAME;
212 attr->u32EXFlag = 0;
213
214 gs_bAioReSample = HI_FALSE;
215 g_in_sample_rate = AUDIO_SAMPLE_RATE_BUTT;
216 g_out_sample_rate = AUDIO_SAMPLE_RATE_BUTT;
217 }
218
SAMPLE_AUDIO_AdecAoInner(AUDIO_DEV AoDev,AO_CHN AoChn,ADEC_CHN AdChn)219 static HI_VOID SAMPLE_AUDIO_AdecAoInner(AUDIO_DEV AoDev, AO_CHN AoChn, ADEC_CHN AdChn)
220 {
221 HI_S32 s32Ret;
222 FILE *pfd = NULL;
223
224 s32Ret = SAMPLE_COMM_AUDIO_AoBindAdec(AoDev, AoChn, AdChn);
225 if (s32Ret != HI_SUCCESS) {
226 SAMPLE_DBG(s32Ret);
227 return;
228 }
229
230 pfd = SAMPLE_AUDIO_OpenAdecFile(AdChn, gs_enPayloadType);
231 if (pfd == NULL) {
232 SAMPLE_DBG(HI_FAILURE);
233 goto ADECAO_ERR0;
234 }
235
236 s32Ret = SAMPLE_COMM_AUDIO_CreateTrdFileAdec(AdChn, pfd);
237 if (s32Ret != HI_SUCCESS) {
238 (HI_VOID)fclose(pfd);
239 pfd = HI_NULL;
240 SAMPLE_DBG(s32Ret);
241 goto ADECAO_ERR0;
242 }
243
244 HI_MPI_AO_SetVolume(AoDev, 0);
245 printf("bind adec:%d to ao(%d,%d) ok \n", AdChn, AoDev, AoChn);
246 printf("\nplease press twice ENTER to exit this sample\n");
247 SAMPLE_AUDIO_Getchar();
248 SAMPLE_AUDIO_Getchar();
249
250 s32Ret = SAMPLE_COMM_AUDIO_DestroyTrdFileAdec(AdChn);
251 if (s32Ret != HI_SUCCESS) {
252 SAMPLE_DBG(s32Ret);
253 return;
254 }
255
256 ADECAO_ERR0:
257 s32Ret = SAMPLE_COMM_AUDIO_AoUnbindAdec(AoDev, AoChn, AdChn);
258 if (s32Ret != HI_SUCCESS) {
259 SAMPLE_DBG(s32Ret);
260 }
261
262 return;
263 }
264
265 /* function : file -> Adec -> Ao */
SAMPLE_AUDIO_AdecAo(HI_VOID)266 static HI_S32 SAMPLE_AUDIO_AdecAo(HI_VOID)
267 {
268 HI_S32 s32Ret, s32AoChnCnt;
269 const AO_CHN AoChn = 0;
270 const ADEC_CHN AdChn = 0;
271 AIO_ATTR_S stAioAttr;
272 AUDIO_DEV AoDev = SAMPLE_AUDIO_INNER_AO_DEV;
273
274 sample_audio_adec_ao_init_param(&stAioAttr);
275
276 s32Ret = SAMPLE_COMM_AUDIO_StartAdec(AdChn, gs_enPayloadType);
277 if (s32Ret != HI_SUCCESS) {
278 SAMPLE_DBG(s32Ret);
279 goto ADECAO_ERR3;
280 }
281
282 s32AoChnCnt = stAioAttr.u32ChnCnt;
283 s32Ret = SAMPLE_COMM_AUDIO_StartAo(AoDev, s32AoChnCnt, &stAioAttr, g_in_sample_rate, gs_bAioReSample);
284 if (s32Ret != HI_SUCCESS) {
285 SAMPLE_DBG(s32Ret);
286 goto ADECAO_ERR2;
287 }
288
289 s32Ret = SAMPLE_COMM_AUDIO_CfgAcodec(&stAioAttr);
290 if (s32Ret != HI_SUCCESS) {
291 SAMPLE_DBG(s32Ret);
292 goto ADECAO_ERR1;
293 }
294
295 SAMPLE_AUDIO_AdecAoInner(AoDev, AoChn, AdChn);
296
297 ADECAO_ERR1:
298 s32Ret = SAMPLE_COMM_AUDIO_StopAo(AoDev, s32AoChnCnt, gs_bAioReSample);
299 if (s32Ret != HI_SUCCESS) {
300 SAMPLE_DBG(s32Ret);
301 }
302 ADECAO_ERR2:
303 s32Ret = SAMPLE_COMM_AUDIO_StopAdec(AdChn);
304 if (s32Ret != HI_SUCCESS) {
305 SAMPLE_DBG(s32Ret);
306 }
307
308 ADECAO_ERR3:
309 return s32Ret;
310 }
311
sample_audio_ai_aenc_init_param(AIO_ATTR_S * attr)312 static hi_void sample_audio_ai_aenc_init_param(AIO_ATTR_S *attr)
313 {
314 attr->enSamplerate = AUDIO_SAMPLE_RATE_48000;
315 attr->enBitwidth = AUDIO_BIT_WIDTH_16;
316 attr->enWorkmode = AIO_MODE_I2S_MASTER;
317 attr->enSoundmode = AUDIO_SOUND_MODE_MONO; // AUDIO_SOUND_MODE_STEREO;
318 attr->u32EXFlag = 0;
319 attr->u32FrmNum = FPS_30;
320 attr->u32ChnCnt = 1; // 2; /* 2: chn num */
321 attr->u32ClkSel = 1;
322 attr->enI2sType = AIO_I2STYPE_INNERCODEC;
323 attr->u32PtNumPerFrm = AACLC_SAMPLES_PER_FRAME;
324
325 gs_bAioReSample = HI_FALSE;
326 g_in_sample_rate = AUDIO_SAMPLE_RATE_BUTT;
327 g_out_sample_rate = AUDIO_SAMPLE_RATE_BUTT;
328 }
329
SAMPLE_AUDIO_StartAdecAo(HI_BOOL bSendAdec,AUDIO_DEV AoDev,AENC_CHN AeChn,AIO_ATTR_S * pstAioAttr)330 static HI_VOID SAMPLE_AUDIO_StartAdecAo(HI_BOOL bSendAdec, AUDIO_DEV AoDev, AENC_CHN AeChn, AIO_ATTR_S *pstAioAttr)
331 {
332 HI_S32 s32Ret, s32AoChnCnt;
333 const AO_CHN AoChn = 0;
334 const ADEC_CHN AdChn = 0;
335 FILE *pfd = NULL;
336
337 if (bSendAdec == HI_TRUE) {
338 s32Ret = SAMPLE_COMM_AUDIO_StartAdec(AdChn, gs_enPayloadType);
339 if (s32Ret != HI_SUCCESS) {
340 return;
341 }
342
343 s32AoChnCnt = pstAioAttr->u32ChnCnt;
344 s32Ret = SAMPLE_COMM_AUDIO_StartAo(AoDev, s32AoChnCnt, pstAioAttr, g_in_sample_rate, gs_bAioReSample);
345 if (s32Ret != HI_SUCCESS) {
346 goto STOP_ADEC;
347 }
348
349 pfd = SAMPLE_AUDIO_OpenAencFile(AdChn, gs_enPayloadType);
350 if (pfd == NULL) {
351 SAMPLE_DBG(HI_FAILURE);
352 goto STOP_AO;
353 }
354 s32Ret = SAMPLE_COMM_AUDIO_CreateTrdAencAdec(AeChn, AdChn, pfd);
355 if (s32Ret != HI_SUCCESS) {
356 (HI_VOID)fclose(pfd);
357 pfd = HI_NULL;
358 SAMPLE_DBG(s32Ret);
359 goto STOP_AO;
360 }
361
362 s32Ret = SAMPLE_COMM_AUDIO_AoBindAdec(AoDev, AoChn, AdChn);
363 if (s32Ret != HI_SUCCESS) {
364 SAMPLE_DBG(s32Ret);
365 goto DESTORY_AENC_THREAD;
366 }
367
368 printf("bind adec:%d to ao(%d,%d) ok \n", AdChn, AoDev, AoChn);
369 }
370
371 printf("\nplease press twice ENTER to exit this sample\n");
372 SAMPLE_AUDIO_Getchar();
373 SAMPLE_AUDIO_Getchar();
374
375 if (bSendAdec == HI_TRUE) {
376 s32Ret = SAMPLE_COMM_AUDIO_AoUnbindAdec(AoDev, AoChn, AdChn);
377 if (s32Ret != HI_SUCCESS) {
378 SAMPLE_DBG(s32Ret);
379 }
380
381 DESTORY_AENC_THREAD:
382 (HI_VOID)SAMPLE_COMM_AUDIO_DestroyTrdAencAdec(AdChn);
383
384 STOP_AO:
385 (HI_VOID)SAMPLE_COMM_AUDIO_StopAo(AoDev, s32AoChnCnt, gs_bAioReSample);
386
387 STOP_ADEC:
388 (HI_VOID)SAMPLE_COMM_AUDIO_StopAdec(AdChn);
389 }
390 }
391
SAMPLE_AUDIO_AiAencInner(AUDIO_DEV AiDev,AUDIO_DEV AoDev,HI_S32 s32AencChnCnt,AIO_ATTR_S * pstAioAttr)392 static HI_VOID SAMPLE_AUDIO_AiAencInner(AUDIO_DEV AiDev, AUDIO_DEV AoDev, HI_S32 s32AencChnCnt, AIO_ATTR_S *pstAioAttr)
393 {
394 HI_S32 i, j, s32Ret;
395 AI_CHN AiChn;
396 AENC_CHN AeChn = 0;
397 HI_BOOL bSendAdec = HI_TRUE;
398
399 for (i = 0; i < s32AencChnCnt; i++) {
400 AeChn = i;
401 AiChn = i;
402
403 if (gs_bUserGetMode == HI_TRUE) {
404 s32Ret = SAMPLE_COMM_AUDIO_CreateTrdAiAenc(AiDev, AiChn, AeChn);
405 } else {
406 s32Ret = SAMPLE_COMM_AUDIO_AencBindAi(AiDev, AiChn, AeChn);
407 }
408 if (s32Ret != HI_SUCCESS) {
409 SAMPLE_DBG(s32Ret);
410 goto EXIT;
411 }
412 printf("Ai(%d,%d) bind to AencChn:%d ok!\n", AiDev, AiChn, AeChn);
413 }
414
415 SAMPLE_AUDIO_StartAdecAo(bSendAdec, AoDev, AeChn, pstAioAttr);
416
417 for (i = 0; i < s32AencChnCnt; i++) {
418 AeChn = i;
419 AiChn = i;
420
421 if (gs_bUserGetMode == HI_TRUE) {
422 s32Ret = SAMPLE_COMM_AUDIO_DestroyTrdAi(AiDev, AiChn);
423 } else {
424 s32Ret = SAMPLE_COMM_AUDIO_AencUnbindAi(AiDev, AiChn, AeChn);
425 }
426 if (s32Ret != HI_SUCCESS) {
427 SAMPLE_DBG(s32Ret);
428 }
429 }
430 return;
431
432 EXIT:
433 for (j = 0; j < i; j++) {
434 if (gs_bUserGetMode == HI_TRUE) {
435 SAMPLE_COMM_AUDIO_DestroyTrdAi(AiDev, j);
436 } else {
437 SAMPLE_COMM_AUDIO_AencUnbindAi(AiDev, j, j);
438 }
439 }
440 return;
441 }
442
443 /* function : Ai -> Aenc -> file -> Adec -> Ao */
SAMPLE_AUDIO_AiAenc(HI_VOID)444 static HI_S32 SAMPLE_AUDIO_AiAenc(HI_VOID)
445 {
446 HI_S32 s32Ret;
447 HI_S32 s32AiChnCnt;
448 HI_S32 s32AencChnCnt;
449 AIO_ATTR_S stAioAttr;
450 AUDIO_DEV AiDev = SAMPLE_AUDIO_INNER_AI_DEV;
451 AUDIO_DEV AoDev = SAMPLE_AUDIO_INNER_AO_DEV;
452
453 sample_audio_ai_aenc_init_param(&stAioAttr);
454
455 /* step 1: start Ai */
456 s32AiChnCnt = stAioAttr.u32ChnCnt;
457 s32Ret = SAMPLE_COMM_AUDIO_StartAi(AiDev, s32AiChnCnt, &stAioAttr, g_out_sample_rate, gs_bAioReSample, NULL, 0);
458 if (s32Ret != HI_SUCCESS) {
459 SAMPLE_DBG(s32Ret);
460 goto EXIT;
461 }
462
463 /* step 2: config audio codec */
464 s32Ret = SAMPLE_COMM_AUDIO_CfgAcodec(&stAioAttr);
465 if (s32Ret != HI_SUCCESS) {
466 SAMPLE_DBG(s32Ret);
467 goto STOP_AI;
468 }
469
470 /* step 3: start Aenc */
471 s32AencChnCnt = stAioAttr.u32ChnCnt >> (HI_U32)stAioAttr.enSoundmode;
472 s32Ret = SAMPLE_COMM_AUDIO_StartAenc(s32AencChnCnt, &stAioAttr, gs_enPayloadType);
473 if (s32Ret != HI_SUCCESS) {
474 SAMPLE_DBG(s32Ret);
475 goto STOP_AI;
476 }
477
478 SAMPLE_AUDIO_AiAencInner(AiDev, AoDev, s32AencChnCnt, &stAioAttr);
479
480 s32Ret = SAMPLE_COMM_AUDIO_StopAenc(s32AencChnCnt);
481 if (s32Ret != HI_SUCCESS) {
482 SAMPLE_DBG(s32Ret);
483 }
484
485 STOP_AI:
486 s32Ret = SAMPLE_COMM_AUDIO_StopAi(AiDev, s32AiChnCnt, gs_bAioReSample, HI_FALSE);
487 if (s32Ret != HI_SUCCESS) {
488 SAMPLE_DBG(s32Ret);
489 }
490
491 EXIT:
492 return s32Ret;
493 }
494
sample_audio_ai_ao_init_param(AIO_ATTR_S * attr)495 static hi_void sample_audio_ai_ao_init_param(AIO_ATTR_S *attr)
496 {
497 attr->enSamplerate = AUDIO_SAMPLE_RATE_48000;
498 attr->enBitwidth = AUDIO_BIT_WIDTH_16;
499 attr->enWorkmode = AIO_MODE_I2S_MASTER;
500 attr->enSoundmode = AUDIO_SOUND_MODE_MONO; // AUDIO_SOUND_MODE_STEREO;
501 attr->u32EXFlag = 0;
502 attr->u32FrmNum = FPS_30;
503 attr->u32PtNumPerFrm = AACLC_SAMPLES_PER_FRAME;
504 attr->u32ChnCnt = 1; // 2; /* 2: chn num */
505 attr->u32ClkSel = 1;
506 attr->enI2sType = AIO_I2STYPE_INNERCODEC;
507
508 gs_bAioReSample = HI_FALSE;
509 /* config ao resample attr if needed */
510 if (gs_bAioReSample == HI_TRUE) {
511 /* ai 48k -> 32k */
512 g_out_sample_rate = AUDIO_SAMPLE_RATE_32000;
513
514 /* ao 32k -> 48k */
515 g_in_sample_rate = AUDIO_SAMPLE_RATE_32000;
516 } else {
517 g_in_sample_rate = AUDIO_SAMPLE_RATE_BUTT;
518 g_out_sample_rate = AUDIO_SAMPLE_RATE_BUTT;
519 }
520
521 /* resample and anr should be user get mode */
522 gs_bUserGetMode = (gs_bAioReSample == HI_TRUE) ? HI_TRUE : HI_FALSE;
523 }
524
SAMPLE_AUDIO_AiAoInner(AUDIO_DEV AiDev,AI_CHN AiChn,AUDIO_DEV AoDev,AO_CHN AoChn)525 static HI_VOID SAMPLE_AUDIO_AiAoInner(AUDIO_DEV AiDev, AI_CHN AiChn, AUDIO_DEV AoDev, AO_CHN AoChn)
526 {
527 HI_S32 s32Ret;
528
529 /* bind AI to AO channel */
530 if (gs_bUserGetMode == HI_TRUE) {
531 s32Ret = SAMPLE_COMM_AUDIO_CreateTrdAiAo(AiDev, AiChn, AoDev, AoChn);
532 if (s32Ret != HI_SUCCESS) {
533 SAMPLE_DBG(s32Ret);
534 return;
535 }
536 } else {
537 s32Ret = SAMPLE_COMM_AUDIO_AoBindAi(AiDev, AiChn, AoDev, AoChn);
538 if (s32Ret != HI_SUCCESS) {
539 SAMPLE_DBG(s32Ret);
540 return;
541 }
542 }
543 printf("ai(%d,%d) bind to ao(%d,%d) ok\n", AiDev, AiChn, AoDev, AoChn);
544
545 if (gs_bAoVolumeCtrl == HI_TRUE) {
546 s32Ret = SAMPLE_COMM_AUDIO_CreateTrdAoVolCtrl(AoDev);
547 if (s32Ret != HI_SUCCESS) {
548 SAMPLE_DBG(s32Ret);
549 goto AIAO_ERR0;
550 }
551 }
552
553 printf("\nplease press twice ENTER to exit this sample\n");
554 SAMPLE_AUDIO_Getchar();
555 SAMPLE_AUDIO_Getchar();
556
557 if (gs_bAoVolumeCtrl == HI_TRUE) {
558 s32Ret = SAMPLE_COMM_AUDIO_DestroyTrdAoVolCtrl(AoDev);
559 if (s32Ret != HI_SUCCESS) {
560 SAMPLE_DBG(s32Ret);
561 return;
562 }
563 }
564
565 AIAO_ERR0:
566 if (gs_bUserGetMode == HI_TRUE) {
567 s32Ret = SAMPLE_COMM_AUDIO_DestroyTrdAi(AiDev, AiChn);
568 if (s32Ret != HI_SUCCESS) {
569 SAMPLE_DBG(s32Ret);
570 }
571 } else {
572 s32Ret = SAMPLE_COMM_AUDIO_AoUnbindAi(AiDev, AiChn, AoDev, AoChn);
573 if (s32Ret != HI_SUCCESS) {
574 SAMPLE_DBG(s32Ret);
575 }
576 }
577
578 return;
579 }
580
581 /* function : Ai -> Ao(with fade in/out and volume adjust) */
SAMPLE_AUDIO_AiAo(HI_VOID)582 static HI_S32 SAMPLE_AUDIO_AiAo(HI_VOID)
583 {
584 HI_S32 s32Ret;
585 HI_S32 s32AiChnCnt;
586 HI_S32 s32AoChnCnt;
587 const AI_CHN AiChn = 0;
588 const AO_CHN AoChn = 0;
589 AIO_ATTR_S stAioAttr;
590 AUDIO_DEV AiDev = SAMPLE_AUDIO_INNER_AI_DEV;
591 AUDIO_DEV AoDev = SAMPLE_AUDIO_INNER_AO_DEV;
592
593 sample_audio_ai_ao_init_param(&stAioAttr);
594
595 /* enable AI channel */
596 s32AiChnCnt = stAioAttr.u32ChnCnt;
597 s32Ret = SAMPLE_COMM_AUDIO_StartAi(AiDev, s32AiChnCnt, &stAioAttr, g_out_sample_rate, gs_bAioReSample, NULL, 0);
598 if (s32Ret != HI_SUCCESS) {
599 SAMPLE_DBG(s32Ret);
600 goto AIAO_ERR3;
601 }
602
603 /* enable AO channel */
604 s32AoChnCnt = stAioAttr.u32ChnCnt;
605 s32Ret = SAMPLE_COMM_AUDIO_StartAo(AoDev, s32AoChnCnt, &stAioAttr, g_in_sample_rate, gs_bAioReSample);
606 if (s32Ret != HI_SUCCESS) {
607 SAMPLE_DBG(s32Ret);
608 goto AIAO_ERR2;
609 }
610
611 /* config internal audio codec */
612 s32Ret = SAMPLE_COMM_AUDIO_CfgAcodec(&stAioAttr);
613 if (s32Ret != HI_SUCCESS) {
614 SAMPLE_DBG(s32Ret);
615 goto AIAO_ERR1;
616 }
617
618 SAMPLE_AUDIO_AiAoInner(AiDev, AiChn, AoDev, AoChn);
619
620 AIAO_ERR1:
621 s32Ret = SAMPLE_COMM_AUDIO_StopAo(AoDev, s32AoChnCnt, gs_bAioReSample);
622 if (s32Ret != HI_SUCCESS) {
623 SAMPLE_DBG(s32Ret);
624 }
625
626 AIAO_ERR2:
627 s32Ret = SAMPLE_COMM_AUDIO_StopAi(AiDev, s32AiChnCnt, gs_bAioReSample, HI_FALSE);
628 if (s32Ret != HI_SUCCESS) {
629 SAMPLE_DBG(s32Ret);
630 }
631
632 AIAO_ERR3:
633 return s32Ret;
634 }
635
sample_audio_ai_to_sys_chn_init_param(AIO_ATTR_S * attr)636 static hi_void sample_audio_ai_to_sys_chn_init_param(AIO_ATTR_S *attr)
637 {
638 attr->enSamplerate = AUDIO_SAMPLE_RATE_48000;
639 attr->u32PtNumPerFrm = AACLC_SAMPLES_PER_FRAME;
640 attr->enBitwidth = AUDIO_BIT_WIDTH_16;
641 attr->enWorkmode = AIO_MODE_I2S_MASTER;
642 attr->enSoundmode = AUDIO_SOUND_MODE_STEREO;
643 attr->u32EXFlag = 0;
644 attr->u32FrmNum = FPS_30;
645 attr->u32ChnCnt = 2; /* 2: chn num */
646 attr->enI2sType = AIO_I2STYPE_INNERCODEC;
647 attr->u32ClkSel = 1;
648
649 gs_bAioReSample = HI_FALSE;
650 /* config ao resample attr if needed */
651 if (gs_bAioReSample == HI_TRUE) {
652 /* ai 48k -> 16k */
653 g_out_sample_rate = AUDIO_SAMPLE_RATE_16000;
654
655 /* ao 16k -> 48k */
656 g_in_sample_rate = AUDIO_SAMPLE_RATE_16000;
657 } else {
658 g_in_sample_rate = AUDIO_SAMPLE_RATE_BUTT;
659 g_out_sample_rate = AUDIO_SAMPLE_RATE_BUTT;
660 }
661
662 /* resample and anr should be user get mode */
663 gs_bUserGetMode = (gs_bAioReSample == HI_TRUE) ? HI_TRUE : HI_FALSE;
664 }
665
666 /* function : Ai -> Ao(with fade in/out and volume adjust) */
SAMPLE_AUDIO_AiToAoSysChn(HI_VOID)667 static HI_S32 SAMPLE_AUDIO_AiToAoSysChn(HI_VOID)
668 {
669 HI_S32 s32Ret, s32AiChnCnt, s32AoChnCnt;
670 const AI_CHN AiChn = 0;
671 AIO_ATTR_S stAioAttr;
672 AUDIO_DEV AiDev = SAMPLE_AUDIO_INNER_AI_DEV;
673 AUDIO_DEV AoDev = SAMPLE_AUDIO_INNER_AO_DEV;
674
675 sample_audio_ai_to_sys_chn_init_param(&stAioAttr);
676
677 /* enable AI channel */
678 s32AiChnCnt = stAioAttr.u32ChnCnt;
679 s32Ret = SAMPLE_COMM_AUDIO_StartAi(AiDev, s32AiChnCnt, &stAioAttr, g_out_sample_rate, gs_bAioReSample, NULL, 0);
680 if (s32Ret != HI_SUCCESS) {
681 SAMPLE_DBG(s32Ret);
682 goto SYS_CHN_ERR3;
683 }
684
685 /* enable AO channel */
686 s32AoChnCnt = stAioAttr.u32ChnCnt;
687 s32Ret = SAMPLE_COMM_AUDIO_StartAo(AoDev, s32AoChnCnt, &stAioAttr, g_in_sample_rate, gs_bAioReSample);
688 if (s32Ret != HI_SUCCESS) {
689 SAMPLE_DBG(s32Ret);
690 goto SYS_CHN_ERR2;
691 }
692
693 /* config internal audio codec */
694 s32Ret = SAMPLE_COMM_AUDIO_CfgAcodec(&stAioAttr);
695 if (s32Ret != HI_SUCCESS) {
696 SAMPLE_DBG(s32Ret);
697 goto SYS_CHN_ERR1;
698 }
699
700 /* bind AI to AO channel */
701 s32Ret = SAMPLE_COMM_AUDIO_CreateTrdAiAo(AiDev, AiChn, AoDev, AO_SYSCHN_CHNID);
702 if (s32Ret != HI_SUCCESS) {
703 SAMPLE_DBG(s32Ret);
704 goto SYS_CHN_ERR1;
705 }
706 printf("ai(%d,%d) bind to ao(%d,%d) ok\n", AiDev, AiChn, AoDev, AO_SYSCHN_CHNID);
707 printf("\nplease press twice ENTER to exit this sample\n");
708 SAMPLE_AUDIO_Getchar();
709 SAMPLE_AUDIO_Getchar();
710
711 s32Ret = SAMPLE_COMM_AUDIO_DestroyTrdAi(AiDev, AiChn);
712 if (s32Ret != HI_SUCCESS) {
713 SAMPLE_DBG(s32Ret);
714 }
715
716 SYS_CHN_ERR1:
717 s32Ret = SAMPLE_COMM_AUDIO_StopAo(AoDev, s32AoChnCnt, gs_bAioReSample);
718 if (s32Ret != HI_SUCCESS) {
719 SAMPLE_DBG(s32Ret);
720 }
721
722 SYS_CHN_ERR2:
723 s32Ret = SAMPLE_COMM_AUDIO_StopAi(AiDev, s32AiChnCnt, gs_bAioReSample, HI_FALSE);
724 if (s32Ret != HI_SUCCESS) {
725 SAMPLE_DBG(s32Ret);
726 }
727
728 SYS_CHN_ERR3:
729 return s32Ret;
730 }
731
sample_audio_ai_vqe_process_ao_init_param(AIO_ATTR_S * attr,hi_void ** ai_vqe_attr)732 static hi_void sample_audio_ai_vqe_process_ao_init_param(AIO_ATTR_S *attr, hi_void **ai_vqe_attr)
733 {
734 attr->enSamplerate = AUDIO_SAMPLE_RATE_48000;
735 attr->enBitwidth = AUDIO_BIT_WIDTH_16;
736 attr->enWorkmode = AIO_MODE_I2S_MASTER;
737 attr->enSoundmode = AUDIO_SOUND_MODE_STEREO;
738 attr->u32EXFlag = 0;
739 attr->u32FrmNum = FPS_30;
740 attr->u32PtNumPerFrm = SAMPLE_AUDIO_PTNUMPERFRM;
741 attr->u32ChnCnt = 2; /* 2: chn num */
742 attr->u32ClkSel = 1;
743 attr->enI2sType = AIO_I2STYPE_INNERCODEC;
744
745 gs_bAioReSample = HI_FALSE;
746 g_in_sample_rate = AUDIO_SAMPLE_RATE_BUTT;
747 g_out_sample_rate = AUDIO_SAMPLE_RATE_BUTT;
748
749 if (g_ai_vqe_type == 1) { /* 1: Record VQE */
750 (hi_void)memset_s(&g_ai_record_vqe_attr, sizeof(AI_RECORDVQE_CONFIG_S), 0, sizeof(AI_RECORDVQE_CONFIG_S));
751 g_ai_record_vqe_attr.s32WorkSampleRate = AUDIO_SAMPLE_RATE_48000;
752 g_ai_record_vqe_attr.s32FrameSample = SAMPLE_AUDIO_PTNUMPERFRM;
753 g_ai_record_vqe_attr.enWorkstate = VQE_WORKSTATE_COMMON;
754 g_ai_record_vqe_attr.s32InChNum = 2; /* 2: chn num */
755 g_ai_record_vqe_attr.s32OutChNum = 2; /* 2: chn num */
756 g_ai_record_vqe_attr.enRecordType = VQE_RECORD_NORMAL;
757 g_ai_record_vqe_attr.stDrcCfg.bUsrMode = HI_FALSE;
758 g_ai_record_vqe_attr.stRnrCfg.bUsrMode = HI_FALSE;
759 g_ai_record_vqe_attr.stHdrCfg.bUsrMode = HI_FALSE;
760 g_ai_record_vqe_attr.stHpfCfg.bUsrMode = HI_TRUE;
761 g_ai_record_vqe_attr.stHpfCfg.enHpfFreq = AUDIO_HPF_FREQ_80;
762 g_ai_record_vqe_attr.u32OpenMask =
763 AI_RECORDVQE_MASK_DRC | AI_RECORDVQE_MASK_HDR | AI_RECORDVQE_MASK_HPF | AI_RECORDVQE_MASK_RNR;
764 *ai_vqe_attr = (hi_void *)&g_ai_record_vqe_attr;
765 } else if (g_ai_vqe_type == 3) { /* 3: TalkV2 VQE */
766 (hi_void)memset_s(&g_ai_talkv2_vqe_attr, sizeof(AI_TALKVQEV2_CONFIG_S), 0, sizeof(AI_TALKVQEV2_CONFIG_S));
767 g_ai_talkv2_vqe_attr.s32WorkSampleRate = AUDIO_SAMPLE_RATE_16000;
768 g_ai_talkv2_vqe_attr.s32FrameSample = SAMPLE_AUDIO_PTNUMPERFRM;
769 g_ai_talkv2_vqe_attr.enWorkstate = VQE_WORKSTATE_COMMON;
770 g_ai_talkv2_vqe_attr.s32InChNum = 2; /* 2: chn num */
771 g_ai_talkv2_vqe_attr.s32OutChNum = 2; /* 2: chn num */
772 g_ai_talkv2_vqe_attr.stPnrCfg.bUsrMode = HI_FALSE;
773 g_ai_talkv2_vqe_attr.stAgcCfg.bUsrMode = HI_FALSE;
774 g_ai_talkv2_vqe_attr.u32OpenMask = AI_TALKVQEV2_MASK_PNR | AI_TALKVQEV2_MASK_AGC | AI_TALKVQEV2_MASK_LIMITER;
775 *ai_vqe_attr = (hi_void *)&g_ai_talkv2_vqe_attr;
776 } else {
777 *ai_vqe_attr = HI_NULL;
778 }
779 }
780
781 /* function : Ai -> Ao */
SAMPLE_AUDIO_AiVqeProcessAo(HI_VOID)782 static HI_S32 SAMPLE_AUDIO_AiVqeProcessAo(HI_VOID)
783 {
784 HI_S32 i, j, s32Ret, s32AiChnCnt, s32AoChnCnt;
785 AUDIO_DEV AiDev = SAMPLE_AUDIO_INNER_AI_DEV;
786 AUDIO_DEV AoDev = SAMPLE_AUDIO_INNER_AO_DEV;
787 AIO_ATTR_S stAioAttr;
788 HI_VOID *pAiVqeAttr = NULL;
789
790 sample_audio_ai_vqe_process_ao_init_param(&stAioAttr, &pAiVqeAttr);
791
792 /* step 1: start Ai */
793 s32AiChnCnt = stAioAttr.u32ChnCnt;
794 s32Ret = SAMPLE_COMM_AUDIO_StartAi(AiDev, s32AiChnCnt, &stAioAttr, g_out_sample_rate, gs_bAioReSample, pAiVqeAttr,
795 g_ai_vqe_type);
796 if (s32Ret != HI_SUCCESS) {
797 goto VQE_ERR2;
798 }
799
800 /* step 2: start Ao */
801 s32AoChnCnt = stAioAttr.u32ChnCnt;
802 s32Ret = SAMPLE_COMM_AUDIO_StartAo(AoDev, s32AoChnCnt, &stAioAttr, g_in_sample_rate, gs_bAioReSample);
803 if (s32Ret != HI_SUCCESS) {
804 goto VQE_ERR1;
805 }
806
807 /* step 3: config audio codec */
808 s32Ret = SAMPLE_COMM_AUDIO_CfgAcodec(&stAioAttr);
809 if (s32Ret != HI_SUCCESS) {
810 SAMPLE_DBG(s32Ret);
811 goto VQE_ERR0;
812 }
813
814 /* step 4: Ao bind Ai Chn */
815 for (i = 0; i < (hi_s32)((HI_U32)s32AiChnCnt >> (HI_U32)stAioAttr.enSoundmode); i++) {
816 s32Ret = SAMPLE_COMM_AUDIO_CreateTrdAiAo(AiDev, i, AoDev, i);
817 if (s32Ret != HI_SUCCESS) {
818 SAMPLE_DBG(s32Ret);
819 for (j = 0; j < i; j++) {
820 SAMPLE_COMM_AUDIO_DestroyTrdAi(AiDev, j);
821 }
822 goto VQE_ERR0;
823 }
824
825 printf("bind ai(%d,%d) to ao(%d,%d) ok \n", AiDev, i, AoDev, i);
826 }
827
828 printf("\nplease press twice ENTER to exit this sample\n");
829 SAMPLE_AUDIO_Getchar();
830 SAMPLE_AUDIO_Getchar();
831
832 /* step 5: exit the process */
833 for (i = 0; i < s32AiChnCnt; i++) {
834 s32Ret = SAMPLE_COMM_AUDIO_DestroyTrdAi(AiDev, i);
835 if (s32Ret != HI_SUCCESS) {
836 SAMPLE_DBG(s32Ret);
837 }
838 }
839
840 VQE_ERR0:
841 (HI_VOID)SAMPLE_COMM_AUDIO_StopAo(AoDev, s32AoChnCnt, gs_bAioReSample);
842
843 VQE_ERR1:
844 (HI_VOID)SAMPLE_COMM_AUDIO_StopAi(AiDev, s32AiChnCnt, gs_bAioReSample, HI_TRUE);
845
846 VQE_ERR2:
847 return s32Ret;
848 }
849
sample_audio_ai_hdmi_ao_init_param(AIO_ATTR_S * ai_attr,AIO_ATTR_S * ao_attr)850 static hi_void sample_audio_ai_hdmi_ao_init_param(AIO_ATTR_S *ai_attr, AIO_ATTR_S *ao_attr)
851 {
852 ai_attr->enI2sType = AIO_I2STYPE_INNERCODEC;
853 ai_attr->enSamplerate = AUDIO_SAMPLE_RATE_48000;
854 ai_attr->enBitwidth = AUDIO_BIT_WIDTH_16;
855 ai_attr->enWorkmode = AIO_MODE_I2S_MASTER;
856 ai_attr->enSoundmode = AUDIO_SOUND_MODE_STEREO;
857 ai_attr->u32EXFlag = 1;
858 ai_attr->u32FrmNum = FPS_30;
859 ai_attr->u32PtNumPerFrm = SAMPLE_AUDIO_PTNUMPERFRM;
860 ai_attr->u32ChnCnt = 2; /* 2: chn num */
861 ai_attr->u32ClkSel = 1;
862
863 ao_attr->enSamplerate = AUDIO_SAMPLE_RATE_48000;
864 ao_attr->enBitwidth = AUDIO_BIT_WIDTH_16;
865 ao_attr->enWorkmode = AIO_MODE_I2S_MASTER;
866 ao_attr->enSoundmode = AUDIO_SOUND_MODE_STEREO;
867 ao_attr->u32EXFlag = 1;
868 ao_attr->u32FrmNum = FPS_30;
869 ao_attr->u32PtNumPerFrm = SAMPLE_AUDIO_PTNUMPERFRM;
870 ao_attr->u32ChnCnt = 2; /* 2: chn num */
871 ao_attr->u32ClkSel = 0;
872 ao_attr->enI2sType = AIO_I2STYPE_INNERHDMI;
873
874 gs_bAioReSample = HI_FALSE;
875 /* resample should be user get mode */
876 gs_bUserGetMode = (gs_bAioReSample == HI_TRUE) ? HI_TRUE : HI_FALSE;
877 }
878
879 /* function : Ai -> Ao(Hdmi) */
SAMPLE_AUDIO_AiHdmiAo(HI_VOID)880 static HI_S32 SAMPLE_AUDIO_AiHdmiAo(HI_VOID)
881 {
882 HI_S32 s32Ret, s32AiChnCnt;
883 AUDIO_DEV AiDev = SAMPLE_AUDIO_INNER_AI_DEV;
884 const AI_CHN AiChn = 0;
885 AUDIO_DEV AoDev = SAMPLE_AUDIO_INNER_HDMI_AO_DEV;
886 const AO_CHN AoChn = 0;
887 AIO_ATTR_S stAioAttr;
888 AIO_ATTR_S stHdmiAoAttr;
889
890 sample_audio_ai_hdmi_ao_init_param(&stAioAttr, &stHdmiAoAttr);
891
892 /* enable AI channel */
893 s32AiChnCnt = stAioAttr.u32ChnCnt;
894 s32Ret = SAMPLE_COMM_AUDIO_StartAi(AiDev, s32AiChnCnt, &stAioAttr, AUDIO_SAMPLE_RATE_BUTT, HI_FALSE, NULL, 0);
895 if (s32Ret != HI_SUCCESS) {
896 SAMPLE_DBG(s32Ret);
897 return HI_FAILURE;
898 }
899
900 /* enable AO channel */
901 s32Ret =
902 SAMPLE_COMM_AUDIO_StartAo(AoDev, stHdmiAoAttr.u32ChnCnt, &stHdmiAoAttr, stHdmiAoAttr.enSamplerate, HI_FALSE);
903 if (s32Ret != HI_SUCCESS) {
904 SAMPLE_DBG(s32Ret);
905 return HI_FAILURE;
906 }
907
908 /* config audio codec */
909 s32Ret = SAMPLE_COMM_AUDIO_CfgAcodec(&stAioAttr);
910 if (s32Ret != HI_SUCCESS) {
911 SAMPLE_DBG(s32Ret);
912 return HI_FAILURE;
913 }
914
915 /* AI to AO channel */
916 s32Ret = SAMPLE_COMM_AUDIO_CreateTrdAiAo(AiDev, AiChn, AoDev, AoChn);
917 if (s32Ret != HI_SUCCESS) {
918 SAMPLE_DBG(s32Ret);
919 return HI_FAILURE;
920 }
921
922 printf("\nplease press twice ENTER to exit this sample\n");
923 SAMPLE_AUDIO_Getchar();
924 SAMPLE_AUDIO_Getchar();
925
926 s32Ret = SAMPLE_COMM_AUDIO_DestroyTrdAi(AiDev, AiChn);
927 if (s32Ret != HI_SUCCESS) {
928 SAMPLE_DBG(s32Ret);
929 return HI_FAILURE;
930 }
931
932 s32Ret = SAMPLE_COMM_AUDIO_StopAi(AiDev, s32AiChnCnt, HI_FALSE, HI_FALSE);
933 if (s32Ret != HI_SUCCESS) {
934 SAMPLE_DBG(s32Ret);
935 return HI_FAILURE;
936 }
937
938 s32Ret = SAMPLE_COMM_AUDIO_StopAo(AoDev, stHdmiAoAttr.u32ChnCnt, HI_FALSE);
939 if (s32Ret != HI_SUCCESS) {
940 SAMPLE_DBG(s32Ret);
941 return HI_FAILURE;
942 }
943
944 return HI_SUCCESS;
945 }
946
SAMPLE_AUDIO_Usage(HI_VOID)947 static HI_VOID SAMPLE_AUDIO_Usage(HI_VOID)
948 {
949 printf("\n\n/Usage:./sample_audio <index>/\n");
950 printf("\tindex and its function list below\n");
951 printf("\t0: start AI to AO loop\n");
952 printf("\t1: send audio frame to AENC channel from AI, save them\n");
953 printf("\t2: read audio stream from file, decode and send AO\n");
954 printf("\t3: start AI(VQE process), then send to AO\n");
955 printf("\t4: start AI to AO(Hdmi) loop\n");
956 printf("\t5: start AI to AO(Syschn) loop\n");
957 }
958
959 /* function : to process abnormal case */
SAMPLE_AUDIO_HandleSig(HI_S32 signo)960 static void SAMPLE_AUDIO_HandleSig(HI_S32 signo)
961 {
962 if (g_sample_audio_exit == HI_TRUE) {
963 return;
964 }
965
966 if ((signo == SIGINT) || (signo == SIGTERM)) {
967 g_sample_audio_exit = HI_TRUE;
968 }
969 }
970
971 #if defined(HI_VQE_USE_STATIC_MODULE_REGISTER)
972 /* function : to register vqe module */
SAMPLE_AUDIO_RegisterVQEModule(HI_VOID)973 static HI_S32 SAMPLE_AUDIO_RegisterVQEModule(HI_VOID)
974 {
975 HI_S32 s32Ret;
976 AUDIO_VQE_REGISTER_S stVqeRegCfg = { 0 };
977
978 /* Resample */
979 stVqeRegCfg.stResModCfg.pHandle = HI_VQE_RESAMPLE_GetHandle();
980
981 /* RecordVQE */
982 stVqeRegCfg.stRecordModCfg.pHandle = HI_VQE_RECORD_GetHandle();
983
984 /* TalkVQE */
985 stVqeRegCfg.stHpfModCfg.pHandle = HI_VQE_HPF_GetHandle();
986 stVqeRegCfg.stAecModCfg.pHandle = HI_VQE_AEC_GetHandle();
987 stVqeRegCfg.stAgcModCfg.pHandle = HI_VQE_AGC_GetHandle();
988 stVqeRegCfg.stAnrModCfg.pHandle = HI_VQE_ANR_GetHandle();
989 stVqeRegCfg.stEqModCfg.pHandle = HI_VQE_EQ_GetHandle();
990
991 s32Ret = HI_MPI_AUDIO_RegisterVQEModule(&stVqeRegCfg);
992 if (s32Ret != HI_SUCCESS) {
993 printf("%s: register vqe module fail with s32Ret = 0x%x!\n", __FUNCTION__, s32Ret);
994 return HI_FAILURE;
995 }
996
997 return HI_SUCCESS;
998 }
999 #endif
1000
main_inner(hi_u32 index)1001 static hi_void main_inner(hi_u32 index)
1002 {
1003 switch (index) {
1004 case 0: {
1005 SAMPLE_AUDIO_AiAo();
1006 break;
1007 }
1008 case 1: {
1009 SAMPLE_AUDIO_AiAenc();
1010 break;
1011 }
1012 case 2: { /* 2: sample index */
1013 SAMPLE_AUDIO_AdecAo();
1014 break;
1015 }
1016 case 3: { /* 3: sample index */
1017 SAMPLE_AUDIO_AiVqeProcessAo();
1018 break;
1019 }
1020 case 4: { /* 4: sample index */
1021 SAMPLE_AUDIO_AiHdmiAo();
1022 break;
1023 }
1024 case 5: { /* 5: sample index */
1025 SAMPLE_AUDIO_AiToAoSysChn();
1026 break;
1027 }
1028 default: {
1029 break;
1030 }
1031 }
1032 }
1033
1034 #if defined(__HuaweiLite__) && (!defined(__OHOS__))
app_main(int argc,char * argv[])1035 HI_S32 app_main(int argc, char *argv[])
1036 #else
1037 HI_S32 main(int argc, char *argv[])
1038 #endif
1039 {
1040 HI_S32 s32Ret;
1041 VB_CONFIG_S stVbConf;
1042 HI_U32 u32Index;
1043 sdk_init();
1044
1045 if (argc != 2) { /* 2: arg count */
1046 SAMPLE_AUDIO_Usage();
1047 return HI_FAILURE;
1048 }
1049
1050 s32Ret = strcmp(argv[1], "-h");
1051 if (s32Ret == HI_SUCCESS) {
1052 SAMPLE_AUDIO_Usage();
1053 return HI_FAILURE;
1054 }
1055
1056 u32Index = atoi(argv[1]);
1057 if (u32Index > 5) { /* 5: sample index */
1058 SAMPLE_AUDIO_Usage();
1059 return HI_FAILURE;
1060 }
1061
1062 #if (!defined(__HuaweiLite__)) || defined(__OHOS__)
1063 SAMPLE_SYS_SIGNAL(&SAMPLE_AUDIO_HandleSig);
1064 #endif
1065
1066 #if defined(HI_VQE_USE_STATIC_MODULE_REGISTER)
1067 SAMPLE_AUDIO_RegisterVQEModule();
1068 #endif
1069
1070 s32Ret = memset_s(&stVbConf, sizeof(VB_CONFIG_S), 0, sizeof(VB_CONFIG_S));
1071 if (s32Ret != EOK) {
1072 printf("%s: memset_s failed, ret:0x%x.\n", __FUNCTION__, s32Ret);
1073 return s32Ret;
1074 }
1075
1076 s32Ret = SAMPLE_COMM_SYS_Init(&stVbConf);
1077 if (s32Ret != HI_SUCCESS) {
1078 printf("%s: system init failed with %d!\n", __FUNCTION__, s32Ret);
1079 return HI_FAILURE;
1080 }
1081
1082 #ifndef HI_VQE_USE_STATIC_MODULE_REGISTER
1083 SAMPLE_AUDIO_AddLibPath();
1084 #endif
1085
1086 HI_MPI_AENC_AacInit();
1087 HI_MPI_ADEC_AacInit();
1088
1089 main_inner(u32Index);
1090
1091 HI_MPI_AENC_AacDeInit();
1092 HI_MPI_ADEC_AacDeInit();
1093
1094 SAMPLE_COMM_SYS_Exit();
1095
1096 sdk_exit();
1097 return s32Ret;
1098 }
1099