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 <math.h> 21 #include <ixheaacd_type_def.h> 22 #include "ixheaacd_bitbuffer.h" 23 #include "ixheaacd_config.h" 24 25 #include "ixheaacd_mps_polyphase.h" 26 27 #include "ixheaacd_mps_dec.h" 28 #include "ixheaacd_mps_interface.h" 29 #include "ixheaacd_mps_nlc_dec.h" 30 #include "ixheaacd_mps_hybfilter.h" 31 32 #include <assert.h> 33 #include <stdio.h> 34 35 #define min(a, b) ((a) < (b) ? (a) : (b)) 36 37 #define max(a, b) ((a) > (b) ? (a) : (b)) 38 39 static int ixheaacd_freq_res_table[] = {0, 28, 20, 14, 10, 7, 5, 4}; 40 41 static int 42 ixheaacd_hybrid_band_71_to_processing_band_4_map[MAX_HYBRID_BANDS_MPS] = { 43 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 44 2, 2, 2, 2, 2, 2, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 45 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3}; 46 47 static int 48 ixheaacd_hybrid_band_71_to_processing_band_5_map[MAX_HYBRID_BANDS_MPS] = { 49 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 3, 3, 3, 3, 3, 3, 3, 3, 50 3, 3, 3, 3, 3, 3, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 51 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4}; 52 53 static int 54 ixheaacd_hybrid_band_71_to_processing_band_7_map[MAX_HYBRID_BANDS_MPS] = { 55 0, 0, 0, 0, 0, 0, 1, 1, 2, 2, 2, 3, 3, 3, 3, 4, 4, 4, 4, 4, 4, 5, 5, 5, 56 5, 5, 5, 5, 5, 5, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 57 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6}; 58 59 static int 60 ixheaacd_hybrid_band_71_to_processing_band_10_map[MAX_HYBRID_BANDS_MPS] = { 61 0, 0, 0, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 7, 7, 7, 8, 8, 8, 62 8, 8, 8, 8, 8, 8, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 63 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9}; 64 65 static int 66 ixheaacd_hybrid_band_71_to_processing_band_14_map[MAX_HYBRID_BANDS_MPS] = { 67 0, 0, 0, 0, 1, 1, 2, 3, 4, 4, 5, 6, 6, 7, 7, 8, 8, 8, 68 9, 9, 9, 10, 10, 10, 10, 11, 11, 11, 11, 11, 12, 12, 12, 12, 12, 12, 69 12, 12, 12, 12, 12, 12, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 70 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13}; 71 72 int ixheaacd_hybrid_band_71_to_processing_band_20_map[MAX_HYBRID_BANDS_MPS] = { 73 1, 0, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 14, 74 15, 15, 15, 16, 16, 16, 16, 17, 17, 17, 17, 17, 18, 18, 18, 18, 18, 18, 75 18, 18, 18, 18, 18, 18, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 76 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19}; 77 78 int ixheaacd_hybrid_band_71_to_processing_band_28_map[MAX_HYBRID_BANDS_MPS] = { 79 1, 0, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 80 16, 17, 17, 18, 18, 19, 19, 20, 20, 21, 21, 21, 22, 22, 22, 23, 23, 23, 81 23, 24, 24, 24, 24, 24, 25, 25, 25, 25, 25, 25, 26, 26, 26, 26, 26, 26, 82 26, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27}; 83 84 static float ixheaacd_mps_clip_gain_table[] = {1.000000f, 1.189207f, 1.414213f, 85 1.681792f, 2.000000f, 2.378414f, 86 2.828427f, 4.000000f}; 87 88 static int ixheaacd_mps_stride_table[] = {1, 2, 5, 28}; 89 90 static float ixheaacd_cld_de_quant_table[] = { 91 -150.0, -45.0, -40.0, -35.0, -30.0, -25.0, -22.0, -19.0, 92 -16.0, -13.0, -10.0, -8.0, -6.0, -4.0, -2.0, 0.0, 93 2.0, 4.0, 6.0, 8.0, 10.0, 13.0, 16.0, 19.0, 94 22.0, 25.0, 30.0, 35.0, 40.0, 45.0, 150.0}; 95 96 static float ixheaacd_icc_de_quant_table[] = { 97 1.0000f, 0.9370f, 0.84118f, 0.60092f, 0.36764f, 0.0f, -0.5890f, -0.9900f}; 98 99 float ixheaacd_ipd_de_quant_table[] = { 100 0.f, 0.392699082f, 0.785398163f, 1.178097245f, 101 1.570796327f, 1.963495408f, 2.35619449f, 2.748893572f, 102 3.141592654f, 3.534291735f, 3.926990817f, 4.319689899f, 103 4.71238898f, 5.105088062f, 5.497787144f, 5.890486225f}; 104 int ixheaacd_ipd_de_quant_table_q28[] = { 105 0, 105414360, 210828720, 316243072, 421657440, 527071776, 106 632486144, 737900480, 843314880, 948729216, 1054143552, 1159557888, 107 1264972288, 1370386688, 1475800960, 1581215360}; 108 static int ixheaacd_smoothing_time_table[] = {64, 128, 256, 512}; 109 110 static int ixheaacd_inverse_smoothing_time_table_q30[] = {16777216, 8388608, 111 4194304, 2097152}; 112 113 static WORD32 bound_check(WORD32 var, WORD32 lower_bound, WORD32 upper_bound) { 114 var = min(var, upper_bound); 115 var = max(var, lower_bound); 116 return var; 117 } 118 119 static VOID ixheaacd_longmult1(unsigned short a[], unsigned short b, 120 unsigned short d[], int len) { 121 int k; 122 UWORD32 tmp; 123 UWORD32 b0 = (UWORD32)b; 124 125 tmp = ((UWORD32)a[0]) * b0; 126 d[0] = (unsigned short)tmp; 127 128 for (k = 1; k < len; k++) { 129 tmp = (tmp >> 16) + ((UWORD32)a[k]) * b0; 130 d[k] = (unsigned short)tmp; 131 } 132 } 133 134 static VOID ixheaacd_longdiv(unsigned short b[], unsigned short a, 135 unsigned short d[], unsigned short *pr, int len) { 136 UWORD32 r; 137 UWORD32 tmp; 138 UWORD32 temp; 139 int k; 140 141 assert(a != 0); 142 143 r = 0; 144 145 for (k = len - 1; k >= 0; k--) { 146 tmp = ((UWORD32)b[k]) + (r << 16); 147 148 if (tmp) { 149 d[k] = (unsigned short)(tmp / a); 150 temp = d[k] * a; 151 r = tmp - temp; 152 } else { 153 d[k] = 0; 154 } 155 } 156 *pr = (unsigned short)r; 157 } 158 159 static VOID ixheaacd_longsub(unsigned short a[], unsigned short b[], int lena, 160 int lenb) { 161 int h; 162 WORD32 carry = 0; 163 164 assert(lena >= lenb); 165 for (h = 0; h < lenb; h++) { 166 carry = carry + (WORD32)(a[h] - b[h]); 167 a[h] = (unsigned short)carry; 168 carry = carry >> 16; 169 } 170 171 for (; h < lena; h++) { 172 carry = ((UWORD32)a[h]) + carry; 173 a[h] = (unsigned short)carry; 174 carry = carry >> 16; 175 } 176 177 assert(carry == 0); 178 return; 179 } 180 181 static int ixheaacd_longcompare(unsigned short a[], unsigned short b[], 182 int len) { 183 int i; 184 185 for (i = len - 1; i > 0; i--) { 186 if (a[i] != b[i]) break; 187 } 188 return (a[i] >= b[i]) ? 1 : 0; 189 } 190 191 static VOID ixheaacd_mps_coarse2fine(int *data, WORD32 data_type, 192 int band_start, int ixheaacd_num_bands) { 193 int i; 194 195 for (i = band_start; i < band_start + ixheaacd_num_bands; i++) { 196 data[i] <<= 1; 197 } 198 199 if (data_type == CLD) { 200 for (i = band_start; i < band_start + ixheaacd_num_bands; i++) { 201 if (data[i] == -14) 202 data[i] = -15; 203 else if (data[i] == 14) 204 data[i] = 15; 205 } 206 } 207 } 208 209 static VOID ixheaacd_mps_fine2coarse(int *data, int ixheaacd_num_bands) { 210 int i; 211 212 for (i = 0; i < ixheaacd_num_bands; i++) { 213 data[i] /= 2; 214 } 215 } 216 217 static int ixheaacd_mps_getstridemap(int freq_res_stride, int band_start, 218 int band_stop, int *strides) { 219 int i, pb, ch_fac, data_bands, start_offset; 220 221 ch_fac = ixheaacd_mps_stride_table[freq_res_stride]; 222 data_bands = (band_stop - band_start - 1) / ch_fac + 1; 223 224 strides[0] = band_start; 225 for (pb = 1; pb <= data_bands; pb++) { 226 strides[pb] = strides[pb - 1] + ch_fac; 227 } 228 start_offset = 0; 229 while (strides[data_bands] > band_stop) { 230 if (start_offset < data_bands) 231 start_offset++; 232 else 233 start_offset = 1; 234 235 for (i = start_offset; i <= data_bands; i++) { 236 strides[i]--; 237 } 238 } 239 240 return data_bands; 241 } 242 243 static VOID ixheaacd_mps_ecdata_decoding( 244 ia_mps_dec_state_struct *self, ia_handle_bit_buf_struct bitstream, 245 int data[MAX_PARAMETER_SETS_MPS][MAX_PARAMETER_BANDS], int datatype) { 246 int i, j, pb, set_index, bs_data_pair, data_bands, old_quant_coarse_xxx; 247 int strides[MAX_PARAMETER_BANDS + 1] = {0}; 248 int band_stop = 0; 249 250 int *lastdata = NULL; 251 ia_mps_data_struct *frame_xxx_data = NULL; 252 int default_val = 0; 253 254 ia_mps_bs_frame *frame = &(self->bs_frame); 255 256 if (datatype == 0) { 257 frame_xxx_data = &frame->cld_data; 258 lastdata = frame->cmp_cld_idx_prev; 259 band_stop = self->bs_param_bands; 260 } else if (datatype == 1) { 261 frame_xxx_data = &frame->icc_data; 262 lastdata = frame->cmp_icc_idx_prev; 263 band_stop = self->bs_param_bands; 264 } else if (datatype == 2) { 265 frame_xxx_data = &frame->ipd_data; 266 lastdata = frame->ipd_idx_data_prev; 267 band_stop = self->num_bands_ipd; 268 } else { 269 frame_xxx_data = &frame->cld_data; 270 lastdata = frame->cmp_cld_idx_prev; 271 band_stop = self->bs_param_bands; 272 } 273 274 for (i = 0; i < self->num_parameter_sets; i++) { 275 frame_xxx_data->bs_xxx_data_mode[i] = ixheaacd_read_bits_buf(bitstream, 2); 276 } 277 278 set_index = 0; 279 bs_data_pair = 0; 280 old_quant_coarse_xxx = frame_xxx_data->bs_quant_coarse_xxx_prev; 281 282 for (i = 0; i < self->num_parameter_sets; i++) { 283 if (frame_xxx_data->bs_xxx_data_mode[i] == 0) { 284 for (pb = 0; pb < band_stop; pb++) { 285 lastdata[pb] = default_val; 286 } 287 288 old_quant_coarse_xxx = 0; 289 } 290 291 if (frame_xxx_data->bs_xxx_data_mode[i] == 3) { 292 if (bs_data_pair) { 293 bs_data_pair = 0; 294 } else { 295 bs_data_pair = ixheaacd_read_bits_buf(bitstream, 1); 296 frame_xxx_data->bs_quant_coarse_xxx[set_index] = 297 ixheaacd_read_bits_buf(bitstream, 1); 298 frame_xxx_data->bs_freq_res_stride_xxx[set_index] = 299 ixheaacd_read_bits_buf(bitstream, 2); 300 301 if (frame_xxx_data->bs_quant_coarse_xxx[set_index] != 302 old_quant_coarse_xxx) { 303 if (old_quant_coarse_xxx) { 304 ixheaacd_mps_coarse2fine(lastdata, datatype, 0, band_stop - 0); 305 } else { 306 ixheaacd_mps_fine2coarse(lastdata, band_stop); 307 } 308 } 309 310 data_bands = ixheaacd_mps_getstridemap( 311 frame_xxx_data->bs_freq_res_stride_xxx[set_index], 0, band_stop, 312 strides); 313 314 for (pb = 0; pb < data_bands; pb++) { 315 lastdata[pb] = lastdata[strides[pb]]; 316 } 317 318 ixheaacd_mps_ecdatapairdec( 319 bitstream, data, lastdata, datatype, set_index, data_bands, 320 bs_data_pair, frame_xxx_data->bs_quant_coarse_xxx[set_index], 321 frame->independency_flag && (i == 0)); 322 323 for (pb = 0; pb < data_bands; pb++) { 324 for (j = strides[pb]; j < strides[pb + 1]; j++) { 325 if (datatype == IPD) { 326 if (frame_xxx_data->bs_quant_coarse_xxx[set_index]) { 327 lastdata[j] = data[set_index + bs_data_pair][pb] & 7; 328 } else { 329 lastdata[j] = data[set_index + bs_data_pair][pb] & 15; 330 } 331 } else { 332 lastdata[j] = data[set_index + bs_data_pair][pb]; 333 } 334 } 335 } 336 337 old_quant_coarse_xxx = frame_xxx_data->bs_quant_coarse_xxx[set_index]; 338 339 if (bs_data_pair) { 340 frame_xxx_data->bs_quant_coarse_xxx[set_index + 1] = 341 frame_xxx_data->bs_quant_coarse_xxx[set_index]; 342 frame_xxx_data->bs_freq_res_stride_xxx[set_index + 1] = 343 frame_xxx_data->bs_freq_res_stride_xxx[set_index]; 344 } 345 set_index += bs_data_pair + 1; 346 } 347 } 348 } 349 } 350 351 VOID ixheaacd_mps_frame_parsing(ia_mps_dec_state_struct *self, 352 int usac_independency_flag, 353 ia_handle_bit_buf_struct bitstream) { 354 int i, bs_frame_type, data_bands, bs_temp_shape_enable, num_of_temp_shape_ch; 355 int ps, pg, ts, pb; 356 int env_shape_data[MAX_TIME_SLOTS]; 357 358 int bits_param_slot = 0; 359 360 ia_mps_bs_frame *frame = &(self->bs_frame); 361 362 if (self->parse_nxt_frame == 0) return; 363 364 self->num_parameter_sets_prev = self->num_parameter_sets; 365 366 if (self->bs_high_rate_mode) { 367 bs_frame_type = ixheaacd_read_bits_buf(bitstream, 1); 368 self->num_parameter_sets = ixheaacd_read_bits_buf(bitstream, 3) + 1; 369 } else { 370 bs_frame_type = 0; 371 self->num_parameter_sets = 1; 372 } 373 374 if (self->time_slots == 32) 375 bits_param_slot = 5; 376 else if (self->time_slots == 64) 377 bits_param_slot = 6; 378 379 if (bs_frame_type) { 380 for (i = 0; i < self->num_parameter_sets; i++) { 381 self->param_slots[i] = ixheaacd_read_bits_buf(bitstream, bits_param_slot); 382 } 383 } else { 384 self->param_slots[0] = self->time_slots - 1; 385 } 386 387 if (!usac_independency_flag) { 388 frame->independency_flag = ixheaacd_read_bits_buf(bitstream, 1); 389 } else { 390 frame->independency_flag = 1; 391 } 392 393 ixheaacd_mps_ecdata_decoding(self, bitstream, frame->cmp_cld_idx, CLD); 394 ixheaacd_mps_ecdata_decoding(self, bitstream, frame->cmp_icc_idx, ICC); 395 396 if (self->config->bs_phase_coding) { 397 self->bs_phase_mode = ixheaacd_read_bits_buf(bitstream, 1); 398 399 if (!self->bs_phase_mode) { 400 for (pb = 0; pb < self->num_bands_ipd; pb++) { 401 frame->ipd_idx_data_prev[pb] = 0; 402 for (i = 0; i < self->num_parameter_sets; i++) { 403 frame->ipd_idx_data[i][pb] = 0; 404 self->bs_frame.ipd_idx[i][pb] = 0; 405 } 406 self->bs_frame.ipd_idx_prev[pb] = 0; 407 } 408 self->opd_smoothing_mode = 0; 409 } else { 410 self->opd_smoothing_mode = ixheaacd_read_bits_buf(bitstream, 1); 411 ixheaacd_mps_ecdata_decoding(self, bitstream, frame->ipd_idx_data, IPD); 412 } 413 } 414 415 else { 416 self->bs_phase_mode = 0; 417 for (pb = 0; pb < self->num_bands_ipd; pb++) { 418 frame->ipd_idx_data_prev[pb] = 0; 419 for (i = 0; i < self->num_parameter_sets; i++) { 420 frame->ipd_idx_data[i][pb] = 0; 421 self->bs_frame.ipd_idx[i][pb] = 0; 422 } 423 self->bs_frame.ipd_idx_prev[pb] = 0; 424 } 425 self->opd_smoothing_mode = 0; 426 } 427 428 if (self->bs_high_rate_mode) { 429 for (ps = 0; ps < self->num_parameter_sets; ps++) { 430 frame->bs_smooth_mode[ps] = ixheaacd_read_bits_buf(bitstream, 2); 431 if (frame->bs_smooth_mode[ps] >= 2) { 432 frame->bs_smooth_time[ps] = ixheaacd_read_bits_buf(bitstream, 2); 433 } 434 if (frame->bs_smooth_mode[ps] == 3) { 435 frame->bs_freq_res_stride_smg[ps] = 436 ixheaacd_read_bits_buf(bitstream, 2); 437 data_bands = 438 (self->bs_param_bands - 1) / 439 ixheaacd_mps_stride_table[frame->bs_freq_res_stride_smg[ps]] + 440 1; 441 for (pg = 0; pg < data_bands; pg++) { 442 frame->bs_smg_data[ps][pg] = ixheaacd_read_bits_buf(bitstream, 1); 443 } 444 } 445 } 446 } else { 447 for (ps = 0; ps < self->num_parameter_sets; ps++) { 448 frame->bs_smooth_mode[ps] = 0; 449 } 450 } 451 452 for (i = 0; i < 2; i++) { 453 self->temp_shape_enable_ch_stp[i] = 0; 454 self->temp_shape_enable_ch_ges[i] = 0; 455 } 456 457 self->bs_tsd_enable = 0; 458 if (self->config->bs_temp_shape_config == 3) { 459 self->bs_tsd_enable = ixheaacd_read_bits_buf(bitstream, 1); 460 } else if (self->config->bs_temp_shape_config != 0) { 461 bs_temp_shape_enable = ixheaacd_read_bits_buf(bitstream, 1); 462 if (bs_temp_shape_enable) { 463 num_of_temp_shape_ch = 2; 464 switch (self->config->bs_temp_shape_config) { 465 case 1: 466 for (i = 0; i < num_of_temp_shape_ch; i++) { 467 self->temp_shape_enable_ch_stp[i] = 468 ixheaacd_read_bits_buf(bitstream, 1); 469 } 470 break; 471 case 2: 472 for (i = 0; i < num_of_temp_shape_ch; i++) { 473 self->temp_shape_enable_ch_ges[i] = 474 ixheaacd_read_bits_buf(bitstream, 1); 475 } 476 for (i = 0; i < num_of_temp_shape_ch; i++) { 477 if (self->temp_shape_enable_ch_ges[i]) { 478 ixheaacd_mps_huff_decode(bitstream, env_shape_data, 479 self->time_slots); 480 for (ts = 0; ts < self->time_slots; ts++) { 481 self->env_shape_data[i][ts] = (float)pow( 482 2, (float)env_shape_data[ts] / 483 (self->config->bs_env_quant_mode + 2) - 484 1); 485 } 486 } 487 } 488 break; 489 default: 490 assert(0); 491 } 492 } 493 } 494 495 if (self->bs_tsd_enable) { 496 unsigned short s[4]; 497 UWORD64 s_64; 498 unsigned short c[5]; 499 UWORD64 c_64; 500 unsigned short b; 501 unsigned short r[1]; 502 unsigned short table_64[] = {6, 11, 16, 20, 23, 27, 30, 33, 35, 38, 40, 503 42, 44, 46, 48, 49, 51, 52, 53, 55, 56, 57, 504 58, 58, 59, 60, 60, 60, 61, 61, 61, 61}; 505 unsigned short table_32[] = {5, 9, 13, 16, 18, 20, 22, 24, 506 25, 26, 27, 28, 29, 29, 30, 30}; 507 unsigned short *tab = NULL; 508 int k; 509 unsigned short h; 510 WORD32 nbits_tr_slots = 0; 511 512 if (self->time_slots == 32) { 513 nbits_tr_slots = 4; 514 tab = table_32; 515 } else if (self->time_slots == 64) { 516 nbits_tr_slots = 5; 517 tab = table_64; 518 } 519 520 self->tsd_num_tr_slots = ixheaacd_read_bits_buf(bitstream, nbits_tr_slots); 521 self->tsd_num_tr_slots++; 522 self->tsd_codeword_len = tab[self->tsd_num_tr_slots - 1]; 523 524 if (self->tsd_codeword_len > 48) { 525 s[3] = ixheaacd_read_bits_buf(bitstream, self->tsd_codeword_len - 48); 526 s_64 = s[3]; 527 s[2] = ixheaacd_read_bits_buf(bitstream, 16); 528 s_64 = (s_64 << 16) | s[2]; 529 s[1] = ixheaacd_read_bits_buf(bitstream, 16); 530 s_64 = (s_64 << 16) | s[1]; 531 s[0] = ixheaacd_read_bits_buf(bitstream, 16); 532 s_64 = (s_64 << 16) | s[0]; 533 } else if (self->tsd_codeword_len > 32) { 534 s[3] = 0; 535 s_64 = s[3]; 536 s[2] = ixheaacd_read_bits_buf(bitstream, self->tsd_codeword_len - 32); 537 s_64 = (s_64 << 16) | s[2]; 538 s[1] = ixheaacd_read_bits_buf(bitstream, 16); 539 s_64 = (s_64 << 16) | s[1]; 540 s[0] = ixheaacd_read_bits_buf(bitstream, 16); 541 s_64 = (s_64 << 16) | s[0]; 542 } else if (self->tsd_codeword_len > 16) { 543 s[3] = 0; 544 s_64 = s[3]; 545 s[2] = 0; 546 s_64 = (s_64 << 16) | s[2]; 547 s[1] = ixheaacd_read_bits_buf(bitstream, self->tsd_codeword_len - 16); 548 s_64 = (s_64 << 16) | s[1]; 549 s[0] = ixheaacd_read_bits_buf(bitstream, 16); 550 s_64 = (s_64 << 16) | s[0]; 551 } else { 552 s[3] = 0; 553 s_64 = s[3]; 554 s[2] = 0; 555 s_64 = (s_64 << 16) | s[2]; 556 s[1] = 0; 557 s_64 = (s_64 << 16) | s[1]; 558 s[0] = ixheaacd_read_bits_buf(bitstream, self->tsd_codeword_len); 559 s_64 = (s_64 << 16) | s[0]; 560 } 561 562 { 563 int p = self->tsd_num_tr_slots; 564 565 for (i = 0; i < self->time_slots; i++) self->bs_tsd_sep_data[i] = 0; 566 567 for (k = self->time_slots - 1; k >= 0; k--) { 568 if (p > k) { 569 for (; k >= 0; k--) self->bs_tsd_sep_data[k] = 1; 570 break; 571 } 572 573 c[0] = k - p + 1; 574 c_64 = c[0]; 575 for (i = 1; i < 5; i++) c[i] = 0; 576 577 for (h = 2; h <= p; h++) { 578 b = k - p + h; 579 c_64 = c_64 * (b / h); 580 ixheaacd_longmult1(c, b, c, 5); 581 b = h; 582 ixheaacd_longdiv(c, b, c, r, 5); 583 } 584 585 if (ixheaacd_longcompare(s, c, 4)) { 586 ixheaacd_longsub(s, c, 4, 4); 587 self->bs_tsd_sep_data[k] = 1; 588 p--; 589 if (p == 0) break; 590 } 591 } 592 } 593 594 for (i = 0; i < self->time_slots; i++) { 595 if (self->bs_tsd_sep_data[i]) 596 self->bs_tsd_tr_phase_data[i] = ixheaacd_read_bits_buf(bitstream, 3); 597 } 598 } 599 600 self->parse_nxt_frame = 0; 601 } 602 603 static VOID ixheaacd_mps_createmapping(int map[MAX_PARAMETER_BANDS + 1], 604 int band_start, int band_stop, 605 int ch_fac) { 606 int input_bands, out_bands, bands_achived, bands_diff, incr, k, i; 607 int vdk[MAX_PARAMETER_BANDS + 1]; 608 input_bands = band_stop - band_start; 609 out_bands = (input_bands - 1) / ch_fac + 1; 610 if (out_bands < 1) { 611 out_bands = 1; 612 } 613 614 bands_achived = out_bands * ch_fac; 615 bands_diff = input_bands - bands_achived; 616 for (i = 0; i < out_bands; i++) { 617 vdk[i] = ch_fac; 618 } 619 620 if (bands_diff > 0) { 621 incr = -1; 622 k = out_bands - 1; 623 } else { 624 incr = 1; 625 k = 0; 626 } 627 628 while (bands_diff != 0) { 629 vdk[k] = vdk[k] - incr; 630 k = k + incr; 631 bands_diff = bands_diff + incr; 632 if (k >= out_bands) { 633 if (bands_diff > 0) { 634 k = out_bands - 1; 635 } else if (bands_diff < 0) { 636 k = 0; 637 } 638 } 639 } 640 map[0] = band_start; 641 for (i = 0; i < out_bands; i++) { 642 map[i + 1] = map[i] + vdk[i]; 643 } 644 } 645 646 static VOID ixheaacd_mps_mapfrequency(int *in, int *out, int *map, 647 int data_bands) { 648 int i, j, band_start, band_stop, value; 649 int start_band_0 = map[0]; 650 651 for (i = 0; i < data_bands; i++) { 652 value = in[i + start_band_0]; 653 654 band_start = map[i]; 655 band_stop = map[i + 1]; 656 for (j = band_start; j < band_stop; j++) { 657 out[j] = value; 658 } 659 } 660 } 661 662 static float ixheaacd_mps_de_quantize(int value, int param_type) { 663 switch (param_type) { 664 case CLD: 665 return ixheaacd_cld_de_quant_table[value + 15]; 666 667 case ICC: 668 return ixheaacd_icc_de_quant_table[value]; 669 670 case IPD: 671 return ixheaacd_ipd_de_quant_table[(value & 15)]; 672 673 default: 674 assert(0); 675 return 0.0; 676 } 677 } 678 679 static WORD32 ixheaacd_mps_mapindexdata( 680 ia_mps_dec_state_struct *self, ia_mps_data_struct *frame_xxx_data, 681 float out_data[MAX_PARAMETER_SETS_MPS][MAX_PARAMETER_BANDS], 682 int out_idx_data[MAX_PARAMETER_SETS_MPS][MAX_PARAMETER_BANDS], 683 int cmp_idx_data[MAX_PARAMETER_SETS_MPS][MAX_PARAMETER_BANDS], 684 int idx_prev[MAX_PARAMETER_BANDS], int param_type) { 685 int interpolate_local[MAX_PARAMETER_SETS_MPS] = {0}; 686 int map[MAX_PARAMETER_BANDS + 1]; 687 688 int set_index, i, band, parm_slot; 689 int data_bands, ch_fac; 690 int ps; 691 692 int i1, i2, x1, xi, x2; 693 int band_start = 0; 694 int ext_frame_flag = self->ext_frame_flag; 695 int *param_slots = self->param_slots; 696 int num_parameter_sets = self->num_parameter_sets; 697 int band_stop = self->bs_param_bands; 698 int default_val = 0; 699 700 set_index = 0; 701 702 for (i = 0; i < num_parameter_sets; i++) { 703 if (frame_xxx_data->bs_xxx_data_mode[i] == 0) { 704 frame_xxx_data->quant_coarse_xxx_flag[i] = 0; 705 for (band = band_start; band < band_stop; band++) { 706 out_idx_data[i][band] = default_val; 707 } 708 for (band = band_start; band < band_stop; band++) { 709 idx_prev[band] = out_idx_data[i][band]; 710 } 711 712 frame_xxx_data->bs_quant_coarse_xxx_prev = 0; 713 } 714 715 if (frame_xxx_data->bs_xxx_data_mode[i] == 1) { 716 for (band = band_start; band < band_stop; band++) { 717 out_idx_data[i][band] = idx_prev[band]; 718 } 719 frame_xxx_data->quant_coarse_xxx_flag[i] = 720 frame_xxx_data->bs_quant_coarse_xxx_prev; 721 } 722 723 if (frame_xxx_data->bs_xxx_data_mode[i] == 2) { 724 for (band = band_start; band < band_stop; band++) { 725 out_idx_data[i][band] = idx_prev[band]; 726 } 727 frame_xxx_data->quant_coarse_xxx_flag[i] = 728 frame_xxx_data->bs_quant_coarse_xxx_prev; 729 interpolate_local[i] = 1; 730 } else { 731 interpolate_local[i] = 0; 732 } 733 734 if (frame_xxx_data->bs_xxx_data_mode[i] == 3) { 735 parm_slot = i; 736 ch_fac = 737 ixheaacd_mps_stride_table[frame_xxx_data 738 ->bs_freq_res_stride_xxx[set_index]]; 739 data_bands = (band_stop - band_start - 1) / ch_fac + 1; 740 ixheaacd_mps_createmapping(map, band_start, band_stop, ch_fac); 741 ixheaacd_mps_mapfrequency(&cmp_idx_data[set_index][0], 742 &out_idx_data[parm_slot][0], map, data_bands); 743 744 for (band = band_start; band < band_stop; band++) { 745 idx_prev[band] = out_idx_data[parm_slot][band]; 746 } 747 748 frame_xxx_data->bs_quant_coarse_xxx_prev = 749 frame_xxx_data->bs_quant_coarse_xxx[set_index]; 750 frame_xxx_data->quant_coarse_xxx_flag[i] = 751 frame_xxx_data->bs_quant_coarse_xxx[set_index]; 752 753 set_index++; 754 } 755 } 756 757 for (i = 0; i < num_parameter_sets; i++) { 758 if (frame_xxx_data->quant_coarse_xxx_flag[i] == 1) { 759 ixheaacd_mps_coarse2fine(out_idx_data[i], param_type, band_start, 760 band_stop - band_start); 761 frame_xxx_data->quant_coarse_xxx_flag[i] = 0; 762 } 763 } 764 765 i1 = -1; 766 x1 = 0; 767 i2 = 0; 768 for (i = 0; i < num_parameter_sets; i++) { 769 if (interpolate_local[i] != 1) { 770 i1 = i; 771 } 772 i2 = i; 773 while (interpolate_local[i2] == 1) { 774 i2++; 775 } 776 if (i1 == -1) { 777 x1 = 0; 778 i1 = 0; 779 } else { 780 x1 = param_slots[i1]; 781 } 782 xi = param_slots[i]; 783 x2 = param_slots[i2]; 784 785 if (interpolate_local[i] == 1) { 786 if (i2 < num_parameter_sets) { 787 return -1; 788 } 789 for (band = band_start; band < band_stop; band++) { 790 int yi, y1, y2; 791 yi = 0; 792 y1 = out_idx_data[i1][band]; 793 y2 = out_idx_data[i2][band]; 794 if (param_type == IPD) { 795 if (y2 - y1 > 8) y1 += 16; 796 if (y1 - y2 > 8) y2 += 16; 797 798 if (x2 != x1) { 799 yi = (y1 + (xi - x1) * (y2 - y1) / (x2 - x1)) % 16; 800 } 801 } else { 802 if (x2 != x1) { 803 yi = y1 + (xi - x1) * (y2 - y1) / (x2 - x1); 804 } 805 } 806 out_idx_data[i][band] = yi; 807 } 808 } 809 } 810 811 for (ps = 0; ps < num_parameter_sets; ps++) { 812 for (band = band_start; band < band_stop; band++) { 813 if (param_type == CLD) { 814 out_idx_data[ps][band] = bound_check(out_idx_data[ps][band], -15, 15); 815 } else if (param_type == ICC) // param_type is ICC 816 { 817 out_idx_data[ps][band] = bound_check(out_idx_data[ps][band], 0, 7); 818 } 819 out_data[ps][band] = 820 ixheaacd_mps_de_quantize(out_idx_data[ps][band], param_type); 821 } 822 } 823 824 if (ext_frame_flag) { 825 for (band = band_start; band < band_stop; band++) { 826 out_data[num_parameter_sets][band] = 827 out_data[num_parameter_sets - 1][band]; 828 out_idx_data[num_parameter_sets][band] = 829 out_idx_data[num_parameter_sets - 1][band]; 830 } 831 } 832 833 return 0; 834 } 835 836 static WORD32 ixheaacd_mps_dec_and_mapframeott(ia_mps_dec_state_struct *self) { 837 ia_mps_bs_frame *cur_bit_stream_ptr = &(self->bs_frame); 838 WORD32 err_code = 0; 839 840 err_code = ixheaacd_mps_mapindexdata( 841 self, &cur_bit_stream_ptr->cld_data, self->cld_data, 842 cur_bit_stream_ptr->cld_idx, cur_bit_stream_ptr->cmp_cld_idx, 843 cur_bit_stream_ptr->cld_idx_pre, CLD); 844 if (err_code != 0) return err_code; 845 846 err_code = ixheaacd_mps_mapindexdata( 847 self, &cur_bit_stream_ptr->icc_data, self->icc_data, 848 cur_bit_stream_ptr->icc_idx, cur_bit_stream_ptr->cmp_icc_idx, 849 cur_bit_stream_ptr->icc_idx_pre, ICC); 850 if (err_code != 0) return err_code; 851 if ((self->config->bs_phase_coding)) { 852 err_code = ixheaacd_mps_mapindexdata( 853 self, &cur_bit_stream_ptr->ipd_data, self->ipd_data, 854 cur_bit_stream_ptr->ipd_idx, cur_bit_stream_ptr->ipd_idx_data, 855 cur_bit_stream_ptr->ipd_idx_prev, IPD); 856 857 if (err_code != 0) return err_code; 858 } 859 860 return 0; 861 } 862 863 static VOID ixheaacd_mps_dec_and_mapframesmg(ia_mps_dec_state_struct *self) { 864 int ps, pb, pg, ch_fac, data_bands, param_band_start, param_band_stop, 865 group_to_band[MAX_PARAMETER_BANDS + 1]; 866 ia_mps_bs_frame *frame = &(self->bs_frame); 867 for (ps = 0; ps < self->num_parameter_sets; ps++) { 868 switch (frame->bs_smooth_mode[ps]) { 869 case 0: 870 self->smoothing_time[ps] = 256; 871 self->inv_smoothing_time[ps] = 4194304; 872 873 for (pb = 0; pb < self->bs_param_bands; pb++) { 874 self->smoothing_data[ps][pb] = 0; 875 } 876 break; 877 878 case 1: 879 if (ps > 0) { 880 self->smoothing_time[ps] = self->smoothing_time[ps - 1]; 881 self->inv_smoothing_time[ps] = self->inv_smoothing_time[ps - 1]; 882 } else { 883 self->smoothing_time[ps] = self->smoothing_filt_state.prev_smg_time; 884 self->inv_smoothing_time[ps] = 885 self->smoothing_filt_state.inv_prev_smg_time; 886 } 887 888 for (pb = 0; pb < self->bs_param_bands; pb++) { 889 if (ps > 0) 890 self->smoothing_data[ps][pb] = self->smoothing_data[ps - 1][pb]; 891 else 892 self->smoothing_data[ps][pb] = 893 self->smoothing_filt_state.prev_smg_data[pb]; 894 } 895 break; 896 897 case 2: 898 self->smoothing_time[ps] = 899 ixheaacd_smoothing_time_table[frame->bs_smooth_time[ps]]; 900 self->inv_smoothing_time[ps] = 901 ixheaacd_inverse_smoothing_time_table_q30[frame 902 ->bs_smooth_time[ps]]; 903 for (pb = 0; pb < self->bs_param_bands; pb++) { 904 self->smoothing_data[ps][pb] = 1; 905 } 906 break; 907 908 case 3: 909 self->smoothing_time[ps] = 910 ixheaacd_smoothing_time_table[frame->bs_smooth_time[ps]]; 911 self->inv_smoothing_time[ps] = 912 ixheaacd_inverse_smoothing_time_table_q30[frame 913 ->bs_smooth_time[ps]]; 914 915 ch_fac = ixheaacd_mps_stride_table[frame->bs_freq_res_stride_smg[ps]]; 916 data_bands = (self->bs_param_bands - 1) / ch_fac + 1; 917 ixheaacd_mps_createmapping(group_to_band, 0, self->bs_param_bands, 918 ch_fac); 919 for (pg = 0; pg < data_bands; pg++) { 920 param_band_start = group_to_band[pg]; 921 param_band_stop = group_to_band[pg + 1]; 922 for (pb = param_band_start; pb < param_band_stop; pb++) { 923 self->smoothing_data[ps][pb] = frame->bs_smg_data[ps][pg]; 924 } 925 } 926 break; 927 } 928 } 929 930 self->smoothing_filt_state.prev_smg_time = 931 self->smoothing_time[self->num_parameter_sets - 1]; 932 self->smoothing_filt_state.inv_prev_smg_time = 933 self->inv_smoothing_time[self->num_parameter_sets - 1]; 934 for (pb = 0; pb < self->bs_param_bands; pb++) { 935 self->smoothing_filt_state.prev_smg_data[pb] = 936 self->smoothing_data[self->num_parameter_sets - 1][pb]; 937 } 938 939 if (self->ext_frame_flag) { 940 self->smoothing_time[self->num_parameter_sets] = 941 self->smoothing_time[self->num_parameter_sets - 1]; 942 self->inv_smoothing_time[self->num_parameter_sets] = 943 self->inv_smoothing_time[self->num_parameter_sets - 1]; 944 for (pb = 0; pb < self->bs_param_bands; pb++) { 945 self->smoothing_data[self->num_parameter_sets][pb] = 946 self->smoothing_data[self->num_parameter_sets - 1][pb]; 947 } 948 } 949 } 950 951 WORD32 ixheaacd_mps_frame_decode(ia_mps_dec_state_struct *self) { 952 int i; 953 WORD32 err_code = 0; 954 if (self->parse_nxt_frame == 1) return 0; 955 956 self->ext_frame_flag = 0; 957 if (self->param_slots[self->num_parameter_sets - 1] != self->time_slots - 1) { 958 self->ext_frame_flag = 1; 959 } 960 961 err_code = ixheaacd_mps_dec_and_mapframeott(self); 962 963 if (err_code != 0) return err_code; 964 965 ixheaacd_mps_dec_and_mapframesmg(self); 966 967 if (self->ext_frame_flag) { 968 self->num_parameter_sets++; 969 self->param_slots[self->num_parameter_sets - 1] = self->time_slots - 1; 970 } 971 self->param_slot_diff[0] = self->param_slots[0] + 1; 972 self->inv_param_slot_diff[0] = (float)1 / self->param_slot_diff[0]; 973 self->inv_param_slot_diff_Q30[0] = 974 (int)floor(self->inv_param_slot_diff[0] * 1073741824 + 0.5); 975 for (i = 1; i < self->num_parameter_sets; i++) { 976 self->param_slot_diff[i] = self->param_slots[i] - self->param_slots[i - 1]; 977 self->inv_param_slot_diff[i] = (float)1 / self->param_slot_diff[i]; 978 self->inv_param_slot_diff_Q30[i] = 979 (int)floor(self->inv_param_slot_diff[i] * 1073741824 + 0.5); 980 } 981 982 return 0; 983 } 984 985 WORD32 ixheaacd_mps_header_decode(ia_mps_dec_state_struct *self) { 986 self->time_slots = self->frame_length; 987 self->frame_len = self->time_slots * self->qmf_band_count; 988 self->bs_param_bands = ixheaacd_freq_res_table[self->config->bs_freq_res]; 989 990 self->hyb_band_count = self->qmf_band_count - QMF_BANDS_TO_HYBRID + 10; 991 992 switch (self->bs_param_bands) { 993 case 4: 994 995 self->hyb_band_to_processing_band_table = 996 ixheaacd_hybrid_band_71_to_processing_band_4_map; 997 break; 998 case 5: 999 1000 self->hyb_band_to_processing_band_table = 1001 ixheaacd_hybrid_band_71_to_processing_band_5_map; 1002 break; 1003 case 7: 1004 1005 self->hyb_band_to_processing_band_table = 1006 ixheaacd_hybrid_band_71_to_processing_band_7_map; 1007 break; 1008 case 10: 1009 1010 self->hyb_band_to_processing_band_table = 1011 ixheaacd_hybrid_band_71_to_processing_band_10_map; 1012 break; 1013 case 14: 1014 1015 self->hyb_band_to_processing_band_table = 1016 ixheaacd_hybrid_band_71_to_processing_band_14_map; 1017 break; 1018 case 20: 1019 1020 self->hyb_band_to_processing_band_table = 1021 ixheaacd_hybrid_band_71_to_processing_band_20_map; 1022 break; 1023 case 28: 1024 1025 self->hyb_band_to_processing_band_table = 1026 ixheaacd_hybrid_band_71_to_processing_band_28_map; 1027 break; 1028 default: 1029 self->hyb_band_to_processing_band_table = NULL; 1030 return -1; 1031 break; 1032 }; 1033 1034 self->in_ch_count = 1; 1035 self->out_ch_count = 2; 1036 1037 self->input_gain = 1038 ixheaacd_mps_clip_gain_table[self->config->bs_fixed_gain_dmx]; 1039 1040 if (self->config->bs_ott_bands_phase_present) { 1041 self->num_bands_ipd = self->config->bs_ott_bands_phase; 1042 } else { 1043 switch (self->bs_param_bands) { 1044 case 4: 1045 case 5: 1046 self->num_bands_ipd = 2; 1047 break; 1048 case 7: 1049 self->num_bands_ipd = 3; 1050 break; 1051 case 10: 1052 self->num_bands_ipd = 5; 1053 break; 1054 case 14: 1055 self->num_bands_ipd = 7; 1056 break; 1057 case 20: 1058 case 28: 1059 self->num_bands_ipd = 10; 1060 break; 1061 default: 1062 assert(0); 1063 break; 1064 } 1065 } 1066 1067 if (self->residual_coding) { 1068 self->num_bands_ipd = max(self->bs_residual_bands, self->num_bands_ipd); 1069 self->max_res_bands = 0; 1070 if (self->bs_residual_present) { 1071 self->res_bands = self->bs_residual_bands; 1072 if (self->res_bands > self->max_res_bands) { 1073 self->max_res_bands = self->res_bands; 1074 } 1075 } else { 1076 self->res_bands = 0; 1077 } 1078 } 1079 1080 if (self->num_bands_ipd > MAX_PARAMETER_BANDS) return -1; 1081 1082 self->dir_sig_count = 1; 1083 self->decor_sig_count = 1; 1084 1085 self->bs_high_rate_mode = self->config->bs_high_rate_mode; 1086 1087 return 0; 1088 } 1089
