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