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