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 <math.h>
22 #include "ixheaacd_sbr_common.h"
23 #include "ixheaacd_type_def.h"
24
25 #include "ixheaacd_constants.h"
26 #include "ixheaacd_basic_ops32.h"
27 #include "ixheaacd_basic_ops16.h"
28 #include "ixheaacd_basic_ops40.h"
29 #include "ixheaacd_basic_ops.h"
30
31 #include "ixheaacd_basic_op.h"
32 #include "ixheaacd_intrinsics.h"
33 #include "ixheaacd_common_rom.h"
34 #include "ixheaacd_basic_funcs.h"
35 #include "ixheaacd_bitbuffer.h"
36 #include "ixheaacd_sbr_common.h"
37 #include "ixheaacd_drc_data_struct.h"
38 #include "ixheaacd_drc_dec.h"
39 #include "ixheaacd_sbrdecoder.h"
40 #include "ixheaacd_sbrdecsettings.h"
41 #include "ixheaacd_sbr_scale.h"
42 #include "ixheaacd_lpp_tran.h"
43 #include "ixheaacd_env_extr_part.h"
44 #include "ixheaacd_sbr_rom.h"
45 #include "ixheaacd_hybrid.h"
46 #include "ixheaacd_ps_dec.h"
47 #include "ixheaacd_env_extr.h"
48
49 #include "ixheaacd_sbr_const.h"
50 #include "ixheaacd_intrinsics.h"
51
52 #include "ixheaacd_pvc_dec.h"
53
54 #include "ixheaacd_ps_bitdec.h"
55
56 #include "ixheaacd_audioobjtypes.h"
57
ixheaacd_cnt_leading_ones(WORD32 a)58 WORD32 ixheaacd_cnt_leading_ones(WORD32 a) {
59 WORD32 count = 0;
60
61 while (a) {
62 if (a & 0x80000000)
63 count++;
64 else
65 break;
66 a = a << 1;
67 }
68 return count;
69 }
ixheaacd_huffman_decode(WORD32 it_bit_buff,WORD16 * h_index,WORD16 * len,const UWORD16 * input_table,const UWORD32 * idx_table)70 VOID ixheaacd_huffman_decode(WORD32 it_bit_buff, WORD16 *h_index, WORD16 *len,
71 const UWORD16 *input_table,
72 const UWORD32 *idx_table) {
73 UWORD32 temp = 0;
74 UWORD32 temp1 = 0;
75 WORD32 found = 0;
76 UWORD32 mask = 0x80000000;
77
78 WORD32 clo;
79 WORD32 MAX_LEN;
80 WORD32 ixheaacd_drc_offset = 0;
81 WORD32 length;
82 UWORD32 cwrd;
83 WORD32 len_end;
84
85 MAX_LEN = input_table[0];
86 mask = mask - (1 << (31 - MAX_LEN));
87 mask = mask << 1;
88 temp = (UWORD32)(it_bit_buff & mask);
89
90 len_end = input_table[0];
91 clo = ixheaacd_cnt_leading_ones(temp);
92 do {
93 ixheaacd_drc_offset = (idx_table[clo] >> 20) & 0xff;
94 length = input_table[ixheaacd_drc_offset + 1] & 0x1f;
95 cwrd = idx_table[clo] & 0xfffff;
96 temp1 = temp >> (32 - length);
97 if (temp1 <= cwrd) {
98 ixheaacd_drc_offset = ixheaacd_drc_offset - (cwrd - temp1);
99 found = 1;
100 } else {
101 len_end = len_end + ((idx_table[clo] >> 28) & 0xf);
102 clo = len_end;
103 }
104 } while (!found);
105 *h_index = input_table[ixheaacd_drc_offset + 1] >> 5;
106 *len = length;
107 }
108
ixheaacd_read_esbr_pvc_envelope(ia_pvc_data_struct * ptr_pvc_data,ia_bit_buf_struct * it_bit_buff,WORD32 indepFlag)109 static WORD32 ixheaacd_read_esbr_pvc_envelope(ia_pvc_data_struct *ptr_pvc_data,
110 ia_bit_buf_struct *it_bit_buff,
111 WORD32 indepFlag) {
112 WORD32 i, j, k;
113 WORD32 fixed_length = 0, num_grid_info = 0, grid_info;
114 UWORD8 div_mode, ns_mode;
115 UWORD16 pvc_id[PVC_NUM_TIME_SLOTS + 1];
116 UWORD8 num_length;
117 UWORD8 length;
118 UWORD8 reuse_pvc_id;
119 WORD32 sum_length = 0;
120 WORD32 length_bits = 4;
121 UWORD8 pvc_id_bits = PVC_ID_BITS;
122 IA_ERRORCODE err = IA_NO_ERROR;
123
124 div_mode = (UWORD8)ixheaacd_read_bits_buf(it_bit_buff, PVC_DIV_MODE_BITS);
125 ns_mode = (UWORD8)ixheaacd_read_bits_buf(it_bit_buff, PVC_NS_MODE_BITS);
126
127 if (ptr_pvc_data->pvc_mode == 3) {
128 pvc_id_bits = 0;
129 }
130
131 if (div_mode <= 3) {
132 num_length = div_mode;
133 if (indepFlag) {
134 reuse_pvc_id = 0;
135 } else {
136 reuse_pvc_id =
137 (UWORD8)ixheaacd_read_bits_buf(it_bit_buff, PVC_REUSE_PVC_ID_BITS);
138 }
139 if (reuse_pvc_id == 1) {
140 pvc_id[0] = ptr_pvc_data->prev_pvc_id;
141 } else {
142 pvc_id[0] = (UWORD16)ixheaacd_read_bits_buf(it_bit_buff, pvc_id_bits);
143 }
144
145 k = 1;
146 if (num_length) {
147 sum_length = 0;
148 for (i = 0; i < num_length; i++) {
149 if (sum_length >= 13) {
150 length_bits = 1;
151 } else if (sum_length >= 11) {
152 length_bits = 2;
153 } else if (sum_length >= 7) {
154 length_bits = 3;
155 } else {
156 length_bits = 4;
157 }
158 length = (UWORD8)ixheaacd_read_bits_buf(it_bit_buff, length_bits);
159 length += 1;
160 sum_length += length;
161 if ((k + length - 1) > PVC_NUM_TIME_SLOTS) {
162 return -1;
163 }
164 for (j = 1; j < length; j++, k++) {
165 pvc_id[k] = pvc_id[k - 1];
166 }
167 pvc_id[k++] = (UWORD16)ixheaacd_read_bits_buf(it_bit_buff, pvc_id_bits);
168 }
169 }
170
171 for (; k < 16; k++) {
172 pvc_id[k] = pvc_id[k - 1];
173 }
174
175 } else {
176 switch (div_mode) {
177 case 4:
178 num_grid_info = 2;
179 fixed_length = 8;
180 break;
181 case 5:
182 num_grid_info = 4;
183 fixed_length = 4;
184 break;
185 case 6:
186 num_grid_info = 8;
187 fixed_length = 2;
188 break;
189 case 7:
190 num_grid_info = 16;
191 fixed_length = 1;
192 break;
193 default:;
194 }
195 if (indepFlag) {
196 grid_info = 1;
197 } else {
198 grid_info = ixheaacd_read_bits_buf(it_bit_buff, PVC_GRID_INFO_BITS);
199 }
200 if (grid_info) {
201 pvc_id[0] = (UWORD16)ixheaacd_read_bits_buf(it_bit_buff, pvc_id_bits);
202 } else {
203 pvc_id[0] = ptr_pvc_data->prev_pvc_id;
204 }
205 for (j = 1, k = 1; j < fixed_length; j++, k++) {
206 pvc_id[k] = pvc_id[k - 1];
207 }
208
209 for (i = 1; i < num_grid_info; i++) {
210 grid_info = ixheaacd_read_bits_buf(it_bit_buff, PVC_GRID_INFO_BITS);
211 if (grid_info == 1) {
212 pvc_id[k++] = (UWORD16)ixheaacd_read_bits_buf(it_bit_buff, pvc_id_bits);
213 } else {
214 pvc_id[k] = pvc_id[k - 1];
215 k++;
216 }
217 for (j = 1; j < fixed_length; j++, k++) {
218 pvc_id[k] = pvc_id[k - 1];
219 }
220 }
221 }
222 ptr_pvc_data->div_mode = div_mode;
223 ptr_pvc_data->ns_mode = ns_mode;
224 for (i = 0; i < PVC_NUM_TIME_SLOTS; i++) {
225 ptr_pvc_data->pvc_id[i] = pvc_id[i];
226 }
227 return err;
228 }
229
ixheaacd_pvc_env_dtdf_data(ia_sbr_frame_info_data_struct * ptr_frame_data,ia_bit_buf_struct * it_bit_buff)230 static VOID ixheaacd_pvc_env_dtdf_data(
231 ia_sbr_frame_info_data_struct *ptr_frame_data,
232 ia_bit_buf_struct *it_bit_buff) {
233 WORD32 i;
234 WORD32 usac_independency_flag = ptr_frame_data->usac_independency_flag;
235 WORD32 bs_num_noise = ptr_frame_data->str_frame_info_details.num_noise_env;
236
237 if (usac_independency_flag) {
238 ptr_frame_data->del_cod_dir_noise_arr[0] = 0;
239 } else {
240 ptr_frame_data->del_cod_dir_noise_arr[0] =
241 ixheaacd_read_bits_buf(it_bit_buff, ESBR_DOMAIN_BITS);
242 }
243
244 for (i = 1; i < bs_num_noise; i++) {
245 ptr_frame_data->del_cod_dir_noise_arr[i] =
246 ixheaacd_read_bits_buf(it_bit_buff, ESBR_DOMAIN_BITS);
247 }
248 }
249
ixheaacd_read_sbr_addi_data(ia_sbr_frame_info_data_struct * ptr_frame_data,ia_sbr_header_data_struct * ptr_header_data,ia_bit_buf_struct * it_bit_buff)250 static VOID ixheaacd_read_sbr_addi_data(
251 ia_sbr_frame_info_data_struct *ptr_frame_data,
252 ia_sbr_header_data_struct *ptr_header_data,
253 ia_bit_buf_struct *it_bit_buff) {
254 WORD32 i;
255
256 WORD32 flag = ixheaacd_read_bits_buf(it_bit_buff, 1);
257
258 ptr_frame_data->sin_start_for_cur_top =
259 ptr_frame_data->sin_start_for_next_top;
260 ptr_frame_data->sin_len_for_cur_top = ptr_frame_data->sin_len_for_next_top;
261 ptr_frame_data->sin_start_for_next_top = 0;
262 ptr_frame_data->sin_len_for_next_top = 0;
263
264 if (flag) {
265 for (i = 0; i < ptr_header_data->pstr_freq_band_data->num_sf_bands[HIGH];
266 i++) {
267 ptr_frame_data->add_harmonics[i] = ixheaacd_read_bits_buf(it_bit_buff, 1);
268 }
269 if (ptr_frame_data->pvc_mode != 0) {
270 ptr_frame_data->sine_position = ESC_SIN_POS;
271
272 ptr_frame_data->bs_sin_pos_present =
273 ixheaacd_read_bits_buf(it_bit_buff, 1);
274
275 if (ptr_frame_data->bs_sin_pos_present == 1) {
276 ptr_frame_data->sine_position = ixheaacd_read_bits_buf(it_bit_buff, 5);
277 }
278 if (ptr_frame_data->var_len > 0) {
279 if (ptr_frame_data->sine_position > 16) {
280 if (ptr_frame_data->sine_position == 31) {
281 ptr_frame_data->sin_start_for_next_top = 0;
282 ptr_frame_data->sin_len_for_next_top = ptr_frame_data->var_len;
283 } else {
284 if ((ptr_frame_data->var_len + 16) ==
285 ptr_frame_data->sine_position) {
286 ptr_frame_data->sin_start_for_next_top = 0;
287 ptr_frame_data->sin_len_for_next_top = ptr_frame_data->var_len;
288 } else {
289 ptr_frame_data->sin_start_for_next_top =
290 ptr_frame_data->sine_position - 16;
291 ptr_frame_data->sin_len_for_next_top = ptr_frame_data->var_len;
292 }
293 }
294 } else {
295 ptr_frame_data->sin_start_for_next_top = 0;
296 ptr_frame_data->sin_len_for_next_top = ptr_frame_data->var_len;
297 }
298 } else {
299 ptr_frame_data->sin_start_for_next_top = 0;
300 ptr_frame_data->sin_len_for_next_top = 0;
301 }
302 }
303 }
304 return;
305 }
306
ixheaacd_ssc_huff_dec(ia_huffman_data_type t_huff,ia_handle_bit_buf_struct it_bit_buff)307 WORD32 ixheaacd_ssc_huff_dec(ia_huffman_data_type t_huff,
308 ia_handle_bit_buf_struct it_bit_buff) {
309 WORD32 index;
310 WORD32 value, bit;
311 WORD16 cw;
312 index = 0;
313
314 while (index >= 0) {
315 cw = t_huff[index];
316
317 bit = ixheaacd_read_bits_buf(it_bit_buff, 1);
318
319 if (bit) {
320 WORD sign = (cw & 0x0080);
321 if (sign) {
322 index = (cw | 0xffffff80);
323 } else {
324 index = (cw & 0x007f);
325 }
326 } else {
327 index = (cw >> 8);
328 }
329 }
330
331 value = (index + 64);
332
333 return (value);
334 }
335
ixheaacd_sbr_read_header_data(ia_sbr_header_data_struct * pstr_sbr_header,ia_bit_buf_struct * it_bit_buff,FLAG stereo_flag,ia_sbr_header_data_struct * pstr_sbr_dflt_header)336 WORD32 ixheaacd_sbr_read_header_data(
337 ia_sbr_header_data_struct *pstr_sbr_header, ia_bit_buf_struct *it_bit_buff,
338 FLAG stereo_flag, ia_sbr_header_data_struct *pstr_sbr_dflt_header) {
339 ia_sbr_header_data_struct prev_header_info;
340 FLAG header_extra_1 = 0, header_extra_2 = 0;
341 WORD32 tmp;
342 WORD32 usac_independency_flag = pstr_sbr_header->usac_independency_flag;
343 WORD32 use_dflt_hdr = 0;
344 WORD32 header_present = 1;
345 WORD32 usac_flag = pstr_sbr_header->usac_flag;
346
347 if (!usac_flag) {
348 memcpy(&prev_header_info, pstr_sbr_header,
349 sizeof(ia_sbr_header_data_struct));
350
351 tmp = ixheaacd_read_bits_buf(
352 it_bit_buff, SBR_AMPLITUDE_RESOLUTION_BITS + SBR_BEGIN_SAMP_FREQ_BITS +
353 SBR_END_SAMP_FREQ_BITS + SBR_CROSS_OVER_BND_BITS);
354
355 pstr_sbr_header->amp_res = (WORD16)(
356 (tmp & 0x0800) >> (SBR_BEGIN_SAMP_FREQ_BITS + SBR_END_SAMP_FREQ_BITS +
357 SBR_CROSS_OVER_BND_BITS));
358
359 pstr_sbr_header->start_freq = (WORD16)(
360 (tmp & 0x0780) >> (SBR_END_SAMP_FREQ_BITS + SBR_CROSS_OVER_BND_BITS));
361
362 pstr_sbr_header->stop_freq =
363 (WORD16)((tmp & 0x078) >> (SBR_CROSS_OVER_BND_BITS));
364
365 pstr_sbr_header->xover_band = (WORD16)((tmp & 0x07));
366
367 tmp = ixheaacd_read_bits_buf(
368 it_bit_buff,
369 SBR_HDR_RESERV_BITS + SBR_HDR_EXTR_1_BITS + SBR_HDR_EXTR_2_BITS);
370 header_extra_1 = (FLAG)((tmp & 0x02) >> (SBR_HDR_EXTR_2_BITS));
371 header_extra_2 = (FLAG)((tmp & 0x01));
372 if (stereo_flag) {
373 pstr_sbr_header->channel_mode = SBR_STEREO;
374 } else {
375 pstr_sbr_header->channel_mode = SBR_MONO;
376 }
377 } else {
378 WORD32 info_present = 0;
379 if (pstr_sbr_header->sync_state == SBR_ACTIVE) {
380 memcpy(&prev_header_info, pstr_sbr_header,
381 sizeof(ia_sbr_header_data_struct));
382 }
383 if (usac_independency_flag) {
384 header_present = 1;
385 info_present = 1;
386 } else {
387 info_present = ixheaacd_read_bits_buf(it_bit_buff, 1);
388 if (info_present) {
389 header_present = ixheaacd_read_bits_buf(it_bit_buff, 1);
390 } else {
391 header_present = 0;
392 }
393 }
394
395 if (info_present) {
396 tmp = ixheaacd_read_bits_buf(it_bit_buff, SBR_AMPLITUDE_RESOLUTION_BITS +
397 ESBR_CROSS_OVER_BND_BITS +
398 ESBR_PRE_FLAT_BITS);
399 pstr_sbr_header->amp_res = (WORD16)(
400 (tmp & 0x0020) >> (ESBR_CROSS_OVER_BND_BITS + ESBR_PRE_FLAT_BITS));
401 pstr_sbr_header->xover_band =
402 (WORD16)((tmp & 0x001E) >> (ESBR_PRE_FLAT_BITS));
403 pstr_sbr_header->pre_proc_flag = (WORD16)((tmp & 0x001));
404 if (pstr_sbr_header->pvc_flag) {
405 pstr_sbr_header->pvc_mode =
406 ixheaacd_read_bits_buf(it_bit_buff, ESBR_PVC_MODE_BITS);
407 } else {
408 pstr_sbr_header->pvc_mode = 0;
409 }
410 }
411
412 if (header_present) {
413 use_dflt_hdr = ixheaacd_read_bits_buf(it_bit_buff, 1);
414 if (use_dflt_hdr) {
415 pstr_sbr_header->start_freq = pstr_sbr_dflt_header->start_freq;
416 pstr_sbr_header->stop_freq = pstr_sbr_dflt_header->stop_freq;
417 pstr_sbr_header->header_extra_1 = pstr_sbr_dflt_header->header_extra_1;
418 pstr_sbr_header->header_extra_2 = pstr_sbr_dflt_header->header_extra_2;
419 pstr_sbr_header->freq_scale = pstr_sbr_dflt_header->freq_scale;
420 pstr_sbr_header->alter_scale = pstr_sbr_dflt_header->alter_scale;
421 pstr_sbr_header->noise_bands = pstr_sbr_dflt_header->noise_bands;
422 pstr_sbr_header->limiter_bands = pstr_sbr_dflt_header->limiter_bands;
423 pstr_sbr_header->limiter_gains = pstr_sbr_dflt_header->limiter_gains;
424 pstr_sbr_header->interpol_freq = pstr_sbr_dflt_header->interpol_freq;
425 pstr_sbr_header->smoothing_mode = pstr_sbr_dflt_header->smoothing_mode;
426 } else {
427 tmp = ixheaacd_read_bits_buf(
428 it_bit_buff, SBR_BEGIN_SAMP_FREQ_BITS + SBR_END_SAMP_FREQ_BITS +
429 SBR_HDR_EXTR_1_BITS + SBR_HDR_EXTR_2_BITS);
430 pstr_sbr_header->start_freq =
431 (tmp & 0x03C0) >> (SBR_END_SAMP_FREQ_BITS + SBR_HDR_EXTR_1_BITS +
432 SBR_HDR_EXTR_2_BITS);
433 pstr_sbr_header->stop_freq =
434 (tmp & 0x003C) >> (SBR_HDR_EXTR_1_BITS + SBR_HDR_EXTR_2_BITS);
435 pstr_sbr_header->header_extra_1 =
436 (tmp & 0x0002) >> (SBR_HDR_EXTR_2_BITS);
437 pstr_sbr_header->header_extra_2 = (tmp & 0x0001);
438 header_extra_1 = pstr_sbr_header->header_extra_1;
439 header_extra_2 = pstr_sbr_header->header_extra_2;
440 }
441 }
442 }
443
444 if (!use_dflt_hdr && header_present) {
445 if (header_extra_1) {
446 tmp = ixheaacd_read_bits_buf(
447 it_bit_buff,
448 SBR_SAMP_FREQ_LVL_BITS + SBR_CHANGE_LVL_BITS + SBR_NOISE_BND_BITS);
449 pstr_sbr_header->freq_scale =
450 (WORD16)((tmp & 0x018) >> (SBR_CHANGE_LVL_BITS + SBR_NOISE_BND_BITS));
451 pstr_sbr_header->alter_scale =
452 (WORD16)((tmp & 0x04) >> (SBR_NOISE_BND_BITS));
453 pstr_sbr_header->noise_bands = (WORD16)((tmp & 0x03));
454 } else {
455 pstr_sbr_header->freq_scale = SBR_SAMP_FEQ_LVL_DEF;
456 pstr_sbr_header->alter_scale = SBR_CHANGE_LVL_DEF;
457 pstr_sbr_header->noise_bands = SBR_NOISE_BND_DEF;
458 }
459
460 if (header_extra_2) {
461 tmp = ixheaacd_read_bits_buf(
462 it_bit_buff, SBR_BND_LIMIT_BITS + SBR_GAIN_LIMIT_BITS +
463 SBR_INTERPOL_SAMP_FREQ_BITS + SBR_SMOOTH_LEN_BITS);
464 pstr_sbr_header->limiter_bands = (WORD16)(
465 (tmp & 0x030) >> (SBR_GAIN_LIMIT_BITS + SBR_INTERPOL_SAMP_FREQ_BITS +
466 SBR_SMOOTH_LEN_BITS));
467 pstr_sbr_header->limiter_gains = (WORD16)(
468 (tmp & 0x0c) >> (SBR_INTERPOL_SAMP_FREQ_BITS + SBR_SMOOTH_LEN_BITS));
469 pstr_sbr_header->interpol_freq =
470 (WORD16)((tmp & 0x02) >> (SBR_SMOOTH_LEN_BITS));
471 pstr_sbr_header->smoothing_mode = (WORD16)((tmp & 0x01));
472 } else {
473 pstr_sbr_header->limiter_bands = SBR_BND_LIMIT_DEF;
474 pstr_sbr_header->limiter_gains = SBR_GAIN_LIMIT_DEF;
475 pstr_sbr_header->interpol_freq = SBR_INTERPOL_SAMP_FEQ_DEF;
476 pstr_sbr_header->smoothing_mode = SBR_SMOOTH_LEN_DEF;
477 }
478 }
479
480 if ((pstr_sbr_header->sync_state != SBR_ACTIVE) ||
481 (prev_header_info.start_freq != pstr_sbr_header->start_freq) ||
482 (prev_header_info.stop_freq != pstr_sbr_header->stop_freq) ||
483 (prev_header_info.xover_band != pstr_sbr_header->xover_band) ||
484 (prev_header_info.freq_scale != pstr_sbr_header->freq_scale) ||
485 (prev_header_info.alter_scale != pstr_sbr_header->alter_scale) ||
486 (prev_header_info.noise_bands != pstr_sbr_header->noise_bands)) {
487 return SBR_RESET;
488 }
489
490 return 0;
491 }
492
ixheaacd_sbr_sin_coding_data(ia_sbr_header_data_struct * ptr_header_data,ia_sbr_frame_info_data_struct * ptr_frame_data,ia_bit_buf_struct * it_bit_buff)493 static VOID ixheaacd_sbr_sin_coding_data(
494 ia_sbr_header_data_struct *ptr_header_data,
495 ia_sbr_frame_info_data_struct *ptr_frame_data,
496 ia_bit_buf_struct *it_bit_buff) {
497 FLAG *p_add_harmonic = ptr_frame_data->add_harmonics;
498 WORD32 i;
499
500 i = ptr_header_data->pstr_freq_band_data->num_sf_bands[HIGH];
501 do {
502 *p_add_harmonic++ =
503 (FLAG)ixheaacd_read_bits_buf(it_bit_buff, SBR_ADD_SINE_FLAG_BITS);
504 i--;
505 } while (i != 0);
506
507 return;
508 }
509
ixheaacd_validate_frame_info(ia_frame_info_struct * pstr_frame_info,WORD16 num_time_slots,WORD audio_object_type)510 static WORD16 ixheaacd_validate_frame_info(
511 ia_frame_info_struct *pstr_frame_info, WORD16 num_time_slots,
512 WORD audio_object_type) {
513 WORD32 i, j;
514
515 WORD32 start_pos, end_pos, transient_env, start_pos_noise, end_pos_noise,
516 num_env_sf, num_noise_env;
517
518 num_env_sf = pstr_frame_info->num_env;
519 num_noise_env = pstr_frame_info->num_noise_env;
520
521 if ((num_env_sf < 1) || (num_env_sf > MAX_ENVELOPES)) return 0;
522
523 if (num_noise_env > MAX_NOISE_ENVELOPES) return 0;
524
525 start_pos = pstr_frame_info->border_vec[0];
526 end_pos = pstr_frame_info->border_vec[num_env_sf];
527 transient_env = pstr_frame_info->transient_env;
528
529 if (transient_env > num_env_sf) return 0;
530
531 start_pos_noise = pstr_frame_info->noise_border_vec[0];
532 end_pos_noise = pstr_frame_info->noise_border_vec[num_noise_env];
533
534 if ((start_pos < 0) || (start_pos >= end_pos)) return 0;
535
536 if (start_pos > SBR_OV_SLOTS) return 0;
537 if (audio_object_type != AOT_ER_AAC_ELD &&
538 audio_object_type != AOT_ER_AAC_LD) {
539 if (end_pos < SBR_TIME_SLOTS) return 0;
540 } else {
541 if (end_pos < num_time_slots) return 0;
542 }
543
544 if (end_pos > add_d(SBR_TIME_SLOTS, SBR_OV_SLOTS)) return 0;
545
546 for (i = 0; i < num_env_sf; i++) {
547 if (pstr_frame_info->border_vec[i] > pstr_frame_info->border_vec[i + 1])
548 return 0;
549 }
550
551 if ((num_env_sf == 1) && (num_noise_env > 1)) return 0;
552
553 if ((start_pos != start_pos_noise) || (end_pos != end_pos_noise)) return 0;
554
555 for (i = 0; i < num_noise_env; i++) {
556 start_pos_noise = pstr_frame_info->noise_border_vec[i];
557
558 for (j = 0; j < num_env_sf; j++) {
559 if (pstr_frame_info->border_vec[j] == start_pos_noise) break;
560 }
561 if (j == num_env_sf) return 0;
562 }
563
564 return 1;
565 }
566
ixheaacd_read_extn_data(ia_sbr_header_data_struct * ptr_header_data,ia_ps_dec_struct * ptr_ps_dec,ia_bit_buf_struct * it_bit_buff,ia_ps_tables_struct * ps_tables_ptr)567 static VOID ixheaacd_read_extn_data(ia_sbr_header_data_struct *ptr_header_data,
568 ia_ps_dec_struct *ptr_ps_dec,
569 ia_bit_buf_struct *it_bit_buff,
570 ia_ps_tables_struct *ps_tables_ptr) {
571 WORD i;
572 WORD extended_data;
573 WORD no_bits_left;
574
575 extended_data = ixheaacd_read_bits_buf(it_bit_buff, SBR_ENLARGED_DATA_BITS);
576
577 if (extended_data) {
578 WORD cnt;
579 FLAG ps_read;
580
581 ps_read = 0;
582
583 cnt = ixheaacd_read_bits_buf(it_bit_buff, SBR_CONT_SIZE_BITS);
584
585 if (cnt == ((1 << SBR_CONT_SIZE_BITS) - 1)) {
586 cnt = (cnt + ixheaacd_read_bits_buf(it_bit_buff, SBR_CONT_ESC_CNT_BITS));
587 }
588
589 no_bits_left = (cnt << 3);
590
591 while (no_bits_left > 7) {
592 WORD extension_id = ixheaacd_read_bits_buf(it_bit_buff, SBR_CONT_ID_BITS);
593
594 no_bits_left = (no_bits_left - SBR_CONT_ID_BITS);
595
596 switch (extension_id) {
597 case EXTENSION_ID_PS_CODING:
598
599 if (ptr_ps_dec == NULL) {
600 return;
601 }
602
603 if (!(ptr_ps_dec->force_mono || ps_read)) {
604 no_bits_left =
605 (no_bits_left - ixheaacd_read_ps_data(ptr_ps_dec, it_bit_buff,
606 (WORD16)no_bits_left,
607 ps_tables_ptr));
608
609 if (no_bits_left < 0) return;
610
611 ptr_header_data->channel_mode = PS_STEREO;
612 ps_read = 1;
613 break;
614 }
615
616 default:
617 cnt = (no_bits_left >> 3);
618 for (i = cnt - 1; i >= 0; i--) ixheaacd_read_bits_buf(it_bit_buff, 8);
619 no_bits_left = (no_bits_left - (cnt << 3));
620 break;
621 }
622 }
623
624 if (no_bits_left < 0) return;
625
626 ixheaacd_read_bits_buf(it_bit_buff, no_bits_left);
627 }
628 return;
629 }
630
ixheaacd_sbr_read_pvc_sce(ia_sbr_frame_info_data_struct * ptr_frame_data,ia_bit_buf_struct * it_bit_buff,WORD32 hbe_flag,ia_pvc_data_struct * ptr_pvc_data,ia_sbr_tables_struct * ptr_sbr_tables,ia_sbr_header_data_struct * ptr_header_data)631 WORD32 ixheaacd_sbr_read_pvc_sce(ia_sbr_frame_info_data_struct *ptr_frame_data,
632 ia_bit_buf_struct *it_bit_buff,
633 WORD32 hbe_flag,
634 ia_pvc_data_struct *ptr_pvc_data,
635 ia_sbr_tables_struct *ptr_sbr_tables,
636 ia_sbr_header_data_struct *ptr_header_data) {
637 WORD32 i;
638 WORD32 err_code = 0;
639 ia_env_extr_tables_struct *env_extr_tables_ptr =
640 ptr_sbr_tables->env_extr_tables_ptr;
641 WORD32 usac_independency_flag = ptr_frame_data->usac_independency_flag;
642
643 if (hbe_flag) {
644 ptr_frame_data->sbr_patching_mode =
645 ixheaacd_read_bits_buf(it_bit_buff, ESBR_PATCHING_MODE_BITS);
646
647 if (ptr_frame_data->sbr_patching_mode == 0) {
648 ptr_frame_data->over_sampling_flag =
649 ixheaacd_read_bits_buf(it_bit_buff, ESBR_OVERSAMPLING_FLAG_BITS);
650 if (ixheaacd_read_bits_buf(it_bit_buff, ESBR_PITCHIN_FLAG_BITS))
651 ptr_frame_data->pitch_in_bins =
652 ixheaacd_read_bits_buf(it_bit_buff, ESBR_PITCHIN_BINS_BITS);
653 else
654 ptr_frame_data->pitch_in_bins = 0;
655 } else {
656 ptr_frame_data->over_sampling_flag = ptr_frame_data->pitch_in_bins = 0;
657 }
658 }
659
660 err_code = ixheaacd_pvc_time_freq_grid_info(it_bit_buff, ptr_frame_data);
661 if (err_code) return err_code;
662
663 ptr_pvc_data->prev_sbr_mode = PVC_SBR;
664
665 ixheaacd_pvc_env_dtdf_data(ptr_frame_data, it_bit_buff);
666
667 for (i = 0; i < ptr_header_data->pstr_freq_band_data->num_nf_bands; i++) {
668 ptr_frame_data->sbr_invf_mode_prev[i] = ptr_frame_data->sbr_invf_mode[i];
669 ptr_frame_data->sbr_invf_mode[i] =
670 (WORD32)ixheaacd_read_bits_buf(it_bit_buff, ESBR_INVF_MODE_BITS);
671 }
672
673 ptr_pvc_data->pvc_mode = ptr_header_data->pvc_mode;
674
675 err_code = ixheaacd_read_esbr_pvc_envelope(ptr_pvc_data, it_bit_buff,
676 usac_independency_flag);
677 if (err_code) return err_code;
678
679 ixheaacd_read_sbr_noise_floor_data(ptr_header_data, ptr_frame_data,
680 it_bit_buff, env_extr_tables_ptr);
681
682 memset(ptr_frame_data->add_harmonics, 0,
683 ptr_header_data->pstr_freq_band_data->num_sf_bands[HIGH] *
684 sizeof(WORD32));
685 ptr_frame_data->pvc_mode = ptr_header_data->pvc_mode;
686
687 ixheaacd_read_sbr_addi_data(ptr_frame_data, ptr_header_data, it_bit_buff);
688
689 ptr_frame_data->coupling_mode = COUPLING_OFF;
690
691 return err_code;
692 }
693
ixheaacd_sbr_read_sce(ia_sbr_header_data_struct * ptr_header_data,ia_sbr_frame_info_data_struct * ptr_frame_data,ia_ps_dec_struct * ptr_ps_dec,ia_bit_buf_struct * it_bit_buff,ia_sbr_tables_struct * ptr_sbr_tables,WORD audio_object_type)694 IA_ERRORCODE ixheaacd_sbr_read_sce(
695 ia_sbr_header_data_struct *ptr_header_data,
696 ia_sbr_frame_info_data_struct *ptr_frame_data, ia_ps_dec_struct *ptr_ps_dec,
697 ia_bit_buf_struct *it_bit_buff, ia_sbr_tables_struct *ptr_sbr_tables,
698 WORD audio_object_type) {
699 WORD32 bit;
700 WORD32 i;
701 WORD32 hbe_flag = ptr_header_data->hbe_flag;
702 WORD32 num_if_bands = ptr_header_data->pstr_freq_band_data->num_if_bands;
703 WORD32 usac_flag = ptr_header_data->usac_flag;
704 ia_env_extr_tables_struct *env_extr_tables_ptr =
705 ptr_sbr_tables->env_extr_tables_ptr;
706 IA_ERRORCODE err = IA_NO_ERROR;
707
708 ptr_frame_data->coupling_mode = COUPLING_OFF;
709
710 if (!usac_flag) {
711 bit = ixheaacd_read_bits_buf(it_bit_buff, 1);
712
713 if (bit) ixheaacd_read_bits_buf(it_bit_buff, SBR_SCE_RESERV_BITS);
714 if (audio_object_type == AOT_ER_AAC_ELD ||
715 audio_object_type == AOT_ER_AAC_LD) {
716 if (ptr_frame_data->eld_sbr_flag == 1) {
717 err = ixheaacd_extract_frame_info_ld(it_bit_buff, ptr_frame_data);
718 if (err) return err;
719 }
720 } else {
721 if (!ixheaacd_sbr_time_freq_grid_info(it_bit_buff, ptr_frame_data,
722 env_extr_tables_ptr))
723
724 return 0;
725 }
726 if (!ixheaacd_validate_frame_info(&ptr_frame_data->str_frame_info_details,
727 ptr_header_data->num_time_slots,
728 audio_object_type))
729 return 0;
730
731 } else {
732 if (hbe_flag) {
733 ptr_frame_data->sbr_patching_mode =
734 ixheaacd_read_bits_buf(it_bit_buff, ESBR_PATCHING_MODE_BITS);
735 if (ptr_frame_data->sbr_patching_mode == 0) {
736 ptr_frame_data->over_sampling_flag =
737 ixheaacd_read_bits_buf(it_bit_buff, ESBR_OVERSAMPLING_FLAG_BITS);
738 if (ixheaacd_read_bits_buf(it_bit_buff, ESBR_PITCHIN_FLAG_BITS))
739 ptr_frame_data->pitch_in_bins =
740 ixheaacd_read_bits_buf(it_bit_buff, ESBR_PITCHIN_BINS_BITS);
741 else
742 ptr_frame_data->pitch_in_bins = 0;
743 } else {
744 ptr_frame_data->over_sampling_flag = ptr_frame_data->pitch_in_bins = 0;
745 }
746 }
747 ptr_frame_data->num_time_slots = ptr_header_data->num_time_slots;
748 if (!ixheaacd_sbr_time_freq_grid_info(it_bit_buff, ptr_frame_data,
749 env_extr_tables_ptr))
750 return 0;
751
752 if (!ixheaacd_validate_frame_info(&ptr_frame_data->str_frame_info_details,
753 ptr_header_data->num_time_slots,
754 audio_object_type))
755 return 0;
756
757 ptr_frame_data->prev_sbr_mode = ORIG_SBR;
758 }
759
760 ixheaacd_sbr_env_dtdf_data(ptr_frame_data, it_bit_buff,
761 ptr_header_data->usac_flag);
762
763 if (ptr_frame_data->del_cod_dir_arr[0] == DTDF_DIR_FREQ) {
764 ptr_header_data->err_flag = 0;
765 }
766
767 for (i = 0; i < num_if_bands; i++) {
768 ptr_frame_data->sbr_invf_mode_prev[i] = ptr_frame_data->sbr_invf_mode[i];
769 ptr_frame_data->sbr_invf_mode[i] =
770 (WORD32)ixheaacd_read_bits_buf(it_bit_buff, SBR_INVERSE_FILT_MODE_BITS);
771 }
772
773 if (!ixheaacd_read_sbr_env_data(ptr_header_data, ptr_frame_data, it_bit_buff,
774 env_extr_tables_ptr, audio_object_type))
775 return 0;
776
777 ixheaacd_read_sbr_noise_floor_data(ptr_header_data, ptr_frame_data,
778 it_bit_buff, env_extr_tables_ptr);
779
780 if (usac_flag) {
781 memset(
782 ptr_frame_data->add_harmonics, 0,
783 ptr_header_data->pstr_freq_band_data->num_sf_bands[1] * sizeof(WORD32));
784 ptr_frame_data->coupling_mode = COUPLING_OFF;
785 }
786
787 bit = (FLAG)ixheaacd_read_bits_buf(it_bit_buff, 1);
788 if (bit) {
789 ixheaacd_sbr_sin_coding_data(ptr_header_data, ptr_frame_data, it_bit_buff);
790 } else {
791 memset(ptr_frame_data->add_harmonics, 0, sizeof(FLAG) * MAX_FREQ_COEFFS);
792 }
793
794 if (!usac_flag) {
795 ixheaacd_read_extn_data(ptr_header_data, ptr_ps_dec, it_bit_buff,
796 ptr_sbr_tables->ps_tables_ptr);
797 }
798
799 return 1;
800 }
801
ixheaacd_sbr_read_cpe(ia_sbr_header_data_struct * ptr_header_data,ia_sbr_frame_info_data_struct ** ptr_frame_data,ia_bit_buf_struct * it_bit_buff,ia_sbr_tables_struct * ptr_sbr_tables,WORD audio_object_type)802 IA_ERRORCODE ixheaacd_sbr_read_cpe(
803 ia_sbr_header_data_struct *ptr_header_data,
804 ia_sbr_frame_info_data_struct **ptr_frame_data,
805 ia_bit_buf_struct *it_bit_buff, ia_sbr_tables_struct *ptr_sbr_tables,
806 WORD audio_object_type) {
807 WORD32 i, k, bit, num_ch = 2;
808 WORD32 num_if_bands = ptr_header_data->pstr_freq_band_data->num_if_bands;
809 WORD32 hbe_flag = ptr_header_data->hbe_flag;
810 WORD32 usac_flag = ptr_header_data->usac_flag;
811 IA_ERRORCODE err = IA_NO_ERROR;
812 ia_env_extr_tables_struct *env_extr_tables_ptr =
813 ptr_sbr_tables->env_extr_tables_ptr;
814 bit = ixheaacd_read_bits_buf(it_bit_buff, 1);
815
816 if (usac_flag) {
817 if (bit) {
818 if (hbe_flag) {
819 ptr_frame_data[0]->sbr_patching_mode =
820 ptr_frame_data[1]->sbr_patching_mode =
821 ixheaacd_read_bits_buf(it_bit_buff, ESBR_PATCHING_MODE_BITS);
822 if (ptr_frame_data[0]->sbr_patching_mode == 0) {
823 ptr_frame_data[0]->over_sampling_flag =
824 ptr_frame_data[1]->over_sampling_flag = ixheaacd_read_bits_buf(
825 it_bit_buff, ESBR_OVERSAMPLING_FLAG_BITS);
826 if (ixheaacd_read_bits_buf(it_bit_buff, ESBR_PITCHIN_FLAG_BITS))
827 ptr_frame_data[0]->pitch_in_bins =
828 ptr_frame_data[1]->pitch_in_bins =
829 ixheaacd_read_bits_buf(it_bit_buff, ESBR_PITCHIN_BINS_BITS);
830 else
831 ptr_frame_data[0]->pitch_in_bins =
832 ptr_frame_data[1]->pitch_in_bins = 0;
833 } else {
834 ptr_frame_data[0]->over_sampling_flag = 0;
835 ptr_frame_data[1]->over_sampling_flag = 0;
836 ptr_frame_data[0]->pitch_in_bins = 0;
837 ptr_frame_data[1]->pitch_in_bins = 0;
838 }
839 }
840 ptr_frame_data[0]->coupling_mode = COUPLING_LEVEL;
841 ptr_frame_data[1]->coupling_mode = COUPLING_BAL;
842 } else {
843 if (hbe_flag) {
844 ptr_frame_data[0]->sbr_patching_mode =
845 ixheaacd_read_bits_buf(it_bit_buff, ESBR_PATCHING_MODE_BITS);
846 if (ptr_frame_data[0]->sbr_patching_mode == 0) {
847 ptr_frame_data[0]->over_sampling_flag =
848 ixheaacd_read_bits_buf(it_bit_buff, ESBR_OVERSAMPLING_FLAG_BITS);
849 if (ixheaacd_read_bits_buf(it_bit_buff, ESBR_PITCHIN_FLAG_BITS))
850 ptr_frame_data[0]->pitch_in_bins =
851 ixheaacd_read_bits_buf(it_bit_buff, ESBR_PITCHIN_BINS_BITS);
852 else
853 ptr_frame_data[0]->pitch_in_bins = 0;
854 } else {
855 ptr_frame_data[0]->over_sampling_flag = 0;
856 ptr_frame_data[0]->pitch_in_bins = 0;
857 }
858 ptr_frame_data[1]->sbr_patching_mode =
859 ixheaacd_read_bits_buf(it_bit_buff, ESBR_PATCHING_MODE_BITS);
860 if (ptr_frame_data[1]->sbr_patching_mode == 0) {
861 ptr_frame_data[1]->over_sampling_flag =
862 ixheaacd_read_bits_buf(it_bit_buff, ESBR_OVERSAMPLING_FLAG_BITS);
863 if (ixheaacd_read_bits_buf(it_bit_buff, ESBR_PITCHIN_FLAG_BITS))
864 ptr_frame_data[1]->pitch_in_bins =
865 ixheaacd_read_bits_buf(it_bit_buff, ESBR_PITCHIN_BINS_BITS);
866 else
867 ptr_frame_data[1]->pitch_in_bins = 0;
868 } else {
869 ptr_frame_data[1]->over_sampling_flag =
870 ptr_frame_data[1]->pitch_in_bins = 0;
871 }
872 }
873
874 ptr_frame_data[0]->coupling_mode = COUPLING_OFF;
875 ptr_frame_data[1]->coupling_mode = COUPLING_OFF;
876 }
877 } else {
878 if (bit) {
879 ixheaacd_read_bits_buf(it_bit_buff,
880 SBR_SCE_RESERV_BITS + SBR_SCE_RESERV_BITS);
881 }
882 if ((audio_object_type != AOT_ER_AAC_ELD) &&
883 (ptr_header_data->channel_mode != SBR_STEREO)) {
884 ptr_header_data->sync_state = UPSAMPLING;
885 return 0;
886 }
887
888 bit = ixheaacd_read_bits_buf(it_bit_buff, SBR_COUPLNG_MODE_BITS);
889
890 if (bit) {
891 ptr_frame_data[0]->coupling_mode = COUPLING_LEVEL;
892 ptr_frame_data[1]->coupling_mode = COUPLING_BAL;
893 } else {
894 ptr_frame_data[0]->coupling_mode = COUPLING_OFF;
895 ptr_frame_data[1]->coupling_mode = COUPLING_OFF;
896 }
897 }
898
899 for (i = 0; i < num_ch; i++) {
900 ptr_frame_data[i]->num_time_slots = ptr_header_data->num_time_slots;
901 if (audio_object_type == AOT_ER_AAC_ELD ||
902 audio_object_type == AOT_ER_AAC_LD) {
903 if (ptr_frame_data[i]->eld_sbr_flag == 1) {
904 err = ixheaacd_extract_frame_info_ld(it_bit_buff, ptr_frame_data[i]);
905 if (err) return err;
906 }
907 } else {
908 if (!ixheaacd_sbr_time_freq_grid_info(it_bit_buff, ptr_frame_data[i],
909 env_extr_tables_ptr))
910 return 0;
911 }
912
913 if (!ixheaacd_validate_frame_info(
914 &ptr_frame_data[i]->str_frame_info_details,
915 ptr_header_data->num_time_slots, audio_object_type))
916 return 0;
917
918 if (ptr_frame_data[0]->coupling_mode) {
919 memcpy(&ptr_frame_data[1]->str_frame_info_details,
920 &ptr_frame_data[0]->str_frame_info_details,
921 sizeof(ia_frame_info_struct));
922 if (audio_object_type == AOT_ER_AAC_ELD ||
923 audio_object_type == AOT_ER_AAC_LD) {
924 ptr_frame_data[1]->amp_res = ptr_frame_data[0]->amp_res;
925 }
926 num_ch = 1;
927 }
928 }
929
930 if (ptr_frame_data[0]->coupling_mode && usac_flag) {
931 ixheaacd_sbr_env_dtdf_data(ptr_frame_data[0], it_bit_buff,
932 ptr_header_data->usac_flag);
933 ixheaacd_sbr_env_dtdf_data(ptr_frame_data[1], it_bit_buff,
934 ptr_header_data->usac_flag);
935
936 for (i = 0; i < ptr_header_data->pstr_freq_band_data->num_if_bands; i++) {
937 ptr_frame_data[0]->sbr_invf_mode_prev[i] =
938 ptr_frame_data[0]->sbr_invf_mode[i];
939 ptr_frame_data[1]->sbr_invf_mode_prev[i] =
940 ptr_frame_data[1]->sbr_invf_mode[i];
941
942 ptr_frame_data[0]->sbr_invf_mode[i] =
943 (WORD32)ixheaacd_read_bits_buf(it_bit_buff, ESBR_INVF_MODE_BITS);
944 ptr_frame_data[1]->sbr_invf_mode[i] = ptr_frame_data[0]->sbr_invf_mode[i];
945 }
946
947 if (!ixheaacd_read_sbr_env_data(ptr_header_data, ptr_frame_data[0],
948 it_bit_buff, env_extr_tables_ptr,
949 audio_object_type)) {
950 return 0;
951 }
952 ixheaacd_read_sbr_noise_floor_data(ptr_header_data, ptr_frame_data[0],
953 it_bit_buff, env_extr_tables_ptr);
954
955 if (!ixheaacd_read_sbr_env_data(ptr_header_data, ptr_frame_data[1],
956 it_bit_buff, env_extr_tables_ptr,
957 audio_object_type)) {
958 return 0;
959 }
960 ixheaacd_read_sbr_noise_floor_data(ptr_header_data, ptr_frame_data[1],
961 it_bit_buff, env_extr_tables_ptr);
962
963 memset(
964 ptr_frame_data[0]->add_harmonics, 0,
965 ptr_header_data->pstr_freq_band_data->num_sf_bands[1] * sizeof(WORD32));
966 memset(
967 ptr_frame_data[1]->add_harmonics, 0,
968 ptr_header_data->pstr_freq_band_data->num_sf_bands[1] * sizeof(WORD32));
969
970 } else {
971 ixheaacd_sbr_env_dtdf_data(ptr_frame_data[0], it_bit_buff,
972 ptr_header_data->usac_flag);
973 ixheaacd_sbr_env_dtdf_data(ptr_frame_data[1], it_bit_buff,
974 ptr_header_data->usac_flag);
975
976 if ((ptr_frame_data[0]->del_cod_dir_arr[0] == DTDF_DIR_FREQ) &&
977 (ptr_frame_data[1]->del_cod_dir_arr[0] == DTDF_DIR_FREQ)) {
978 ptr_header_data->err_flag = 0;
979 }
980
981 for (k = 0; k < num_ch; k++) {
982 for (i = 0; i < num_if_bands; i++) {
983 ptr_frame_data[k]->sbr_invf_mode_prev[i] =
984 ptr_frame_data[k]->sbr_invf_mode[i];
985 ptr_frame_data[k]->sbr_invf_mode[i] = (WORD32)ixheaacd_read_bits_buf(
986 it_bit_buff, SBR_INVERSE_FILT_MODE_BITS);
987 }
988 }
989
990 if (ptr_frame_data[0]->coupling_mode) {
991 memcpy(ptr_frame_data[1]->sbr_invf_mode, ptr_frame_data[0]->sbr_invf_mode,
992 sizeof(WORD32) * num_if_bands);
993
994 if (!ixheaacd_read_sbr_env_data(ptr_header_data, ptr_frame_data[0],
995 it_bit_buff, env_extr_tables_ptr,
996 audio_object_type)) {
997 return 0;
998 }
999
1000 ixheaacd_read_sbr_noise_floor_data(ptr_header_data, ptr_frame_data[0],
1001 it_bit_buff, env_extr_tables_ptr);
1002
1003 if (!ixheaacd_read_sbr_env_data(ptr_header_data, ptr_frame_data[1],
1004 it_bit_buff, env_extr_tables_ptr,
1005 audio_object_type)) {
1006 return 0;
1007 }
1008 } else {
1009 if (!ixheaacd_read_sbr_env_data(ptr_header_data, ptr_frame_data[0],
1010 it_bit_buff, env_extr_tables_ptr,
1011 audio_object_type))
1012 return 0;
1013
1014 if (!ixheaacd_read_sbr_env_data(ptr_header_data, ptr_frame_data[1],
1015 it_bit_buff, env_extr_tables_ptr,
1016 audio_object_type))
1017 return 0;
1018
1019 ixheaacd_read_sbr_noise_floor_data(ptr_header_data, ptr_frame_data[0],
1020 it_bit_buff, env_extr_tables_ptr);
1021 }
1022 ixheaacd_read_sbr_noise_floor_data(ptr_header_data, ptr_frame_data[1],
1023 it_bit_buff, env_extr_tables_ptr);
1024 }
1025
1026 bit = (FLAG)ixheaacd_read_bits_buf(it_bit_buff, 1);
1027 if (bit) {
1028 ixheaacd_sbr_sin_coding_data(ptr_header_data, ptr_frame_data[0],
1029 it_bit_buff);
1030 } else {
1031 memset(ptr_frame_data[0]->add_harmonics, 0, sizeof(FLAG) * MAX_FREQ_COEFFS);
1032 }
1033
1034 bit = (FLAG)ixheaacd_read_bits_buf(it_bit_buff, 1);
1035 if (bit) {
1036 ixheaacd_sbr_sin_coding_data(ptr_header_data, ptr_frame_data[1],
1037 it_bit_buff);
1038 } else {
1039 memset(ptr_frame_data[1]->add_harmonics, 0, sizeof(FLAG) * MAX_FREQ_COEFFS);
1040 }
1041
1042 if (!usac_flag) {
1043 ixheaacd_read_extn_data(ptr_header_data, NULL, it_bit_buff,
1044 ptr_sbr_tables->ps_tables_ptr);
1045 }
1046 return 1;
1047 }
1048
ixheaacd_sbr_env_dtdf_data(ia_sbr_frame_info_data_struct * ptr_frame_data,ia_bit_buf_struct * it_bit_buff,WORD32 usac_flag)1049 VOID ixheaacd_sbr_env_dtdf_data(ia_sbr_frame_info_data_struct *ptr_frame_data,
1050 ia_bit_buf_struct *it_bit_buff,
1051 WORD32 usac_flag) {
1052 WORD32 i;
1053 WORD32 num_env = ptr_frame_data->str_frame_info_details.num_env;
1054 WORD32 num_noise_env = ptr_frame_data->str_frame_info_details.num_noise_env;
1055 WORD16 *p_coding_dir_vec = ptr_frame_data->del_cod_dir_arr;
1056 WORD16 *p_coding_dir_noise_vec = ptr_frame_data->del_cod_dir_noise_arr;
1057 WORD32 usac_independency_flag = ptr_frame_data->usac_independency_flag;
1058
1059 if (usac_flag) {
1060 if (usac_independency_flag) {
1061 *p_coding_dir_vec = 0;
1062 p_coding_dir_vec++;
1063 } else {
1064 *p_coding_dir_vec =
1065 (WORD16)ixheaacd_read_bits_buf(it_bit_buff, SBR_DEL_COD_DIR_BITS);
1066 p_coding_dir_vec++;
1067 }
1068 for (i = num_env - 1; i >= 1; i--) {
1069 *p_coding_dir_vec++ =
1070 (WORD16)ixheaacd_read_bits_buf(it_bit_buff, SBR_DEL_COD_DIR_BITS);
1071 }
1072 if (usac_independency_flag) {
1073 *p_coding_dir_noise_vec = 0;
1074 p_coding_dir_noise_vec++;
1075 } else {
1076 *p_coding_dir_noise_vec =
1077 (WORD16)ixheaacd_read_bits_buf(it_bit_buff, SBR_DEL_COD_DIR_BITS);
1078 p_coding_dir_noise_vec++;
1079 }
1080 for (i = num_noise_env - 1; i >= 1; i--) {
1081 *p_coding_dir_noise_vec++ =
1082 (WORD16)ixheaacd_read_bits_buf(it_bit_buff, SBR_DEL_COD_DIR_BITS);
1083 }
1084 } else {
1085 for (i = num_env - 1; i >= 0; i--) {
1086 *p_coding_dir_vec++ =
1087 (WORD16)ixheaacd_read_bits_buf(it_bit_buff, SBR_DEL_COD_DIR_BITS);
1088 }
1089
1090 for (i = num_noise_env - 1; i >= 0; i--) {
1091 *p_coding_dir_noise_vec++ =
1092 (WORD16)ixheaacd_read_bits_buf(it_bit_buff, SBR_DEL_COD_DIR_BITS);
1093 }
1094 }
1095 }
1096
ixheaacd_read_env_data(ia_sbr_frame_info_data_struct * ptr_frame_data,ia_bit_buf_struct * it_bit_buff,ia_huffman_data_type hcb_t,ia_huffman_data_type hcb_f,WORD32 * idx_t,WORD32 * idx_f,WORD16 * no_band,WORD32 num_env,WORD32 env_data_tbl_comp_factor,WORD32 start_bits,WORD32 start_bits_balance,WORD32 num_noise_env,WORD32 lav,WORD32 usac_flag)1097 VOID ixheaacd_read_env_data(ia_sbr_frame_info_data_struct *ptr_frame_data,
1098 ia_bit_buf_struct *it_bit_buff,
1099 ia_huffman_data_type hcb_t,
1100 ia_huffman_data_type hcb_f, WORD32 *idx_t,
1101 WORD32 *idx_f, WORD16 *no_band, WORD32 num_env,
1102 WORD32 env_data_tbl_comp_factor, WORD32 start_bits,
1103 WORD32 start_bits_balance, WORD32 num_noise_env,
1104 WORD32 lav, WORD32 usac_flag) {
1105 WORD32 j, i, ixheaacd_drc_offset = 0,
1106 coupling_mode = ptr_frame_data->coupling_mode, delta, bits,
1107 shift;
1108 WORD16 *p_coding_dir_vec, *p_sbr_sf;
1109 WORD16 index, length;
1110 WORD32 readword;
1111 FLOAT32 *p_sbr_sf_float;
1112
1113 if (num_noise_env) {
1114 p_coding_dir_vec = ptr_frame_data->del_cod_dir_noise_arr;
1115 p_sbr_sf = ptr_frame_data->int_noise_floor;
1116 p_sbr_sf_float = ptr_frame_data->flt_noise_floor;
1117 } else {
1118 p_coding_dir_vec = ptr_frame_data->del_cod_dir_arr;
1119 p_sbr_sf = ptr_frame_data->int_env_sf_arr;
1120 p_sbr_sf_float = ptr_frame_data->flt_env_sf_arr;
1121 }
1122
1123 if (coupling_mode == COUPLING_BAL) {
1124 bits = start_bits_balance;
1125 shift = env_data_tbl_comp_factor;
1126
1127 } else {
1128 bits = start_bits;
1129 shift = 0;
1130 }
1131
1132 for (j = 0; j < num_env; j++) {
1133 ia_huffman_data_type h;
1134 const WORD32 *idx_tab;
1135 WORD32 dtdf_dir_flag = p_coding_dir_vec[j];
1136
1137 if (dtdf_dir_flag == DTDF_DIR_FREQ) {
1138 p_sbr_sf[ixheaacd_drc_offset] =
1139 (WORD16)(ixheaacd_read_bits_buf(it_bit_buff, bits) << shift);
1140 p_sbr_sf_float[ixheaacd_drc_offset] = p_sbr_sf[ixheaacd_drc_offset];
1141 h = hcb_f;
1142 idx_tab = idx_f;
1143 } else {
1144 h = hcb_t;
1145 idx_tab = idx_t;
1146 }
1147
1148 for (i = (1 - dtdf_dir_flag); i < no_band[j]; i++) {
1149 if (it_bit_buff->cnt_bits < 20) {
1150 readword = ixheaacd_show_bits_buf(it_bit_buff, it_bit_buff->cnt_bits);
1151 readword = readword << (32 - it_bit_buff->cnt_bits);
1152 } else {
1153 readword = ixheaacd_show_bits_buf(it_bit_buff, 20);
1154 readword = readword << 12;
1155 }
1156 ixheaacd_huffman_decode(readword, &index, &length, (const UWORD16 *)h,
1157 (const UWORD32 *)idx_tab);
1158 delta = index - lav;
1159 ixheaacd_read_bits_buf(it_bit_buff, length);
1160 p_sbr_sf[ixheaacd_drc_offset + i] =
1161 (WORD16)(delta << env_data_tbl_comp_factor);
1162 p_sbr_sf_float[ixheaacd_drc_offset + i] =
1163 p_sbr_sf[ixheaacd_drc_offset + i];
1164 }
1165 if (usac_flag && (num_noise_env == 0)) {
1166 ptr_frame_data->inter_temp_shape_mode[j] = 0;
1167 if (ptr_frame_data->inter_tes_flag) {
1168 WORD32 flag = (WORD32)ixheaacd_read_bits_buf(it_bit_buff, 1);
1169 if (flag) {
1170 ptr_frame_data->inter_temp_shape_mode[j] =
1171 (WORD32)ixheaacd_read_bits_buf(it_bit_buff, 2);
1172 }
1173 }
1174 }
1175 ixheaacd_drc_offset += (no_band[j]);
1176 }
1177 }
1178
ixheaacd_read_sbr_noise_floor_data(ia_sbr_header_data_struct * ptr_header_data,ia_sbr_frame_info_data_struct * ptr_frame_data,ia_bit_buf_struct * it_bit_buff,ia_env_extr_tables_struct * env_extr_tables_ptr)1179 VOID ixheaacd_read_sbr_noise_floor_data(
1180 ia_sbr_header_data_struct *ptr_header_data,
1181 ia_sbr_frame_info_data_struct *ptr_frame_data,
1182 ia_bit_buf_struct *it_bit_buff,
1183 ia_env_extr_tables_struct *env_extr_tables_ptr) {
1184 WORD32 i;
1185 WORD32 coupling_mode;
1186 WORD16 num_noise_bands[MAX_NOISE_ENVELOPES];
1187 ia_huffman_data_type hcb_noise_env;
1188 ia_huffman_data_type hcb_noise;
1189 WORD32 *idx_noise_env;
1190 WORD32 *idx_noise;
1191 WORD32 lav;
1192 WORD32 env_data_tbl_comp_factor;
1193
1194 WORD32 start_bits;
1195 WORD32 start_bits_balance;
1196 WORD32 num_noise_env = ptr_frame_data->str_frame_info_details.num_noise_env;
1197
1198 for (i = 0; i < num_noise_env; i++)
1199 num_noise_bands[i] = ptr_header_data->pstr_freq_band_data->num_nf_bands;
1200
1201 start_bits = SBR_BEGIN_NOISE_BITS_AMPLITUDE_RESOLUTION_3_0;
1202 start_bits_balance = SBR_BEGIN_NOISE_BITS_BALNCE_AMPLITUDE_RESOLUTION_3_0;
1203
1204 coupling_mode = ptr_frame_data->coupling_mode;
1205
1206 if (coupling_mode == COUPLING_BAL) {
1207 lav = 12;
1208 hcb_noise = (ia_huffman_data_type)&env_extr_tables_ptr
1209 ->ixheaacd_t_huffman_noise_bal_3_0db_inp_table;
1210 idx_noise =
1211 env_extr_tables_ptr->ixheaacd_t_huffman_noise_bal_3_0db_idx_table;
1212 hcb_noise_env = (ia_huffman_data_type)&env_extr_tables_ptr
1213 ->ixheaacd_f_huffman_env_bal_3_0db_inp_table;
1214 idx_noise_env =
1215 env_extr_tables_ptr->ixheaacd_f_huffman_env_bal_3_0db_idx_table;
1216 env_data_tbl_comp_factor = 1;
1217 } else {
1218 lav = 31;
1219 hcb_noise = (ia_huffman_data_type)&env_extr_tables_ptr
1220 ->ixheaacd_t_huffman_noise_3_0db_inp_table;
1221 idx_noise = env_extr_tables_ptr->ixheaacd_t_huffman_noise_3_0db_idx_table;
1222 hcb_noise_env = (ia_huffman_data_type)&env_extr_tables_ptr
1223 ->ixheaacd_f_huffman_env_3_0db_inp_table;
1224 idx_noise_env = env_extr_tables_ptr->ixheaacd_f_huffman_env_3_0db_idx_table;
1225 env_data_tbl_comp_factor = 0;
1226 }
1227
1228 ixheaacd_read_env_data(ptr_frame_data, it_bit_buff, hcb_noise, hcb_noise_env,
1229 idx_noise, idx_noise_env, &num_noise_bands[0],
1230 num_noise_env, env_data_tbl_comp_factor, start_bits,
1231 start_bits_balance, 1, lav,
1232 ptr_header_data->usac_flag);
1233 }
1234
ixheaacd_read_sbr_env_data(ia_sbr_header_data_struct * ptr_header_data,ia_sbr_frame_info_data_struct * ptr_frame_data,ia_bit_buf_struct * it_bit_buff,ia_env_extr_tables_struct * env_extr_tables_ptr,WORD audio_object_type)1235 WORD16 ixheaacd_read_sbr_env_data(
1236 ia_sbr_header_data_struct *ptr_header_data,
1237 ia_sbr_frame_info_data_struct *ptr_frame_data,
1238 ia_bit_buf_struct *it_bit_buff,
1239 ia_env_extr_tables_struct *env_extr_tables_ptr, WORD audio_object_type) {
1240 WORD32 coupling_mode = ptr_frame_data->coupling_mode;
1241 WORD32 *idx_t, *idx_f;
1242 WORD32 lav;
1243 WORD32 i;
1244 WORD16 no_band[MAX_ENVELOPES];
1245 WORD32 delta;
1246 WORD32 amp_res, num_env, env_data_tbl_comp_factor, start_bits,
1247 start_bits_balance;
1248 WORD16 *p_freq_res = ptr_frame_data->str_frame_info_details.freq_res;
1249 WORD16 *p_num_sf_bands = ptr_header_data->pstr_freq_band_data->num_sf_bands;
1250 ia_huffman_data_type hcb_t, hcb_f;
1251
1252 delta = 0;
1253 amp_res = ptr_header_data->amp_res;
1254 num_env = ptr_frame_data->str_frame_info_details.num_env;
1255
1256 ptr_frame_data->num_env_sfac = 0;
1257
1258 if ((ptr_frame_data->str_frame_info_details.frame_class == FIXFIX) &&
1259 (num_env == 1)) {
1260 if (audio_object_type != AOT_ER_AAC_ELD &&
1261 audio_object_type != AOT_ER_AAC_LD) {
1262 amp_res = SBR_AMPLITUDE_RESOLUTION_1_5;
1263 } else {
1264 amp_res = ptr_frame_data->amp_res;
1265 }
1266 }
1267 ptr_frame_data->amp_res = amp_res;
1268
1269 if (amp_res == SBR_AMPLITUDE_RESOLUTION_3_0) {
1270 start_bits = SBR_BEGIN_ENVN_BITS_AMPLITUDE_RESOLUTION_3_0;
1271 start_bits_balance = SBR_BEGIN_ENVN_BITS_BALNCE_AMPLITUDE_RESOLUTION_3_0;
1272 } else {
1273 start_bits = SBR_BEGIN_ENVN_BITS_AMPLITUDE_RESOLUTION_1_5;
1274 start_bits_balance = SBR_BEGIN_ENVN_BITS_BALNCE_AMPLITUDE_RESOLUTION_1_5;
1275 }
1276
1277 for (i = 0; i < num_env; i++) {
1278 no_band[i] = p_num_sf_bands[*p_freq_res++];
1279 ptr_frame_data->num_env_sfac =
1280 ixheaacd_add16(ptr_frame_data->num_env_sfac, no_band[i]);
1281 }
1282
1283 if (ptr_frame_data->num_env_sfac > MAX_NUM_ENVELOPE_VALUES) return 0;
1284
1285 if (coupling_mode == COUPLING_BAL) {
1286 env_data_tbl_comp_factor = 1;
1287
1288 if (amp_res == SBR_AMPLITUDE_RESOLUTION_1_5) {
1289 lav = 24;
1290 hcb_t = (ia_huffman_data_type)&env_extr_tables_ptr
1291 ->ixheaacd_t_huffman_env_bal_1_5db_inp_table;
1292 idx_t = env_extr_tables_ptr->ixheaacd_t_huffman_env_bal_1_5db_idx_table;
1293 hcb_f = (ia_huffman_data_type)&env_extr_tables_ptr
1294 ->ixheaacd_f_huffman_env_bal_1_5db_inp_table;
1295 idx_f = env_extr_tables_ptr->ixheaacd_f_huffman_env_bal_1_5db_idx_table;
1296 } else {
1297 lav = 12;
1298 hcb_t = (ia_huffman_data_type)&env_extr_tables_ptr
1299 ->ixheaacd_t_huffman_env_bal_3_0db_inp_table;
1300 idx_t = env_extr_tables_ptr->ixheaacd_t_huffman_env_bal_3_0db_idx_table;
1301 hcb_f = (ia_huffman_data_type)&env_extr_tables_ptr
1302 ->ixheaacd_f_huffman_env_bal_3_0db_inp_table;
1303 idx_f = env_extr_tables_ptr->ixheaacd_f_huffman_env_bal_3_0db_idx_table;
1304 }
1305 } else {
1306 env_data_tbl_comp_factor = 0;
1307
1308 if (amp_res == SBR_AMPLITUDE_RESOLUTION_1_5) {
1309 lav = 60;
1310 hcb_t = (ia_huffman_data_type)&env_extr_tables_ptr
1311 ->ixheaacd_t_huffman_env_1_5db_inp_table;
1312 idx_t = env_extr_tables_ptr->ixheaacd_t_huffman_env_1_5db_idx_table;
1313 hcb_f = (ia_huffman_data_type)&env_extr_tables_ptr
1314 ->ixheaacd_f_huffman_env_1_5db_inp_table;
1315 idx_f = env_extr_tables_ptr->ixheaacd_f_huffman_env_1_5db_idx_table;
1316 } else {
1317 lav = 31;
1318 hcb_t = (ia_huffman_data_type)&env_extr_tables_ptr
1319 ->ixheaacd_t_huffman_env_3_0db_inp_table;
1320 idx_t = env_extr_tables_ptr->ixheaacd_t_huffman_env_3_0db_idx_table;
1321 hcb_f = (ia_huffman_data_type)&env_extr_tables_ptr
1322 ->ixheaacd_f_huffman_env_3_0db_inp_table;
1323 idx_f = env_extr_tables_ptr->ixheaacd_f_huffman_env_3_0db_idx_table;
1324 }
1325 }
1326
1327 ixheaacd_read_env_data(ptr_frame_data, it_bit_buff, hcb_t, hcb_f, idx_t,
1328 idx_f, &no_band[0], num_env, env_data_tbl_comp_factor,
1329 start_bits, start_bits_balance, 0, lav,
1330 ptr_header_data->usac_flag);
1331
1332 return 1;
1333 }
1334
ixheaacd_extract_frame_info_ld(ia_bit_buf_struct * it_bit_buff,ia_sbr_frame_info_data_struct * h_frame_data)1335 IA_ERRORCODE ixheaacd_extract_frame_info_ld(
1336 ia_bit_buf_struct *it_bit_buff,
1337 ia_sbr_frame_info_data_struct *h_frame_data) {
1338 int abs_bord_lead = 0, num_rel_lead = 0, num_rel_trail = 0, bs_num_env = 0,
1339 frame_class, temp, env, k, abs_bord_trail = 0, middle_bord = 0,
1340 bs_num_noise, transient_env_temp = 0, bs_transient_position = 0;
1341
1342 IA_ERRORCODE err = IA_NO_ERROR;
1343 WORD16 time_border[MAX_ENVELOPES + 1];
1344 WORD16 time_border_noise[2 + 1];
1345 WORD16 f[MAX_ENVELOPES + 1];
1346 int rel_bord_lead[7] = {0};
1347
1348 ia_frame_info_struct *v_frame_info = &h_frame_data->str_frame_info_details;
1349
1350 int numTimeSlots = h_frame_data->num_time_slots;
1351
1352 v_frame_info->frame_class = frame_class =
1353 ixheaacd_read_bits_buf(it_bit_buff, SBRLD_CLA_BITS);
1354
1355 switch (frame_class) {
1356 case FIXFIX:
1357 temp = ixheaacd_read_bits_buf(it_bit_buff, SBR_ENV_BITS);
1358 bs_num_env = 1 << temp;
1359
1360 if (bs_num_env == 1)
1361 h_frame_data->amp_res =
1362 ixheaacd_read_bits_buf(it_bit_buff, SBR_AMPLITUDE_RESOLUTION_BITS);
1363
1364 f[0] = ixheaacd_read_bits_buf(it_bit_buff, SBR_RES_BITS);
1365
1366 for (env = 1; env < bs_num_env; env++) f[env] = f[0];
1367 break;
1368 case LD_TRAN:
1369 bs_transient_position =
1370 ixheaacd_read_bits_buf(it_bit_buff, SBR_TRAN_BITS);
1371 v_frame_info->frame_class = 0;
1372 if ((numTimeSlots != 16) && (bs_transient_position >= LD_ENV_TBL_480)) {
1373 return -1;
1374 }
1375 bs_num_env = (numTimeSlots == 16)
1376 ? ixheaacd_ld_env_table_512[bs_transient_position]
1377 [SBR_ENVT_NUMENV]
1378 : ixheaacd_ld_env_table_480[bs_transient_position]
1379 [SBR_ENVT_NUMENV];
1380 for (env = 0; env < bs_num_env; env++)
1381 f[env] = ixheaacd_read_bits_buf(it_bit_buff, SBR_RES_BITS);
1382 break;
1383 }
1384
1385 switch (frame_class) {
1386 case FIXFIX:
1387 abs_bord_lead = 0;
1388 abs_bord_trail = numTimeSlots;
1389 num_rel_lead = bs_num_env - 1;
1390 num_rel_trail = 0;
1391
1392 for (k = 0; k < num_rel_lead; k++) {
1393 rel_bord_lead[k] = ixheaacd_ld_env_table_time_slot[num_rel_lead - 1];
1394 }
1395
1396 time_border[0] = abs_bord_lead;
1397 time_border[bs_num_env] = abs_bord_trail;
1398 for (env = 1; env <= num_rel_lead; env++) {
1399 time_border[env] = abs_bord_lead;
1400 for (k = 0; k <= env - 1; k++) time_border[env] += rel_bord_lead[k];
1401 }
1402 break;
1403
1404 case LD_TRAN:
1405 time_border[0] = 0;
1406 time_border[bs_num_env] = numTimeSlots;
1407 for (k = 1; k < bs_num_env; k++)
1408 time_border[k] =
1409 (numTimeSlots == 16)
1410 ? ixheaacd_ld_env_table_512[bs_transient_position][k]
1411 : ixheaacd_ld_env_table_480[bs_transient_position][k];
1412 break;
1413
1414 default:
1415 time_border[0] = 0;
1416
1417 break;
1418 };
1419
1420 switch (frame_class) {
1421 case FIXFIX:
1422 middle_bord = bs_num_env / 2;
1423 break;
1424 case LD_TRAN:
1425 middle_bord = 1;
1426 break;
1427 };
1428
1429 time_border_noise[0] = time_border[0];
1430 if (bs_num_env > 1) {
1431 time_border_noise[1] = time_border[middle_bord];
1432 time_border_noise[2] = time_border[bs_num_env];
1433 bs_num_noise = 2;
1434 } else {
1435 time_border_noise[1] = time_border[bs_num_env];
1436 bs_num_noise = 1;
1437 }
1438
1439 switch (frame_class) {
1440 case FIXFIX:
1441 transient_env_temp = -1;
1442 break;
1443 case LD_TRAN:
1444 transient_env_temp =
1445 (numTimeSlots == 16)
1446 ? ixheaacd_ld_env_table_512[bs_transient_position]
1447 [SBR_ENVT_TRANIDX]
1448 : ixheaacd_ld_env_table_480[bs_transient_position]
1449 [SBR_ENVT_TRANIDX];
1450 break;
1451 };
1452
1453 v_frame_info->num_env = bs_num_env;
1454 memcpy(v_frame_info->border_vec, time_border,
1455 (bs_num_env + 1) * sizeof(WORD16));
1456 memcpy(v_frame_info->freq_res, f, bs_num_env * sizeof(WORD16));
1457 v_frame_info->transient_env = transient_env_temp;
1458 v_frame_info->num_noise_env = bs_num_noise;
1459 memcpy(v_frame_info->noise_border_vec, time_border_noise,
1460 (bs_num_noise + 1) * sizeof(WORD16));
1461
1462 return err;
1463 }
1464
ixheaacd_pvc_time_freq_grid_info(ia_bit_buf_struct * it_bit_buff,ia_sbr_frame_info_data_struct * ptr_frame_data)1465 WORD32 ixheaacd_pvc_time_freq_grid_info(
1466 ia_bit_buf_struct *it_bit_buff,
1467 ia_sbr_frame_info_data_struct *ptr_frame_data) {
1468 WORD32 bs_num_env = 0, bs_num_noise = 0;
1469 WORD32 time_border[MAX_ENVELOPES + 1];
1470 WORD32 time_border_noise[2 + 1];
1471 WORD32 pvc_time_border[MAX_ENVELOPES + 1];
1472 WORD32 pvc_time_border_noise[2 + 1];
1473 WORD32 bs_freq_res[MAX_ENVELOPES + 1];
1474 WORD32 var_len;
1475 ia_frame_info_struct *p_frame_info = &ptr_frame_data->str_frame_info_details;
1476 ia_frame_info_struct *pvc_frame_info = &ptr_frame_data->str_pvc_frame_info;
1477 WORD32 i;
1478 WORD32 prev_sbr_mode = ptr_frame_data->prev_sbr_mode;
1479
1480 WORD32 tmp;
1481 WORD32 bs_noise_pos;
1482 bs_noise_pos = ixheaacd_read_bits_buf(it_bit_buff, 4);
1483
1484 tmp = ixheaacd_read_bits_buf(it_bit_buff, 1);
1485 if (tmp == 0) {
1486 ptr_frame_data->var_len = 0;
1487 } else {
1488 tmp = ixheaacd_read_bits_buf(it_bit_buff, 2);
1489 ptr_frame_data->var_len = tmp + 1;
1490 }
1491 var_len = ptr_frame_data->var_len;
1492
1493 if (p_frame_info->num_env > 0) {
1494 time_border[0] = p_frame_info->border_vec[p_frame_info->num_env] - 16;
1495 } else {
1496 time_border[0] = 0;
1497 }
1498 if (time_border[0] < 0) return -1;
1499 pvc_time_border[0] = 0;
1500 bs_freq_res[0] = 0;
1501
1502 if (bs_noise_pos == 0) {
1503 time_border[1] = 16 + var_len;
1504 pvc_time_border[1] = 16;
1505 bs_num_noise = 1;
1506 bs_num_env = 1;
1507 } else {
1508 time_border[1] = bs_noise_pos;
1509 pvc_time_border[1] = bs_noise_pos;
1510 time_border[2] = 16 + var_len;
1511 pvc_time_border[2] = 16;
1512 bs_freq_res[1] = 0;
1513 bs_num_noise = 2;
1514 bs_num_env = 2;
1515 }
1516
1517 for (i = 0; i < 3; i++) {
1518 time_border_noise[i] = time_border[i];
1519 pvc_time_border_noise[i] = pvc_time_border[i];
1520 }
1521
1522 if (prev_sbr_mode == ORIG_SBR) {
1523 pvc_time_border[0] = time_border[0];
1524 pvc_time_border_noise[0] = time_border[0];
1525 }
1526
1527 pvc_frame_info->num_env = bs_num_env;
1528 for (i = 0; i < (bs_num_env + 1); i++) {
1529 pvc_frame_info->border_vec[i] = pvc_time_border[i];
1530 }
1531 for (i = 0; i < (bs_num_env); i++) {
1532 pvc_frame_info->freq_res[i] = bs_freq_res[i];
1533 }
1534 pvc_frame_info->transient_env = -1;
1535 pvc_frame_info->num_noise_env = bs_num_noise;
1536 for (i = 0; i < (bs_num_noise + 1); i++) {
1537 pvc_frame_info->noise_border_vec[i] = pvc_time_border_noise[i];
1538 }
1539 p_frame_info->num_env = bs_num_env;
1540 for (i = 0; i < (bs_num_env + 1); i++) {
1541 p_frame_info->border_vec[i] = time_border[i];
1542 }
1543 for (i = 0; i < (bs_num_env); i++) {
1544 p_frame_info->freq_res[i] = bs_freq_res[i];
1545 }
1546 p_frame_info->transient_env = -1;
1547 p_frame_info->num_noise_env = bs_num_noise;
1548 for (i = 0; i < (bs_num_noise + 1); i++) {
1549 p_frame_info->noise_border_vec[i] = time_border_noise[i];
1550 }
1551 return 0;
1552 }
1553
ixheaacd_sbr_time_freq_grid_info(ia_bit_buf_struct * it_bit_buff,ia_sbr_frame_info_data_struct * ptr_frame_data,ia_env_extr_tables_struct * env_extr_tables_ptr)1554 WORD16 ixheaacd_sbr_time_freq_grid_info(
1555 ia_bit_buf_struct *it_bit_buff,
1556 ia_sbr_frame_info_data_struct *ptr_frame_data,
1557 ia_env_extr_tables_struct *env_extr_tables_ptr) {
1558 WORD32 i, k, bs_num_rel = 0;
1559 WORD32 bs_pointer_bits = 0, bs_num_env = 0, border, bs_pointer,
1560 bs_var_bord = 0, temp = 0;
1561 WORD32 freq_res_0 = 0, frame_class;
1562 WORD32 abs_bord_lead, abs_bord_trail, num_rel_trail, num_rel_lead;
1563 static const WORD32 pointer_bits_array[7] = {1, 2, 2, 3, 3, 3, 3};
1564 ia_frame_info_struct *p_fixfix_tab;
1565 ia_frame_info_struct *p_frame_info = &ptr_frame_data->str_frame_info_details;
1566
1567 frame_class = ixheaacd_read_bits_buf(it_bit_buff, SBR_FRAME_CLASS_BITS);
1568 p_frame_info->frame_class = frame_class;
1569
1570 switch (frame_class) {
1571 case FIXFIX:
1572 temp =
1573 ixheaacd_read_bits_buf(it_bit_buff, SBR_ENV_BITS + SBR_FRQ_RES_BITS);
1574 bs_num_env = (temp & 0x6) >> SBR_FRQ_RES_BITS;
1575 p_fixfix_tab = &env_extr_tables_ptr->sbr_frame_info1_2_4_16[bs_num_env];
1576 memcpy(p_frame_info, p_fixfix_tab, sizeof(ia_frame_info_struct));
1577 bs_num_env = (1 << bs_num_env);
1578 freq_res_0 = temp & 0x1;
1579
1580 if (!freq_res_0) {
1581 memset(&p_frame_info->freq_res[0], 0, sizeof(WORD16) * bs_num_env);
1582 }
1583 break;
1584 case FIXVAR:
1585 bs_var_bord =
1586 ixheaacd_read_bits_buf(it_bit_buff, SBR_VAR_BORD_BITS + SBR_NUM_BITS);
1587 bs_num_rel = bs_var_bord & 3;
1588 bs_var_bord = bs_var_bord >> SBR_NUM_BITS;
1589 bs_num_env = bs_num_rel + 1;
1590 p_frame_info->border_vec[0] = 0;
1591 border = bs_var_bord + SBR_TIME_SLOTS;
1592 p_frame_info->border_vec[bs_num_env] = border;
1593 for (k = bs_num_rel; k > 0; k--) {
1594 temp = ixheaacd_read_bits_buf(it_bit_buff, SBR_REL_BITS);
1595 border = border - ((temp << 1) + 2);
1596 if (border < 0) border = 0;
1597 p_frame_info->border_vec[k] = border;
1598 }
1599
1600 bs_pointer_bits = pointer_bits_array[bs_num_rel];
1601 bs_pointer = ixheaacd_read_bits_buf(it_bit_buff, bs_pointer_bits);
1602
1603 if ((bs_pointer - (bs_num_rel + 1)) > 0) return 0;
1604
1605 for (k = bs_num_rel; k >= 0; k--) {
1606 p_frame_info->freq_res[k] =
1607 ixheaacd_read_bits_buf(it_bit_buff, SBR_FRQ_RES_BITS);
1608 }
1609 if (bs_pointer) {
1610 p_frame_info->transient_env = bs_num_env + 1 - bs_pointer;
1611 } else {
1612 p_frame_info->transient_env = -1;
1613 }
1614 if ((bs_pointer == 0) || (bs_pointer == 1))
1615 p_frame_info->noise_border_vec[1] =
1616 p_frame_info->border_vec[bs_num_rel];
1617 else
1618 p_frame_info->noise_border_vec[1] =
1619 p_frame_info->border_vec[p_frame_info->transient_env];
1620
1621 break;
1622
1623 case VARFIX:
1624 bs_var_bord =
1625 ixheaacd_read_bits_buf(it_bit_buff, SBR_VAR_BORD_BITS + SBR_NUM_BITS);
1626 bs_num_rel = bs_var_bord & 3;
1627 bs_var_bord = bs_var_bord >> SBR_NUM_BITS;
1628 bs_num_env = bs_num_rel + 1;
1629
1630 border = bs_var_bord;
1631 p_frame_info->border_vec[0] = border;
1632 for (k = 1; k <= bs_num_rel; k++) {
1633 temp = ixheaacd_read_bits_buf(it_bit_buff, SBR_REL_BITS);
1634 border = border + ((temp << 1) + 2);
1635 if (border > SBR_TIME_SLOTS) border = SBR_TIME_SLOTS;
1636 p_frame_info->border_vec[k] = border;
1637 }
1638 p_frame_info->border_vec[k] = SBR_TIME_SLOTS;
1639
1640 bs_pointer_bits = pointer_bits_array[bs_num_rel];
1641
1642 bs_pointer = ixheaacd_read_bits_buf(it_bit_buff, bs_pointer_bits);
1643
1644 if ((bs_pointer - (bs_num_rel + 1)) > 0) return 0;
1645
1646 if (bs_pointer == 0 || (bs_pointer - 1) == 0) {
1647 p_frame_info->transient_env = -1;
1648 } else {
1649 p_frame_info->transient_env = bs_pointer - 1;
1650 }
1651
1652 for (k = 0; k <= bs_num_rel; k++) {
1653 p_frame_info->freq_res[k] =
1654 ixheaacd_read_bits_buf(it_bit_buff, SBR_FRQ_RES_BITS);
1655 }
1656
1657 switch (bs_pointer) {
1658 case 0:
1659 p_frame_info->noise_border_vec[1] = p_frame_info->border_vec[1];
1660 break;
1661 case 1:
1662 p_frame_info->noise_border_vec[1] =
1663 p_frame_info->border_vec[bs_num_rel];
1664 break;
1665 default:
1666 p_frame_info->noise_border_vec[1] =
1667 p_frame_info->border_vec[(WORD32)p_frame_info->transient_env];
1668 break;
1669 }
1670
1671 break;
1672
1673 case VARVAR:
1674 abs_bord_lead = ixheaacd_read_bits_buf(
1675 it_bit_buff, 2 * SBR_VAR_BORD_BITS + 2 * SBR_NUM_BITS);
1676 abs_bord_trail =
1677 (((abs_bord_lead & 0x30) >> (2 * SBR_NUM_BITS)) + SBR_TIME_SLOTS);
1678 num_rel_trail = ((abs_bord_lead & 0xc) >> SBR_NUM_BITS);
1679 num_rel_lead = (abs_bord_lead & 0x3);
1680 abs_bord_lead = abs_bord_lead >> (SBR_VAR_BORD_BITS + 2 * SBR_NUM_BITS);
1681 bs_num_env = ((num_rel_trail + num_rel_lead) + 1);
1682 border = abs_bord_lead;
1683 p_frame_info->border_vec[0] = border;
1684
1685 for (k = 1; k <= num_rel_trail; k++) {
1686 temp = ixheaacd_read_bits_buf(it_bit_buff, SBR_REL_BITS);
1687 border = border + ((temp << 1) + 2);
1688 p_frame_info->border_vec[k] = border;
1689 }
1690
1691 border = abs_bord_trail;
1692 i = bs_num_env;
1693
1694 p_frame_info->border_vec[i] = border;
1695
1696 for (k = 0; k < num_rel_lead; k++) {
1697 temp = ixheaacd_read_bits_buf(it_bit_buff, SBR_REL_BITS);
1698 border = border - ((temp << 1) + 2);
1699 i--;
1700 p_frame_info->border_vec[i] = border;
1701 }
1702 bs_pointer_bits = pointer_bits_array[num_rel_trail + num_rel_lead];
1703
1704 bs_pointer = ixheaacd_read_bits_buf(it_bit_buff, bs_pointer_bits);
1705 if ((bs_pointer - ((num_rel_trail + num_rel_lead) + 1)) > 0) return 0;
1706
1707 if (bs_pointer) {
1708 p_frame_info->transient_env = bs_num_env + 1 - bs_pointer;
1709 } else {
1710 p_frame_info->transient_env = -1;
1711 }
1712
1713 for (k = 0; k < bs_num_env; k++) {
1714 p_frame_info->freq_res[k] =
1715 ixheaacd_read_bits_buf(it_bit_buff, SBR_FRQ_RES_BITS);
1716 }
1717 p_frame_info->noise_border_vec[0] = abs_bord_lead;
1718 if (bs_num_env == 1) {
1719 p_frame_info->noise_border_vec[1] = abs_bord_trail;
1720 } else {
1721 if (bs_pointer == 0 || (bs_pointer - 1) == 0)
1722 p_frame_info->noise_border_vec[1] =
1723 p_frame_info->border_vec[bs_num_env - 1];
1724 else
1725 p_frame_info->noise_border_vec[1] =
1726 p_frame_info->border_vec[(WORD32)p_frame_info->transient_env];
1727
1728 p_frame_info->noise_border_vec[2] = abs_bord_trail;
1729 }
1730 break;
1731 }
1732 p_frame_info->num_env = bs_num_env;
1733
1734 if (bs_num_env == 1)
1735 p_frame_info->num_noise_env = 1;
1736 else
1737 p_frame_info->num_noise_env = 2;
1738
1739 if (frame_class == VARFIX || frame_class == FIXVAR) {
1740 p_frame_info->noise_border_vec[0] = p_frame_info->border_vec[0];
1741 p_frame_info->noise_border_vec[p_frame_info->num_noise_env] =
1742 p_frame_info->border_vec[bs_num_env];
1743 }
1744 return 1;
1745 }