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
16 #include <stdlib.h>
17 #include <stdio.h>
18 #include <string.h>
19 #include <unistd.h>
20 #include <sys/types.h>
21 #include <sys/stat.h>
22 #include <sys/ioctl.h>
23 #include <fcntl.h>
24 #include <pthread.h>
25 #include <errno.h>
26 #include <signal.h>
27 #include <sys/eventfd.h>
28
29 #include "hi_resampler_api.h"
30 #include "sample_comm.h"
31 #include "acodec.h"
32 #include "audio_aac_adp.h"
33 #include "audio_dl_adp.h"
34 #include "audio_mp3_adp.h"
35 #include "sample_comm_ive.h"
36 #include "sample_media_ai.h"
37
38 static PAYLOAD_TYPE_E gs_enPayloadType = PT_AAC;
39 static HI_BOOL gs_bAioReSample = HI_FALSE;
40 static HI_BOOL gs_bUserGetMode = HI_FALSE;
41 static HI_BOOL gs_bAoVolumeCtrl = HI_FALSE;
42 static AUDIO_SAMPLE_RATE_E g_in_sample_rate = AUDIO_SAMPLE_RATE_BUTT;
43 static AUDIO_SAMPLE_RATE_E g_out_sample_rate = AUDIO_SAMPLE_RATE_BUTT;
44 /*
45 * 0：关闭，1：录音，2：保留，3：talkv2
46 * 0: close, 1: record, 2:reserved, 3:talkv2
47 */
48 static HI_U32 g_ai_vqe_type = 1;
49 static HI_BOOL g_sample_audio_exit = HI_FALSE;
50
51 static AI_RECORDVQE_CONFIG_S g_ai_record_vqe_attr;
52 static AI_TALKVQEV2_CONFIG_S g_ai_talkv2_vqe_attr;
53
audio_wait_quit(int quitFd)54 static int audio_wait_quit(int quitFd)
55 {
56 eventfd_t eval;
57 int ret = eventfd_read(quitFd, &eval);
58 assert(ret == 0);
59
60 return 0;
61 }
62
63 /*
64 * 函数：PT Number到字符串转换
65 * function : PT Number to String
66 */
SAMPLE_AUDIO_Pt2Str(PAYLOAD_TYPE_E enType)67 static char *SAMPLE_AUDIO_Pt2Str(PAYLOAD_TYPE_E enType)
68 {
69 if (enType == PT_G711A) {
70 return "g711a";
71 } else if (enType == PT_G711U) {
72 return "g711u";
73 } else if (enType == PT_ADPCMA) {
74 return "adpcm";
75 } else if (enType == PT_G726) {
76 return "g726";
77 } else if (enType == PT_LPCM) {
78 return "pcm";
79 } else if (enType == PT_AAC) {
80 return "aac";
81 } else if (enType == PT_MP3) {
82 return "mp3";
83 } else {
84 return "data";
85 }
86 }
87
88 /*
89 * 函数：添加动态加载路径
90 * function : Add dynamic load path
91 */
92 #ifndef HI_VQE_USE_STATIC_MODULE_REGISTER
SAMPLE_AUDIO_AddLibPath(HI_VOID)93 static HI_VOID SAMPLE_AUDIO_AddLibPath(HI_VOID)
94 {
95 HI_S32 s32Ret;
96 HI_CHAR aszLibPath[FILE_NAME_LEN] = {0};
97 #if defined(__HuaweiLite__) && (!defined(__OHOS__))
98 s32Ret = snprintf_s(aszLibPath, FILE_NAME_LEN, FILE_NAME_LEN - 1, "/sharefs/");
99 if (s32Ret <= EOK) {
100 SAMPLE_PRT("\n snprintf_s fail! ret = 0x%x", s32Ret);
101 return;
102 }
103 #else
104 #endif
105 s32Ret = Audio_Dlpath(aszLibPath);
106 if (s32Ret != HI_SUCCESS) {
107 SAMPLE_PRT("%s: add lib path %s failed\n", __FUNCTION__, aszLibPath);
108 }
109 return;
110 }
111 #endif
112
113 /*
114 * 函数：打开Adec文件
115 * function : Open Adec File
116 */
SAMPLE_AUDIO_OpenAdecFile_AAC(int num,ADEC_CHN AdChn,PAYLOAD_TYPE_E enType)117 static FILE* SAMPLE_AUDIO_OpenAdecFile_AAC(int num, ADEC_CHN AdChn, PAYLOAD_TYPE_E enType)
118 {
119 FILE* pfd;
120 HI_CHAR aszFileName[FILE_NAME_LEN] = {0};
121
122 /*
123 * 创建文件为了保存流
124 * Create file for save stream
125 */
126 #ifdef __HuaweiLite__
127 if (snprintf_s(aszFileName, FILE_NAME_LEN, FILE_NAME_LEN - 1, "/sharefs/audio_chn%d.%s",
128 AdChn, SAMPLE_AUDIO_Pt2Str(enType)) < 0) {
129 HI_ASSERT(0);
130 }
131 #else
132 if (num == -1) {
133 if (snprintf_s(aszFileName, FILE_NAME_LEN, FILE_NAME_LEN - 1,
134 "audio_chn%d.%s", AdChn, SAMPLE_AUDIO_Pt2Str(enType)) < 0) {
135 HI_ASSERT(0);
136 }
137 } else {
138 SAMPLE_PRT("SAMPLE_AUDIO_OpenAdecFile_AAC\n");
139 SAMPLE_PRT("filename:%d.%s\n", num, SAMPLE_AUDIO_Pt2Str(enType));
140 if (snprintf_s(aszFileName, FILE_NAME_LEN, FILE_NAME_LEN - 1,
141 "/userdata/aac_file/%d.%s", num, SAMPLE_AUDIO_Pt2Str(enType)) < 0) {
142 HI_ASSERT(0);
143 }
144 }
145 #endif
146
147 pfd = fopen(aszFileName, "rb");
148 if (pfd == NULL) {
149 SAMPLE_PRT("%s: open file %s failed\n", __FUNCTION__, aszFileName);
150 return NULL;
151 }
152 SAMPLE_PRT("open stream file:\"%s\" for adec ok\n", aszFileName);
153 return pfd;
154 }
155
sample_audio_adec_ao_init_param(AIO_ATTR_S * attr)156 static hi_void sample_audio_adec_ao_init_param(AIO_ATTR_S *attr)
157 {
158 attr->enSamplerate = AUDIO_SAMPLE_RATE_48000;
159 attr->u32FrmNum = FPS_30;
160 attr->enBitwidth = AUDIO_BIT_WIDTH_16;
161 attr->enWorkmode = AIO_MODE_I2S_MASTER;
162 attr->enSoundmode = AUDIO_SOUND_MODE_STEREO;
163 attr->u32ChnCnt = 2; /* 2: chn num */
164 attr->u32ClkSel = 1;
165 attr->enI2sType = AIO_I2STYPE_INNERCODEC;
166 attr->u32PtNumPerFrm = AACLC_SAMPLES_PER_FRAME;
167 attr->u32EXFlag = 0;
168
169 gs_bAioReSample = HI_FALSE;
170 g_in_sample_rate = AUDIO_SAMPLE_RATE_BUTT;
171 g_out_sample_rate = AUDIO_SAMPLE_RATE_BUTT;
172 }
173
SAMPLE_AUDIO_AdecAoInner(HI_S32 num,HI_S32 fd,AUDIO_DEV AoDev,AO_CHN AoChn,ADEC_CHN AdChn)174 static HI_VOID SAMPLE_AUDIO_AdecAoInner(HI_S32 num, HI_S32 fd, AUDIO_DEV AoDev, AO_CHN AoChn, ADEC_CHN AdChn)
175 {
176 HI_S32 s32Ret;
177 FILE *pfd = NULL;
178
179 s32Ret = SAMPLE_COMM_AUDIO_AoBindAdec(AoDev, AoChn, AdChn);
180 if (s32Ret != HI_SUCCESS) {
181 SAMPLE_PRT(s32Ret);
182 return;
183 }
184
185 pfd = SAMPLE_AUDIO_OpenAdecFile_AAC(num, AdChn, gs_enPayloadType);
186 if (pfd == NULL) {
187 SAMPLE_PRT(HI_FAILURE);
188 SAMPLE_CHECK_EXPR_GOTO(pfd == NULL, ADECAO_ERR0,
189 "SAMPLE_AUDIO_OpenAdecFile_AAC FAIL, ret=%#x\n", s32Ret);
190 }
191
192 s32Ret = SAMPLE_COMM_AUDIO_CreateTrdFileAdec(AdChn, pfd);
193 if (s32Ret != HI_SUCCESS) {
194 fclose(pfd);
195 pfd = HI_NULL;
196 SAMPLE_PRT(s32Ret);
197 SAMPLE_CHECK_EXPR_GOTO(s32Ret != HI_SUCCESS, ADECAO_ERR0,
198 "SAMPLE_COMM_AUDIO_CreateTrdFileAdec FAIL, ret=%#x\n", s32Ret);
199 }
200
201 printf("bind adec:%d to ao(%d,%d) ok \n", AdChn, AoDev, AoChn);
202
203 if (num == -1) {
204 audio_wait_quit(fd);
205 } else {
206 sleep(3); // 3: sleep time
207 }
208
209 s32Ret = SAMPLE_COMM_AUDIO_DestroyTrdFileAdec(AdChn);
210 if (s32Ret != HI_SUCCESS) {
211 SAMPLE_PRT(s32Ret);
212 return;
213 }
214
215 ADECAO_ERR0:
216 s32Ret = SAMPLE_COMM_AUDIO_AoUnbindAdec(AoDev, AoChn, AdChn);
217 if (s32Ret != HI_SUCCESS) {
218 SAMPLE_PRT(s32Ret);
219 }
220
221 return;
222 }
223
224 /*
225 * 函数：文件 —> 音频解码 -> 音频输出
226 * function : file -> Adec -> Ao
227 */
SAMPLE_AUDIO_AdecAo(HI_S32 num,HI_S32 quitFd)228 static HI_S32 SAMPLE_AUDIO_AdecAo(HI_S32 num, HI_S32 quitFd)
229 {
230 HI_S32 s32Ret, s32AoChnCnt;
231 const AO_CHN AoChn = 0;
232 const ADEC_CHN AdChn = 0;
233 AIO_ATTR_S stAioAttr;
234 AUDIO_DEV AoDev = SAMPLE_AUDIO_INNER_AO_DEV;
235
236 sample_audio_adec_ao_init_param(&stAioAttr);
237
238 s32Ret = SAMPLE_COMM_AUDIO_StartAdec(AdChn, gs_enPayloadType);
239 SAMPLE_CHECK_EXPR_GOTO(s32Ret != HI_SUCCESS, ADECAO_ERR3,
240 "SAMPLE_COMM_AUDIO_StartAdec FAIL, ret=%#x\n", s32Ret);
241
242 s32AoChnCnt = stAioAttr.u32ChnCnt;
243 s32Ret = SAMPLE_COMM_AUDIO_StartAo(AoDev, s32AoChnCnt, &stAioAttr, g_in_sample_rate, gs_bAioReSample);
244 SAMPLE_CHECK_EXPR_GOTO(s32Ret != HI_SUCCESS, ADECAO_ERR2,
245 "SAMPLE_COMM_AUDIO_StartAo FAIL, ret=%#x\n", s32Ret);
246
247 s32Ret = SAMPLE_COMM_AUDIO_CfgAcodec(&stAioAttr);
248 SAMPLE_CHECK_EXPR_GOTO(s32Ret != HI_SUCCESS, ADECAO_ERR1,
249 "SAMPLE_COMM_AUDIO_CfgAcodec FAIL, ret=%#x\n", s32Ret);
250
251 SAMPLE_AUDIO_AdecAoInner(num, quitFd, AoDev, AoChn, AdChn);
252
253 ADECAO_ERR1:
254 s32Ret = SAMPLE_COMM_AUDIO_StopAo(AoDev, s32AoChnCnt, gs_bAioReSample);
255 if (s32Ret != HI_SUCCESS) {
256 SAMPLE_PRT(s32Ret);
257 }
258 ADECAO_ERR2:
259 s32Ret = SAMPLE_COMM_AUDIO_StopAdec(AdChn);
260 if (s32Ret != HI_SUCCESS) {
261 SAMPLE_PRT(s32Ret);
262 }
263
264 ADECAO_ERR3:
265 return s32Ret;
266 }
267
SAMPLE_AUDIO_StartAdecAo(HI_BOOL bSendAdec,AUDIO_DEV AoDev,AENC_CHN AeChn,AIO_ATTR_S * pstAioAttr)268 static HI_VOID SAMPLE_AUDIO_StartAdecAo(HI_BOOL bSendAdec, AUDIO_DEV AoDev, AENC_CHN AeChn, AIO_ATTR_S *pstAioAttr)
269 {
270 HI_S32 s32Ret, s32AoChnCnt;
271 const AO_CHN AoChn = 0;
272 const ADEC_CHN AdChn = 0;
273 FILE *pfd = NULL;
274
275 if (bSendAdec == HI_TRUE) {
276 s32Ret = SAMPLE_COMM_AUDIO_StartAdec(AdChn, gs_enPayloadType);
277 if (s32Ret != HI_SUCCESS) {
278 return;
279 }
280
281 s32AoChnCnt = pstAioAttr->u32ChnCnt;
282 s32Ret = SAMPLE_COMM_AUDIO_StartAo(AoDev, s32AoChnCnt, pstAioAttr, g_in_sample_rate, gs_bAioReSample);
283 SAMPLE_CHECK_EXPR_GOTO(s32Ret != HI_SUCCESS, STOP_ADEC,
284 "SAMPLE_COMM_AUDIO_StartAo FAIL. s32Ret: 0x%x\n", s32Ret);
285
286 pfd = SAMPLE_AUDIO_OpenAencFile(AdChn, gs_enPayloadType);
287 SAMPLE_CHECK_EXPR_GOTO(pfd == NULL, STOP_AO, "SAMPLE_AUDIO_OpenAencFile FAIL. s32Ret: 0x%x\n", s32Ret);
288
289 s32Ret = SAMPLE_COMM_AUDIO_CreateTrdAencAdec(AeChn, AdChn, pfd);
290 if (s32Ret != HI_SUCCESS) {
291 fclose(pfd);
292 pfd = HI_NULL;
293 SAMPLE_PRT(s32Ret);
294 SAMPLE_CHECK_EXPR_GOTO(s32Ret != HI_SUCCESS, STOP_AO,
295 "SAMPLE_COMM_AUDIO_CreateTrdAencAdec FAIL. s32Ret: 0x%x\n", s32Ret);
296 }
297
298 s32Ret = SAMPLE_COMM_AUDIO_AoBindAdec(AoDev, AoChn, AdChn);
299 if (s32Ret != HI_SUCCESS) {
300 SAMPLE_PRT(s32Ret);
301 SAMPLE_CHECK_EXPR_GOTO(s32Ret != HI_SUCCESS, DESTORY_AENC_THREAD,
302 "SAMPLE_COMM_AUDIO_AoBindAdec FAIL. s32Ret: 0x%x\n", s32Ret);
303 }
304
305 SAMPLE_PRT("bind adec:%d to ao(%d,%d) ok \n", AdChn, AoDev, AoChn);
306 }
307
308 if (bSendAdec == HI_TRUE) {
309 s32Ret = SAMPLE_COMM_AUDIO_AoUnbindAdec(AoDev, AoChn, AdChn);
310 if (s32Ret != HI_SUCCESS) {
311 SAMPLE_PRT(s32Ret);
312 }
313
314 DESTORY_AENC_THREAD:
315 (HI_VOID)SAMPLE_COMM_AUDIO_DestroyTrdAencAdec(AdChn);
316
317 STOP_AO:
318 (HI_VOID)SAMPLE_COMM_AUDIO_StopAo(AoDev, s32AoChnCnt, gs_bAioReSample);
319
320 STOP_ADEC:
321 (HI_VOID)SAMPLE_COMM_AUDIO_StopAdec(AdChn);
322 }
323 }
324
sample_audio_ai_ao_init_param(AIO_ATTR_S * attr)325 static hi_void sample_audio_ai_ao_init_param(AIO_ATTR_S *attr)
326 {
327 attr->enSamplerate = AUDIO_SAMPLE_RATE_48000;
328 attr->enBitwidth = AUDIO_BIT_WIDTH_16;
329 attr->enWorkmode = AIO_MODE_I2S_MASTER;
330 attr->enSoundmode = AUDIO_SOUND_MODE_STEREO;
331 attr->u32EXFlag = 0;
332 attr->u32FrmNum = FPS_30;
333 attr->u32PtNumPerFrm = AACLC_SAMPLES_PER_FRAME;
334 attr->u32ChnCnt = 2; /* 2: chn num */
335 attr->u32ClkSel = 1;
336 attr->enI2sType = AIO_I2STYPE_INNERCODEC;
337
338 gs_bAioReSample = HI_FALSE;
339 /*
340 * 如果需要，配置ao resample
341 * Config ao resample attr if needed
342 */
343 if (gs_bAioReSample == HI_TRUE) {
344 g_out_sample_rate = AUDIO_SAMPLE_RATE_32000; // ai 48k -> 32k
345 g_in_sample_rate = AUDIO_SAMPLE_RATE_32000; // ao 32k -> 48k
346 } else {
347 g_in_sample_rate = AUDIO_SAMPLE_RATE_BUTT;
348 g_out_sample_rate = AUDIO_SAMPLE_RATE_BUTT;
349 }
350
351 gs_bUserGetMode = (gs_bAioReSample == HI_TRUE) ? HI_TRUE : HI_FALSE;
352 }
353
SAMPLE_AUDIO_AiAoInner(AUDIO_DEV AiDev,AI_CHN AiChn,AUDIO_DEV AoDev,AO_CHN AoChn)354 static HI_VOID SAMPLE_AUDIO_AiAoInner(AUDIO_DEV AiDev, AI_CHN AiChn, AUDIO_DEV AoDev, AO_CHN AoChn)
355 {
356 HI_S32 s32Ret;
357
358 /*
359 * 绑定AI到AO通道
360 * Bind AI to AO channel
361 */
362 if (gs_bUserGetMode == HI_TRUE) {
363 s32Ret = SAMPLE_COMM_AUDIO_CreateTrdAiAo(AiDev, AiChn, AoDev, AoChn);
364 if (s32Ret != HI_SUCCESS) {
365 SAMPLE_PRT(s32Ret);
366 return;
367 }
368 } else {
369 s32Ret = SAMPLE_COMM_AUDIO_AoBindAi(AiDev, AiChn, AoDev, AoChn);
370 if (s32Ret != HI_SUCCESS) {
371 SAMPLE_PRT(s32Ret);
372 return;
373 }
374 }
375 SAMPLE_PRT("ai(%d,%d) bind to ao(%d,%d) ok\n", AiDev, AiChn, AoDev, AoChn);
376
377 if (gs_bAoVolumeCtrl == HI_TRUE) {
378 s32Ret = SAMPLE_COMM_AUDIO_CreateTrdAoVolCtrl(AoDev);
379 if (s32Ret != HI_SUCCESS) {
380 SAMPLE_PRT(s32Ret);
381 SAMPLE_CHECK_EXPR_GOTO(s32Ret != HI_SUCCESS, AIAO_ERR0,
382 "SAMPLE_COMM_AUDIO_CreateTrdAoVolCtrl FAIL. s32Ret: 0x%x\n", s32Ret);
383 }
384 }
385
386 if (gs_bAoVolumeCtrl == HI_TRUE) {
387 s32Ret = SAMPLE_COMM_AUDIO_DestroyTrdAoVolCtrl(AoDev);
388 if (s32Ret != HI_SUCCESS) {
389 SAMPLE_PRT(s32Ret);
390 return;
391 }
392 }
393
394 AIAO_ERR0:
395 if (gs_bUserGetMode == HI_TRUE) {
396 s32Ret = SAMPLE_COMM_AUDIO_DestroyTrdAi(AiDev, AiChn);
397 if (s32Ret != HI_SUCCESS) {
398 SAMPLE_PRT(s32Ret);
399 }
400 } else {
401 s32Ret = SAMPLE_COMM_AUDIO_AoUnbindAi(AiDev, AiChn, AoDev, AoChn);
402 if (s32Ret != HI_SUCCESS) {
403 SAMPLE_PRT(s32Ret);
404 }
405 }
406
407 return;
408 }
409
410 /*
411 * 函数：音频输入到音频输出
412 * function : Ai -> Ao
413 */
SAMPLE_AUDIO_AiAo(HI_VOID)414 static HI_S32 SAMPLE_AUDIO_AiAo(HI_VOID)
415 {
416 HI_S32 s32Ret;
417 HI_S32 s32AiChnCnt;
418 HI_S32 s32AoChnCnt;
419 const AI_CHN AiChn = 0;
420 const AO_CHN AoChn = 0;
421 AIO_ATTR_S stAioAttr;
422 AUDIO_DEV AiDev = SAMPLE_AUDIO_INNER_AI_DEV;
423 AUDIO_DEV AoDev = SAMPLE_AUDIO_INNER_AO_DEV;
424
425 sample_audio_ai_ao_init_param(&stAioAttr);
426
427 /*
428 * 启用AI通道
429 * Enable AI channel
430 */
431 s32AiChnCnt = stAioAttr.u32ChnCnt;
432 s32Ret = SAMPLE_COMM_AUDIO_StartAi(AiDev, s32AiChnCnt, &stAioAttr, g_out_sample_rate, gs_bAioReSample, NULL, 0);
433 if (s32Ret != HI_SUCCESS) {
434 SAMPLE_PRT(s32Ret);
435 SAMPLE_CHECK_EXPR_GOTO(s32Ret != HI_SUCCESS, AIAO_ERR3,
436 "SAMPLE_COMM_AUDIO_StartAi FAIL. s32Ret: 0x%x\n", s32Ret);
437 }
438
439 /*
440 * 启动AO通道
441 * Enable AO channel
442 */
443 s32AoChnCnt = stAioAttr.u32ChnCnt;
444 s32Ret = SAMPLE_COMM_AUDIO_StartAo(AoDev, s32AoChnCnt, &stAioAttr, g_in_sample_rate, gs_bAioReSample);
445 if (s32Ret != HI_SUCCESS) {
446 SAMPLE_PRT(s32Ret);
447 SAMPLE_CHECK_EXPR_GOTO(s32Ret != HI_SUCCESS, AIAO_ERR2,
448 "SAMPLE_COMM_AUDIO_StartAo FAIL. s32Ret: 0x%x\n", s32Ret);
449 }
450
451 /*
452 * 配置内置的acodec
453 * Config internal audio codec
454 */
455 s32Ret = SAMPLE_COMM_AUDIO_CfgAcodec(&stAioAttr);
456 SAMPLE_CHECK_EXPR_GOTO(s32Ret != HI_SUCCESS, AIAO_ERR1,
457 "SAMPLE_COMM_AUDIO_CfgAcodec FAIL. s32Ret: 0x%x\n", s32Ret);
458
459 SAMPLE_AUDIO_AiAoInner(AiDev, AiChn, AoDev, AoChn);
460
461 AIAO_ERR1:
462 s32Ret = SAMPLE_COMM_AUDIO_StopAo(AoDev, s32AoChnCnt, gs_bAioReSample);
463 if (s32Ret != HI_SUCCESS) {
464 SAMPLE_PRT(s32Ret);
465 }
466
467 AIAO_ERR2:
468 s32Ret = SAMPLE_COMM_AUDIO_StopAi(AiDev, s32AiChnCnt, gs_bAioReSample, HI_FALSE);
469 if (s32Ret != HI_SUCCESS) {
470 SAMPLE_PRT(s32Ret);
471 }
472
473 AIAO_ERR3:
474 return s32Ret;
475 }
476
477 /*
478 * 函数：主入口
479 * function : main()
480 */
AudioTest(HI_U32 num,HI_S32 quitFd)481 HI_S32 AudioTest(HI_U32 num, HI_S32 quitFd)
482 {
483 HI_S32 s32Ret = HI_SUCCESS;
484 SAMPLE_AUDIO_AddLibPath();
485
486 HI_MPI_AENC_AacInit();
487 HI_MPI_ADEC_AacInit();
488 SAMPLE_AUDIO_AdecAo(num, quitFd);
489
490 HI_MPI_AENC_AacDeInit();
491 HI_MPI_ADEC_AacDeInit();
492
493 return s32Ret;
494 }