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