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 "ixheaacd_sbr_common.h" 21 #include <ixheaacd_type_def.h> 22 23 #include "ixheaacd_constants.h" 24 #include <ixheaacd_basic_ops32.h> 25 #include <ixheaacd_basic_ops16.h> 26 #include <ixheaacd_basic_ops40.h> 27 #include "ixheaacd_basic_ops.h" 28 #include "ixheaacd_common_rom.h" 29 #include "ixheaacd_basic_funcs.h" 30 #include "ixheaacd_defines.h" 31 #include <ixheaacd_aac_rom.h> 32 #include "ixheaacd_bitbuffer.h" 33 #include "ixheaacd_intrinsics.h" 34 #include "ixheaacd_pulsedata.h" 35 36 #include "ixheaacd_pns.h" 37 #include "ixheaacd_drc_data_struct.h" 38 39 #include "ixheaacd_lt_predict.h" 40 41 #include "ixheaacd_channelinfo.h" 42 #include "ixheaacd_drc_dec.h" 43 44 #include "ixheaacd_block.h" 45 #include "ixheaacd_channel.h" 46 47 #include <ixheaacd_basic_op.h> 48 49 #include "ixheaacd_tns.h" 50 #include "ixheaacd_sbrdecoder.h" 51 #include "ixheaacd_error_codes.h" 52 53 #include "ixheaacd_audioobjtypes.h" 54 #include "ixheaacd_latmdemux.h" 55 56 #include "ixheaacd_aacdec.h" 57 58 static PLATFORM_INLINE WORD32 ixheaacd_shr32_drc(WORD32 a, WORD32 b) { 59 WORD32 out_val; 60 61 b = ((UWORD32)(b << 24) >> 24); 62 if (b >= 31) { 63 if (a < 0) 64 out_val = -1; 65 else 66 out_val = 0; 67 } else { 68 a += (1 << (b - 1)); 69 out_val = (WORD32)a >> b; 70 } 71 72 return out_val; 73 } 74 75 static PLATFORM_INLINE WORD32 ixheaacd_mult32x16in32_drc(WORD32 a, WORD16 b) { 76 WORD32 result; 77 WORD64 temp_result; 78 79 temp_result = (WORD64)a * (WORD64)b; 80 81 if (temp_result < (WORD64)MIN_32) 82 result = MIN_32; 83 84 else if (temp_result > (WORD64)MAX_32) 85 result = MAX_32; 86 87 else 88 result = (WORD32)(temp_result); 89 90 return (result); 91 } 92 static PLATFORM_INLINE WORD32 ixheaacd_mac32x16in32_drc(WORD32 a, WORD32 b, 93 WORD16 c) { 94 WORD32 acc; 95 96 acc = ixheaacd_mult32x16in32_drc(b, c); 97 98 acc = ixheaacd_add32_sat(a, acc); 99 100 return acc; 101 } 102 103 WORD32 ixheaacd_cnt_leading_ones(WORD32 a); 104 105 VOID ixheaacd_huff_sfb_table(WORD32 it_bit_buff, WORD16 *huff_index, 106 WORD32 *len, const UWORD16 *code_book_tbl, 107 const UWORD32 *idx_table) { 108 UWORD32 temp = 0; 109 UWORD32 temp1 = 0; 110 WORD32 found = 0; 111 UWORD32 mask = 0x80000000; 112 113 WORD32 leading_ones; 114 WORD32 max_len; 115 WORD32 ixheaacd_drc_offset = 0; 116 WORD32 length; 117 UWORD32 code_word; 118 WORD32 len_end; 119 120 max_len = code_book_tbl[0]; 121 mask = mask - (1 << (31 - max_len)); 122 mask = mask << 1; 123 124 temp = (UWORD32)((it_bit_buff & mask)); 125 126 len_end = code_book_tbl[0]; 127 leading_ones = ixheaacd_cnt_leading_ones(temp); 128 do { 129 ixheaacd_drc_offset = (idx_table[leading_ones] >> 20) & 0x1ff; 130 length = code_book_tbl[ixheaacd_drc_offset + 1] & 0x1f; 131 code_word = idx_table[leading_ones] & 0xfffff; 132 temp1 = temp >> (32 - length); 133 if (temp1 <= code_word) { 134 ixheaacd_drc_offset = ixheaacd_drc_offset - (code_word - temp1); 135 found = 1; 136 } else { 137 len_end = len_end + ((idx_table[leading_ones] >> 29) & 0x7); 138 leading_ones = len_end; 139 } 140 } while (!found); 141 *huff_index = code_book_tbl[ixheaacd_drc_offset + 1] >> 5; 142 *len = length; 143 } 144 145 VOID ixheaacd_inverse_quantize(WORD32 *x_invquant, WORD no_band, 146 WORD32 *ixheaacd_pow_table_Q13, 147 WORD8 *scratch_in) { 148 WORD32 j; 149 WORD32 temp; 150 WORD32 q_abs; 151 152 for (j = no_band - 1; j >= 0; j--) { 153 q_abs = *scratch_in++; 154 temp = (ixheaacd_pow_table_Q13[q_abs]); 155 *x_invquant++ = -temp; 156 } 157 } 158 159 static PLATFORM_INLINE WORD ixheaacd_huffman_dec_word1( 160 ia_bit_buf_struct *it_bit_buff, WORD32 *spec_coef, WORD16 *offsets, 161 WORD no_bands, WORD group_len, const UWORD16 *code_book_tbl, 162 WORD32 *ixheaacd_pow_table_Q13, const UWORD32 *idx_table) { 163 WORD32 sp1, sp2; 164 WORD32 flush_cw; 165 WORD32 i, value, norm_val, off; 166 WORD idx, grp_idx; 167 WORD32 out1, out2; 168 WORD32 err_code = 0; 169 WORD len_idx = 0; 170 UWORD8 *ptr_read_next = it_bit_buff->ptr_read_next; 171 WORD32 bit_pos = it_bit_buff->bit_pos; 172 WORD16 index; 173 WORD32 length; 174 WORD32 read_word; 175 WORD32 increment; 176 177 read_word = ixheaacd_aac_showbits_32(ptr_read_next, it_bit_buff->cnt_bits, 178 &increment); 179 ptr_read_next += increment; 180 181 do { 182 len_idx = offsets[1] - offsets[0]; 183 grp_idx = group_len; 184 185 do { 186 spec_coef = spec_coef + offsets[0]; 187 idx = len_idx; 188 do { 189 { 190 UWORD32 read_word1; 191 192 read_word1 = read_word << bit_pos; 193 ixheaacd_huff_sfb_table(read_word1, &index, &length, code_book_tbl, 194 idx_table); 195 bit_pos += length; 196 ixheaacd_aac_read_byte_corr(&ptr_read_next, &bit_pos, &read_word, 197 it_bit_buff->ptr_bit_buf_end); 198 } 199 200 out1 = index / 17; 201 out2 = index - out1 * 17; 202 flush_cw = read_word << bit_pos; 203 204 sp1 = out1; 205 sp2 = out2; 206 207 if (out1) { 208 if (flush_cw & 0x80000000) { 209 out1 = -out1; 210 } 211 bit_pos++; 212 flush_cw = (WORD32)flush_cw << 1; 213 } 214 215 if (out2) { 216 bit_pos++; 217 if (flush_cw & 0x80000000) { 218 out2 = -out2; 219 } 220 } 221 ixheaacd_aac_read_byte_corr(&ptr_read_next, &bit_pos, &read_word, 222 it_bit_buff->ptr_bit_buf_end); 223 224 if (sp1 == 16) { 225 i = 4; 226 value = ixheaacd_extu(read_word, bit_pos, 23); 227 value = value | 0xfffffe00; 228 norm_val = ixheaacd_norm32(value); 229 230 i += (norm_val - 22); 231 bit_pos += (norm_val - 21); 232 ixheaacd_aac_read_byte_corr(&ptr_read_next, &bit_pos, &read_word, 233 it_bit_buff->ptr_bit_buf_end); 234 235 off = ixheaacd_extu(read_word, bit_pos, 32 - i); 236 237 bit_pos += i; 238 239 ixheaacd_aac_read_byte_corr(&ptr_read_next, &bit_pos, &read_word, 240 it_bit_buff->ptr_bit_buf_end); 241 ixheaacd_aac_read_byte_corr(&ptr_read_next, &bit_pos, &read_word, 242 it_bit_buff->ptr_bit_buf_end); 243 244 i = off + ((WORD32)1 << i); 245 246 if (i <= IQ_TABLE_SIZE_HALF) 247 i = ixheaacd_pow_table_Q13[i]; 248 else { 249 err_code |= ixheaacd_inv_quant(&i, ixheaacd_pow_table_Q13); 250 } 251 252 if (out1 < 0) { 253 out1 = -i; 254 } else { 255 out1 = i; 256 } 257 *spec_coef++ = out1; 258 } else { 259 if (out1 <= 0) { 260 out1 = -out1; 261 out1 = ixheaacd_pow_table_Q13[out1]; 262 *spec_coef++ = -out1; 263 } else { 264 out1 = ixheaacd_pow_table_Q13[out1]; 265 *spec_coef++ = out1; 266 } 267 } 268 269 if (sp2 == 16) { 270 i = 4; 271 value = ixheaacd_extu(read_word, bit_pos, 23); 272 value = value | 0xfffffe00; 273 norm_val = ixheaacd_norm32(value); 274 275 i += (norm_val - 22); 276 277 bit_pos += (norm_val - 21); 278 ixheaacd_aac_read_byte_corr(&ptr_read_next, &bit_pos, &read_word, 279 it_bit_buff->ptr_bit_buf_end); 280 281 off = ixheaacd_extu(read_word, bit_pos, 32 - i); 282 283 bit_pos += i; 284 285 ixheaacd_aac_read_byte_corr(&ptr_read_next, &bit_pos, &read_word, 286 it_bit_buff->ptr_bit_buf_end); 287 ixheaacd_aac_read_byte_corr(&ptr_read_next, &bit_pos, &read_word, 288 it_bit_buff->ptr_bit_buf_end); 289 290 i = off + ((WORD32)1 << i); 291 292 if (i <= IQ_TABLE_SIZE_HALF) 293 i = ixheaacd_pow_table_Q13[i]; 294 else { 295 err_code |= ixheaacd_inv_quant(&i, ixheaacd_pow_table_Q13); 296 } 297 298 if (out2 < 0) { 299 out2 = -i; 300 } else { 301 out2 = i; 302 } 303 *spec_coef++ = out2; 304 } else { 305 if (out2 <= 0) { 306 out2 = -out2; 307 out2 = ixheaacd_pow_table_Q13[out2]; 308 *spec_coef++ = -out2; 309 } else { 310 out2 = ixheaacd_pow_table_Q13[out2]; 311 *spec_coef++ = out2; 312 } 313 } 314 315 idx -= 2; 316 } while (idx != 0); 317 318 spec_coef += (MAX_BINS_SHORT - offsets[1]); 319 grp_idx--; 320 } while (grp_idx != 0); 321 322 offsets++; 323 spec_coef -= (MAX_BINS_SHORT * group_len); 324 no_bands--; 325 } while (no_bands >= 0); 326 327 ptr_read_next = ptr_read_next - increment; 328 ixheaacd_aac_read_byte_corr1(&ptr_read_next, &bit_pos, &read_word, 329 it_bit_buff->ptr_bit_buf_end); 330 331 it_bit_buff->bit_pos = bit_pos; 332 it_bit_buff->ptr_read_next = ptr_read_next; 333 334 return err_code; 335 } 336 337 static PLATFORM_INLINE WORD ixheaacd_huffman_dec_word2_11( 338 ia_bit_buf_struct *it_bit_buff, WORD32 width, const UWORD16 *code_book_tbl, 339 WORD32 *x_invquant, WORD32 *ixheaacd_pow_table_Q13, WORD8 *ptr_scratch, 340 const UWORD32 *idx_table) { 341 WORD32 sp1, sp2; 342 WORD32 flush_cw; 343 WORD32 i, value, norm_val, off; 344 WORD idx; 345 WORD32 out1, out2; 346 WORD32 err_code = 0; 347 WORD16 index; 348 WORD32 length; 349 UWORD8 *ptr_read_next = it_bit_buff->ptr_read_next; 350 WORD32 bit_pos = it_bit_buff->bit_pos; 351 WORD32 read_word; 352 WORD32 increment; 353 354 read_word = ixheaacd_aac_showbits_32(ptr_read_next, it_bit_buff->cnt_bits, 355 &increment); 356 ptr_read_next += increment; 357 358 for (idx = width; idx != 0; idx -= 2) { 359 { 360 UWORD32 read_word1; 361 362 read_word1 = read_word << bit_pos; 363 ixheaacd_huff_sfb_table(read_word1, &index, &length, code_book_tbl, 364 idx_table); 365 bit_pos += length; 366 ixheaacd_aac_read_byte_corr(&ptr_read_next, &bit_pos, &read_word, 367 it_bit_buff->ptr_bit_buf_end); 368 } 369 370 flush_cw = read_word << bit_pos; 371 out1 = index / 17; 372 out2 = index - out1 * 17; 373 sp1 = out1; 374 375 if (out1) { 376 if (flush_cw & 0x80000000) { 377 out1 = -out1; 378 } 379 380 bit_pos++; 381 flush_cw = (WORD32)flush_cw << 1; 382 } 383 384 sp2 = out2; 385 if (out2) { 386 bit_pos++; 387 if (flush_cw & 0x80000000) { 388 out2 = -out2; 389 } 390 } 391 392 ixheaacd_aac_read_byte_corr(&ptr_read_next, &bit_pos, &read_word, 393 it_bit_buff->ptr_bit_buf_end); 394 395 if (sp1 == 16) { 396 i = 4; 397 value = ixheaacd_extu(read_word, bit_pos, 23); 398 value = value | 0xfffffe00; 399 norm_val = ixheaacd_norm32(value); 400 i += (norm_val - 22); 401 bit_pos += (norm_val - 21); 402 403 ixheaacd_aac_read_byte_corr(&ptr_read_next, &bit_pos, &read_word, 404 it_bit_buff->ptr_bit_buf_end); 405 406 off = ixheaacd_extu(read_word, bit_pos, 32 - i); 407 408 bit_pos += i; 409 ixheaacd_aac_read_byte_corr(&ptr_read_next, &bit_pos, &read_word, 410 it_bit_buff->ptr_bit_buf_end); 411 412 value = *ptr_scratch++; 413 414 ixheaacd_aac_read_byte_corr(&ptr_read_next, &bit_pos, &read_word, 415 it_bit_buff->ptr_bit_buf_end); 416 i = off + ((WORD32)1 << i); 417 i += value; 418 419 if (i <= IQ_TABLE_SIZE_HALF) 420 i = ixheaacd_pow_table_Q13[i]; 421 else { 422 err_code |= ixheaacd_inv_quant(&i, ixheaacd_pow_table_Q13); 423 } 424 if (out1 < 0) { 425 i = -i; 426 } 427 *x_invquant++ = i; 428 } else { 429 WORD8 temp = *ptr_scratch++; 430 if (out1 <= 0) { 431 out1 = temp - out1; 432 out1 = ixheaacd_pow_table_Q13[out1]; 433 *x_invquant++ = -out1; 434 } else { 435 out1 += temp; 436 out1 = ixheaacd_pow_table_Q13[out1]; 437 *x_invquant++ = out1; 438 } 439 } 440 441 if (sp2 == 16) { 442 i = 4; 443 value = ixheaacd_extu(read_word, bit_pos, 23); 444 value = value | 0xfffffe00; 445 norm_val = ixheaacd_norm32(value); 446 447 i += (norm_val - 22); 448 449 bit_pos += (norm_val - 21); 450 ixheaacd_aac_read_byte_corr(&ptr_read_next, &bit_pos, &read_word, 451 it_bit_buff->ptr_bit_buf_end); 452 453 off = ixheaacd_extu(read_word, bit_pos, 32 - i); 454 455 bit_pos += i; 456 ixheaacd_aac_read_byte_corr(&ptr_read_next, &bit_pos, &read_word, 457 it_bit_buff->ptr_bit_buf_end); 458 value = *ptr_scratch++; 459 ixheaacd_aac_read_byte_corr(&ptr_read_next, &bit_pos, &read_word, 460 it_bit_buff->ptr_bit_buf_end); 461 462 i = off + ((WORD32)1 << i); 463 i += value; 464 if (i <= IQ_TABLE_SIZE_HALF) 465 i = ixheaacd_pow_table_Q13[i]; 466 else { 467 err_code |= ixheaacd_inv_quant(&i, ixheaacd_pow_table_Q13); 468 } 469 470 if (out2 < 0) { 471 i = -i; 472 } 473 *x_invquant++ = i; 474 475 } else { 476 WORD8 temp = *ptr_scratch++; 477 if (out2 <= 0) { 478 out2 = temp - out2; 479 out2 = ixheaacd_pow_table_Q13[out2]; 480 *x_invquant++ = -out2; 481 } else { 482 out2 += temp; 483 out2 = ixheaacd_pow_table_Q13[out2]; 484 *x_invquant++ = out2; 485 } 486 } 487 } 488 ptr_read_next = ptr_read_next - increment; 489 ixheaacd_aac_read_byte_corr1(&ptr_read_next, &bit_pos, &read_word, 490 it_bit_buff->ptr_bit_buf_end); 491 492 it_bit_buff->ptr_read_next = ptr_read_next; 493 it_bit_buff->bit_pos = bit_pos; 494 495 return err_code; 496 } 497 498 static PLATFORM_INLINE WORD ixheaacd_huffman_dec_quad( 499 ia_bit_buf_struct *it_bit_buff, WORD32 *spec_coef, WORD16 *offsets, 500 WORD no_bands, WORD group_len, const UWORD16 *code_book_tbl, 501 WORD32 *ixheaacd_pow_table_Q13, WORD32 tbl_sign, const UWORD32 *idx_table) { 502 WORD idx, grp_idx; 503 WORD idx_len; 504 WORD32 *spec_orig; 505 WORD16 index, length; 506 UWORD8 *ptr_read_next = it_bit_buff->ptr_read_next; 507 WORD32 bit_pos = it_bit_buff->bit_pos; 508 WORD32 read_word; 509 WORD32 increment; 510 511 read_word = ixheaacd_aac_showbits_32(ptr_read_next, it_bit_buff->cnt_bits, 512 &increment); 513 ptr_read_next += increment; 514 spec_orig = spec_coef; 515 do { 516 idx_len = offsets[1] - offsets[0]; 517 grp_idx = group_len; 518 519 do { 520 spec_coef = spec_coef + offsets[0]; 521 idx = idx_len; 522 do { 523 UWORD32 read_word1; 524 525 read_word1 = read_word << bit_pos; 526 ixheaacd_huffman_decode(read_word1, &index, &length, code_book_tbl, 527 idx_table); 528 bit_pos += length; 529 ixheaacd_aac_read_byte_corr(&ptr_read_next, &bit_pos, &read_word, 530 it_bit_buff->ptr_bit_buf_end); 531 if (tbl_sign) { 532 WORD32 temp_word; 533 WORD32 w, x, y, z; 534 temp_word = read_word << bit_pos; 535 w = index / 27; 536 index = index - w * 27; 537 x = index / 9; 538 index = index - x * 9; 539 y = index / 3; 540 z = index - y * 3; 541 if (w) { 542 w = ixheaacd_pow_table_Q13[w]; 543 if (temp_word & 0x80000000) w = -w; 544 temp_word <<= 1; 545 bit_pos++; 546 } 547 *spec_coef++ = w; 548 549 if (x) { 550 x = ixheaacd_pow_table_Q13[x]; 551 if (temp_word & 0x80000000) x = -x; 552 temp_word <<= 1; 553 bit_pos++; 554 } 555 *spec_coef++ = x; 556 if (y) { 557 y = ixheaacd_pow_table_Q13[y]; 558 if (temp_word & 0x80000000) y = -y; 559 temp_word <<= 1; 560 bit_pos++; 561 } 562 *spec_coef++ = y; 563 if (z) { 564 z = ixheaacd_pow_table_Q13[z]; 565 if (temp_word & 0x80000000) z = -z; 566 temp_word <<= 1; 567 bit_pos++; 568 } 569 *spec_coef++ = z; 570 571 } 572 573 else { 574 WORD32 w, x, y, z; 575 576 w = index / 27 - 1; 577 index = index - (w + 1) * 27; 578 x = index / 9 - 1; 579 index = index - (x + 1) * 9; 580 y = index / 3 - 1; 581 z = index - ((y + 1) * 3) - 1; 582 if (w < 0) { 583 w = -w; 584 w = ixheaacd_pow_table_Q13[w]; 585 w = -w; 586 } else 587 w = ixheaacd_pow_table_Q13[w]; 588 589 *spec_coef++ = w; 590 591 if (x < 0) { 592 x = -x; 593 x = ixheaacd_pow_table_Q13[x]; 594 x = -x; 595 } else 596 x = ixheaacd_pow_table_Q13[x]; 597 598 *spec_coef++ = x; 599 600 if (y < 0) { 601 y = -y; 602 y = ixheaacd_pow_table_Q13[y]; 603 y = -y; 604 } else 605 y = ixheaacd_pow_table_Q13[y]; 606 607 *spec_coef++ = y; 608 609 if (z < 0) { 610 z = -z; 611 z = ixheaacd_pow_table_Q13[z]; 612 z = -z; 613 } else 614 z = ixheaacd_pow_table_Q13[z]; 615 616 *spec_coef++ = z; 617 } 618 619 ixheaacd_aac_read_byte_corr(&ptr_read_next, &bit_pos, &read_word, 620 it_bit_buff->ptr_bit_buf_end); 621 idx -= 4; 622 } while (idx != 0); 623 624 spec_coef += (MAX_BINS_SHORT - offsets[1]); 625 grp_idx--; 626 } while (grp_idx != 0); 627 offsets++; 628 spec_coef = spec_orig; 629 no_bands--; 630 } while (no_bands >= 0); 631 632 ptr_read_next = ptr_read_next - increment; 633 ixheaacd_aac_read_byte_corr1(&ptr_read_next, &bit_pos, &read_word, 634 it_bit_buff->ptr_bit_buf_end); 635 it_bit_buff->ptr_read_next = ptr_read_next; 636 it_bit_buff->bit_pos = bit_pos; 637 638 return 0; 639 } 640 641 static PLATFORM_INLINE WORD ixheaacd_huffman_dec_word2_quad( 642 ia_bit_buf_struct *it_bit_buff, WORD32 width, const UWORD16 *code_book_tbl, 643 WORD32 *x_invquant, WORD32 *ixheaacd_pow_table_Q13, WORD8 *ptr_scratch, 644 WORD32 tbl_sign, const UWORD32 *idx_table) { 645 WORD idx; 646 WORD16 index, length; 647 UWORD8 *ptr_read_next = it_bit_buff->ptr_read_next; 648 WORD32 bit_pos = it_bit_buff->bit_pos; 649 WORD32 read_word; 650 WORD32 increment; 651 652 read_word = ixheaacd_aac_showbits_32(ptr_read_next, it_bit_buff->cnt_bits, 653 &increment); 654 ptr_read_next += increment; 655 656 for (idx = width; idx != 0; idx -= 4) { 657 WORD32 ampres, ampres1; 658 WORD32 ampres2, ampres3; 659 UWORD32 read_word1; 660 661 read_word1 = read_word << bit_pos; 662 ixheaacd_huffman_decode(read_word1, &index, &length, code_book_tbl, 663 idx_table); 664 bit_pos += length; 665 ixheaacd_aac_read_byte_corr(&ptr_read_next, &bit_pos, &read_word, 666 it_bit_buff->ptr_bit_buf_end); 667 if (tbl_sign) { 668 WORD32 w, x, y, z; 669 WORD32 ampout0, ampout1, ampout2, ampout3; 670 WORD32 temp_word; 671 temp_word = read_word << bit_pos; 672 673 w = index / 27; 674 index = index - w * 27; 675 x = index / 9; 676 index = index - x * 9; 677 y = index / 3; 678 z = index - y * 3; 679 680 ampout0 = w + *ptr_scratch++; 681 ampout0 = ixheaacd_pow_table_Q13[ampout0]; 682 683 if (w) { 684 if (temp_word & 0x80000000) { 685 ampout0 = -ampout0; 686 } 687 temp_word = temp_word << 1; 688 bit_pos++; 689 } else { 690 ampout0 = -ampout0; 691 } 692 693 ampout1 = x + *ptr_scratch++; 694 ampout1 = ixheaacd_pow_table_Q13[ampout1]; 695 696 if (x) { 697 if (temp_word & 0x80000000) { 698 ampout1 = -ampout1; 699 } 700 temp_word = temp_word << 1; 701 bit_pos++; 702 } else { 703 ampout1 = -ampout1; 704 } 705 706 ampout2 = y + *ptr_scratch++; 707 ampout2 = ixheaacd_pow_table_Q13[ampout2]; 708 709 if (y) { 710 if (temp_word & 0x80000000) { 711 ampout2 = -ampout2; 712 } 713 temp_word = temp_word << 1; 714 bit_pos++; 715 } else { 716 ampout2 = -ampout2; 717 } 718 719 ampout3 = z + *ptr_scratch++; 720 ampout3 = ixheaacd_pow_table_Q13[ampout3]; 721 722 if (z) { 723 if (temp_word & 0x80000000) { 724 ampout3 = -ampout3; 725 } 726 temp_word = temp_word << 1; 727 bit_pos++; 728 } else { 729 ampout3 = -ampout3; 730 } 731 *x_invquant++ = ampout0; 732 *x_invquant++ = ampout1; 733 *x_invquant++ = ampout2; 734 *x_invquant++ = ampout3; 735 } else { 736 WORD32 w, x, y, z; 737 ampres = *ptr_scratch++; 738 ampres1 = *ptr_scratch++; 739 ampres2 = *ptr_scratch++; 740 ampres3 = *ptr_scratch++; 741 742 w = index / 27 - 1; 743 index = index - (w + 1) * 27; 744 x = index / 9 - 1; 745 index = index - (x + 1) * 9; 746 y = index / 3 - 1; 747 z = index - ((y + 1) * 3) - 1; 748 if (w <= 0) { 749 ampres = ampres - w; 750 ampres = ixheaacd_pow_table_Q13[ampres]; 751 ampres = -ampres; 752 } else { 753 ampres += w; 754 ampres = ixheaacd_pow_table_Q13[ampres]; 755 } 756 757 if (x <= 0) { 758 ampres1 = ampres1 - x; 759 ampres1 = ixheaacd_pow_table_Q13[ampres1]; 760 ampres1 = -ampres1; 761 } else { 762 ampres1 += x; 763 ampres1 = ixheaacd_pow_table_Q13[ampres1]; 764 } 765 766 if (y <= 0) { 767 ampres2 = ampres2 - y; 768 ampres2 = ixheaacd_pow_table_Q13[ampres2]; 769 ampres2 = -ampres2; 770 } else { 771 ampres2 += y; 772 ampres2 = ixheaacd_pow_table_Q13[ampres2]; 773 } 774 775 if (z <= 0) { 776 ampres3 = ampres3 - z; 777 ampres3 = ixheaacd_pow_table_Q13[ampres3]; 778 ampres3 = -ampres3; 779 } else { 780 ampres3 += z; 781 ampres3 = ixheaacd_pow_table_Q13[ampres3]; 782 } 783 784 *x_invquant++ = ampres; 785 *x_invquant++ = ampres1; 786 *x_invquant++ = ampres2; 787 *x_invquant++ = ampres3; 788 } 789 790 ixheaacd_aac_read_byte_corr(&ptr_read_next, &bit_pos, &read_word, 791 it_bit_buff->ptr_bit_buf_end); 792 } 793 794 ptr_read_next = ptr_read_next - increment; 795 ixheaacd_aac_read_byte_corr1(&ptr_read_next, &bit_pos, &read_word, 796 it_bit_buff->ptr_bit_buf_end); 797 it_bit_buff->ptr_read_next = ptr_read_next; 798 it_bit_buff->bit_pos = bit_pos; 799 800 return 0; 801 } 802 803 static PLATFORM_INLINE WORD ixheaacd_huffman_dec_pair( 804 ia_bit_buf_struct *it_bit_buff, WORD32 *spec_coef, WORD16 *offsets, 805 WORD no_bands, WORD group_len, const UWORD16 *code_book_tbl, 806 WORD32 *ixheaacd_pow_table_Q13, WORD32 tbl_sign, const UWORD32 *idx_table, 807 WORD32 huff_mode) 808 809 { 810 WORD idx, grp_idx; 811 WORD len_idx; 812 WORD16 index, length; 813 WORD32 y, z; 814 WORD32 *spec_orig = spec_coef; 815 816 UWORD8 *ptr_read_next = it_bit_buff->ptr_read_next; 817 WORD32 bit_pos = it_bit_buff->bit_pos; 818 WORD32 read_word; 819 WORD32 increment; 820 821 read_word = ixheaacd_aac_showbits_32(ptr_read_next, it_bit_buff->cnt_bits, 822 &increment); 823 ptr_read_next += increment; 824 825 do { 826 len_idx = offsets[1] - offsets[0]; 827 grp_idx = group_len; 828 do { 829 spec_coef += offsets[0]; 830 idx = len_idx; 831 do { 832 UWORD32 read_word1; 833 read_word1 = read_word << bit_pos; 834 ixheaacd_huffman_decode(read_word1, &index, &length, code_book_tbl, 835 idx_table); 836 bit_pos += length; 837 ixheaacd_aac_read_byte_corr(&ptr_read_next, &bit_pos, &read_word, 838 it_bit_buff->ptr_bit_buf_end); 839 if (tbl_sign) { 840 WORD32 temp_word; 841 temp_word = read_word << bit_pos; 842 y = index / huff_mode; 843 z = index - huff_mode * y; 844 if (y) { 845 y = ixheaacd_pow_table_Q13[y]; 846 if (temp_word & 0x80000000) y = -y; 847 848 temp_word = temp_word << 1; 849 bit_pos++; 850 } 851 *spec_coef++ = y; 852 853 if (z) { 854 z = ixheaacd_pow_table_Q13[z]; 855 if (temp_word & 0x80000000) { 856 z = -z; 857 } 858 temp_word <<= 1; 859 bit_pos++; 860 } 861 *spec_coef++ = z; 862 } else { 863 y = (index / huff_mode) - 4; 864 z = index - ((y + 4) * huff_mode) - 4; 865 if (y < 0) { 866 y = -y; 867 y = ixheaacd_pow_table_Q13[y]; 868 y = -y; 869 } else 870 y = ixheaacd_pow_table_Q13[y]; 871 872 if (z < 0) { 873 z = -z; 874 z = ixheaacd_pow_table_Q13[z]; 875 z = -z; 876 } else 877 z = ixheaacd_pow_table_Q13[z]; 878 879 *spec_coef++ = y; 880 *spec_coef++ = z; 881 } 882 ixheaacd_aac_read_byte_corr(&ptr_read_next, &bit_pos, &read_word, 883 it_bit_buff->ptr_bit_buf_end); 884 idx -= 2; 885 } while (idx != 0); 886 887 spec_coef += (MAX_BINS_SHORT - offsets[1]); 888 grp_idx--; 889 } while (grp_idx != 0); 890 891 offsets++; 892 spec_coef = spec_orig; 893 no_bands--; 894 } while (no_bands >= 0); 895 896 ptr_read_next = ptr_read_next - increment; 897 ixheaacd_aac_read_byte_corr1(&ptr_read_next, &bit_pos, &read_word, 898 it_bit_buff->ptr_bit_buf_end); 899 it_bit_buff->ptr_read_next = ptr_read_next; 900 it_bit_buff->bit_pos = bit_pos; 901 902 return 0; 903 } 904 905 static PLATFORM_INLINE WORD ixheaacd_huffman_dec_word2_pair( 906 ia_bit_buf_struct *it_bit_buff, WORD32 width, const UWORD16 *code_book_tbl, 907 WORD32 *x_invquant, WORD32 *ixheaacd_pow_table_Q13, WORD8 *ptr_scratch, 908 WORD32 tbl_sign, const UWORD32 *idx_table, WORD32 huff_mode) 909 910 { 911 WORD32 ampres; 912 WORD idx; 913 WORD16 index, length; 914 UWORD8 *ptr_read_next = it_bit_buff->ptr_read_next; 915 WORD32 bit_pos = it_bit_buff->bit_pos; 916 WORD32 read_word; 917 WORD32 increment; 918 919 read_word = ixheaacd_aac_showbits_32(ptr_read_next, it_bit_buff->cnt_bits, 920 &increment); 921 ptr_read_next += increment; 922 923 for (idx = width; idx != 0; idx -= 2) { 924 { 925 UWORD32 read_word1; 926 read_word1 = read_word << bit_pos; 927 ixheaacd_huffman_decode(read_word1, &index, &length, code_book_tbl, 928 idx_table); 929 bit_pos += length; 930 ixheaacd_aac_read_byte_corr(&ptr_read_next, &bit_pos, &read_word, 931 it_bit_buff->ptr_bit_buf_end); 932 } 933 934 if (tbl_sign) { 935 WORD32 out0, out1, temp_word; 936 WORD32 ampout0, ampout1; 937 938 ampout0 = *ptr_scratch++; 939 ampout1 = *ptr_scratch++; 940 out0 = index / huff_mode; 941 out1 = index - huff_mode * out0; 942 ampout0 += out0; 943 ampout0 = ixheaacd_pow_table_Q13[ampout0]; 944 945 ampout1 += out1; 946 ampout1 = ixheaacd_pow_table_Q13[ampout1]; 947 temp_word = read_word << bit_pos; 948 if (out0) { 949 if (temp_word & 0x80000000) { 950 ampout0 = -(ampout0); 951 } 952 953 bit_pos++; 954 temp_word = temp_word << 1; 955 } else { 956 ampout0 = -(ampout0); 957 } 958 959 if (out1) { 960 if (temp_word & 0x80000000) { 961 ampout1 = -(ampout1); 962 } 963 bit_pos++; 964 } else { 965 ampout1 = -(ampout1); 966 } 967 968 ixheaacd_aac_read_byte_corr(&ptr_read_next, &bit_pos, &read_word, 969 it_bit_buff->ptr_bit_buf_end); 970 *x_invquant++ = ampout0; 971 *x_invquant++ = ampout1; 972 } else { 973 WORD32 y, z; 974 y = (index / huff_mode) - 4; 975 z = index - ((y + 4) * huff_mode) - 4; 976 977 ampres = *ptr_scratch++; 978 if (y <= 0) { 979 ampres = ampres - y; 980 ampres = ixheaacd_pow_table_Q13[ampres]; 981 *x_invquant++ = -ampres; 982 } else { 983 ampres += y; 984 *x_invquant++ = ixheaacd_pow_table_Q13[ampres]; 985 } 986 ampres = *ptr_scratch++; 987 if (z <= 0) { 988 ampres = ampres - z; 989 ampres = ixheaacd_pow_table_Q13[ampres]; 990 *x_invquant++ = -ampres; 991 } else { 992 ampres += z; 993 *x_invquant++ = ixheaacd_pow_table_Q13[ampres]; 994 } 995 } 996 ixheaacd_aac_read_byte_corr(&ptr_read_next, &bit_pos, &read_word, 997 it_bit_buff->ptr_bit_buf_end); 998 } 999 1000 ptr_read_next = ptr_read_next - increment; 1001 ixheaacd_aac_read_byte_corr1(&ptr_read_next, &bit_pos, &read_word, 1002 it_bit_buff->ptr_bit_buf_end); 1003 it_bit_buff->ptr_read_next = ptr_read_next; 1004 it_bit_buff->bit_pos = bit_pos; 1005 1006 return 0; 1007 } 1008 1009 WORD ixheaacd_decode_huffman(ia_bit_buf_struct *it_bit_buff, WORD32 cb_no, 1010 WORD32 *spec_coef, WORD16 *sfb_offset, WORD start, 1011 WORD sfb, WORD group_len, 1012 ia_aac_dec_tables_struct *ptr_aac_tables) { 1013 WORD ret_val = 0; 1014 WORD start_bit_pos = it_bit_buff->bit_pos; 1015 UWORD8 *start_read_pos = it_bit_buff->ptr_read_next; 1016 const UWORD16 *cb_table = (UWORD16 *)(ptr_aac_tables->code_book[cb_no]); 1017 WORD32 huff_mode; 1018 const UWORD32 *idx_table = (UWORD32 *)(ptr_aac_tables->index_table[cb_no]); 1019 WORD32 *pow_table = 1020 (WORD32 *)ptr_aac_tables->pstr_block_tables->ixheaacd_pow_table_Q13; 1021 WORD32 no_bands = sfb - start - 1; 1022 WORD16 *band_offset = sfb_offset + start; 1023 1024 if (cb_no == 11) { 1025 const UWORD32 *idx_table = 1026 ptr_aac_tables->pstr_huffmann_tables->idx_table_hf11; 1027 const UWORD16 *cb_table = 1028 ptr_aac_tables->pstr_huffmann_tables->input_table_cb11; 1029 1030 ret_val = ixheaacd_huffman_dec_word1(it_bit_buff, spec_coef, band_offset, 1031 no_bands, group_len, cb_table, 1032 pow_table, idx_table); 1033 1034 } else if (cb_no <= 4) { 1035 WORD32 tbl_sign = 0; 1036 1037 if (cb_no > 2) { 1038 tbl_sign = 1; 1039 } 1040 ret_val = ixheaacd_huffman_dec_quad(it_bit_buff, spec_coef, band_offset, 1041 no_bands, group_len, cb_table, 1042 pow_table, tbl_sign, idx_table); 1043 } 1044 1045 else if (cb_no <= 10) { 1046 WORD32 tbl_sign = 0; 1047 huff_mode = 9; 1048 if (cb_no > 6) { 1049 if (cb_no > 8) 1050 huff_mode = 13; 1051 else 1052 huff_mode = 8; 1053 tbl_sign = 1; 1054 } 1055 ret_val = ixheaacd_huffman_dec_pair( 1056 it_bit_buff, spec_coef, band_offset, no_bands, group_len, cb_table, 1057 pow_table, tbl_sign, idx_table, huff_mode); 1058 } 1059 1060 { 1061 WORD bits_cons; 1062 bits_cons = ((it_bit_buff->ptr_read_next - start_read_pos) << 3) + 1063 (it_bit_buff->bit_pos - start_bit_pos); 1064 it_bit_buff->cnt_bits -= bits_cons; 1065 } 1066 return ret_val; 1067 } 1068 1069 WORD ixheaacd_huffman_dec_word2(ia_bit_buf_struct *it_bit_buff, WORD32 cb_no, 1070 WORD32 width, 1071 ia_aac_dec_tables_struct *ptr_aac_tables, 1072 WORD32 *x_invquant, WORD8 *scratch_ptr) { 1073 WORD ret_val = 0; 1074 WORD32 huff_mode; 1075 WORD start_bit_pos = it_bit_buff->bit_pos; 1076 WORD32 cnt_bits = it_bit_buff->cnt_bits; 1077 WORD32 *pow_table = 1078 (WORD32 *)ptr_aac_tables->pstr_block_tables->ixheaacd_pow_table_Q13; 1079 UWORD8 *start_read_pos = it_bit_buff->ptr_read_next; 1080 1081 const UWORD16 *cb_table = (UWORD16 *)(ptr_aac_tables->code_book[cb_no]); 1082 const UWORD32 *idx_table = (UWORD32 *)(ptr_aac_tables->index_table[cb_no]); 1083 1084 if (cb_no == 11) { 1085 const UWORD16 *cb_table = 1086 ptr_aac_tables->pstr_huffmann_tables->input_table_cb11; 1087 1088 ret_val = ixheaacd_huffman_dec_word2_11( 1089 it_bit_buff, width, cb_table, x_invquant, pow_table, scratch_ptr, 1090 ptr_aac_tables->pstr_huffmann_tables->idx_table_hf11); 1091 } else if (cb_no <= 4) { 1092 WORD32 tbl_sign = 0; 1093 if (cb_no > 2) tbl_sign = 1; 1094 ret_val = ixheaacd_huffman_dec_word2_quad(it_bit_buff, width, cb_table, 1095 x_invquant, pow_table, 1096 scratch_ptr, tbl_sign, idx_table); 1097 } else if (cb_no <= 10) { 1098 WORD32 tbl_sign = 0; 1099 huff_mode = 9; 1100 if (cb_no > 6) { 1101 if (cb_no > 8) { 1102 huff_mode = 13; 1103 } else { 1104 huff_mode = 8; 1105 } 1106 1107 tbl_sign = 1; 1108 } 1109 ret_val = ixheaacd_huffman_dec_word2_pair( 1110 it_bit_buff, width, cb_table, x_invquant, pow_table, scratch_ptr, 1111 tbl_sign, idx_table, huff_mode); 1112 } 1113 1114 { 1115 WORD bits_cons; 1116 if (it_bit_buff->bit_pos <= 7) { 1117 bits_cons = ((it_bit_buff->ptr_read_next - start_read_pos) << 3) + 1118 (it_bit_buff->bit_pos - start_bit_pos); 1119 it_bit_buff->cnt_bits = cnt_bits - bits_cons; 1120 } else { 1121 it_bit_buff->ptr_read_next += (it_bit_buff->bit_pos) >> 3; 1122 it_bit_buff->bit_pos = it_bit_buff->bit_pos & 0x7; 1123 1124 bits_cons = ((it_bit_buff->ptr_read_next - start_read_pos) << 3) + 1125 ((it_bit_buff->bit_pos - start_bit_pos)); 1126 it_bit_buff->cnt_bits = cnt_bits - bits_cons; 1127 } 1128 } 1129 return ret_val; 1130 } 1131 1132 void ixheaacd_lap1_512_480(WORD32 *coef, WORD32 *prev, WORD16 *out, 1133 const WORD16 *window, WORD16 q_shift, WORD16 size, 1134 WORD16 stride) { 1135 WORD32 accu; 1136 WORD32 i; 1137 WORD16 rounding_fac = -0x2000; 1138 1139 WORD32 *window_i = (WORD32 *)window; 1140 1141 WORD16 *ptr_out1, *ptr_out2; 1142 1143 WORD32 *pwin1, *pwin2; 1144 WORD32 *pCoef = &coef[size * 2 - 1 - 0]; 1145 1146 pwin1 = &window_i[size - 1 - 0]; 1147 pwin2 = &window_i[size + 0]; 1148 1149 ptr_out1 = &out[stride * (size - 1 - 0)]; 1150 ptr_out2 = &out[stride * (size + 0)]; 1151 1152 for (i = 0; i < size; i++) { 1153 WORD32 win1, win2, coeff; 1154 WORD32 prev_data = *prev++; 1155 1156 win1 = *pwin1--; 1157 coeff = *pCoef--; 1158 win2 = *pwin2++; 1159 1160 accu = ixheaacd_sub32_sat( 1161 ixheaacd_shl32_dir_sat_limit(ixheaacd_mult32_shl(coeff, win1), q_shift), 1162 ixheaacd_mac32x16in32_shl(rounding_fac, win2, (WORD16)(prev_data))); 1163 1164 accu = ixheaacd_add32_sat(accu, accu); 1165 accu = ixheaacd_add32_sat(accu, accu); 1166 1167 *ptr_out1 = ixheaacd_shr32(accu, 16); 1168 ptr_out1 -= stride; 1169 1170 accu = ixheaacd_sub32_sat( 1171 ixheaacd_shl32_dir_sat_limit( 1172 ixheaacd_mult32_shl(ixheaacd_negate32(coeff), win2), q_shift), 1173 ixheaacd_mac32x16in32_shl(rounding_fac, win1, (WORD16)(prev_data))); 1174 1175 accu = ixheaacd_add32_sat(accu, accu); 1176 accu = ixheaacd_add32_sat(accu, accu); 1177 1178 *ptr_out2 = ixheaacd_shr32(accu, 16); 1179 ptr_out2 += stride; 1180 } 1181 } 1182 1183 VOID ixheaacd_over_lap_add1_dec(WORD32 *coef, WORD32 *prev, WORD16 *out, 1184 const WORD16 *window, WORD16 q_shift, 1185 WORD16 size, WORD16 ch_fac) { 1186 WORD32 accu; 1187 WORD32 i; 1188 WORD16 rounding_fac = -0x2000; 1189 1190 for (i = 0; i < size; i++) { 1191 WORD16 window1, window2; 1192 1193 window1 = window[2 * size - 2 * i - 1]; 1194 window2 = window[2 * size - 2 * i - 2]; 1195 accu = ixheaacd_sub32_sat( 1196 ixheaacd_shl32_dir_sat_limit( 1197 ixheaacd_mult32x16in32(coef[size * 2 - 1 - i], window2), q_shift), 1198 ixheaacd_mac32x16in32_drc(rounding_fac, prev[i], window1)); 1199 out[ch_fac * (size - i - 1)] = 1200 ixheaacd_shr32(ixheaacd_shl32_dir_sat_limit(accu, 2), 16); 1201 accu = ixheaacd_sub32_sat( 1202 ixheaacd_shl32_dir_sat_limit( 1203 ixheaacd_mult32x16in32(ixheaacd_negate32(coef[size * 2 - 1 - i]), 1204 window1), 1205 q_shift), 1206 ixheaacd_mac32x16in32_drc(rounding_fac, prev[i], window2)); 1207 out[ch_fac * (size + i)] = 1208 ixheaacd_shr32(ixheaacd_shl32_dir_sat_limit(accu, 2), 16); 1209 } 1210 } 1211 1212 VOID ixheaacd_over_lap_add2_dec(WORD32 *coef, WORD32 *prev, WORD32 *out, 1213 const WORD16 *window, WORD16 q_shift, 1214 WORD16 size, WORD16 ch_fac) { 1215 WORD32 accu; 1216 WORD32 i; 1217 1218 for (i = 0; i < size; i++) { 1219 accu = ixheaacd_sub32_sat( 1220 ixheaacd_mult32x16in32(coef[size + i], window[2 * i]), 1221 ixheaacd_mult32x16in32(prev[size - 1 - i], window[2 * i + 1])); 1222 out[ch_fac * i] = ixheaacd_shr32_drc(accu, 16 - (q_shift + 1)); 1223 } 1224 1225 for (i = 0; i < size; i++) { 1226 accu = ixheaacd_sub32_sat( 1227 ixheaacd_mult32x16in32(ixheaacd_negate32_sat(coef[size * 2 - 1 - i]), 1228 window[2 * size - 2 * i - 1]), 1229 ixheaacd_mult32x16in32(prev[i], window[2 * size - 2 * i - 2])); 1230 out[ch_fac * (i + size)] = ixheaacd_shr32_drc(accu, 16 - (q_shift + 1)); 1231 } 1232 } 1233 1234 VOID ixheaacd_process_single_scf(WORD32 scale_factor, WORD32 *x_invquant, 1235 WORD32 width, WORD32 *ptr_scale_table, 1236 WORD32 total_channels, WORD32 object_type, 1237 WORD32 aac_sf_data_resil_flag) { 1238 WORD32 j; 1239 1240 WORD32 temp1; 1241 WORD32 q_factor; 1242 WORD32 buffer1; 1243 WORD16 scale_short; 1244 1245 object_type = 0; 1246 aac_sf_data_resil_flag = 0; 1247 1248 if (scale_factor < 24) { 1249 for (j = width; j > 0; j--) { 1250 *x_invquant++ = 0; 1251 } 1252 } else { 1253 WORD32 shift; 1254 1255 if (total_channels > 2) 1256 q_factor = 34 - (scale_factor >> 2); 1257 else 1258 q_factor = 37 - (scale_factor >> 2); 1259 1260 scale_short = ptr_scale_table[(scale_factor & 0x0003)]; 1261 shift = q_factor; 1262 if (shift > 0) { 1263 if (scale_short == (WORD16)0x8000) { 1264 for (j = width; j > 0; j--) { 1265 temp1 = *x_invquant; 1266 buffer1 = ixheaacd_mult32x16in32_shl_sat(temp1, scale_short); 1267 buffer1 = ixheaacd_shr32(buffer1, shift); 1268 *x_invquant++ = buffer1; 1269 } 1270 } else { 1271 for (j = width; j > 0; j--) { 1272 temp1 = *x_invquant; 1273 buffer1 = ixheaacd_mult32x16in32_shl(temp1, scale_short); 1274 buffer1 = ixheaacd_shr32(buffer1, shift); 1275 *x_invquant++ = buffer1; 1276 } 1277 } 1278 } else { 1279 shift = -shift; 1280 if (shift > 0) { 1281 if (scale_short == (WORD16)0x8000) { 1282 for (j = width; j > 0; j--) { 1283 temp1 = *x_invquant; 1284 temp1 = ixheaacd_shl32(temp1, shift - 1); 1285 buffer1 = ixheaacd_mult32x16in32_shl_sat(temp1, scale_short); 1286 buffer1 = ixheaacd_shl32(buffer1, 1); 1287 *x_invquant++ = buffer1; 1288 } 1289 } else { 1290 for (j = width; j > 0; j--) { 1291 temp1 = *x_invquant; 1292 temp1 = ixheaacd_shl32(temp1, shift - 1); 1293 buffer1 = ixheaacd_mult32x16in32_shl(temp1, scale_short); 1294 buffer1 = ixheaacd_shl32(buffer1, 1); 1295 *x_invquant++ = buffer1; 1296 } 1297 } 1298 1299 } else { 1300 if (scale_short == (WORD16)0x8000) { 1301 for (j = width; j > 0; j--) { 1302 temp1 = *x_invquant; 1303 buffer1 = ixheaacd_mult32x16in32_shl_sat(temp1, scale_short); 1304 *x_invquant++ = buffer1; 1305 } 1306 } else { 1307 for (j = width; j > 0; j--) { 1308 temp1 = *x_invquant; 1309 buffer1 = ixheaacd_mult32x16in32_shl(temp1, scale_short); 1310 *x_invquant++ = buffer1; 1311 } 1312 } 1313 } 1314 } 1315 } 1316 } 1317 1318 VOID ixheaacd_scale_factor_process_dec(WORD32 *x_invquant, WORD16 *scale_fact, 1319 WORD no_band, WORD8 *width, 1320 WORD32 *ptr_scale_table, 1321 WORD32 total_channels, 1322 WORD32 object_type, 1323 WORD32 aac_sf_data_resil_flag) { 1324 WORD32 i; 1325 WORD16 scale_factor; 1326 1327 for (i = no_band - 1; i >= 0; i--) { 1328 scale_factor = *scale_fact++; 1329 ixheaacd_process_single_scf(scale_factor, x_invquant, *width, 1330 ptr_scale_table, total_channels, object_type, 1331 aac_sf_data_resil_flag); 1332 1333 x_invquant += *width; 1334 width++; 1335 } 1336 } 1337 1338 void ixheaacd_right_shift_block(WORD32 *p_spectrum, WORD32 length, 1339 WORD32 shift_val) { 1340 WORD32 i; 1341 WORD32 temp1, temp2; 1342 WORD32 *temp_ptr = &p_spectrum[0]; 1343 length = length >> 2; 1344 1345 for (i = length - 1; i >= 0; i--) { 1346 temp1 = *temp_ptr; 1347 temp2 = *(temp_ptr + 1); 1348 *temp_ptr++ = temp1 >> shift_val; 1349 temp1 = *(temp_ptr + 1); 1350 *temp_ptr++ = temp2 >> shift_val; 1351 temp2 = *(temp_ptr + 1); 1352 *temp_ptr++ = temp1 >> shift_val; 1353 *temp_ptr++ = temp2 >> shift_val; 1354 } 1355 } 1356
