1 /******************************************************************************
2 * *
3 * Copyright (C) 2018 The Android Open Source Project
4 *
5 * Licensed under the Apache License, Version 2.0 (the "License");
6 * you may not use this file except in compliance with the License.
7 * You may obtain a copy of the License at:
8 *
9 * http://www.apache.org/licenses/LICENSE-2.0
10 *
11 * Unless required by applicable law or agreed to in writing, software
12 * distributed under the License is distributed on an "AS IS" BASIS,
13 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14 * See the License for the specific language governing permissions and
15 * limitations under the License.
16 *
17 *****************************************************************************
18 * Originally developed and contributed by Ittiam Systems Pvt. Ltd, Bangalore
19 */
20 #include <string.h>
21 #include <stdlib.h>
22 #include <stdio.h>
23
24 #define AOSP_CHANGE
25
26 #include "ixheaacd_fileifc.h"
27 #include <ixheaacd_type_def.h>
28 #include "ixheaacd_error_standards.h"
29 #include "ixheaacd_error_handler.h"
30 #include "ixheaacd_apicmd_standards.h"
31 #include "ixheaacd_memory_standards.h"
32 #include "ixheaacd_aac_config.h"
33 #include "ixheaacd_metadata_read.h"
34 #include "impd_drc_config_params.h"
35
36 IA_ERRORCODE ixheaacd_dec_api(pVOID p_ia_module_obj, WORD32 i_cmd, WORD32 i_idx,
37 pVOID pv_value);
38
39 IA_ERRORCODE ia_drc_dec_api(pVOID p_ia_module_obj, WORD32 i_cmd, WORD32 i_idx,
40 pVOID pv_value);
41
42 VOID ixheaacd_error_handler_init();
43 VOID ia_testbench_error_handler_init();
44
45 extern ia_error_info_struct ixheaacd_ia_testbench_error_info;
46 extern ia_error_info_struct ixheaacd_error_info;
47
48 /*****************************************************************************/
49 /* Process select hash defines */
50 /*****************************************************************************/
51 #define WAV_HEADER
52 #define DISPLAY_MESSAGE
53
54 /*****************************************************************************/
55 /* Constant hash defines */
56 /*****************************************************************************/
57 #define MAX_STACK_PROC 10
58 #define MAX_MEM_ALLOCS 100
59 #define IA_MAX_CMD_LINE_LENGTH 300
60 #define IA_MAX_ARGS 20
61 #define IA_SCREEN_WIDTH 80
62 #define PARAMFILE "paramfilesimple.txt"
63
64 /*****************************************************************************/
65 /* Error codes for the testbench */
66 /*****************************************************************************/
67 #define IA_TESTBENCH_MFMAN_FATAL_MEM_ALLOC_FAILED 0xFFFF8000
68 #define IA_TESTBENCH_MFMAN_FATAL_FILE_OPEN_FAILED 0xFFFF8001
69
70 #define IA_HE_AAC_DEC_TABLE_RELOCATABLE_ENABLE 0
71
72 #ifdef ARM_PROFILE_HW
73 #include <sys/time.h>
74 #define CLK_FREQ_BOARD_MHZ 716 // a9 omap4430 board
75 //#define CLK_FREQ_BOARD_MHZ 1555 //Nexus6P
76 //#define CLK_FREQ_BOARD_MHZ 2035 //Tegra Board
77 //#define CLK_FREQ_BOARD_MHZ 550 //a8 board
78 //#define CLK_FREQ_BOARD_MHZ 297 //dm365 board
79 //#define CLK_FREQ_BOARD_MHZ 1209.6 //a5 board
80 #endif
81 #ifdef ARM_PROFILE_HW
itGetMs(void)82 long long itGetMs(void) {
83 struct timeval t;
84 long long currTime;
85
86 if (gettimeofday(&t, NULL) == -1) {
87 printf("Error in gettimeofday. It has returned -1. \n");
88 }
89 currTime = ((t.tv_sec * 1000 * 1000) + (t.tv_usec));
90 return currTime;
91 }
92 #endif
93 /*****************************************************************************/
94 /* Global variables */
95 /*****************************************************************************/
96 pVOID g_pv_arr_alloc_memory[MAX_MEM_ALLOCS];
97 WORD g_w_malloc_count;
98 FILE *g_pf_out;
99 FileWrapperPtr g_pf_inp; /* file pointer to bitstream file (mp4) */
100
101 FILE *g_pf_interface;
102 WORD32 interface_file_present = 0;
103
104 metadata_info meta_info; // metadata pointer;
105 WORD32 ixheaacd_i_bytes_to_read;
106 FILE *g_pf_meta;
107
108 WORD32 raw_testing = 0;
109 WORD32 eld_testing = 0;
110
111 #define _IA_PRINT_ERROR(p_mod_err_info, context, e) \
112 if ((e) != IA_NO_ERROR) { \
113 ixheaacd_error_handler((p_mod_err_info), (context), (e)); \
114 }
115
116 #ifndef WIN32
ia_fwrite(pVOID buffer[],int size,int nwords,FILE * fp)117 int ia_fwrite(pVOID buffer[], int size, int nwords, FILE *fp) {
118 int i, j;
119 pWORD8 pb_buf = (pWORD8)buffer;
120
121 for (i = 0; i < nwords; i++) {
122 for (j = 0; j < size; j++) {
123 putc(pb_buf[i * size + j], fp);
124 }
125 }
126 return 1;
127 }
128
129 #endif
130
131 #ifdef WAV_HEADER
132 #ifndef ARM_PROFILE_BOARD
133 /*****************************************************************************/
134 /* */
135 /* Function name : ixheaacd_write16_bits_lh */
136 /* */
137 /* Description : write 16 bits low high (always little endian) */
138 /* */
139 /* Inputs : none */
140 /* */
141 /* Globals : pVOID g_pv_arr_alloc_memory[MAX_MEM_ALLOCS]; */
142 /* WORD g_w_malloc_count; */
143 /* FILE *g_pf_inp, *g_pf_out; */
144 /* */
145 /* Processing : write 16 bits low high (always little endian) */
146 /* */
147 /* Outputs : none */
148 /* */
149 /* Returns : none */
150 /* */
151 /* Issues : none */
152 /* */
153 /* Revision history : */
154 /* */
155 /* DD MM YYYY Author Changes */
156 /* 29 07 2005 Ittiam Created */
157 /* */
158 /*****************************************************************************/
159
ixheaacd_write16_bits_lh(FILE * fp,WORD32 i)160 static VOID ixheaacd_write16_bits_lh(FILE *fp, WORD32 i) {
161 putc(i & 0xff, fp);
162 putc((i >> 8) & 0xff, fp);
163 }
164
165 /*****************************************************************************/
166 /* */
167 /* Function name : ixheaacd_write32_bits_lh */
168 /* */
169 /* Description : write 32 bits low high (always little endian) */
170 /* */
171 /* Inputs : none */
172 /* */
173 /* Globals : FILE* fp (file to write) */
174 /* WORD32 i (value to write) */
175 /* */
176 /* Processing : write 32 bits low high (always little endian) */
177 /* */
178 /* Outputs : none */
179 /* */
180 /* Returns : none */
181 /* */
182 /* Issues : none */
183 /* */
184 /* Revision history : */
185 /* */
186 /* DD MM YYYY Author Changes */
187 /* 29 07 2005 Ittiam Created */
188 /* */
189 /*****************************************************************************/
190
ixheaacd_write32_bits_lh(FILE * fp,WORD32 i)191 static VOID ixheaacd_write32_bits_lh(FILE *fp, WORD32 i) {
192 ixheaacd_write16_bits_lh(fp, (WORD32)(i & 0xffffL));
193 ixheaacd_write16_bits_lh(fp, (WORD32)((i >> 16) & 0xffffL));
194 }
195
196 /*****************************************************************************/
197 /* */
198 /* Function name : write_wav_header */
199 /* */
200 /* Description : Write wav header to a wav file */
201 /* */
202 /* Inputs : none */
203 /* */
204 /* Globals : FILE* fp (file to write) */
205 /* WORD32 pcmbytes (total bytes in wav file) */
206 /* WORD32 freq (sampling freq) */
207 /* WORD32 channels (output channels) */
208 /* WORD32 bits (bits per sample) */
209 /* */
210 /* Processing : Write wav header */
211 /* */
212 /* Outputs : none */
213 /* */
214 /* Returns : none */
215 /* */
216 /* Issues : none */
217 /* */
218 /* Revision history : */
219 /* */
220 /* DD MM YYYY Author Changes */
221 /* 29 07 2005 Ittiam Created */
222 /* */
223 /*****************************************************************************/
224
write_wav_header(FILE * fp,WORD32 pcmbytes,WORD32 freq,WORD32 channels,WORD32 bits,WORD32 i_channel_mask)225 WORD32 write_wav_header(FILE *fp, WORD32 pcmbytes, WORD32 freq, WORD32 channels,
226 WORD32 bits, WORD32 i_channel_mask) {
227 if (channels > 2) {
228 WORD32 bytes = (bits + 7) / 8;
229 fwrite("RIFF", 1, 4, fp); /* label */
230 ixheaacd_write32_bits_lh(
231 fp, pcmbytes + 44 - 8); /* length in bytes without header */
232 fwrite("WAVEfmt ", 2, 4, fp); /* 2 labels */
233 /* tag for WAVE_FORMAT_EXTENSIBLE */
234 if (channels > 2) {
235 ixheaacd_write16_bits_lh(fp, 0x28);
236 ixheaacd_write16_bits_lh(fp, 0x00);
237 ixheaacd_write16_bits_lh(fp, 0xfffe);
238 } else {
239 ixheaacd_write32_bits_lh(
240 fp, 2 + 2 + 4 + 4 + 2 + 2); /* length of PCM format decl area */
241 ixheaacd_write16_bits_lh(fp, 1); /* is pcm? */
242 }
243
244 ixheaacd_write16_bits_lh(fp, channels);
245 ixheaacd_write32_bits_lh(fp, freq);
246 ixheaacd_write32_bits_lh(fp, freq * channels * bytes); /* bps */
247 ixheaacd_write16_bits_lh(fp, channels * bytes);
248 ixheaacd_write16_bits_lh(fp, bits);
249
250 /* tag for WAVE_FORMAT_EXTENSIBLE */
251 if (channels > 2) {
252 ixheaacd_write16_bits_lh(fp, 0x16);
253 ixheaacd_write16_bits_lh(fp, 0x10); /*Samples.wReserved*/
254 ixheaacd_write32_bits_lh(fp, i_channel_mask); /* dwChannelMask */
255
256 ixheaacd_write32_bits_lh(fp, 0x0001); /* SubFormat.Data1 */
257 ixheaacd_write32_bits_lh(
258 fp, 0x00100000); /* SubFormat.Data2 and SubFormat.Data3 */
259
260 ixheaacd_write16_bits_lh(fp, 0x0080);
261 ixheaacd_write16_bits_lh(fp, 0xAA00);
262
263 ixheaacd_write16_bits_lh(fp, 0x3800);
264 ixheaacd_write16_bits_lh(fp, 0x719b);
265 }
266
267 fwrite("data", 1, 4, fp);
268 ixheaacd_write32_bits_lh(fp, pcmbytes);
269
270 return (ferror(fp) ? -1 : 0);
271
272 } else {
273 WORD32 bytes = (bits + 7) / 8;
274 fwrite("RIFF", 1, 4, fp); /* label */
275 ixheaacd_write32_bits_lh(
276 fp, pcmbytes + 44 - 8); /* length in bytes without header */
277 fwrite("WAVEfmt ", 2, 4, fp); /* 2 labels */
278 ixheaacd_write32_bits_lh(
279 fp, 2 + 2 + 4 + 4 + 2 + 2); /* length of PCM format decl area */
280 ixheaacd_write16_bits_lh(fp, 1); /* is pcm? */
281 ixheaacd_write16_bits_lh(fp, channels);
282 ixheaacd_write32_bits_lh(fp, freq);
283 ixheaacd_write32_bits_lh(fp, freq * channels * bytes); /* bps */
284 ixheaacd_write16_bits_lh(fp, channels * bytes);
285 ixheaacd_write16_bits_lh(fp, bits);
286 fwrite("data", 1, 4, fp);
287 ixheaacd_write32_bits_lh(fp, pcmbytes);
288
289 return (ferror(fp) ? -1 : 0);
290 }
291 }
292 #endif /* WAV_HEADER */
293 #endif /*ARM_PROFILE_BOARD*/
294
295 #ifdef DISPLAY_MESSAGE
296
297 /*****************************************************************************/
298 /* */
299 /* Function name : ia_display_id_message */
300 /* */
301 /* Description : Display the ID message of the process */
302 /* */
303 /* Inputs : WORD8 lib_name[] (library name) */
304 /* WORD8 lib_version[] (library version) */
305 /* WORD8 api_version[] (API version) */
306 /* */
307 /* Globals : none */
308 /* */
309 /* Processing : Display all the information about the process */
310 /* */
311 /* Outputs : none */
312 /* */
313 /* Returns : none */
314 /* */
315 /* Issues : none */
316 /* */
317 /* Revision history : */
318 /* */
319 /* DD MM YYYY Author Changes */
320 /* 29 07 2005 Tejaswi/Vishal Created */
321 /* */
322 /*****************************************************************************/
323
ia_display_id_message(WORD8 lib_name[],WORD8 lib_version[])324 VOID ia_display_id_message(WORD8 lib_name[], WORD8 lib_version[]) {
325 WORD8 str[4][IA_SCREEN_WIDTH] = {"ITTIAM SYSTEMS PVT LTD, BANGALORE\n",
326 "http:\\\\www.ittiam.com\n", "", ""};
327 WORD8 spaces[IA_SCREEN_WIDTH / 2 + 1];
328 WORD32 i, spclen;
329
330 strcpy((pCHAR8)str[2], (pCHAR8)lib_name);
331 strcat((pCHAR8)str[2], (pCHAR8)lib_version);
332 strcat((pCHAR8)str[2], "\n");
333 strcat((pCHAR8)str[4 - 1], "\n");
334
335 for (i = 0; i < IA_SCREEN_WIDTH / 2 + 1; i++) {
336 spaces[i] = ' ';
337 }
338
339 for (i = 0; i < 4; i++) {
340 spclen = IA_SCREEN_WIDTH / 2 - strlen((pCHAR8)str[i]) / 2;
341 spaces[spclen] = '\0';
342 printf("%s", (pCHAR8)spaces);
343 spaces[spclen] = ' ';
344 printf("%s", (pCHAR8)str[i]);
345 }
346 }
347 #endif /* DISPLAY_MESSAGE */
348
349 /*****************************************************************************/
350 /* */
351 /* Function name : ixheaacd_set_config_param */
352 /* */
353 /* Description : Set config parameters */
354 /* */
355 /* Inputs : pVOID p_ia_process_api_obj (process API obj) */
356 /* WORD32 argc (Arguments count) */
357 /* pWORD8 argv[] (Argument strings) */
358 /* */
359 /* Globals : none */
360 /* */
361 /* Processing : Set config params inside API */
362 /* */
363 /* Outputs : none */
364 /* */
365 /* Returns : IA_ERRORCODE error_value (Error value) */
366 /* */
367 /* Issues : none */
368 /* */
369 /* Revision history : */
370 /* */
371 /* DD MM YYYY Author Changes */
372 /* 29 07 2005 Ittiam Created */
373 /* */
374 /*****************************************************************************/
375
ixheaacd_set_config_param(WORD32 argc,pWORD8 argv[],pVOID p_ia_process_api_obj)376 IA_ERRORCODE ixheaacd_set_config_param(WORD32 argc, pWORD8 argv[],
377 pVOID p_ia_process_api_obj) {
378 LOOPIDX i;
379 IA_ERRORCODE err_code = IA_NO_ERROR;
380 /* the process API function */
381 IA_ERRORCODE(*p_ia_process_api)
382 (pVOID p_ia_process_api_obj, WORD32 i_cmd, WORD32 i_idx, pVOID pv_value) =
383 ixheaacd_dec_api;
384 ia_error_info_struct *p_proc_err_info = &ixheaacd_error_info;
385
386 for (i = 0; i < argc; i++) {
387 /* PCM WORD Size (For single input file) */
388 if (!strncmp((pCHAR8)argv[i], "-pcmsz:", 7)) {
389 pCHAR8 pb_arg_val = (pCHAR8)(argv[i] + 7);
390 UWORD32 ui_pcm_wd_sz = atoi(pb_arg_val);
391 err_code = (*p_ia_process_api)(
392 p_ia_process_api_obj, IA_API_CMD_SET_CONFIG_PARAM,
393 IA_ENHAACPLUS_DEC_CONFIG_PARAM_PCM_WDSZ, &ui_pcm_wd_sz);
394 _IA_HANDLE_ERROR(p_proc_err_info, (pWORD8) "", err_code);
395 }
396 /* Down-mix stereo to mono. */
397 if (!strncmp((pCHAR8)argv[i], "-dmix:", 6)) {
398 pCHAR8 pb_arg_val = (pCHAR8)(argv[i] + 6);
399 UWORD32 ui_down_mix = atoi(pb_arg_val);
400 err_code = (*p_ia_process_api)(
401 p_ia_process_api_obj, IA_API_CMD_SET_CONFIG_PARAM,
402 IA_ENHAACPLUS_DEC_CONFIG_PARAM_DOWNMIX, &ui_down_mix);
403 _IA_HANDLE_ERROR(p_proc_err_info, (pWORD8) "", err_code);
404 }
405 #ifdef RESAMPLE_SUPPORT
406 /* Resample the output to 8 kHz. */
407 if (!strncmp((pCHAR8)argv[i], "-f08:", 5)) {
408 pCHAR8 pb_arg_val = (pCHAR8)(argv[i] + 5);
409 UWORD32 ui_08khz_out = atoi(pb_arg_val);
410 err_code = (*p_ia_process_api)(
411 p_ia_process_api_obj, IA_API_CMD_SET_CONFIG_PARAM,
412 IA_ENHAACPLUS_DEC_CONFIG_PARAM_OUT08KHZ, &ui_08khz_out);
413 _IA_HANDLE_ERROR(p_proc_err_info, (pWORD8) "", err_code);
414 }
415 /* Resample the output to 16 kHz. */
416 if (!strncmp((pCHAR8)argv[i], "-f16:", 5)) {
417 pCHAR8 pb_arg_val = (pCHAR8)(argv[i] + 5);
418 UWORD32 ui_16khz_out = atoi(pb_arg_val);
419 err_code = (*p_ia_process_api)(
420 p_ia_process_api_obj, IA_API_CMD_SET_CONFIG_PARAM,
421 IA_ENHAACPLUS_DEC_CONFIG_PARAM_OUT16KHZ, &ui_16khz_out);
422 _IA_HANDLE_ERROR(p_proc_err_info, (pWORD8) "", err_code);
423 }
424 #endif
425 /* Interleave mono output to stereo */
426 if (!strncmp((pCHAR8)argv[i], "-tostereo:", 10)) {
427 pCHAR8 pb_arg_val = (pCHAR8)(argv[i] + 10);
428 UWORD32 ui_to_stereo = atoi(pb_arg_val);
429 err_code = (*p_ia_process_api)(
430 p_ia_process_api_obj, IA_API_CMD_SET_CONFIG_PARAM,
431 IA_ENHAACPLUS_DEC_CONFIG_PARAM_TOSTEREO, &ui_to_stereo);
432 _IA_HANDLE_ERROR(p_proc_err_info, (pWORD8) "", err_code);
433 }
434 /* Downsampled synthesis to be used */
435 if (!strncmp((pCHAR8)argv[i], "-dsample:", 9)) {
436 pCHAR8 pb_arg_val = (pCHAR8)(argv[i] + 9);
437 UWORD32 ui_dsample = atoi(pb_arg_val);
438 err_code = (*p_ia_process_api)(
439 p_ia_process_api_obj, IA_API_CMD_SET_CONFIG_PARAM,
440 IA_ENHAACPLUS_DEC_CONFIG_PARAM_DSAMPLE, &ui_dsample);
441 _IA_HANDLE_ERROR(p_proc_err_info, (pWORD8) "", err_code);
442 }
443 /* To indicate if its a MP4 file or not. */
444 if (!strncmp((pCHAR8)argv[i], "-mp4:", 5)) {
445 pCHAR8 pb_arg_val = (pCHAR8)(argv[i] + 5);
446 UWORD32 ui_mp4_flag = atoi(pb_arg_val);
447 err_code = (*p_ia_process_api)(
448 p_ia_process_api_obj, IA_API_CMD_SET_CONFIG_PARAM,
449 IA_ENHAACPLUS_DEC_CONFIG_PARAM_ISMP4, &ui_mp4_flag);
450 _IA_HANDLE_ERROR(p_proc_err_info, (pWORD8) "", err_code);
451 }
452
453 #ifdef HEAACV2_AS_AACLC
454 /* To indicate if its a MP4 file or not. */
455 if (!strncmp((pCHAR8)argv[i], "-aac_lc_only:", 13)) {
456 pCHAR8 pb_arg_val = (pCHAR8)(argv[i] + 13);
457 UWORD32 ui_aac_lc_only = atoi(pb_arg_val);
458 err_code = (*p_ia_process_api)(
459 p_ia_process_api_obj, IA_API_CMD_SET_CONFIG_PARAM,
460 IA_ENHAACPLUS_DEC_CONFIG_PARAM_AAC_ONLY, &ui_aac_lc_only);
461 _IA_HANDLE_ERROR(p_proc_err_info, (pWORD8) "", err_code);
462 }
463 #endif
464
465 #ifdef LATM_LOAS
466 /* To indicate if its a LOAS file or not. */
467 if (!strncmp((pCHAR8)argv[i], "-isLOAS:", 8)) {
468 pCHAR8 pb_arg_val = (pCHAR8)(argv[i] + 8);
469 UWORD32 ui_loas_flag = atoi(pb_arg_val);
470 err_code = (*p_ia_process_api)(
471 p_ia_process_api_obj, IA_API_CMD_SET_CONFIG_PARAM,
472 IA_ENHAACPLUS_DEC_CONFIG_PARAM_ISLOAS, &ui_loas_flag);
473 _IA_HANDLE_ERROR(p_proc_err_info, (pWORD8) "", err_code);
474 }
475
476 #endif
477
478 #ifdef DRC_ENABLE
479 if (!strncmp((pCHAR8)argv[i], "-drc:", 5)) {
480 pCHAR8 pb_arg_val = (pCHAR8)(argv[i] + 5);
481 UWORD32 ui_drc_enable = atoi(pb_arg_val);
482 err_code = (*p_ia_process_api)(
483 p_ia_process_api_obj, IA_API_CMD_SET_CONFIG_PARAM,
484 IA_ENHAACPLUS_DEC_CONFIG_PARAM_DRC_ENABLE, &ui_drc_enable);
485 _IA_HANDLE_ERROR(p_proc_err_info, (pWORD8) "", err_code);
486 }
487 if (!strncmp((pCHAR8)argv[i], "-drc_cut_fac:", 13)) {
488 pCHAR8 pb_arg_val = (pCHAR8)(argv[i] + 13);
489 UWORD32 ui_drc_enable = atoi(pb_arg_val);
490 err_code = (*p_ia_process_api)(
491 p_ia_process_api_obj, IA_API_CMD_SET_CONFIG_PARAM,
492 IA_ENHAACPLUS_DEC_CONFIG_PARAM_DRC_CUT, &ui_drc_enable);
493 _IA_HANDLE_ERROR(p_proc_err_info, (pWORD8) "", err_code);
494 }
495 if (!strncmp((pCHAR8)argv[i], "-drc_boost_fac:", 15)) {
496 pCHAR8 pb_arg_val = (pCHAR8)(argv[i] + 15);
497 UWORD32 ui_drc_enable = atoi(pb_arg_val);
498 err_code = (*p_ia_process_api)(
499 p_ia_process_api_obj, IA_API_CMD_SET_CONFIG_PARAM,
500 IA_ENHAACPLUS_DEC_CONFIG_PARAM_DRC_BOOST, &ui_drc_enable);
501 _IA_HANDLE_ERROR(p_proc_err_info, (pWORD8) "", err_code);
502 }
503 if (!strncmp((pCHAR8)argv[i], "-drc_target_level:", 18)) {
504 pCHAR8 pb_arg_val = (pCHAR8)(argv[i] + 18);
505 UWORD32 ui_drc_enable = atoi(pb_arg_val);
506 err_code = (*p_ia_process_api)(
507 p_ia_process_api_obj, IA_API_CMD_SET_CONFIG_PARAM,
508 IA_ENHAACPLUS_DEC_CONFIG_PARAM_DRC_TARGET_LEVEL, &ui_drc_enable);
509 _IA_HANDLE_ERROR(p_proc_err_info, (pWORD8) "", err_code);
510 }
511 if (!strncmp((pCHAR8)argv[i], "-drc_heavy_comp:", 16)) {
512 pCHAR8 pb_arg_val = (pCHAR8)(argv[i] + 16);
513 UWORD32 ui_drc_enable = atoi(pb_arg_val);
514 err_code = (*p_ia_process_api)(
515 p_ia_process_api_obj, IA_API_CMD_SET_CONFIG_PARAM,
516 IA_ENHAACPLUS_DEC_CONFIG_PARAM_DRC_HEAVY_COMP, &ui_drc_enable);
517 _IA_HANDLE_ERROR(p_proc_err_info, (pWORD8) "", err_code);
518 }
519
520 #endif
521 /* To indicate if its a MP4 file or not. */
522 if (!strncmp((pCHAR8)argv[i], "-nosync:", 8)) {
523 pCHAR8 pb_arg_val = (pCHAR8)(argv[i] + 8);
524 UWORD32 ui_disable_sync = atoi(pb_arg_val);
525 err_code = (*p_ia_process_api)(
526 p_ia_process_api_obj, IA_API_CMD_SET_CONFIG_PARAM,
527 IA_ENHAACPLUS_DEC_CONFIG_PARAM_DISABLE_SYNC, &ui_disable_sync);
528 _IA_HANDLE_ERROR(p_proc_err_info, (pWORD8) "", err_code);
529 }
530 /* To indicate SBR upsampling. */
531 if (!strncmp((pCHAR8)argv[i], "-sbrup:", 7)) {
532 pCHAR8 pb_arg_val = (pCHAR8)(argv[i] + 7);
533 UWORD32 ui_auto_sbr_upsample = atoi(pb_arg_val);
534 err_code =
535 (*p_ia_process_api)(p_ia_process_api_obj, IA_API_CMD_SET_CONFIG_PARAM,
536 IA_ENHAACPLUS_DEC_CONFIG_PARAM_AUTO_SBR_UPSAMPLE,
537 &ui_auto_sbr_upsample);
538 _IA_HANDLE_ERROR(p_proc_err_info, (pWORD8) "", err_code);
539 }
540 /* To indicate sample rate for a RAW bit-stream. */
541 if (!strncmp((pCHAR8)argv[i], "-fs:", 4)) {
542 pCHAR8 pb_arg_val = (pCHAR8)(argv[i] + 4);
543 UWORD32 ui_samp_freq = atoi(pb_arg_val);
544 err_code = (*p_ia_process_api)(
545 p_ia_process_api_obj, IA_API_CMD_SET_CONFIG_PARAM,
546 IA_ENHAACPLUS_DEC_CONFIG_PARAM_SAMP_FREQ, &ui_samp_freq);
547 _IA_HANDLE_ERROR(p_proc_err_info, (pWORD8) "", err_code);
548 }
549 /* To indicate the number of maximum channels */
550 if (!strncmp((pCHAR8)argv[i], "-maxchannel:", 12)) {
551 pCHAR8 pb_arg_val = (pCHAR8)(argv[i] + 12);
552 UWORD32 ui_max_channel = atoi(pb_arg_val);
553 err_code = (*p_ia_process_api)(
554 p_ia_process_api_obj, IA_API_CMD_SET_CONFIG_PARAM,
555 IA_ENHAACPLUS_DEC_CONFIG_PARAM_MAX_CHANNEL, &ui_max_channel);
556 _IA_HANDLE_ERROR(p_proc_err_info, (pWORD8) "", err_code);
557 }
558
559 /* To indicate the number of coupling channels to be used for coupling */
560 if (!strncmp((pCHAR8)argv[i], "-coupchannel:", 13)) {
561 pCHAR8 pb_arg_val = (pCHAR8)(argv[i] + 13);
562 UWORD32 ui_coupling_channel = atoi(pb_arg_val);
563 err_code = (*p_ia_process_api)(
564 p_ia_process_api_obj, IA_API_CMD_SET_CONFIG_PARAM,
565 IA_ENHAACPLUS_DEC_CONFIG_PARAM_COUP_CHANNEL, &ui_coupling_channel);
566 _IA_HANDLE_ERROR(p_proc_err_info, (pWORD8) "", err_code);
567 }
568
569 /* Down-mix N.1 to stereo */
570 if (!strncmp((pCHAR8)argv[i], "-downmix:", 9)) {
571 pCHAR8 pb_arg_val = (pCHAR8)(argv[i] + 9);
572 UWORD32 ui_downmix = atoi(pb_arg_val);
573 err_code = (*p_ia_process_api)(
574 p_ia_process_api_obj, IA_API_CMD_SET_CONFIG_PARAM,
575 IA_ENHAACPLUS_DEC_CONFIG_PARAM_DOWNMIX_STEREO, &ui_downmix);
576 _IA_HANDLE_ERROR(p_proc_err_info, (pWORD8) "", err_code);
577 }
578
579 /* For LD files, to indicate */
580 if (!strncmp((pCHAR8)argv[i], "-fs480:", 7)) {
581 pCHAR8 pb_arg_val = (pCHAR8)(argv[i] + 7);
582 UWORD32 ui_fs480 = atoi(pb_arg_val);
583 err_code = (*p_ia_process_api)(
584 p_ia_process_api_obj, IA_API_CMD_SET_CONFIG_PARAM,
585 IA_ENHAACPLUS_DEC_CONFIG_PARAM_FRAMESIZE, &ui_fs480);
586 _IA_HANDLE_ERROR(p_proc_err_info, (pWORD8) "", err_code);
587 }
588
589 /*For MPEG-D DRC effect type*/
590 if (!strncmp((pCHAR8)argv[i], "-effect:", 8)) {
591 pCHAR8 pb_arg_val = (pCHAR8)(argv[i] + 8);
592 WORD32 ui_effect = atoi(pb_arg_val);
593 err_code = (*p_ia_process_api)(
594 p_ia_process_api_obj, IA_API_CMD_SET_CONFIG_PARAM,
595 IA_ENHAACPLUS_DEC_DRC_EFFECT_TYPE, &ui_effect);
596 _IA_HANDLE_ERROR(p_proc_err_info, (pWORD8) "", err_code);
597 }
598 /*For MPEG-D DRC target loudness*/
599 if (!strncmp((pCHAR8)argv[i], "-target_loudness:", 17)) {
600 pCHAR8 pb_arg_val = (pCHAR8)(argv[i] + 17);
601 WORD32 ui_target_loudness = atoi(pb_arg_val);
602 err_code = (*p_ia_process_api)(
603 p_ia_process_api_obj, IA_API_CMD_SET_CONFIG_PARAM,
604 IA_ENHAACPLUS_DEC_DRC_TARGET_LOUDNESS, &ui_target_loudness);
605 _IA_HANDLE_ERROR(p_proc_err_info, (pWORD8) "", err_code);
606 }
607 if (!strncmp((pCHAR8)argv[i], "-ld_testing:", 12)) {
608 pCHAR8 pb_arg_val = (pCHAR8)(argv[i] + 12);
609 UWORD32 ld_testing = atoi(pb_arg_val);
610 err_code = (*p_ia_process_api)(
611 p_ia_process_api_obj, IA_API_CMD_SET_CONFIG_PARAM,
612 IA_ENHAACPLUS_DEC_CONFIG_PARAM_LD_TESTING, &ld_testing);
613 _IA_HANDLE_ERROR(p_proc_err_info, (pWORD8) "", err_code);
614 }
615 }
616
617 return IA_NO_ERROR;
618 }
619
620 /*****************************************************************************/
621 /* */
622 /* Function name : ixheaacd_get_config_param */
623 /* */
624 /* Description : Get config parameters */
625 /* */
626 /* Inputs : pVOID p_ia_process_api_obj (process API obj) */
627 /* pWORD32 pi_samp_freq (Ptr for samp freq param) */
628 /* pWORD32 pi_num_chan (Ptr for num chan param) */
629 /* pWORD32 pi_pcm_wd_sz (Ptr for PCM WORD size param) */
630 /* */
631 /* Globals : none */
632 /* */
633 /* Processing : Get config params from API */
634 /* */
635 /* Outputs : none */
636 /* */
637 /* Returns : IA_ERRORCODE error_value (Error value) */
638 /* */
639 /* Issues : none */
640 /* */
641 /* Revision history : */
642 /* */
643 /* DD MM YYYY Author Changes */
644 /* 29 07 2005 Ittiam Created */
645 /* */
646 /*****************************************************************************/
647
ixheaacd_get_config_param(pVOID p_ia_process_api_obj,pWORD32 pi_samp_freq,pWORD32 pi_num_chan,pWORD32 pi_pcm_wd_sz,pWORD32 pi_channel_mask)648 IA_ERRORCODE ixheaacd_get_config_param(pVOID p_ia_process_api_obj,
649 pWORD32 pi_samp_freq,
650 pWORD32 pi_num_chan,
651 pWORD32 pi_pcm_wd_sz,
652 pWORD32 pi_channel_mask) {
653 IA_ERRORCODE err_code = IA_NO_ERROR;
654 /* the process API function */
655 IA_ERRORCODE(*p_ia_process_api)
656 (pVOID p_ia_process_api_obj, WORD32 i_cmd, WORD32 i_idx, pVOID pv_value) =
657 ixheaacd_dec_api;
658 ia_error_info_struct *p_proc_err_info = &ixheaacd_error_info;
659
660 /* Sampling frequency */
661 {
662 err_code = (*p_ia_process_api)(
663 p_ia_process_api_obj, IA_API_CMD_GET_CONFIG_PARAM,
664 IA_ENHAACPLUS_DEC_CONFIG_PARAM_SAMP_FREQ, pi_samp_freq);
665 _IA_HANDLE_ERROR(p_proc_err_info, (pWORD8) "", err_code);
666 }
667 /* Total Number of Channels */
668 {
669 err_code = (*p_ia_process_api)(
670 p_ia_process_api_obj, IA_API_CMD_GET_CONFIG_PARAM,
671 IA_ENHAACPLUS_DEC_CONFIG_PARAM_NUM_CHANNELS, pi_num_chan);
672 _IA_HANDLE_ERROR(p_proc_err_info, (pWORD8) "", err_code);
673 }
674 /* PCM word size */
675 {
676 err_code = (*p_ia_process_api)(
677 p_ia_process_api_obj, IA_API_CMD_GET_CONFIG_PARAM,
678 IA_ENHAACPLUS_DEC_CONFIG_PARAM_PCM_WDSZ, pi_pcm_wd_sz);
679 _IA_HANDLE_ERROR(p_proc_err_info, (pWORD8) "", err_code);
680 }
681 /* channel mask to tell the arrangement of channels in bit stream */
682 {
683 err_code = (*p_ia_process_api)(
684 p_ia_process_api_obj, IA_API_CMD_GET_CONFIG_PARAM,
685 IA_ENHAACPLUS_DEC_CONFIG_PARAM_CHANNEL_MASK, pi_channel_mask);
686 _IA_HANDLE_ERROR(p_proc_err_info, (pWORD8) "", err_code);
687 }
688
689 /* Channel mode to tell MONO/STEREO/DUAL-MONO/NONE_OF_THESE */
690 {
691 UWORD32 ui_channel_mode;
692 err_code = (*p_ia_process_api)(
693 p_ia_process_api_obj, IA_API_CMD_GET_CONFIG_PARAM,
694 IA_ENHAACPLUS_DEC_CONFIG_PARAM_CHANNEL_MODE, &ui_channel_mode);
695 _IA_HANDLE_ERROR(p_proc_err_info, (pWORD8) "", err_code);
696 if (ui_channel_mode == 0)
697 printf("Channel Mode: MONO_OR_PS\n");
698 else if (ui_channel_mode == 1)
699 printf("Channel Mode: STEREO\n");
700 else if (ui_channel_mode == 2)
701 printf("Channel Mode: DUAL-MONO\n");
702 else
703 printf("Channel Mode: NONE_OF_THESE or MULTICHANNEL\n");
704 }
705
706 /* Channel mode to tell SBR PRESENT/NOT_PRESENT */
707 {
708 UWORD32 ui_sbr_mode;
709 err_code = (*p_ia_process_api)(
710 p_ia_process_api_obj, IA_API_CMD_GET_CONFIG_PARAM,
711 IA_ENHAACPLUS_DEC_CONFIG_PARAM_SBR_MODE, &ui_sbr_mode);
712 _IA_HANDLE_ERROR(p_proc_err_info, (pWORD8) "", err_code);
713 if (ui_sbr_mode == 0)
714 printf("SBR Mode: NOT_PRESENT\n");
715 else if (ui_sbr_mode == 1)
716 printf("SBR Mode: UPSAMPLING FACTOR 2 or 8/3\n");
717 else if (ui_sbr_mode == 2)
718 printf("SBR Mode: ILLEGAL\n");
719 else if (ui_sbr_mode == 3)
720 printf("ESBR Mode: UPSAMPLING FACTOR 4\n");
721 else
722 printf("ui_sbr_mode not vaild\n");
723 }
724 return IA_NO_ERROR;
725 }
726
727 int counter_bl;
728 /*****************************************************************************/
729 /* */
730 /* Function name : ixheaacd_main_process */
731 /* */
732 /* Description : Stacked processing with function pointer selection */
733 /* */
734 /* Inputs : WORD32 argc (Arguments count) */
735 /* pWORD8 argv[] (Argument strings) */
736 /* */
737 /* Globals : pVOID g_pv_arr_alloc_memory[MAX_MEM_ALLOCS]; */
738 /* WORD g_w_malloc_count; */
739 /* FILE *g_pf_inp, *g_pf_out; */
740 /* */
741 /* Processing : Stacked processing of multiple components */
742 /* Loop1: Set params + Mem alloc */
743 /* Loop2: Set params + Init process + Get params */
744 /* Loop3: Execute */
745 /* */
746 /* Outputs : None */
747 /* */
748 /* Returns : IA_ERRORCODE error_value (Error value) */
749 /* */
750 /* Issues : none */
751 /* */
752 /* Revision history : */
753 /* */
754 /* DD MM YYYY Author Changes */
755 /* 29 07 2005 Tejaswi/Vishal Created */
756 /* */
757 /*****************************************************************************/
758
ixheaacd_main_process(WORD32 argc,pWORD8 argv[])759 int ixheaacd_main_process(WORD32 argc, pWORD8 argv[]) {
760 LOOPIDX i;
761 WORD frame_counter = 0;
762 #ifdef DISPLAY_MESSAGE
763 /* Library Info and Identification strings */
764 WORD8 pb_process_name[IA_SCREEN_WIDTH] = "";
765 WORD8 pb_lib_version[IA_SCREEN_WIDTH] = "";
766 #endif
767
768 /* Error code */
769 IA_ERRORCODE err_code = IA_NO_ERROR;
770 IA_ERRORCODE err_code_reinit = IA_NO_ERROR;
771
772 /* API obj */
773 pVOID pv_ia_process_api_obj;
774
775 pVOID pv_ia_drc_process_api_obj;
776 UWORD32 pui_api_size;
777
778 /* First part */
779 /* Error Handler Init */
780 /* Get Library Name, Library Version and API Version */
781 /* Initialize API structure + Default config set */
782 /* Set config params from user */
783 /* Initialize memory tables */
784 /* Get memory information and allocate memory */
785
786 UWORD8 drc_ip_buf[8192 * 4];
787 UWORD8 drc_op_buf[8192 * 4];
788
789 /* Memory variables */
790 UWORD32 n_mems, ui_rem;
791 UWORD32 ui_proc_mem_tabs_size;
792 /* API size */
793 UWORD32 pui_ap_isize;
794 /* Process initing done query variable */
795 UWORD32 ui_init_done, ui_exec_done;
796 pWORD8 pb_inp_buf = 0, pb_out_buf = 0;
797
798 // pWORD16 litt2big;
799
800 UWORD32 ui_inp_size = 0;
801 WORD32 i_bytes_consumed, i_bytes_read;
802 WORD32 i_buff_size;
803 WORD32 prev_sampling_rate = 0;
804 WORD32 skip_samples = 0;
805 WORD32 total_samples = 0;
806 WORD32 write_flag = 1;
807 WORD32 bytes_to_write = 0;
808 WORD32 ixheaacd_drc_offset = 0;
809 WORD32 current_samples = 0;
810 WORD32 samples_written = 0;
811 WORD32 init_iteration = 1;
812
813 #ifdef ARM_PROFILE_HW
814 int frame_count_b = 0;
815 long long cycles_b = 0;
816 long long start1_b, stop1_b;
817 double Curr_b, Ave_b = 0, Sum_b = 0;
818 double Peak_b = 0;
819 WORD32 Peak_frame_b = 0;
820 #endif
821 WORD32 i_out_bytes, i_total_bytes = 0;
822 WORD32 i_samp_freq, i_num_chan, i_pcm_wd_sz, i_channel_mask;
823
824 UWORD32 i_sbr_mode;
825 WORD32 i_effect_type = 0;
826 WORD32 i_target_loudness = 0;
827 WORD32 i_loud_norm = 0;
828 WORD32 drc_flag = 0;
829 WORD32 mpegd_drc_present = 0;
830 WORD32 uo_num_chan;
831
832 /* The process API function */
833 IA_ERRORCODE(*p_ia_process_api)
834 (pVOID p_ia_process_api_obj, WORD32 i_cmd, WORD32 i_idx, pVOID pv_value);
835
836 /* The set config from argc argv */
837 IA_ERRORCODE(*p_set_config_param)
838 (WORD32 argc, pWORD8 argv[], pVOID p_ia_process_api_obj);
839
840 /* The get config from API */
841 IA_ERRORCODE(*p_get_config_param)
842 (pVOID p_ia_process_api_obj, pWORD32 pi_samp_freq, pWORD32 pi_num_chan,
843 pWORD32 pi_pcm_wd_sz, pWORD32 pi_channel_mask);
844
845 /* The error init function */
846 VOID (*p_error_init)();
847
848 /* The process error info structure */
849 ia_error_info_struct *p_proc_err_info;
850
851 /* Process struct initing */
852 p_ia_process_api = ixheaacd_dec_api;
853 p_set_config_param = ixheaacd_set_config_param;
854 p_get_config_param = ixheaacd_get_config_param;
855 p_error_init = ixheaacd_error_handler_init;
856 p_proc_err_info = &ixheaacd_error_info;
857 /* Process struct initing end */
858
859 /* ******************************************************************/
860 /* Initialize the error handler */
861 /* ******************************************************************/
862 (*p_error_init)();
863
864 /* ******************************************************************/
865 /* Get the library name, library version and API version */
866 /* ******************************************************************/
867
868 #ifdef DISPLAY_MESSAGE
869 /* Get the library name string */
870 err_code = (*p_ia_process_api)(NULL, IA_API_CMD_GET_LIB_ID_STRINGS,
871 IA_CMD_TYPE_LIB_NAME, pb_process_name);
872
873 _IA_HANDLE_ERROR(p_proc_err_info, (pWORD8) "", err_code);
874
875 /* Get the library version string */
876 err_code = (*p_ia_process_api)(NULL, IA_API_CMD_GET_LIB_ID_STRINGS,
877 IA_CMD_TYPE_LIB_VERSION, pb_lib_version);
878
879 _IA_HANDLE_ERROR(p_proc_err_info, (pWORD8) "", err_code);
880
881 /* Display the ittiam identification message */
882 ia_display_id_message(pb_process_name, pb_lib_version);
883 #endif
884
885 /* ******************************************************************/
886 /* Initialize API structure and set config params to default */
887 /* ******************************************************************/
888
889 /* Get the API size */
890 err_code =
891 (*p_ia_process_api)(NULL, IA_API_CMD_GET_API_SIZE, 0, &pui_ap_isize);
892 _IA_HANDLE_ERROR(p_proc_err_info, (pWORD8) "", err_code);
893
894 /* Allocate memory for API */
895 g_pv_arr_alloc_memory[g_w_malloc_count] = malloc(pui_ap_isize + 4);
896
897 if (g_pv_arr_alloc_memory[g_w_malloc_count] == NULL) {
898 err_code = IA_TESTBENCH_MFMAN_FATAL_MEM_ALLOC_FAILED;
899 _IA_HANDLE_ERROR(&ixheaacd_ia_testbench_error_info,
900 (pWORD8) "API struct alloc", err_code);
901 }
902
903 /* API object requires 4 bytes (WORD32) alignment */
904 ui_rem = ((WORD32)g_pv_arr_alloc_memory[g_w_malloc_count] & 3);
905 /* Set API object with the memory allocated */
906 pv_ia_process_api_obj =
907 (pVOID)((WORD8 *)g_pv_arr_alloc_memory[g_w_malloc_count] + 4 - ui_rem);
908
909 g_w_malloc_count++;
910
911 /* Set the config params to default values */
912 err_code = (*p_ia_process_api)(pv_ia_process_api_obj, IA_API_CMD_INIT,
913 IA_CMD_TYPE_INIT_API_PRE_CONFIG_PARAMS, NULL);
914
915 _IA_HANDLE_ERROR(p_proc_err_info, (pWORD8) "", err_code);
916
917 /*ITTIAM: Get API size for DRC*/
918
919 /* Get the API size */
920 err_code = ia_drc_dec_api(NULL, IA_API_CMD_GET_API_SIZE, 0, &pui_api_size);
921
922 _IA_HANDLE_ERROR(p_proc_err_info, (pWORD8) "", err_code);
923
924 /* Allocate memory for API */
925 g_pv_arr_alloc_memory[g_w_malloc_count] = malloc(pui_api_size + 4);
926 memset(g_pv_arr_alloc_memory[g_w_malloc_count], 0, pui_api_size);
927 if (g_pv_arr_alloc_memory[g_w_malloc_count] == NULL) {
928 _IA_HANDLE_ERROR(&ixheaacd_ia_testbench_error_info,
929 (pWORD8) "API struct alloc", err_code);
930 }
931
932 /* API object requires 4 bytes (WORD32) alignment */
933 ui_rem = ((SIZE_T)g_pv_arr_alloc_memory[g_w_malloc_count] & 3);
934 /* Set API object with the memory allocated */
935 pv_ia_drc_process_api_obj =
936 (pVOID)((WORD8 *)g_pv_arr_alloc_memory[g_w_malloc_count] + 4 - ui_rem);
937
938 g_w_malloc_count++;
939
940 err_code = ia_drc_dec_api(pv_ia_drc_process_api_obj, IA_API_CMD_INIT,
941 IA_CMD_TYPE_INIT_API_PRE_CONFIG_PARAMS, NULL);
942
943 _IA_HANDLE_ERROR(p_proc_err_info, (pWORD8) "", err_code);
944
945
946 /* ******************************************************************/
947 /* Set config parameters got from the user present in argc argv */
948 /* ******************************************************************/
949
950 err_code = (*p_set_config_param)(argc, argv, pv_ia_process_api_obj);
951 _IA_HANDLE_ERROR(p_proc_err_info, (pWORD8) "", err_code);
952
953 /* ******************************************************************/
954 /* Table Relocatibility */
955 /* ******************************************************************/
956 #if IA_HE_AAC_DEC_TABLE_RELOCATABLE_ENABLE
957
958 /* Get number of tables required */
959 err_code = (*p_ia_process_api)(pv_ia_process_api_obj, IA_API_CMD_GET_N_TABLES,
960 0, &n_mems);
961 _IA_HANDLE_ERROR(p_proc_err_info, (pWORD8) "", err_code);
962
963 for (i = 0; i < (WORD32)n_mems; i++) {
964 int ui_size, ui_alignment;
965 pVOID pv_alloc_ptr = NULL, pv_curr_ptr = NULL;
966 LOOPIDX k;
967
968 /* Get table size */
969 err_code = (*p_ia_process_api)(pv_ia_process_api_obj,
970 IA_API_CMD_GET_TABLE_INFO_SIZE, i, &ui_size);
971 _IA_HANDLE_ERROR(p_proc_err_info, (pWORD8) "", err_code);
972
973 /* Get table alignment */
974 err_code = (*p_ia_process_api)(pv_ia_process_api_obj,
975 IA_API_CMD_GET_TABLE_INFO_ALIGNMENT, i,
976 &ui_alignment);
977
978 _IA_HANDLE_ERROR(p_proc_err_info, (pWORD8) "", err_code);
979
980 g_pv_arr_alloc_memory[g_w_malloc_count] = malloc(ui_size + ui_alignment);
981
982 if (g_pv_arr_alloc_memory[g_w_malloc_count] == NULL) {
983 _IA_HANDLE_ERROR(&ixheaacd_ia_testbench_error_info,
984 (pWORD8) "Mem for table relocation alloc",
985 IA_TESTBENCH_MFMAN_FATAL_MEM_ALLOC_FAILED);
986 }
987
988 ui_rem = ((WORD32)g_pv_arr_alloc_memory[g_w_malloc_count] % ui_alignment);
989 pv_alloc_ptr = (pVOID)((WORD8 *)g_pv_arr_alloc_memory[g_w_malloc_count] +
990 ui_alignment - ui_rem);
991
992 g_w_malloc_count++;
993
994 /* Get the current table pointer */
995 err_code = (*p_ia_process_api)(pv_ia_process_api_obj,
996 IA_API_CMD_GET_TABLE_PTR, i, &pv_curr_ptr);
997
998 _IA_HANDLE_ERROR(p_proc_err_info, (pWORD8) "", err_code);
999
1000 for (k = 0; k < ui_size; k++) {
1001 ((pWORD8)pv_alloc_ptr)[k] = ((pWORD8)pv_curr_ptr)[k];
1002 /* Disabled for multiple files running
1003 ((pWORD8)pv_curr_ptr)[k] = (WORD8)0xab; */
1004 }
1005
1006 /* Set the relocated table pointer */
1007 err_code = (*p_ia_process_api)(pv_ia_process_api_obj,
1008 IA_API_CMD_SET_TABLE_PTR, i, pv_alloc_ptr);
1009
1010 _IA_HANDLE_ERROR(p_proc_err_info, (pWORD8) "", err_code);
1011 }
1012 #endif
1013 /* ******************************************************************/
1014 /* Initialize Memory info tables */
1015 /* ******************************************************************/
1016
1017 /* Get memory info tables size */
1018 err_code =
1019 (*p_ia_process_api)(pv_ia_process_api_obj, IA_API_CMD_GET_MEMTABS_SIZE, 0,
1020 &ui_proc_mem_tabs_size);
1021 _IA_HANDLE_ERROR(p_proc_err_info, (pWORD8) "", err_code);
1022
1023 g_pv_arr_alloc_memory[g_w_malloc_count] = malloc(ui_proc_mem_tabs_size + 4);
1024
1025 if (g_pv_arr_alloc_memory[g_w_malloc_count] == NULL) {
1026 err_code = IA_TESTBENCH_MFMAN_FATAL_MEM_ALLOC_FAILED;
1027 _IA_HANDLE_ERROR(&ixheaacd_ia_testbench_error_info,
1028 (pWORD8) "Mem tables alloc", err_code);
1029 }
1030
1031 /* API object requires 4 bytes (WORD32) alignment */
1032 ui_rem = ((WORD32)g_pv_arr_alloc_memory[g_w_malloc_count] & 3);
1033
1034 /* Set pointer for process memory tables */
1035 err_code = (*p_ia_process_api)(
1036 pv_ia_process_api_obj, IA_API_CMD_SET_MEMTABS_PTR, 0,
1037 (pVOID)((WORD8 *)g_pv_arr_alloc_memory[g_w_malloc_count] + 4 - ui_rem));
1038
1039 _IA_HANDLE_ERROR(p_proc_err_info, (pWORD8) "", err_code);
1040
1041 g_w_malloc_count++;
1042
1043 /* initialize the API, post config, fill memory tables */
1044 err_code = (*p_ia_process_api)(pv_ia_process_api_obj, IA_API_CMD_INIT,
1045 IA_CMD_TYPE_INIT_API_POST_CONFIG_PARAMS, NULL);
1046
1047 _IA_HANDLE_ERROR(p_proc_err_info, (pWORD8) "", err_code);
1048
1049 /* ******************************************************************/
1050 /* Allocate Memory with info from library */
1051 /* ******************************************************************/
1052
1053 /* Get number of memory tables required */
1054 err_code = (*p_ia_process_api)(pv_ia_process_api_obj,
1055 IA_API_CMD_GET_N_MEMTABS, 0, &n_mems);
1056
1057 _IA_HANDLE_ERROR(p_proc_err_info, (pWORD8) "", err_code);
1058
1059 for (i = 0; i < (WORD32)n_mems; i++) {
1060 int ui_size, ui_alignment, ui_type;
1061 pVOID pv_alloc_ptr;
1062
1063 /* Get memory size */
1064 err_code = (*p_ia_process_api)(pv_ia_process_api_obj,
1065 IA_API_CMD_GET_MEM_INFO_SIZE, i, &ui_size);
1066 _IA_HANDLE_ERROR(p_proc_err_info, (pWORD8) "", err_code);
1067
1068 /* Get memory alignment */
1069 err_code = (*p_ia_process_api)(pv_ia_process_api_obj,
1070 IA_API_CMD_GET_MEM_INFO_ALIGNMENT, i,
1071 &ui_alignment);
1072
1073 _IA_HANDLE_ERROR(p_proc_err_info, (pWORD8) "", err_code);
1074
1075 /* Get memory type */
1076 err_code = (*p_ia_process_api)(pv_ia_process_api_obj,
1077 IA_API_CMD_GET_MEM_INFO_TYPE, i, &ui_type);
1078
1079 _IA_HANDLE_ERROR(p_proc_err_info, (pWORD8) "", err_code);
1080
1081 err_code =
1082 (*p_get_config_param)(pv_ia_process_api_obj, &i_samp_freq, &i_num_chan,
1083 &i_pcm_wd_sz, &i_channel_mask);
1084 _IA_HANDLE_ERROR(p_proc_err_info, (pWORD8) "", err_code);
1085
1086 /*if (ui_type == IA_MEMTYPE_OUTPUT) {
1087 if (i_pcm_wd_sz == 16)
1088 ui_size = 11 * 2048 * sizeof(WORD16);
1089 else
1090 ui_size = 11 * 2048 * 3 * sizeof(WORD8);
1091 }*/
1092
1093 g_pv_arr_alloc_memory[g_w_malloc_count] = malloc(ui_size + ui_alignment);
1094
1095 if (g_pv_arr_alloc_memory[g_w_malloc_count] == NULL) {
1096 err_code = IA_TESTBENCH_MFMAN_FATAL_MEM_ALLOC_FAILED;
1097 _IA_HANDLE_ERROR(&ixheaacd_ia_testbench_error_info,
1098 (pWORD8) "Mem tables alloc", err_code);
1099 }
1100
1101 ui_rem = ((WORD32)g_pv_arr_alloc_memory[g_w_malloc_count] % ui_alignment);
1102 pv_alloc_ptr = (pVOID)((WORD8 *)g_pv_arr_alloc_memory[g_w_malloc_count] +
1103 ui_alignment - ui_rem);
1104
1105 g_w_malloc_count++;
1106
1107 /* Set the buffer pointer */
1108 err_code = (*p_ia_process_api)(pv_ia_process_api_obj,
1109 IA_API_CMD_SET_MEM_PTR, i, pv_alloc_ptr);
1110
1111 _IA_HANDLE_ERROR(p_proc_err_info, (pWORD8) "", err_code);
1112 if (ui_type == IA_MEMTYPE_INPUT) {
1113 pb_inp_buf = pv_alloc_ptr;
1114 ui_inp_size = ui_size;
1115 }
1116 if (ui_type == IA_MEMTYPE_OUTPUT) {
1117 pb_out_buf = pv_alloc_ptr;
1118 }
1119 }
1120
1121 /* End first part */
1122
1123 /* Second part */
1124 /* Initialize process */
1125 /* Get config params */
1126
1127 /* ******************************************************************/
1128 /* Initialize process in a loop (to handle junk data at beginning) */
1129 /* ******************************************************************/
1130
1131 i_bytes_consumed = ui_inp_size;
1132 i_buff_size = ui_inp_size;
1133
1134 do {
1135 i_bytes_read = 0;
1136
1137 if ((ui_inp_size - (i_buff_size - i_bytes_consumed)) > 0) {
1138 for (i = 0; i < (i_buff_size - i_bytes_consumed); i++) {
1139 pb_inp_buf[i] = pb_inp_buf[i + i_bytes_consumed];
1140 }
1141
1142 FileWrapper_Read(g_pf_inp, (unsigned char *)(pb_inp_buf + i_buff_size -
1143 i_bytes_consumed),
1144 (ui_inp_size - (i_buff_size - i_bytes_consumed)),
1145 (pUWORD32)&i_bytes_read);
1146
1147 i_buff_size = i_buff_size - (i_bytes_consumed - i_bytes_read);
1148
1149 /* Tell input is over, if algorithm returns with insufficient input and
1150 there is no
1151 more input left in the bitstream*/
1152 if ((i_buff_size <= 0) ||
1153 ((err_code_reinit == 0x00001804) && i_bytes_read == 0))
1154
1155 {
1156 i_buff_size = 0;
1157 /* Tell that the input is over in this buffer */
1158 err_code = (*p_ia_process_api)(pv_ia_process_api_obj,
1159 IA_API_CMD_INPUT_OVER, 0, NULL);
1160
1161 _IA_HANDLE_ERROR(p_proc_err_info, (pWORD8) "", err_code);
1162 }
1163 }
1164
1165 if ((i_buff_size <= 0) ||
1166 ((err_code_reinit == 0x00001804) && i_bytes_read == 0)) {
1167 i_buff_size = 0;
1168 /* Tell that the input is over in this buffer */
1169 err_code = (*p_ia_process_api)(pv_ia_process_api_obj,
1170 IA_API_CMD_INPUT_OVER, 0, NULL);
1171
1172 _IA_HANDLE_ERROR(p_proc_err_info, (pWORD8) "", err_code);
1173 #ifdef WAV_HEADER
1174 #ifndef ARM_PROFILE_BOARD
1175 /* ******************************************************************/
1176 /* Get config params from API */
1177 /* ******************************************************************/
1178
1179 err_code =
1180 (*p_get_config_param)(pv_ia_process_api_obj, &i_samp_freq,
1181 &i_num_chan, &i_pcm_wd_sz, &i_channel_mask);
1182 _IA_HANDLE_ERROR(p_proc_err_info, (pWORD8) "", err_code);
1183
1184 // This is done in those cases, where file decodes ends at init time
1185 // Since init is incomplete, sampling freq might be zero and will result
1186 // in
1187 // writing invalid wave header
1188
1189 if (i_samp_freq == 0) i_samp_freq = prev_sampling_rate;
1190
1191 if (!fseek(g_pf_out, 0, SEEK_SET))
1192 write_wav_header(g_pf_out, i_total_bytes, i_samp_freq, i_num_chan,
1193 i_pcm_wd_sz, i_channel_mask);
1194 #endif
1195 #endif
1196 return 1;
1197 }
1198
1199 if (init_iteration == 1) {
1200 if (raw_testing)
1201 ixheaacd_i_bytes_to_read = get_metadata_dec_info_init(meta_info);
1202 else
1203 ixheaacd_i_bytes_to_read = i_buff_size;
1204
1205 /* Set number of bytes to be processed */
1206 err_code =
1207 (*p_ia_process_api)(pv_ia_process_api_obj, IA_API_CMD_SET_INPUT_BYTES,
1208 0, &ixheaacd_i_bytes_to_read);
1209 init_iteration++;
1210
1211 } else {
1212 if (raw_testing) {
1213 ixheaacd_i_bytes_to_read =
1214 get_metadata_dec_exec(meta_info, frame_counter);
1215 /* Set number of bytes to be processed */
1216 err_code = (*p_ia_process_api)(pv_ia_process_api_obj,
1217 IA_API_CMD_SET_INPUT_BYTES, 0,
1218 &ixheaacd_i_bytes_to_read);
1219 } else {
1220 /* Set number of bytes to be processed */
1221 err_code = (*p_ia_process_api)(
1222 pv_ia_process_api_obj, IA_API_CMD_SET_INPUT_BYTES, 0, &i_buff_size);
1223 }
1224 }
1225
1226 _IA_HANDLE_ERROR(p_proc_err_info, (pWORD8) "", err_code);
1227
1228 /* Initialize the process */
1229 err_code = (*p_ia_process_api)(pv_ia_process_api_obj, IA_API_CMD_INIT,
1230 IA_CMD_TYPE_INIT_PROCESS, NULL);
1231 err_code_reinit = err_code;
1232
1233 _IA_HANDLE_ERROR(p_proc_err_info, (pWORD8) "", err_code);
1234
1235 /* Checking for end of initialization */
1236 err_code = (*p_ia_process_api)(pv_ia_process_api_obj, IA_API_CMD_INIT,
1237 IA_CMD_TYPE_INIT_DONE_QUERY, &ui_init_done);
1238
1239 _IA_HANDLE_ERROR(p_proc_err_info, (pWORD8) "", err_code);
1240
1241 /* How much buffer is used in input buffers */
1242 err_code = (*p_ia_process_api)(pv_ia_process_api_obj,
1243 IA_API_CMD_GET_CURIDX_INPUT_BUF, 0,
1244 &i_bytes_consumed);
1245
1246 _IA_HANDLE_ERROR(p_proc_err_info, (pWORD8) "", err_code);
1247
1248 } while (!ui_init_done);
1249
1250 if (interface_file_present == 1) {
1251 err_code =
1252 (*p_get_config_param)(pv_ia_process_api_obj, &i_samp_freq, &i_num_chan,
1253 &i_pcm_wd_sz, &i_channel_mask);
1254 _IA_HANDLE_ERROR(p_proc_err_info, (pWORD8) "", err_code);
1255
1256 /* Sampling Frequency */
1257 {
1258 err_code =
1259 ia_drc_dec_api(pv_ia_drc_process_api_obj, IA_API_CMD_SET_CONFIG_PARAM,
1260 IA_DRC_DEC_CONFIG_PARAM_SAMP_FREQ, &i_samp_freq);
1261 _IA_HANDLE_ERROR(p_proc_err_info, (pWORD8) "", err_code);
1262 }
1263 /* Total Number of Channels */
1264 {
1265 err_code =
1266 ia_drc_dec_api(pv_ia_drc_process_api_obj, IA_API_CMD_SET_CONFIG_PARAM,
1267 IA_DRC_DEC_CONFIG_PARAM_NUM_CHANNELS, &i_num_chan);
1268 _IA_HANDLE_ERROR(p_proc_err_info, (pWORD8) "", err_code);
1269 }
1270
1271 /* PCM word size */
1272 {
1273 err_code =
1274 ia_drc_dec_api(pv_ia_drc_process_api_obj, IA_API_CMD_SET_CONFIG_PARAM,
1275 IA_DRC_DEC_CONFIG_PARAM_PCM_WDSZ, &i_pcm_wd_sz);
1276 _IA_HANDLE_ERROR(p_proc_err_info, (pWORD8) "", err_code);
1277 }
1278
1279 /*Set Effect Type*/
1280
1281 {
1282 err_code = (*p_ia_process_api)(
1283 pv_ia_process_api_obj, IA_API_CMD_GET_CONFIG_PARAM,
1284 IA_ENHAACPLUS_DEC_CONFIG_PARAM_DRC_EFFECT_TYPE, &i_effect_type);
1285 _IA_HANDLE_ERROR(p_proc_err_info, (pWORD8) "", err_code);
1286
1287 err_code =
1288 ia_drc_dec_api(pv_ia_drc_process_api_obj, IA_API_CMD_SET_CONFIG_PARAM,
1289 IA_DRC_DEC_CONFIG_DRC_EFFECT_TYPE, &i_effect_type);
1290 _IA_HANDLE_ERROR(p_proc_err_info, (pWORD8) "", err_code);
1291
1292 }
1293
1294 /*Set target loudness */
1295
1296 {
1297 err_code = (*p_ia_process_api)(
1298 pv_ia_process_api_obj, IA_API_CMD_GET_CONFIG_PARAM,
1299 IA_ENHAACPLUS_DEC_CONFIG_PARAM_DRC_TARGET_LOUDNESS, &i_target_loudness);
1300 _IA_HANDLE_ERROR(p_proc_err_info, (pWORD8) "", err_code);
1301
1302 err_code =
1303 ia_drc_dec_api(pv_ia_drc_process_api_obj, IA_API_CMD_SET_CONFIG_PARAM,
1304 IA_DRC_DEC_CONFIG_DRC_TARGET_LOUDNESS, &i_target_loudness);
1305 _IA_HANDLE_ERROR(p_proc_err_info, (pWORD8) "", err_code);
1306
1307 }
1308
1309 /*Set loud_norm_flag*/
1310 {
1311 err_code = (*p_ia_process_api)(
1312 pv_ia_process_api_obj, IA_API_CMD_GET_CONFIG_PARAM,
1313 IA_ENHAACPLUS_DEC_CONFIG_PARAM_DRC_LOUD_NORM, &i_loud_norm);
1314 _IA_HANDLE_ERROR(p_proc_err_info, (pWORD8) "", err_code);
1315
1316 err_code =
1317 ia_drc_dec_api(pv_ia_drc_process_api_obj, IA_API_CMD_SET_CONFIG_PARAM,
1318 IA_DRC_DEC_CONFIG_DRC_LOUD_NORM, &i_loud_norm);
1319 _IA_HANDLE_ERROR(p_proc_err_info, (pWORD8) "", err_code);
1320
1321 }
1322
1323
1324
1325
1326
1327
1328 err_code = ia_drc_dec_api(pv_ia_drc_process_api_obj, IA_API_CMD_INIT,
1329 IA_CMD_TYPE_INIT_API_POST_CONFIG_PARAMS, NULL);
1330
1331 _IA_HANDLE_ERROR(p_proc_err_info, (pWORD8) "", err_code);
1332
1333 /* Get number of memory tables required */
1334 err_code = ia_drc_dec_api(pv_ia_drc_process_api_obj,
1335 IA_API_CMD_GET_N_MEMTABS, 0, &n_mems);
1336
1337 _IA_HANDLE_ERROR(p_proc_err_info, (pWORD8) "", err_code);
1338
1339 for (i = 0; i < (WORD32)n_mems - 2; i++) {
1340 WORD32 ui_size, ui_alignment, ui_type;
1341 pVOID pv_alloc_ptr;
1342
1343 /* Get memory size */
1344 err_code = ia_drc_dec_api(pv_ia_drc_process_api_obj,
1345 IA_API_CMD_GET_MEM_INFO_SIZE, i, &ui_size);
1346
1347 _IA_HANDLE_ERROR(p_proc_err_info, (pWORD8) "", err_code);
1348
1349 /* Get memory alignment */
1350 err_code =
1351 ia_drc_dec_api(pv_ia_drc_process_api_obj,
1352 IA_API_CMD_GET_MEM_INFO_ALIGNMENT, i, &ui_alignment);
1353
1354 _IA_HANDLE_ERROR(p_proc_err_info, (pWORD8) "", err_code);
1355
1356 /* Get memory type */
1357 err_code = ia_drc_dec_api(pv_ia_drc_process_api_obj,
1358 IA_API_CMD_GET_MEM_INFO_TYPE, i, &ui_type);
1359
1360 _IA_HANDLE_ERROR(p_proc_err_info, (pWORD8) "", err_code);
1361
1362 g_pv_arr_alloc_memory[g_w_malloc_count] = malloc(ui_size + ui_alignment);
1363
1364 if (g_pv_arr_alloc_memory[g_w_malloc_count] == NULL) {
1365 _IA_HANDLE_ERROR(&ixheaacd_ia_testbench_error_info,
1366 (pWORD8) "Mem tables alloc", err_code);
1367 }
1368
1369 ui_rem = ((SIZE_T)g_pv_arr_alloc_memory[g_w_malloc_count] % ui_alignment);
1370 pv_alloc_ptr = (pVOID)((WORD8 *)g_pv_arr_alloc_memory[g_w_malloc_count] +
1371 ui_alignment - ui_rem);
1372
1373 g_w_malloc_count++;
1374
1375 /* Set the buffer pointer */
1376 err_code = ia_drc_dec_api(pv_ia_drc_process_api_obj,
1377 IA_API_CMD_SET_MEM_PTR, i, pv_alloc_ptr);
1378
1379 _IA_HANDLE_ERROR(p_proc_err_info, (pWORD8) "", err_code);
1380 }
1381 err_code = ia_drc_dec_api(pv_ia_drc_process_api_obj, IA_API_CMD_SET_MEM_PTR,
1382 2, drc_ip_buf);
1383 _IA_HANDLE_ERROR(p_proc_err_info, (pWORD8) "", err_code);
1384
1385 err_code = ia_drc_dec_api(pv_ia_drc_process_api_obj, IA_API_CMD_SET_MEM_PTR,
1386 3, drc_op_buf);
1387 _IA_HANDLE_ERROR(p_proc_err_info, (pWORD8) "", err_code);
1388
1389 /*ITTIAM: DRC buffers
1390 buf[0] - contains extension element pay load loudness related
1391 buf[1] - contains extension element pay load*/
1392 {
1393 VOID *p_array[2][16];
1394 WORD32 ii;
1395 WORD32 buf_sizes[2][16];
1396 WORD32 num_elements;
1397 WORD32 num_config_ext;
1398 WORD32 bit_str_fmt = 1;
1399
1400 memset(buf_sizes, 0, 32 * sizeof(WORD32));
1401
1402 err_code = (*p_ia_process_api)(
1403 pv_ia_process_api_obj, IA_API_CMD_GET_CONFIG_PARAM,
1404 IA_ENHAACPLUS_DEC_CONFIG_EXT_ELE_BUF_SIZES, &buf_sizes[0][0]);
1405 _IA_HANDLE_ERROR(p_proc_err_info, (pWORD8) "", err_code);
1406
1407 err_code = (*p_ia_process_api)(
1408 pv_ia_process_api_obj, IA_API_CMD_GET_CONFIG_PARAM,
1409 IA_ENHAACPLUS_DEC_CONFIG_EXT_ELE_PTR, &p_array);
1410 _IA_HANDLE_ERROR(p_proc_err_info, (pWORD8) "", err_code);
1411
1412 err_code = ia_drc_dec_api(pv_ia_drc_process_api_obj, IA_API_CMD_INIT,
1413 IA_CMD_TYPE_INIT_SET_BUFF_PTR, 0);
1414
1415 _IA_HANDLE_ERROR(p_proc_err_info, (pWORD8) "", err_code);
1416
1417 err_code = (*p_ia_process_api)(
1418 pv_ia_process_api_obj, IA_API_CMD_GET_CONFIG_PARAM,
1419 IA_ENHAACPLUS_DEC_CONFIG_NUM_ELE, &num_elements);
1420 _IA_HANDLE_ERROR(p_proc_err_info, (pWORD8) "", err_code);
1421
1422 err_code = (*p_ia_process_api)(
1423 pv_ia_process_api_obj, IA_API_CMD_GET_CONFIG_PARAM,
1424 IA_ENHAACPLUS_DEC_CONFIG_NUM_CONFIG_EXT, &num_config_ext);
1425 _IA_HANDLE_ERROR(p_proc_err_info, (pWORD8) "", err_code);
1426
1427 for (ii = 0; ii < num_config_ext; ii++) {
1428 /*copy loudness bitstream*/
1429 if (buf_sizes[0][ii] > 0) {
1430 memcpy(drc_ip_buf, p_array[0][ii], buf_sizes[0][ii]);
1431
1432 /*Set bitstream_split_format */
1433 err_code = ia_drc_dec_api(
1434 pv_ia_drc_process_api_obj, IA_API_CMD_SET_CONFIG_PARAM,
1435 IA_DRC_DEC_CONFIG_PARAM_BITS_FORMAT, &bit_str_fmt);
1436
1437 /* Set number of bytes to be processed */
1438 err_code = ia_drc_dec_api(pv_ia_drc_process_api_obj,
1439 IA_API_CMD_SET_INPUT_BYTES_IL_BS, 0,
1440 &buf_sizes[0][ii]);
1441
1442 _IA_HANDLE_ERROR(p_proc_err_info, (pWORD8) "", err_code);
1443
1444 /* Execute process */
1445 err_code = ia_drc_dec_api(pv_ia_drc_process_api_obj, IA_API_CMD_INIT,
1446 IA_CMD_TYPE_INIT_CPY_IL_BSF_BUFF, NULL);
1447
1448 _IA_HANDLE_ERROR(p_proc_err_info, (pWORD8) "", err_code);
1449
1450 drc_flag = 1;
1451 }
1452 }
1453
1454 for (ii = 0; ii < num_elements; ii++) {
1455 /*copy config bitstream*/
1456 if (buf_sizes[1][ii] > 0) {
1457 memcpy(drc_ip_buf, p_array[1][ii], buf_sizes[1][ii]);
1458 /* Set number of bytes to be processed */
1459
1460 /*Set bitstream_split_format */
1461 err_code = ia_drc_dec_api(
1462 pv_ia_drc_process_api_obj, IA_API_CMD_SET_CONFIG_PARAM,
1463 IA_DRC_DEC_CONFIG_PARAM_BITS_FORMAT, &bit_str_fmt);
1464
1465 err_code = ia_drc_dec_api(pv_ia_drc_process_api_obj,
1466 IA_API_CMD_SET_INPUT_BYTES_IC_BS, 0,
1467 &buf_sizes[1][ii]);
1468
1469 _IA_HANDLE_ERROR(p_proc_err_info, (pWORD8) "", err_code);
1470
1471 /* Execute process */
1472 err_code = ia_drc_dec_api(pv_ia_drc_process_api_obj, IA_API_CMD_INIT,
1473 IA_CMD_TYPE_INIT_CPY_IC_BSF_BUFF, NULL);
1474
1475 _IA_HANDLE_ERROR(p_proc_err_info, (pWORD8) "", err_code);
1476
1477 drc_flag = 1;
1478 }
1479 }
1480
1481 if (drc_flag == 1) {
1482 mpegd_drc_present = 1;
1483 } else {
1484 mpegd_drc_present = 0;
1485 }
1486
1487 /*Read interface buffer config file bitstream*/
1488
1489 if(mpegd_drc_present==1){
1490 WORD32 interface_is_present = 1;
1491
1492
1493 err_code = ia_drc_dec_api(
1494 pv_ia_drc_process_api_obj, IA_API_CMD_SET_CONFIG_PARAM,
1495 IA_DRC_DEC_CONFIG_PARAM_INT_PRESENT, &interface_is_present);
1496 _IA_HANDLE_ERROR(p_proc_err_info, (pWORD8) "", err_code);
1497
1498 /* Execute process */
1499 err_code = ia_drc_dec_api(pv_ia_drc_process_api_obj, IA_API_CMD_INIT,
1500 IA_CMD_TYPE_INIT_CPY_IN_BSF_BUFF, NULL);
1501
1502 _IA_HANDLE_ERROR(p_proc_err_info, (pWORD8) "", err_code);
1503
1504 err_code = ia_drc_dec_api(pv_ia_drc_process_api_obj, IA_API_CMD_INIT,
1505 IA_CMD_TYPE_INIT_PROCESS, NULL);
1506
1507 _IA_HANDLE_ERROR(p_proc_err_info, (pWORD8) "", err_code);
1508
1509 err_code = ia_drc_dec_api(
1510 pv_ia_drc_process_api_obj, IA_API_CMD_GET_CONFIG_PARAM,
1511 IA_DRC_DEC_CONFIG_PARAM_NUM_CHANNELS, &uo_num_chan);
1512 _IA_HANDLE_ERROR(p_proc_err_info, (pWORD8) "", err_code);
1513 }
1514 }
1515 }
1516
1517 /* ******************************************************************/
1518 /* Get config params from API */
1519 /* ******************************************************************/
1520
1521 err_code = (*p_get_config_param)(pv_ia_process_api_obj, &i_samp_freq,
1522 &i_num_chan, &i_pcm_wd_sz, &i_channel_mask);
1523 _IA_HANDLE_ERROR(p_proc_err_info, (pWORD8) "", err_code);
1524
1525 if (raw_testing) {
1526 skip_samples = get_start_offset_in_samples(meta_info);
1527 if (eld_testing == 0) total_samples = get_play_time_in_samples(meta_info);
1528 }
1529
1530 /* End second part */
1531
1532 #ifdef WAV_HEADER
1533 // This condition is added so as to avoid re-writing wave header in
1534 // middle of wave file in case of errors and when we are not opening
1535 // new file in case of errors.
1536
1537 #ifndef ARM_PROFILE_BOARD
1538
1539 write_wav_header(g_pf_out, 0, i_samp_freq, i_num_chan, i_pcm_wd_sz,
1540 i_channel_mask);
1541 #endif
1542 #endif
1543 prev_sampling_rate = i_samp_freq;
1544
1545 do {
1546 if (((WORD32)ui_inp_size - (WORD32)(i_buff_size - i_bytes_consumed)) > 0) {
1547 for (i = 0; i < (i_buff_size - i_bytes_consumed); i++) {
1548 pb_inp_buf[i] = pb_inp_buf[i + i_bytes_consumed];
1549 }
1550 #ifdef ENABLE_LD_DEC
1551 if (0 != frame_counter) {
1552 #endif
1553 FileWrapper_Read(g_pf_inp, (unsigned char *)(pb_inp_buf + i_buff_size -
1554 i_bytes_consumed),
1555 ((WORD32)ui_inp_size - (WORD32)(i_buff_size - i_bytes_consumed)),
1556 (pUWORD32)&i_bytes_read);
1557 #ifdef ENABLE_LD_DEC
1558 } else
1559 i_bytes_read = 0;
1560 #endif
1561
1562 i_buff_size = i_buff_size - (i_bytes_consumed - i_bytes_read);
1563
1564 if ((i_buff_size <= 0) ||
1565 ((err_code_reinit == 0x00001804) && i_bytes_read == 0)) {
1566 i_buff_size = 0;
1567 raw_testing = 0;
1568 /* Tell that the input is over in this buffer */
1569 err_code = (*p_ia_process_api)(pv_ia_process_api_obj,
1570 IA_API_CMD_INPUT_OVER, 0, NULL);
1571
1572 _IA_HANDLE_ERROR(p_proc_err_info, (pWORD8) "", err_code);
1573 }
1574 }
1575
1576 if (raw_testing) {
1577 ixheaacd_i_bytes_to_read =
1578 get_metadata_dec_exec(meta_info, frame_counter);
1579 err_code =
1580 (*p_ia_process_api)(pv_ia_process_api_obj, IA_API_CMD_SET_INPUT_BYTES,
1581 0, &ixheaacd_i_bytes_to_read);
1582 } else {
1583 /* Set number of bytes to be processed */
1584 err_code = (*p_ia_process_api)(
1585 pv_ia_process_api_obj, IA_API_CMD_SET_INPUT_BYTES, 0, &i_buff_size);
1586 }
1587
1588 _IA_HANDLE_ERROR(p_proc_err_info, (pWORD8) "", err_code);
1589
1590 #ifdef ARM_PROFILE_HW
1591 start1_b = itGetMs();
1592 #endif
1593
1594 /* Execute process */
1595
1596 counter_bl = frame_counter;
1597
1598 err_code = (*p_ia_process_api)(pv_ia_process_api_obj, IA_API_CMD_EXECUTE,
1599 IA_CMD_TYPE_DO_EXECUTE, NULL);
1600
1601 err_code_reinit = err_code;
1602
1603 #ifdef ARM_PROFILE_HW
1604 stop1_b = itGetMs();
1605 cycles_b = (stop1_b - start1_b);
1606 #endif
1607
1608 _IA_HANDLE_ERROR(p_proc_err_info, (pWORD8) "", err_code);
1609
1610 /* Checking for end of processing */
1611 err_code = (*p_ia_process_api)(pv_ia_process_api_obj, IA_API_CMD_EXECUTE,
1612 IA_CMD_TYPE_DONE_QUERY, &ui_exec_done);
1613
1614 _IA_HANDLE_ERROR(p_proc_err_info, (pWORD8) "", err_code);
1615
1616 if (interface_file_present == 1) {
1617 if (ui_exec_done != 1) {
1618 VOID *p_array; // ITTIAM:buffer to handle gain payload
1619 WORD32 buf_size = 0; // ITTIAM:gain payload length
1620 WORD32 bit_str_fmt = 1;
1621 WORD32 gain_stream_flag = 1;
1622
1623 err_code = (*p_ia_process_api)(
1624 pv_ia_process_api_obj, IA_API_CMD_GET_CONFIG_PARAM,
1625 IA_ENHAACPLUS_DEC_CONFIG_GAIN_PAYLOAD_LEN, &buf_size);
1626 _IA_HANDLE_ERROR(p_proc_err_info, (pWORD8) "", err_code);
1627
1628 err_code = (*p_ia_process_api)(
1629 pv_ia_process_api_obj, IA_API_CMD_GET_CONFIG_PARAM,
1630 IA_ENHAACPLUS_DEC_CONFIG_GAIN_PAYLOAD_BUF, &p_array);
1631 _IA_HANDLE_ERROR(p_proc_err_info, (pWORD8) "", err_code);
1632
1633 if (buf_size > 0) {
1634 /*Set bitstream_split_format */
1635 err_code = ia_drc_dec_api(
1636 pv_ia_drc_process_api_obj, IA_API_CMD_SET_CONFIG_PARAM,
1637 IA_DRC_DEC_CONFIG_PARAM_BITS_FORMAT, &bit_str_fmt);
1638
1639 memcpy(drc_ip_buf, p_array, buf_size);
1640 /* Set number of bytes to be processed */
1641 err_code =
1642 ia_drc_dec_api(pv_ia_drc_process_api_obj,
1643 IA_API_CMD_SET_INPUT_BYTES_BS, 0, &buf_size);
1644
1645 err_code = ia_drc_dec_api(
1646 pv_ia_drc_process_api_obj, IA_API_CMD_SET_CONFIG_PARAM,
1647 IA_DRC_DEC_CONFIG_GAIN_STREAM_FLAG, &gain_stream_flag);
1648
1649 _IA_HANDLE_ERROR(p_proc_err_info, (pWORD8) "", err_code);
1650
1651 /* Execute process */
1652 err_code = ia_drc_dec_api(pv_ia_drc_process_api_obj, IA_API_CMD_INIT,
1653 IA_CMD_TYPE_INIT_CPY_BSF_BUFF, NULL);
1654
1655 _IA_HANDLE_ERROR(p_proc_err_info, (pWORD8) "", err_code);
1656
1657 mpegd_drc_present = 1;
1658 }
1659 }
1660 }
1661 /* How much buffer is used in input buffers */
1662 err_code = (*p_ia_process_api)(pv_ia_process_api_obj,
1663 IA_API_CMD_GET_CURIDX_INPUT_BUF, 0,
1664 &i_bytes_consumed);
1665
1666 // printf("bytes_consumed: %d \n", i_bytes_consumed);
1667 _IA_HANDLE_ERROR(p_proc_err_info, (pWORD8) "", err_code);
1668
1669 /* Get the output bytes */
1670 err_code = (*p_ia_process_api)(
1671 pv_ia_process_api_obj, IA_API_CMD_GET_OUTPUT_BYTES, 0, &i_out_bytes);
1672
1673 _IA_HANDLE_ERROR(p_proc_err_info, (pWORD8) "", err_code);
1674
1675 if (err_code_reinit != 0) memset(pb_out_buf, 0, i_out_bytes);
1676
1677 i_total_bytes += i_out_bytes;
1678
1679 if (mpegd_drc_present == 1) {
1680 memcpy(drc_ip_buf, pb_out_buf, i_out_bytes);
1681
1682
1683 err_code = (*p_ia_process_api)(
1684 pv_ia_process_api_obj, IA_API_CMD_GET_CONFIG_PARAM,
1685 IA_ENHAACPLUS_DEC_CONFIG_PARAM_SBR_MODE, &i_sbr_mode);
1686 _IA_HANDLE_ERROR(p_proc_err_info, (pWORD8) "", err_code);
1687
1688
1689 if (i_sbr_mode != 0)
1690 {
1691 WORD32 frame_length;
1692 if (i_sbr_mode == 1)
1693 {
1694 frame_length = 2048;
1695 }
1696 else if(i_sbr_mode == 3)
1697 {
1698 frame_length = 4096;
1699 }
1700 else
1701 {
1702 frame_length = 1024;
1703 }
1704
1705 err_code =
1706 ia_drc_dec_api(pv_ia_drc_process_api_obj, IA_API_CMD_SET_CONFIG_PARAM,
1707 IA_DRC_DEC_CONFIG_PARAM_FRAME_SIZE, &frame_length);
1708 _IA_HANDLE_ERROR(p_proc_err_info, (pWORD8) "", err_code);
1709 }
1710
1711
1712 err_code = ia_drc_dec_api(pv_ia_drc_process_api_obj,
1713 IA_API_CMD_SET_INPUT_BYTES, 0, &i_out_bytes);
1714
1715 _IA_HANDLE_ERROR(p_proc_err_info, (pWORD8) "", err_code);
1716
1717 err_code = ia_drc_dec_api(pv_ia_drc_process_api_obj, IA_API_CMD_EXECUTE,
1718 IA_CMD_TYPE_DO_EXECUTE, NULL);
1719
1720 _IA_HANDLE_ERROR(p_proc_err_info, (pWORD8) "", err_code);
1721
1722 memcpy(pb_out_buf, drc_op_buf, i_out_bytes);
1723 }
1724
1725
1726 if (total_samples != 0) // Usac stream
1727 {
1728 if (raw_testing) {
1729 if (i_total_bytes <= skip_samples * i_num_chan * (i_pcm_wd_sz >> 3)) {
1730 err_code =
1731 (*p_get_config_param)(pv_ia_process_api_obj, &i_samp_freq,
1732 &i_num_chan, &i_pcm_wd_sz, &i_channel_mask);
1733
1734 write_flag = 0;
1735 } else {
1736 write_flag = 1;
1737 bytes_to_write =
1738 i_total_bytes - skip_samples * i_num_chan * (i_pcm_wd_sz >> 3);
1739 if (bytes_to_write < i_out_bytes) {
1740 ixheaacd_drc_offset = i_out_bytes - bytes_to_write;
1741 i_out_bytes = bytes_to_write;
1742 current_samples =
1743 bytes_to_write / (i_num_chan * (i_pcm_wd_sz >> 3));
1744 } else {
1745 ixheaacd_drc_offset = 0;
1746 current_samples = i_out_bytes / (i_num_chan * (i_pcm_wd_sz >> 3));
1747 }
1748 }
1749 }
1750
1751 if (raw_testing) {
1752 samples_written += current_samples;
1753
1754 if (samples_written > total_samples) {
1755 i_out_bytes = (total_samples - (samples_written - current_samples)) *
1756 (i_num_chan * (i_pcm_wd_sz >> 3)); // hack
1757 if (i_out_bytes < 0) i_out_bytes = 0;
1758 }
1759 }
1760 }
1761
1762 if (write_flag) {
1763 #ifndef WIN32
1764 #ifndef ARM_PROFILE_BOARD
1765 ia_fwrite((pVOID)(pb_out_buf + ixheaacd_drc_offset), (i_pcm_wd_sz / 8),
1766 i_out_bytes / (i_pcm_wd_sz / 8), g_pf_out);
1767 #endif
1768 #else
1769 #ifndef ARM_PROFILE_BOARD
1770 fwrite(pb_out_buf + ixheaacd_drc_offset, sizeof(WORD8), i_out_bytes,
1771 g_pf_out);
1772 fflush(g_pf_out);
1773 #endif
1774 #endif
1775 }
1776
1777 if (i_out_bytes) {
1778 frame_counter++;
1779 }
1780
1781 #ifdef _DEBUG
1782 if (frame_counter == 80) frame_counter = frame_counter;
1783 // ui_exec_done=1;
1784 // frame_counter = frame_counter;
1785
1786 // printf("frame_counter = %d\n", frame_counter);
1787 #endif
1788
1789 #ifdef ARM_PROFILE_HW
1790 if (i_out_bytes != 0) {
1791 int i_out_samples = i_out_bytes >> 2;
1792 if (frame_count_b) {
1793 double i_out_samples_per_ch =
1794 (i_out_bytes) / ((i_pcm_wd_sz / 8) * i_num_chan);
1795 Curr_b = (((double)cycles_b / 1000000) * CLK_FREQ_BOARD_MHZ) /
1796 (i_out_samples_per_ch / i_samp_freq);
1797 frame_count_b++;
1798 // fprintf(stderr, "Microseconds: %d\t", cycles_b);
1799 // fprintf(stderr, "MCPS: %f\n", Curr_b);
1800 Sum_b += Curr_b;
1801 Ave_b = Sum_b / frame_count_b;
1802 if (Peak_b < Curr_b) {
1803 Peak_b = Curr_b;
1804 Peak_frame_b = frame_count_b;
1805 }
1806 } else {
1807 frame_count_b++;
1808 }
1809
1810 cycles_b = 0;
1811 }
1812 #endif
1813
1814 /* Do till the process execution is done */
1815 } while (!ui_exec_done);
1816
1817 #ifdef ARM_PROFILE_HW
1818 fprintf(stdout, "\n Peak MCPS = %f\n", Peak_b);
1819 fprintf(stdout, " Avg MCPS = %f\n", Ave_b);
1820 fprintf(stdout, " Peak frame = %d\n", Peak_frame_b);
1821 #endif
1822 fprintf(stderr, "TOTAL FRAMES : [%5d] \n", frame_counter);
1823
1824 err_code = (*p_get_config_param)(pv_ia_process_api_obj, &i_samp_freq,
1825 &i_num_chan, &i_pcm_wd_sz, &i_channel_mask);
1826 _IA_HANDLE_ERROR(p_proc_err_info, (pWORD8) "", err_code);
1827
1828 #ifdef WAV_HEADER
1829 #ifndef ARM_PROFILE_BOARD
1830 if (!fseek(g_pf_out, 0, SEEK_SET))
1831 write_wav_header(g_pf_out, i_total_bytes, i_samp_freq, i_num_chan,
1832 i_pcm_wd_sz, i_channel_mask);
1833 #endif
1834 #endif
1835
1836 return IA_NO_ERROR;
1837 }
1838
1839 /*****************************************************************************/
1840 /* */
1841 /* Function Name : ixheaacd_main */
1842 /* */
1843 /* Description : Main function */
1844 /* */
1845 /* Inputs : None */
1846 /* */
1847 /* Globals : None */
1848 /* */
1849 /* Processing : Parse the parameter file and run the ixheaacd_main process
1850 */
1851 /* */
1852 /* Outputs : None */
1853 /* */
1854 /* Returns : 0 on success, -1 on error */
1855 /* */
1856 /* Issues : None */
1857 /* */
1858 /* Revision history : */
1859 /* */
1860 /* DD MM YYYY Author Changes */
1861 /* 04 09 2005 Ittiam Created */
1862 /* */
1863 /*****************************************************************************/
1864
print_usage()1865 void print_usage() {
1866 printf("\n Usage \n");
1867 printf("\n <exceutable> -ifile:<input_file> -ofile:<out_file> [options]\n");
1868 printf("\n[options] can be,");
1869 printf("\n[-pcmsz:<pcmwordsize>]");
1870 printf("\n[-dmix:<down_mix>]");
1871 #ifdef RESAMPLE_SUPPORT
1872 /* By default not available */
1873 printf("\n[-f08:<out_08khz>]");
1874 printf("\n[-f16:<out_16khz>]");
1875 #endif
1876 printf("\n[-tostereo:<interleave_to_stereo>]");
1877 printf("\n[-dsample:<down_sample_sbr>]");
1878 printf("\n[-fs:<RAW_sample_rate>]");
1879 printf("\n[-nosync:<disable_sync>]");
1880 printf("\n[-sbrup:<auto_sbr_upsample>]");
1881
1882 printf("\n[-maxchannel:<maximum_num_channels>]");
1883 #ifdef MULTICHANNEL_ENABLE
1884 printf("\n[-coupchannel:<coupling_channel>]");
1885 printf("\n[-downmix:<down_mix_stereo>]");
1886 #endif
1887
1888 printf("\n\nwhere, \n <inputfile> is the input AAC file name");
1889 printf("\n <outputfile> is the output file name");
1890 printf("\n <pcmwordsize> is the bits per sample info. Only 16 is valid");
1891
1892 printf("\n <down_mix> is to enable/disable always mono output. Default 0");
1893 #ifdef RESAMPLE_SUPPORT
1894 printf("\n <out_08khz> is to enable/disable 8 kHz output. Default 0 ");
1895 printf("\n <out_16khz> is to enable/disable 16 kHz output. Default 0 ");
1896 #endif
1897 printf("\n <interleave_to_stereo> is to enable/disable always ");
1898 printf("\n interleaved to stereo output. Default 1 ");
1899 printf("\n <down_sample_sbr> is to enable/disable down-sampled SBR ");
1900 printf("\n output. Default auto identification from header");
1901 printf("\n <RAW_sample_rate> is to indicate the core AAC sample rate for");
1902 printf("\n a RAW stream. If this is specified no other file format");
1903 printf("\n headers are searched for. \n");
1904 printf("\n <disable_sync> is to disable the ADTS/ADIF sync search i.e");
1905 printf("\n when enabled the decoder expects the header to ");
1906 printf("\n be at the start of input buffer. Default 0");
1907 printf(
1908 "\n <auto_sbr_upsample> is to enable(1) or disable(0) auto SBR "
1909 "upsample ");
1910 printf(
1911 "\n in case of stream changing from SBR present to SBR not present. "
1912 "Default 1");
1913 printf("\n <maximum_num_channels> is the number of maxiumum ");
1914 printf("\n channels the input may have. Default is 6 (5.1)");
1915
1916 #ifdef MULTICHANNEL_ENABLE
1917 printf("\n <coupling_channel> is element instance tag of ");
1918 printf("\n independent coupling channel to be mixed. Default is 0");
1919 printf("\n <down_mix_stereo> is flag for Downmix. Give 1 to");
1920 printf("\n get stereo (downmix) output. Default is 0");
1921 #endif
1922 }
1923
1924 /*******************************************************************************/
1925 /* */
1926 /* Function Name : ixheaacd_main */
1927 /* */
1928 /* Description : Main function */
1929 /* */
1930 /* Inputs : None */
1931 /* */
1932 /* Globals : None */
1933 /* */
1934 /* Processing : Parse the parameter file and run the ixheaacd_main_process
1935 */
1936 /* */
1937 /* Outputs : None */
1938 /* */
1939 /* Returns : 0 on success, -1 on error */
1940 /* */
1941 /* Issues : None */
1942 /* */
1943 /* Revision history : */
1944 /* */
1945 /* DD MM YYYY Author Changes */
1946 /* 04 09 2005 Ittiam Created */
1947 /* */
1948 /*******************************************************************************/
1949
main(WORD32 argc,char * argv[])1950 int main(WORD32 argc, char *argv[]) {
1951 FILE *param_file_id;
1952
1953 WORD8 curr_cmd[IA_MAX_CMD_LINE_LENGTH];
1954 WORD32 fargc, curpos;
1955 WORD32 processcmd = 0;
1956
1957 WORD8 fargv[IA_MAX_ARGS][IA_MAX_CMD_LINE_LENGTH];
1958
1959 pWORD8 pargv[IA_MAX_ARGS];
1960
1961 WORD8 pb_input_file_path[IA_MAX_CMD_LINE_LENGTH] = "";
1962 WORD8 pb_output_file_path[IA_MAX_CMD_LINE_LENGTH] = "";
1963
1964 ia_testbench_error_handler_init();
1965
1966 if (argc == 1) {
1967 param_file_id = fopen(PARAMFILE, "r");
1968 if (param_file_id == NULL) {
1969 print_usage();
1970 return IA_NO_ERROR;
1971 }
1972
1973 /* Process one line at a time */
1974 while (fgets((char *)curr_cmd, IA_MAX_CMD_LINE_LENGTH, param_file_id)) {
1975 curpos = 0;
1976 fargc = 0;
1977 /* if it is not a param_file command and if */
1978 /* CLP processing is not enabled */
1979 if (curr_cmd[0] != '@' && !processcmd) { /* skip it */
1980 continue;
1981 }
1982
1983 while (sscanf((char *)curr_cmd + curpos, "%s", fargv[fargc]) != EOF) {
1984 if (fargv[0][0] == '/' && fargv[0][1] == '/') break;
1985 if (strcmp((const char *)fargv[0], "@echo") == 0) break;
1986 if (strcmp((const char *)fargv[fargc], "@New_line") == 0) {
1987 fgets((char *)curr_cmd + curpos, IA_MAX_CMD_LINE_LENGTH,
1988 param_file_id);
1989 continue;
1990 }
1991 curpos += strlen((const char *)fargv[fargc]);
1992 while (*(curr_cmd + curpos) == ' ' || *(curr_cmd + curpos) == '\t')
1993 curpos++;
1994 fargc++;
1995 }
1996
1997 if (fargc < 1) /* for blank lines etc. */
1998 continue;
1999
2000 if (strcmp((const char *)fargv[0], "@Output_path") == 0) {
2001 if (fargc > 1)
2002 strcpy((char *)pb_output_file_path, (const char *)fargv[1]);
2003 else
2004 strcpy((char *)pb_output_file_path, "");
2005 continue;
2006 }
2007
2008 if (strcmp((const char *)fargv[0], "@Input_path") == 0) {
2009 if (fargc > 1)
2010 strcpy((char *)pb_input_file_path, (const char *)fargv[1]);
2011 else
2012 strcpy((char *)pb_input_file_path, "");
2013 continue;
2014 }
2015
2016 if (strcmp((const char *)fargv[0], "@Start") == 0) {
2017 processcmd = 1;
2018 continue;
2019 }
2020
2021 if (strcmp((const char *)fargv[0], "@Stop") == 0) {
2022 processcmd = 0;
2023 continue;
2024 }
2025
2026 /* otherwise if this a normal command and its enabled for execution */
2027 if (processcmd) {
2028 int i;
2029 int err_code = IA_NO_ERROR;
2030 int file_count = 0;
2031
2032 for (i = 0; i < fargc; i++) {
2033 printf("%s ", fargv[i]);
2034 pargv[i] = fargv[i];
2035
2036 if (!strncmp((const char *)fargv[i], "-ifile:", 7)) {
2037 pWORD8 pb_arg_val = fargv[i] + 7;
2038 WORD8 pb_input_file_name[IA_MAX_CMD_LINE_LENGTH] = "";
2039
2040 strcat((char *)pb_input_file_name,
2041 (const char *)pb_input_file_path);
2042 strcat((char *)pb_input_file_name, (const char *)pb_arg_val);
2043
2044 g_pf_inp = NULL;
2045 g_pf_inp = FileWrapper_Open((char *)pb_input_file_name);
2046
2047 if (g_pf_inp == NULL) {
2048 err_code = IA_TESTBENCH_MFMAN_FATAL_FILE_OPEN_FAILED;
2049 ixheaacd_error_handler(&ixheaacd_ia_testbench_error_info,
2050 (pWORD8) "Input File", err_code);
2051 exit(1);
2052 }
2053 file_count++;
2054 raw_testing = 0;
2055 }
2056
2057 if (!strncmp((const char *)fargv[i], "-imeta:", 7)) {
2058 pWORD8 pb_arg_val = fargv[i] + 7;
2059 WORD8 pb_metadata_file_name[IA_MAX_CMD_LINE_LENGTH] = "";
2060
2061 strcat((char *)pb_metadata_file_name,
2062 (const char *)pb_input_file_path);
2063 strcat((char *)pb_metadata_file_name, (const char *)pb_arg_val);
2064
2065 g_pf_meta = fopen((const char *)pb_metadata_file_name, "r");
2066
2067 if (g_pf_meta == NULL) {
2068 err_code = IA_TESTBENCH_MFMAN_FATAL_FILE_OPEN_FAILED;
2069 ixheaacd_error_handler(&ixheaacd_ia_testbench_error_info,
2070 (pWORD8) "Metadata File", err_code);
2071 exit(1);
2072 }
2073
2074 metadata_info_init(&meta_info);
2075 err_code = ixheaacd_read_metadata_info(g_pf_meta, &meta_info);
2076
2077 if (err_code == -1) exit(1);
2078
2079 raw_testing = 1;
2080
2081 file_count++;
2082 }
2083
2084 if (!strncmp((const char *)fargv[i], "-ofile:", 7)) {
2085 pWORD8 pb_arg_val = fargv[i] + 7;
2086 WORD8 pb_output_file_name[IA_MAX_CMD_LINE_LENGTH] = "";
2087
2088 strcat((char *)pb_output_file_name,
2089 (const char *)pb_output_file_path);
2090 strcat((char *)pb_output_file_name, (const char *)pb_arg_val);
2091
2092 g_pf_out = NULL;
2093 g_pf_out = fopen((const char *)pb_output_file_name, "wb");
2094 if (g_pf_out == NULL) {
2095 err_code = IA_TESTBENCH_MFMAN_FATAL_FILE_OPEN_FAILED;
2096 ixheaacd_error_handler(&ixheaacd_ia_testbench_error_info,
2097 (pWORD8) "Output File", err_code);
2098 exit(1);
2099 }
2100 file_count++;
2101 }
2102 if (!strncmp((const char *)fargv[i], "-infile:", 8)) {
2103 pWORD8 pb_arg_val = fargv[i] + 8;
2104 WORD8 pb_interface_file_name[IA_MAX_CMD_LINE_LENGTH] = "";
2105
2106 strcat((char *)pb_interface_file_name,
2107 (const char *)pb_input_file_path);
2108 strcat((char *)pb_interface_file_name, (const char *)pb_arg_val);
2109
2110 g_pf_interface = NULL;
2111 g_pf_interface = fopen((const char *)pb_interface_file_name, "rb");
2112
2113 if (g_pf_interface == NULL) {
2114 err_code = IA_TESTBENCH_MFMAN_FATAL_FILE_OPEN_FAILED;
2115 ixheaacd_error_handler(&ixheaacd_ia_testbench_error_info,
2116 (pWORD8) "DRC Interface File", err_code);
2117 exit(1);
2118 }
2119 interface_file_present = 1;
2120 file_count++;
2121 }
2122 }
2123 g_w_malloc_count = 0;
2124
2125 printf("\n");
2126
2127 if (file_count != 4 && file_count != 3 && file_count != 2)
2128 {
2129 err_code = IA_TESTBENCH_MFMAN_FATAL_FILE_OPEN_FAILED;
2130 ixheaacd_error_handler(&ixheaacd_ia_testbench_error_info,
2131 (pWORD8) "Input or Output File", err_code);
2132 }
2133
2134 if (err_code == IA_NO_ERROR) {
2135 if (g_pf_inp->isMp4File == 1) {
2136 strcpy((pCHAR8)fargv[fargc], "-mp4:1");
2137 pargv[fargc] = fargv[fargc];
2138 fargc++;
2139 }
2140
2141 for (i = 0; i < fargc; i++) {
2142 if (strcmp((pCHAR8)fargv[i], "-eld_testing:1"))
2143 eld_testing = 0;
2144 else {
2145 eld_testing = 1;
2146 break;
2147 }
2148 }
2149
2150 ixheaacd_main_process(fargc, pargv);
2151 }
2152
2153 for (i = 0; i < g_w_malloc_count; i++) {
2154 if (g_pv_arr_alloc_memory[i]) free(g_pv_arr_alloc_memory[i]);
2155 }
2156 if (g_pf_out) fclose(g_pf_out);
2157
2158 if (g_pf_meta) {
2159 raw_testing = 0;
2160 fclose(g_pf_meta);
2161 memset_metadata(meta_info);
2162 g_pf_meta=NULL;
2163 }
2164 FileWrapper_Close(g_pf_inp);
2165
2166 if (g_pf_interface) {
2167 fclose(g_pf_interface);
2168 interface_file_present = 0;
2169 }
2170 }
2171 }
2172 } else {
2173 int i;
2174 int err_code = IA_NO_ERROR;
2175 int file_count = 0;
2176
2177 for (i = 1; i < argc; i++) {
2178 pargv[i] = fargv[i];
2179 strcpy((pCHAR8)fargv[i], (pCHAR8)argv[i]);
2180 printf("%s ", pargv[i]);
2181
2182 if (!strncmp((const char *)pargv[i], "-ifile:", 7)) {
2183 pWORD8 pb_arg_val = pargv[i] + 7;
2184 WORD8 pb_input_file_name[IA_MAX_CMD_LINE_LENGTH] = "";
2185
2186 err_code = IA_NO_ERROR;
2187 strcat((char *)pb_input_file_name, (const char *)pb_input_file_path);
2188 strcat((char *)pb_input_file_name, (const char *)pb_arg_val);
2189
2190 g_pf_inp = NULL;
2191 g_pf_inp = FileWrapper_Open((char *)pb_input_file_name);
2192 if (g_pf_inp == NULL) {
2193 err_code = IA_TESTBENCH_MFMAN_FATAL_FILE_OPEN_FAILED;
2194 ixheaacd_error_handler(&ixheaacd_ia_testbench_error_info,
2195 (pWORD8) "Input File", err_code);
2196 exit(1);
2197 }
2198 file_count++;
2199 raw_testing = 0;
2200 }
2201
2202 if (!strncmp((const char *)fargv[i], "-imeta:", 7)) {
2203 pWORD8 pb_arg_val = fargv[i] + 7;
2204 WORD8 pb_metadata_file_name[IA_MAX_CMD_LINE_LENGTH] = "";
2205
2206 strcat((char *)pb_metadata_file_name, (const char *)pb_input_file_path);
2207 strcat((char *)pb_metadata_file_name, (const char *)pb_arg_val);
2208
2209 g_pf_meta = NULL;
2210 g_pf_meta = fopen((const char *)pb_metadata_file_name, "r");
2211
2212 if (g_pf_meta == NULL) {
2213 err_code = IA_TESTBENCH_MFMAN_FATAL_FILE_OPEN_FAILED;
2214 ixheaacd_error_handler(&ixheaacd_ia_testbench_error_info,
2215 (pWORD8) "Metadata File", err_code);
2216 exit(1);
2217 }
2218
2219 metadata_info_init(&meta_info);
2220 err_code = ixheaacd_read_metadata_info(g_pf_meta, &meta_info);
2221
2222 if (err_code == -1) {
2223 exit(1);
2224 }
2225
2226 raw_testing = 1;
2227
2228 file_count++;
2229 }
2230
2231 if (!strncmp((const char *)pargv[i], "-ofile:", 7)) {
2232 pWORD8 pb_arg_val = pargv[i] + 7;
2233 WORD8 pb_output_file_name[IA_MAX_CMD_LINE_LENGTH] = "";
2234
2235 strcat((char *)pb_output_file_name, (const char *)pb_output_file_path);
2236 strcat((char *)pb_output_file_name, (const char *)pb_arg_val);
2237
2238 g_pf_out = NULL;
2239 g_pf_out = fopen((const char *)pb_output_file_name, "wb");
2240 if (g_pf_out == NULL) {
2241 err_code = IA_TESTBENCH_MFMAN_FATAL_FILE_OPEN_FAILED;
2242 ixheaacd_error_handler(&ixheaacd_ia_testbench_error_info,
2243 (pWORD8) "Output File", err_code);
2244 exit(1);
2245 }
2246 file_count++;
2247 }
2248
2249 if (!strncmp((const char *)fargv[i], "-infile:", 8)) {
2250 pWORD8 pb_arg_val = fargv[i] + 8;
2251 WORD8 pb_interface_file_name[IA_MAX_CMD_LINE_LENGTH] = "";
2252
2253 strcat((char *)pb_interface_file_name,
2254 (const char *)pb_input_file_path);
2255 strcat((char *)pb_interface_file_name, (const char *)pb_arg_val);
2256
2257 g_pf_interface = NULL;
2258 g_pf_interface = fopen((const char *)pb_interface_file_name, "rb");
2259
2260 if (g_pf_interface == NULL) {
2261 err_code = IA_TESTBENCH_MFMAN_FATAL_FILE_OPEN_FAILED;
2262 ixheaacd_error_handler(&ixheaacd_ia_testbench_error_info,
2263 (pWORD8) "DRC Interface File", err_code);
2264 exit(1);
2265 }
2266 interface_file_present = 1;
2267 file_count++;
2268 }
2269 }
2270 g_w_malloc_count = 0;
2271
2272 printf("\n");
2273
2274 if (file_count != 4 && file_count != 3 && file_count != 2)
2275 {
2276 err_code = IA_TESTBENCH_MFMAN_FATAL_FILE_OPEN_FAILED;
2277 ixheaacd_error_handler(&ixheaacd_ia_testbench_error_info,
2278 (pWORD8) "Input or Output File", err_code);
2279 }
2280
2281 if (err_code == IA_NO_ERROR) {
2282 if (g_pf_inp->isMp4File == 1) {
2283 strcpy((pCHAR8)fargv[argc], "-mp4:1");
2284 pargv[argc] = fargv[argc];
2285 argc++;
2286 }
2287
2288 for (i = 0; i < argc; i++) {
2289 if (strcmp((pCHAR8)fargv[i], "-eld_testing:1"))
2290 eld_testing = 0;
2291 else {
2292 eld_testing = 1;
2293 break;
2294 }
2295 }
2296
2297 ixheaacd_main_process(argc - 1, &pargv[1]);
2298 }
2299
2300 for (i = 0; i < g_w_malloc_count; i++) {
2301 if (g_pv_arr_alloc_memory[i]) free(g_pv_arr_alloc_memory[i]);
2302 }
2303 if (g_pf_out) fclose(g_pf_out);
2304
2305 if (g_pf_meta) {
2306 fclose(g_pf_meta);
2307 memset_metadata(meta_info);
2308 }
2309 FileWrapper_Close(g_pf_inp);
2310 if (g_pf_interface) {
2311 fclose(g_pf_interface);
2312 interface_file_present = 0;
2313 }
2314 }
2315
2316 return IA_NO_ERROR;
2317 } /* end ixheaacd_main */
2318