| /****************************************************************************** |
| * * |
| * Copyright (C) 2018 The Android Open Source Project |
| * |
| * Licensed under the Apache License, Version 2.0 (the "License"); |
| * you may not use this file except in compliance with the License. |
| * You may obtain a copy of the License at: |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| * |
| ***************************************************************************** |
| * Originally developed and contributed by Ittiam Systems Pvt. Ltd, Bangalore |
| */ |
| #include "ixheaacd_sbr_common.h" |
| #include <ixheaacd_type_def.h> |
| |
| #include "ixheaacd_constants.h" |
| #include <ixheaacd_basic_ops32.h> |
| #include <ixheaacd_basic_ops16.h> |
| #include <ixheaacd_basic_ops40.h> |
| #include "ixheaacd_basic_ops.h" |
| #include "ixheaacd_common_rom.h" |
| #include "ixheaacd_basic_funcs.h" |
| #include "ixheaacd_defines.h" |
| #include <ixheaacd_aac_rom.h> |
| #include "ixheaacd_bitbuffer.h" |
| #include "ixheaacd_intrinsics.h" |
| #include "ixheaacd_pulsedata.h" |
| |
| #include "ixheaacd_pns.h" |
| #include "ixheaacd_drc_data_struct.h" |
| |
| #include "ixheaacd_lt_predict.h" |
| |
| #include "ixheaacd_channelinfo.h" |
| #include "ixheaacd_drc_dec.h" |
| |
| #include "ixheaacd_block.h" |
| #include "ixheaacd_channel.h" |
| |
| #include <ixheaacd_basic_op.h> |
| |
| #include "ixheaacd_tns.h" |
| #include "ixheaacd_sbrdecoder.h" |
| #include "ixheaacd_error_codes.h" |
| |
| #include "ixheaacd_audioobjtypes.h" |
| #include "ixheaacd_latmdemux.h" |
| |
| #include "ixheaacd_aacdec.h" |
| |
| static PLATFORM_INLINE WORD32 ixheaacd_shr32_drc(WORD32 a, WORD32 b) { |
| WORD32 out_val; |
| |
| b = ((UWORD32)(b << 24) >> 24); |
| if (b >= 31) { |
| if (a < 0) |
| out_val = -1; |
| else |
| out_val = 0; |
| } else { |
| a += (1 << (b - 1)); |
| out_val = (WORD32)a >> b; |
| } |
| |
| return out_val; |
| } |
| |
| static PLATFORM_INLINE WORD32 ixheaacd_mult32x16in32_drc(WORD32 a, WORD16 b) { |
| WORD32 result; |
| WORD64 temp_result; |
| |
| temp_result = (WORD64)a * (WORD64)b; |
| |
| if (temp_result < (WORD64)MIN_32) |
| result = MIN_32; |
| |
| else if (temp_result > (WORD64)MAX_32) |
| result = MAX_32; |
| |
| else |
| result = (WORD32)(temp_result); |
| |
| return (result); |
| } |
| static PLATFORM_INLINE WORD32 ixheaacd_mac32x16in32_drc(WORD32 a, WORD32 b, |
| WORD16 c) { |
| WORD32 acc; |
| |
| acc = ixheaacd_mult32x16in32_drc(b, c); |
| |
| acc = ixheaacd_add32_sat(a, acc); |
| |
| return acc; |
| } |
| |
| WORD32 ixheaacd_cnt_leading_ones(WORD32 a); |
| |
| VOID ixheaacd_huff_sfb_table(WORD32 it_bit_buff, WORD16 *huff_index, |
| WORD32 *len, const UWORD16 *code_book_tbl, |
| const UWORD32 *idx_table) { |
| UWORD32 temp = 0; |
| UWORD32 temp1 = 0; |
| WORD32 found = 0; |
| UWORD32 mask = 0x80000000; |
| |
| WORD32 leading_ones; |
| WORD32 max_len; |
| WORD32 ixheaacd_drc_offset = 0; |
| WORD32 length; |
| UWORD32 code_word; |
| WORD32 len_end; |
| |
| max_len = code_book_tbl[0]; |
| mask = mask - (1 << (31 - max_len)); |
| mask = mask << 1; |
| |
| temp = (UWORD32)((it_bit_buff & mask)); |
| |
| len_end = code_book_tbl[0]; |
| leading_ones = ixheaacd_cnt_leading_ones(temp); |
| do { |
| ixheaacd_drc_offset = (idx_table[leading_ones] >> 20) & 0x1ff; |
| length = code_book_tbl[ixheaacd_drc_offset + 1] & 0x1f; |
| code_word = idx_table[leading_ones] & 0xfffff; |
| temp1 = temp >> (32 - length); |
| if (temp1 <= code_word) { |
| ixheaacd_drc_offset = ixheaacd_drc_offset - (code_word - temp1); |
| found = 1; |
| } else { |
| len_end = len_end + ((idx_table[leading_ones] >> 29) & 0x7); |
| leading_ones = len_end; |
| } |
| } while (!found); |
| *huff_index = code_book_tbl[ixheaacd_drc_offset + 1] >> 5; |
| *len = length; |
| } |
| |
| VOID ixheaacd_inverse_quantize(WORD32 *x_invquant, WORD no_band, |
| WORD32 *ixheaacd_pow_table_Q13, |
| WORD8 *scratch_in) { |
| WORD32 j; |
| WORD32 temp; |
| WORD32 q_abs; |
| |
| for (j = no_band - 1; j >= 0; j--) { |
| q_abs = *scratch_in++; |
| temp = (ixheaacd_pow_table_Q13[q_abs]); |
| *x_invquant++ = -temp; |
| } |
| } |
| |
| static PLATFORM_INLINE WORD ixheaacd_huffman_dec_word1( |
| ia_bit_buf_struct *it_bit_buff, WORD32 *spec_coef, WORD16 *offsets, |
| WORD no_bands, WORD group_len, const UWORD16 *code_book_tbl, |
| WORD32 *ixheaacd_pow_table_Q13, const UWORD32 *idx_table) { |
| WORD32 sp1, sp2; |
| WORD32 flush_cw; |
| WORD32 i, value, norm_val, off; |
| WORD idx, grp_idx; |
| WORD32 out1, out2; |
| WORD32 err_code = 0; |
| WORD len_idx = 0; |
| UWORD8 *ptr_read_next = it_bit_buff->ptr_read_next; |
| WORD32 bit_pos = it_bit_buff->bit_pos; |
| WORD16 index; |
| WORD32 length; |
| WORD32 read_word; |
| WORD32 increment; |
| |
| read_word = ixheaacd_aac_showbits_32(ptr_read_next, it_bit_buff->cnt_bits, |
| &increment); |
| ptr_read_next += increment; |
| |
| do { |
| len_idx = offsets[1] - offsets[0]; |
| grp_idx = group_len; |
| |
| do { |
| spec_coef = spec_coef + offsets[0]; |
| idx = len_idx; |
| do { |
| { |
| UWORD32 read_word1; |
| |
| read_word1 = read_word << bit_pos; |
| ixheaacd_huff_sfb_table(read_word1, &index, &length, code_book_tbl, |
| idx_table); |
| bit_pos += length; |
| ixheaacd_aac_read_byte_corr(&ptr_read_next, &bit_pos, &read_word, |
| it_bit_buff->ptr_bit_buf_end); |
| } |
| |
| out1 = index / 17; |
| out2 = index - out1 * 17; |
| flush_cw = read_word << bit_pos; |
| |
| sp1 = out1; |
| sp2 = out2; |
| |
| if (out1) { |
| if (flush_cw & 0x80000000) { |
| out1 = -out1; |
| } |
| bit_pos++; |
| flush_cw = (WORD32)flush_cw << 1; |
| } |
| |
| if (out2) { |
| bit_pos++; |
| if (flush_cw & 0x80000000) { |
| out2 = -out2; |
| } |
| } |
| ixheaacd_aac_read_byte_corr(&ptr_read_next, &bit_pos, &read_word, |
| it_bit_buff->ptr_bit_buf_end); |
| |
| if (sp1 == 16) { |
| i = 4; |
| value = ixheaacd_extu(read_word, bit_pos, 23); |
| value = value | 0xfffffe00; |
| norm_val = ixheaacd_norm32(value); |
| |
| i += (norm_val - 22); |
| bit_pos += (norm_val - 21); |
| ixheaacd_aac_read_byte_corr(&ptr_read_next, &bit_pos, &read_word, |
| it_bit_buff->ptr_bit_buf_end); |
| |
| off = ixheaacd_extu(read_word, bit_pos, 32 - i); |
| |
| bit_pos += i; |
| |
| ixheaacd_aac_read_byte_corr(&ptr_read_next, &bit_pos, &read_word, |
| it_bit_buff->ptr_bit_buf_end); |
| ixheaacd_aac_read_byte_corr(&ptr_read_next, &bit_pos, &read_word, |
| it_bit_buff->ptr_bit_buf_end); |
| |
| i = off + ((WORD32)1 << i); |
| |
| if (i <= IQ_TABLE_SIZE_HALF) |
| i = ixheaacd_pow_table_Q13[i]; |
| else { |
| err_code |= ixheaacd_inv_quant(&i, ixheaacd_pow_table_Q13); |
| } |
| |
| if (out1 < 0) { |
| out1 = -i; |
| } else { |
| out1 = i; |
| } |
| *spec_coef++ = out1; |
| } else { |
| if (out1 <= 0) { |
| out1 = -out1; |
| out1 = ixheaacd_pow_table_Q13[out1]; |
| *spec_coef++ = -out1; |
| } else { |
| out1 = ixheaacd_pow_table_Q13[out1]; |
| *spec_coef++ = out1; |
| } |
| } |
| |
| if (sp2 == 16) { |
| i = 4; |
| value = ixheaacd_extu(read_word, bit_pos, 23); |
| value = value | 0xfffffe00; |
| norm_val = ixheaacd_norm32(value); |
| |
| i += (norm_val - 22); |
| |
| bit_pos += (norm_val - 21); |
| ixheaacd_aac_read_byte_corr(&ptr_read_next, &bit_pos, &read_word, |
| it_bit_buff->ptr_bit_buf_end); |
| |
| off = ixheaacd_extu(read_word, bit_pos, 32 - i); |
| |
| bit_pos += i; |
| |
| ixheaacd_aac_read_byte_corr(&ptr_read_next, &bit_pos, &read_word, |
| it_bit_buff->ptr_bit_buf_end); |
| ixheaacd_aac_read_byte_corr(&ptr_read_next, &bit_pos, &read_word, |
| it_bit_buff->ptr_bit_buf_end); |
| |
| i = off + ((WORD32)1 << i); |
| |
| if (i <= IQ_TABLE_SIZE_HALF) |
| i = ixheaacd_pow_table_Q13[i]; |
| else { |
| err_code |= ixheaacd_inv_quant(&i, ixheaacd_pow_table_Q13); |
| } |
| |
| if (out2 < 0) { |
| out2 = -i; |
| } else { |
| out2 = i; |
| } |
| *spec_coef++ = out2; |
| } else { |
| if (out2 <= 0) { |
| out2 = -out2; |
| out2 = ixheaacd_pow_table_Q13[out2]; |
| *spec_coef++ = -out2; |
| } else { |
| out2 = ixheaacd_pow_table_Q13[out2]; |
| *spec_coef++ = out2; |
| } |
| } |
| |
| idx -= 2; |
| } while (idx != 0); |
| |
| spec_coef += (MAX_BINS_SHORT - offsets[1]); |
| grp_idx--; |
| } while (grp_idx != 0); |
| |
| offsets++; |
| spec_coef -= (MAX_BINS_SHORT * group_len); |
| no_bands--; |
| } while (no_bands >= 0); |
| |
| ptr_read_next = ptr_read_next - increment; |
| ixheaacd_aac_read_byte_corr1(&ptr_read_next, &bit_pos, &read_word, |
| it_bit_buff->ptr_bit_buf_end); |
| |
| it_bit_buff->bit_pos = bit_pos; |
| it_bit_buff->ptr_read_next = ptr_read_next; |
| |
| return err_code; |
| } |
| |
| static PLATFORM_INLINE WORD ixheaacd_huffman_dec_word2_11( |
| ia_bit_buf_struct *it_bit_buff, WORD32 width, const UWORD16 *code_book_tbl, |
| WORD32 *x_invquant, WORD32 *ixheaacd_pow_table_Q13, WORD8 *ptr_scratch, |
| const UWORD32 *idx_table) { |
| WORD32 sp1, sp2; |
| WORD32 flush_cw; |
| WORD32 i, value, norm_val, off; |
| WORD idx; |
| WORD32 out1, out2; |
| WORD32 err_code = 0; |
| WORD16 index; |
| WORD32 length; |
| UWORD8 *ptr_read_next = it_bit_buff->ptr_read_next; |
| WORD32 bit_pos = it_bit_buff->bit_pos; |
| WORD32 read_word; |
| WORD32 increment; |
| |
| read_word = ixheaacd_aac_showbits_32(ptr_read_next, it_bit_buff->cnt_bits, |
| &increment); |
| ptr_read_next += increment; |
| |
| for (idx = width; idx != 0; idx -= 2) { |
| { |
| UWORD32 read_word1; |
| |
| read_word1 = read_word << bit_pos; |
| ixheaacd_huff_sfb_table(read_word1, &index, &length, code_book_tbl, |
| idx_table); |
| bit_pos += length; |
| ixheaacd_aac_read_byte_corr(&ptr_read_next, &bit_pos, &read_word, |
| it_bit_buff->ptr_bit_buf_end); |
| } |
| |
| flush_cw = read_word << bit_pos; |
| out1 = index / 17; |
| out2 = index - out1 * 17; |
| sp1 = out1; |
| |
| if (out1) { |
| if (flush_cw & 0x80000000) { |
| out1 = -out1; |
| } |
| |
| bit_pos++; |
| flush_cw = (WORD32)flush_cw << 1; |
| } |
| |
| sp2 = out2; |
| if (out2) { |
| bit_pos++; |
| if (flush_cw & 0x80000000) { |
| out2 = -out2; |
| } |
| } |
| |
| ixheaacd_aac_read_byte_corr(&ptr_read_next, &bit_pos, &read_word, |
| it_bit_buff->ptr_bit_buf_end); |
| |
| if (sp1 == 16) { |
| i = 4; |
| value = ixheaacd_extu(read_word, bit_pos, 23); |
| value = value | 0xfffffe00; |
| norm_val = ixheaacd_norm32(value); |
| i += (norm_val - 22); |
| bit_pos += (norm_val - 21); |
| |
| ixheaacd_aac_read_byte_corr(&ptr_read_next, &bit_pos, &read_word, |
| it_bit_buff->ptr_bit_buf_end); |
| |
| off = ixheaacd_extu(read_word, bit_pos, 32 - i); |
| |
| bit_pos += i; |
| ixheaacd_aac_read_byte_corr(&ptr_read_next, &bit_pos, &read_word, |
| it_bit_buff->ptr_bit_buf_end); |
| |
| value = *ptr_scratch++; |
| |
| ixheaacd_aac_read_byte_corr(&ptr_read_next, &bit_pos, &read_word, |
| it_bit_buff->ptr_bit_buf_end); |
| i = off + ((WORD32)1 << i); |
| i += value; |
| |
| if (i <= IQ_TABLE_SIZE_HALF) |
| i = ixheaacd_pow_table_Q13[i]; |
| else { |
| err_code |= ixheaacd_inv_quant(&i, ixheaacd_pow_table_Q13); |
| } |
| if (out1 < 0) { |
| i = -i; |
| } |
| *x_invquant++ = i; |
| } else { |
| WORD8 temp = *ptr_scratch++; |
| if (out1 <= 0) { |
| out1 = temp - out1; |
| out1 = ixheaacd_pow_table_Q13[out1]; |
| *x_invquant++ = -out1; |
| } else { |
| out1 += temp; |
| out1 = ixheaacd_pow_table_Q13[out1]; |
| *x_invquant++ = out1; |
| } |
| } |
| |
| if (sp2 == 16) { |
| i = 4; |
| value = ixheaacd_extu(read_word, bit_pos, 23); |
| value = value | 0xfffffe00; |
| norm_val = ixheaacd_norm32(value); |
| |
| i += (norm_val - 22); |
| |
| bit_pos += (norm_val - 21); |
| ixheaacd_aac_read_byte_corr(&ptr_read_next, &bit_pos, &read_word, |
| it_bit_buff->ptr_bit_buf_end); |
| |
| off = ixheaacd_extu(read_word, bit_pos, 32 - i); |
| |
| bit_pos += i; |
| ixheaacd_aac_read_byte_corr(&ptr_read_next, &bit_pos, &read_word, |
| it_bit_buff->ptr_bit_buf_end); |
| value = *ptr_scratch++; |
| ixheaacd_aac_read_byte_corr(&ptr_read_next, &bit_pos, &read_word, |
| it_bit_buff->ptr_bit_buf_end); |
| |
| i = off + ((WORD32)1 << i); |
| i += value; |
| if (i <= IQ_TABLE_SIZE_HALF) |
| i = ixheaacd_pow_table_Q13[i]; |
| else { |
| err_code |= ixheaacd_inv_quant(&i, ixheaacd_pow_table_Q13); |
| } |
| |
| if (out2 < 0) { |
| i = -i; |
| } |
| *x_invquant++ = i; |
| |
| } else { |
| WORD8 temp = *ptr_scratch++; |
| if (out2 <= 0) { |
| out2 = temp - out2; |
| out2 = ixheaacd_pow_table_Q13[out2]; |
| *x_invquant++ = -out2; |
| } else { |
| out2 += temp; |
| out2 = ixheaacd_pow_table_Q13[out2]; |
| *x_invquant++ = out2; |
| } |
| } |
| } |
| ptr_read_next = ptr_read_next - increment; |
| ixheaacd_aac_read_byte_corr1(&ptr_read_next, &bit_pos, &read_word, |
| it_bit_buff->ptr_bit_buf_end); |
| |
| it_bit_buff->ptr_read_next = ptr_read_next; |
| it_bit_buff->bit_pos = bit_pos; |
| |
| return err_code; |
| } |
| |
| static PLATFORM_INLINE WORD ixheaacd_huffman_dec_quad( |
| ia_bit_buf_struct *it_bit_buff, WORD32 *spec_coef, WORD16 *offsets, |
| WORD no_bands, WORD group_len, const UWORD16 *code_book_tbl, |
| WORD32 *ixheaacd_pow_table_Q13, WORD32 tbl_sign, const UWORD32 *idx_table) { |
| WORD idx, grp_idx; |
| WORD idx_len; |
| WORD32 *spec_orig; |
| WORD16 index, length; |
| UWORD8 *ptr_read_next = it_bit_buff->ptr_read_next; |
| WORD32 bit_pos = it_bit_buff->bit_pos; |
| WORD32 read_word; |
| WORD32 increment; |
| |
| read_word = ixheaacd_aac_showbits_32(ptr_read_next, it_bit_buff->cnt_bits, |
| &increment); |
| ptr_read_next += increment; |
| spec_orig = spec_coef; |
| do { |
| idx_len = offsets[1] - offsets[0]; |
| grp_idx = group_len; |
| |
| do { |
| spec_coef = spec_coef + offsets[0]; |
| idx = idx_len; |
| do { |
| UWORD32 read_word1; |
| |
| read_word1 = read_word << bit_pos; |
| ixheaacd_huffman_decode(read_word1, &index, &length, code_book_tbl, |
| idx_table); |
| bit_pos += length; |
| ixheaacd_aac_read_byte_corr(&ptr_read_next, &bit_pos, &read_word, |
| it_bit_buff->ptr_bit_buf_end); |
| if (tbl_sign) { |
| WORD32 temp_word; |
| WORD32 w, x, y, z; |
| temp_word = read_word << bit_pos; |
| w = index / 27; |
| index = index - w * 27; |
| x = index / 9; |
| index = index - x * 9; |
| y = index / 3; |
| z = index - y * 3; |
| if (w) { |
| w = ixheaacd_pow_table_Q13[w]; |
| if (temp_word & 0x80000000) w = -w; |
| temp_word <<= 1; |
| bit_pos++; |
| } |
| *spec_coef++ = w; |
| |
| if (x) { |
| x = ixheaacd_pow_table_Q13[x]; |
| if (temp_word & 0x80000000) x = -x; |
| temp_word <<= 1; |
| bit_pos++; |
| } |
| *spec_coef++ = x; |
| if (y) { |
| y = ixheaacd_pow_table_Q13[y]; |
| if (temp_word & 0x80000000) y = -y; |
| temp_word <<= 1; |
| bit_pos++; |
| } |
| *spec_coef++ = y; |
| if (z) { |
| z = ixheaacd_pow_table_Q13[z]; |
| if (temp_word & 0x80000000) z = -z; |
| temp_word <<= 1; |
| bit_pos++; |
| } |
| *spec_coef++ = z; |
| |
| } |
| |
| else { |
| WORD32 w, x, y, z; |
| |
| w = index / 27 - 1; |
| index = index - (w + 1) * 27; |
| x = index / 9 - 1; |
| index = index - (x + 1) * 9; |
| y = index / 3 - 1; |
| z = index - ((y + 1) * 3) - 1; |
| if (w < 0) { |
| w = -w; |
| w = ixheaacd_pow_table_Q13[w]; |
| w = -w; |
| } else |
| w = ixheaacd_pow_table_Q13[w]; |
| |
| *spec_coef++ = w; |
| |
| if (x < 0) { |
| x = -x; |
| x = ixheaacd_pow_table_Q13[x]; |
| x = -x; |
| } else |
| x = ixheaacd_pow_table_Q13[x]; |
| |
| *spec_coef++ = x; |
| |
| if (y < 0) { |
| y = -y; |
| y = ixheaacd_pow_table_Q13[y]; |
| y = -y; |
| } else |
| y = ixheaacd_pow_table_Q13[y]; |
| |
| *spec_coef++ = y; |
| |
| if (z < 0) { |
| z = -z; |
| z = ixheaacd_pow_table_Q13[z]; |
| z = -z; |
| } else |
| z = ixheaacd_pow_table_Q13[z]; |
| |
| *spec_coef++ = z; |
| } |
| |
| ixheaacd_aac_read_byte_corr(&ptr_read_next, &bit_pos, &read_word, |
| it_bit_buff->ptr_bit_buf_end); |
| idx -= 4; |
| } while (idx != 0); |
| |
| spec_coef += (MAX_BINS_SHORT - offsets[1]); |
| grp_idx--; |
| } while (grp_idx != 0); |
| offsets++; |
| spec_coef = spec_orig; |
| no_bands--; |
| } while (no_bands >= 0); |
| |
| ptr_read_next = ptr_read_next - increment; |
| ixheaacd_aac_read_byte_corr1(&ptr_read_next, &bit_pos, &read_word, |
| it_bit_buff->ptr_bit_buf_end); |
| it_bit_buff->ptr_read_next = ptr_read_next; |
| it_bit_buff->bit_pos = bit_pos; |
| |
| return 0; |
| } |
| |
| static PLATFORM_INLINE WORD ixheaacd_huffman_dec_word2_quad( |
| ia_bit_buf_struct *it_bit_buff, WORD32 width, const UWORD16 *code_book_tbl, |
| WORD32 *x_invquant, WORD32 *ixheaacd_pow_table_Q13, WORD8 *ptr_scratch, |
| WORD32 tbl_sign, const UWORD32 *idx_table) { |
| WORD idx; |
| WORD16 index, length; |
| UWORD8 *ptr_read_next = it_bit_buff->ptr_read_next; |
| WORD32 bit_pos = it_bit_buff->bit_pos; |
| WORD32 read_word; |
| WORD32 increment; |
| |
| read_word = ixheaacd_aac_showbits_32(ptr_read_next, it_bit_buff->cnt_bits, |
| &increment); |
| ptr_read_next += increment; |
| |
| for (idx = width; idx != 0; idx -= 4) { |
| WORD32 ampres, ampres1; |
| WORD32 ampres2, ampres3; |
| UWORD32 read_word1; |
| |
| read_word1 = read_word << bit_pos; |
| ixheaacd_huffman_decode(read_word1, &index, &length, code_book_tbl, |
| idx_table); |
| bit_pos += length; |
| ixheaacd_aac_read_byte_corr(&ptr_read_next, &bit_pos, &read_word, |
| it_bit_buff->ptr_bit_buf_end); |
| if (tbl_sign) { |
| WORD32 w, x, y, z; |
| WORD32 ampout0, ampout1, ampout2, ampout3; |
| WORD32 temp_word; |
| temp_word = read_word << bit_pos; |
| |
| w = index / 27; |
| index = index - w * 27; |
| x = index / 9; |
| index = index - x * 9; |
| y = index / 3; |
| z = index - y * 3; |
| |
| ampout0 = w + *ptr_scratch++; |
| ampout0 = ixheaacd_pow_table_Q13[ampout0]; |
| |
| if (w) { |
| if (temp_word & 0x80000000) { |
| ampout0 = -ampout0; |
| } |
| temp_word = temp_word << 1; |
| bit_pos++; |
| } else { |
| ampout0 = -ampout0; |
| } |
| |
| ampout1 = x + *ptr_scratch++; |
| ampout1 = ixheaacd_pow_table_Q13[ampout1]; |
| |
| if (x) { |
| if (temp_word & 0x80000000) { |
| ampout1 = -ampout1; |
| } |
| temp_word = temp_word << 1; |
| bit_pos++; |
| } else { |
| ampout1 = -ampout1; |
| } |
| |
| ampout2 = y + *ptr_scratch++; |
| ampout2 = ixheaacd_pow_table_Q13[ampout2]; |
| |
| if (y) { |
| if (temp_word & 0x80000000) { |
| ampout2 = -ampout2; |
| } |
| temp_word = temp_word << 1; |
| bit_pos++; |
| } else { |
| ampout2 = -ampout2; |
| } |
| |
| ampout3 = z + *ptr_scratch++; |
| ampout3 = ixheaacd_pow_table_Q13[ampout3]; |
| |
| if (z) { |
| if (temp_word & 0x80000000) { |
| ampout3 = -ampout3; |
| } |
| temp_word = temp_word << 1; |
| bit_pos++; |
| } else { |
| ampout3 = -ampout3; |
| } |
| *x_invquant++ = ampout0; |
| *x_invquant++ = ampout1; |
| *x_invquant++ = ampout2; |
| *x_invquant++ = ampout3; |
| } else { |
| WORD32 w, x, y, z; |
| ampres = *ptr_scratch++; |
| ampres1 = *ptr_scratch++; |
| ampres2 = *ptr_scratch++; |
| ampres3 = *ptr_scratch++; |
| |
| w = index / 27 - 1; |
| index = index - (w + 1) * 27; |
| x = index / 9 - 1; |
| index = index - (x + 1) * 9; |
| y = index / 3 - 1; |
| z = index - ((y + 1) * 3) - 1; |
| if (w <= 0) { |
| ampres = ampres - w; |
| ampres = ixheaacd_pow_table_Q13[ampres]; |
| ampres = -ampres; |
| } else { |
| ampres += w; |
| ampres = ixheaacd_pow_table_Q13[ampres]; |
| } |
| |
| if (x <= 0) { |
| ampres1 = ampres1 - x; |
| ampres1 = ixheaacd_pow_table_Q13[ampres1]; |
| ampres1 = -ampres1; |
| } else { |
| ampres1 += x; |
| ampres1 = ixheaacd_pow_table_Q13[ampres1]; |
| } |
| |
| if (y <= 0) { |
| ampres2 = ampres2 - y; |
| ampres2 = ixheaacd_pow_table_Q13[ampres2]; |
| ampres2 = -ampres2; |
| } else { |
| ampres2 += y; |
| ampres2 = ixheaacd_pow_table_Q13[ampres2]; |
| } |
| |
| if (z <= 0) { |
| ampres3 = ampres3 - z; |
| ampres3 = ixheaacd_pow_table_Q13[ampres3]; |
| ampres3 = -ampres3; |
| } else { |
| ampres3 += z; |
| ampres3 = ixheaacd_pow_table_Q13[ampres3]; |
| } |
| |
| *x_invquant++ = ampres; |
| *x_invquant++ = ampres1; |
| *x_invquant++ = ampres2; |
| *x_invquant++ = ampres3; |
| } |
| |
| ixheaacd_aac_read_byte_corr(&ptr_read_next, &bit_pos, &read_word, |
| it_bit_buff->ptr_bit_buf_end); |
| } |
| |
| ptr_read_next = ptr_read_next - increment; |
| ixheaacd_aac_read_byte_corr1(&ptr_read_next, &bit_pos, &read_word, |
| it_bit_buff->ptr_bit_buf_end); |
| it_bit_buff->ptr_read_next = ptr_read_next; |
| it_bit_buff->bit_pos = bit_pos; |
| |
| return 0; |
| } |
| |
| static PLATFORM_INLINE WORD ixheaacd_huffman_dec_pair( |
| ia_bit_buf_struct *it_bit_buff, WORD32 *spec_coef, WORD16 *offsets, |
| WORD no_bands, WORD group_len, const UWORD16 *code_book_tbl, |
| WORD32 *ixheaacd_pow_table_Q13, WORD32 tbl_sign, const UWORD32 *idx_table, |
| WORD32 huff_mode) |
| |
| { |
| WORD idx, grp_idx; |
| WORD len_idx; |
| WORD16 index, length; |
| WORD32 y, z; |
| WORD32 *spec_orig = spec_coef; |
| |
| UWORD8 *ptr_read_next = it_bit_buff->ptr_read_next; |
| WORD32 bit_pos = it_bit_buff->bit_pos; |
| WORD32 read_word; |
| WORD32 increment; |
| |
| read_word = ixheaacd_aac_showbits_32(ptr_read_next, it_bit_buff->cnt_bits, |
| &increment); |
| ptr_read_next += increment; |
| |
| do { |
| len_idx = offsets[1] - offsets[0]; |
| grp_idx = group_len; |
| do { |
| spec_coef += offsets[0]; |
| idx = len_idx; |
| do { |
| UWORD32 read_word1; |
| read_word1 = read_word << bit_pos; |
| ixheaacd_huffman_decode(read_word1, &index, &length, code_book_tbl, |
| idx_table); |
| bit_pos += length; |
| ixheaacd_aac_read_byte_corr(&ptr_read_next, &bit_pos, &read_word, |
| it_bit_buff->ptr_bit_buf_end); |
| if (tbl_sign) { |
| WORD32 temp_word; |
| temp_word = read_word << bit_pos; |
| y = index / huff_mode; |
| z = index - huff_mode * y; |
| if (y) { |
| y = ixheaacd_pow_table_Q13[y]; |
| if (temp_word & 0x80000000) y = -y; |
| |
| temp_word = temp_word << 1; |
| bit_pos++; |
| } |
| *spec_coef++ = y; |
| |
| if (z) { |
| z = ixheaacd_pow_table_Q13[z]; |
| if (temp_word & 0x80000000) { |
| z = -z; |
| } |
| temp_word <<= 1; |
| bit_pos++; |
| } |
| *spec_coef++ = z; |
| } else { |
| y = (index / huff_mode) - 4; |
| z = index - ((y + 4) * huff_mode) - 4; |
| if (y < 0) { |
| y = -y; |
| y = ixheaacd_pow_table_Q13[y]; |
| y = -y; |
| } else |
| y = ixheaacd_pow_table_Q13[y]; |
| |
| if (z < 0) { |
| z = -z; |
| z = ixheaacd_pow_table_Q13[z]; |
| z = -z; |
| } else |
| z = ixheaacd_pow_table_Q13[z]; |
| |
| *spec_coef++ = y; |
| *spec_coef++ = z; |
| } |
| ixheaacd_aac_read_byte_corr(&ptr_read_next, &bit_pos, &read_word, |
| it_bit_buff->ptr_bit_buf_end); |
| idx -= 2; |
| } while (idx != 0); |
| |
| spec_coef += (MAX_BINS_SHORT - offsets[1]); |
| grp_idx--; |
| } while (grp_idx != 0); |
| |
| offsets++; |
| spec_coef = spec_orig; |
| no_bands--; |
| } while (no_bands >= 0); |
| |
| ptr_read_next = ptr_read_next - increment; |
| ixheaacd_aac_read_byte_corr1(&ptr_read_next, &bit_pos, &read_word, |
| it_bit_buff->ptr_bit_buf_end); |
| it_bit_buff->ptr_read_next = ptr_read_next; |
| it_bit_buff->bit_pos = bit_pos; |
| |
| return 0; |
| } |
| |
| static PLATFORM_INLINE WORD ixheaacd_huffman_dec_word2_pair( |
| ia_bit_buf_struct *it_bit_buff, WORD32 width, const UWORD16 *code_book_tbl, |
| WORD32 *x_invquant, WORD32 *ixheaacd_pow_table_Q13, WORD8 *ptr_scratch, |
| WORD32 tbl_sign, const UWORD32 *idx_table, WORD32 huff_mode) |
| |
| { |
| WORD32 ampres; |
| WORD idx; |
| WORD16 index, length; |
| UWORD8 *ptr_read_next = it_bit_buff->ptr_read_next; |
| WORD32 bit_pos = it_bit_buff->bit_pos; |
| WORD32 read_word; |
| WORD32 increment; |
| |
| read_word = ixheaacd_aac_showbits_32(ptr_read_next, it_bit_buff->cnt_bits, |
| &increment); |
| ptr_read_next += increment; |
| |
| for (idx = width; idx != 0; idx -= 2) { |
| { |
| UWORD32 read_word1; |
| read_word1 = read_word << bit_pos; |
| ixheaacd_huffman_decode(read_word1, &index, &length, code_book_tbl, |
| idx_table); |
| bit_pos += length; |
| ixheaacd_aac_read_byte_corr(&ptr_read_next, &bit_pos, &read_word, |
| it_bit_buff->ptr_bit_buf_end); |
| } |
| |
| if (tbl_sign) { |
| WORD32 out0, out1, temp_word; |
| WORD32 ampout0, ampout1; |
| |
| ampout0 = *ptr_scratch++; |
| ampout1 = *ptr_scratch++; |
| out0 = index / huff_mode; |
| out1 = index - huff_mode * out0; |
| ampout0 += out0; |
| ampout0 = ixheaacd_pow_table_Q13[ampout0]; |
| |
| ampout1 += out1; |
| ampout1 = ixheaacd_pow_table_Q13[ampout1]; |
| temp_word = read_word << bit_pos; |
| if (out0) { |
| if (temp_word & 0x80000000) { |
| ampout0 = -(ampout0); |
| } |
| |
| bit_pos++; |
| temp_word = temp_word << 1; |
| } else { |
| ampout0 = -(ampout0); |
| } |
| |
| if (out1) { |
| if (temp_word & 0x80000000) { |
| ampout1 = -(ampout1); |
| } |
| bit_pos++; |
| } else { |
| ampout1 = -(ampout1); |
| } |
| |
| ixheaacd_aac_read_byte_corr(&ptr_read_next, &bit_pos, &read_word, |
| it_bit_buff->ptr_bit_buf_end); |
| *x_invquant++ = ampout0; |
| *x_invquant++ = ampout1; |
| } else { |
| WORD32 y, z; |
| y = (index / huff_mode) - 4; |
| z = index - ((y + 4) * huff_mode) - 4; |
| |
| ampres = *ptr_scratch++; |
| if (y <= 0) { |
| ampres = ampres - y; |
| ampres = ixheaacd_pow_table_Q13[ampres]; |
| *x_invquant++ = -ampres; |
| } else { |
| ampres += y; |
| *x_invquant++ = ixheaacd_pow_table_Q13[ampres]; |
| } |
| ampres = *ptr_scratch++; |
| if (z <= 0) { |
| ampres = ampres - z; |
| ampres = ixheaacd_pow_table_Q13[ampres]; |
| *x_invquant++ = -ampres; |
| } else { |
| ampres += z; |
| *x_invquant++ = ixheaacd_pow_table_Q13[ampres]; |
| } |
| } |
| ixheaacd_aac_read_byte_corr(&ptr_read_next, &bit_pos, &read_word, |
| it_bit_buff->ptr_bit_buf_end); |
| } |
| |
| ptr_read_next = ptr_read_next - increment; |
| ixheaacd_aac_read_byte_corr1(&ptr_read_next, &bit_pos, &read_word, |
| it_bit_buff->ptr_bit_buf_end); |
| it_bit_buff->ptr_read_next = ptr_read_next; |
| it_bit_buff->bit_pos = bit_pos; |
| |
| return 0; |
| } |
| |
| WORD ixheaacd_decode_huffman(ia_bit_buf_struct *it_bit_buff, WORD32 cb_no, |
| WORD32 *spec_coef, WORD16 *sfb_offset, WORD start, |
| WORD sfb, WORD group_len, |
| ia_aac_dec_tables_struct *ptr_aac_tables) { |
| WORD ret_val = 0; |
| WORD start_bit_pos = it_bit_buff->bit_pos; |
| UWORD8 *start_read_pos = it_bit_buff->ptr_read_next; |
| const UWORD16 *cb_table = (UWORD16 *)(ptr_aac_tables->code_book[cb_no]); |
| WORD32 huff_mode; |
| const UWORD32 *idx_table = (UWORD32 *)(ptr_aac_tables->index_table[cb_no]); |
| WORD32 *pow_table = |
| (WORD32 *)ptr_aac_tables->pstr_block_tables->ixheaacd_pow_table_Q13; |
| WORD32 no_bands = sfb - start - 1; |
| WORD16 *band_offset = sfb_offset + start; |
| |
| if (cb_no == 11) { |
| const UWORD32 *idx_table = |
| ptr_aac_tables->pstr_huffmann_tables->idx_table_hf11; |
| const UWORD16 *cb_table = |
| ptr_aac_tables->pstr_huffmann_tables->input_table_cb11; |
| |
| ret_val = ixheaacd_huffman_dec_word1(it_bit_buff, spec_coef, band_offset, |
| no_bands, group_len, cb_table, |
| pow_table, idx_table); |
| |
| } else if (cb_no <= 4) { |
| WORD32 tbl_sign = 0; |
| |
| if (cb_no > 2) { |
| tbl_sign = 1; |
| } |
| ret_val = ixheaacd_huffman_dec_quad(it_bit_buff, spec_coef, band_offset, |
| no_bands, group_len, cb_table, |
| pow_table, tbl_sign, idx_table); |
| } |
| |
| else if (cb_no <= 10) { |
| WORD32 tbl_sign = 0; |
| huff_mode = 9; |
| if (cb_no > 6) { |
| if (cb_no > 8) |
| huff_mode = 13; |
| else |
| huff_mode = 8; |
| tbl_sign = 1; |
| } |
| ret_val = ixheaacd_huffman_dec_pair( |
| it_bit_buff, spec_coef, band_offset, no_bands, group_len, cb_table, |
| pow_table, tbl_sign, idx_table, huff_mode); |
| } |
| |
| { |
| WORD bits_cons; |
| bits_cons = ((it_bit_buff->ptr_read_next - start_read_pos) << 3) + |
| (it_bit_buff->bit_pos - start_bit_pos); |
| it_bit_buff->cnt_bits -= bits_cons; |
| } |
| return ret_val; |
| } |
| |
| WORD ixheaacd_huffman_dec_word2(ia_bit_buf_struct *it_bit_buff, WORD32 cb_no, |
| WORD32 width, |
| ia_aac_dec_tables_struct *ptr_aac_tables, |
| WORD32 *x_invquant, WORD8 *scratch_ptr) { |
| WORD ret_val = 0; |
| WORD32 huff_mode; |
| WORD start_bit_pos = it_bit_buff->bit_pos; |
| WORD32 cnt_bits = it_bit_buff->cnt_bits; |
| WORD32 *pow_table = |
| (WORD32 *)ptr_aac_tables->pstr_block_tables->ixheaacd_pow_table_Q13; |
| UWORD8 *start_read_pos = it_bit_buff->ptr_read_next; |
| |
| const UWORD16 *cb_table = (UWORD16 *)(ptr_aac_tables->code_book[cb_no]); |
| const UWORD32 *idx_table = (UWORD32 *)(ptr_aac_tables->index_table[cb_no]); |
| |
| if (cb_no == 11) { |
| const UWORD16 *cb_table = |
| ptr_aac_tables->pstr_huffmann_tables->input_table_cb11; |
| |
| ret_val = ixheaacd_huffman_dec_word2_11( |
| it_bit_buff, width, cb_table, x_invquant, pow_table, scratch_ptr, |
| ptr_aac_tables->pstr_huffmann_tables->idx_table_hf11); |
| } else if (cb_no <= 4) { |
| WORD32 tbl_sign = 0; |
| if (cb_no > 2) tbl_sign = 1; |
| ret_val = ixheaacd_huffman_dec_word2_quad(it_bit_buff, width, cb_table, |
| x_invquant, pow_table, |
| scratch_ptr, tbl_sign, idx_table); |
| } else if (cb_no <= 10) { |
| WORD32 tbl_sign = 0; |
| huff_mode = 9; |
| if (cb_no > 6) { |
| if (cb_no > 8) { |
| huff_mode = 13; |
| } else { |
| huff_mode = 8; |
| } |
| |
| tbl_sign = 1; |
| } |
| ret_val = ixheaacd_huffman_dec_word2_pair( |
| it_bit_buff, width, cb_table, x_invquant, pow_table, scratch_ptr, |
| tbl_sign, idx_table, huff_mode); |
| } |
| |
| { |
| WORD bits_cons; |
| if (it_bit_buff->bit_pos <= 7) { |
| bits_cons = ((it_bit_buff->ptr_read_next - start_read_pos) << 3) + |
| (it_bit_buff->bit_pos - start_bit_pos); |
| it_bit_buff->cnt_bits = cnt_bits - bits_cons; |
| } else { |
| it_bit_buff->ptr_read_next += (it_bit_buff->bit_pos) >> 3; |
| it_bit_buff->bit_pos = it_bit_buff->bit_pos & 0x7; |
| |
| bits_cons = ((it_bit_buff->ptr_read_next - start_read_pos) << 3) + |
| ((it_bit_buff->bit_pos - start_bit_pos)); |
| it_bit_buff->cnt_bits = cnt_bits - bits_cons; |
| } |
| } |
| return ret_val; |
| } |
| |
| void ixheaacd_lap1_512_480(WORD32 *coef, WORD32 *prev, WORD16 *out, |
| const WORD16 *window, WORD16 q_shift, WORD16 size, |
| WORD16 stride) { |
| WORD32 accu; |
| WORD32 i; |
| WORD16 rounding_fac = -0x2000; |
| |
| WORD32 *window_i = (WORD32 *)window; |
| |
| WORD16 *ptr_out1, *ptr_out2; |
| |
| WORD32 *pwin1, *pwin2; |
| WORD32 *pCoef = &coef[size * 2 - 1 - 0]; |
| |
| pwin1 = &window_i[size - 1 - 0]; |
| pwin2 = &window_i[size + 0]; |
| |
| ptr_out1 = &out[stride * (size - 1 - 0)]; |
| ptr_out2 = &out[stride * (size + 0)]; |
| |
| for (i = 0; i < size; i++) { |
| WORD32 win1, win2, coeff; |
| WORD32 prev_data = *prev++; |
| |
| win1 = *pwin1--; |
| coeff = *pCoef--; |
| win2 = *pwin2++; |
| |
| accu = ixheaacd_sub32_sat( |
| ixheaacd_shl32_dir_sat_limit(ixheaacd_mult32_shl(coeff, win1), q_shift), |
| ixheaacd_mac32x16in32_shl(rounding_fac, win2, (WORD16)(prev_data))); |
| |
| accu = ixheaacd_add32_sat(accu, accu); |
| accu = ixheaacd_add32_sat(accu, accu); |
| |
| *ptr_out1 = ixheaacd_shr32(accu, 16); |
| ptr_out1 -= stride; |
| |
| accu = ixheaacd_sub32_sat( |
| ixheaacd_shl32_dir_sat_limit( |
| ixheaacd_mult32_shl(ixheaacd_negate32(coeff), win2), q_shift), |
| ixheaacd_mac32x16in32_shl(rounding_fac, win1, (WORD16)(prev_data))); |
| |
| accu = ixheaacd_add32_sat(accu, accu); |
| accu = ixheaacd_add32_sat(accu, accu); |
| |
| *ptr_out2 = ixheaacd_shr32(accu, 16); |
| ptr_out2 += stride; |
| } |
| } |
| |
| VOID ixheaacd_over_lap_add1_dec(WORD32 *coef, WORD32 *prev, WORD16 *out, |
| const WORD16 *window, WORD16 q_shift, |
| WORD16 size, WORD16 ch_fac) { |
| WORD32 accu; |
| WORD32 i; |
| WORD16 rounding_fac = -0x2000; |
| |
| for (i = 0; i < size; i++) { |
| WORD16 window1, window2; |
| |
| window1 = window[2 * size - 2 * i - 1]; |
| window2 = window[2 * size - 2 * i - 2]; |
| accu = ixheaacd_sub32_sat( |
| ixheaacd_shl32_dir_sat_limit( |
| ixheaacd_mult32x16in32(coef[size * 2 - 1 - i], window2), q_shift), |
| ixheaacd_mac32x16in32_drc(rounding_fac, prev[i], window1)); |
| out[ch_fac * (size - i - 1)] = |
| ixheaacd_shr32(ixheaacd_shl32_dir_sat_limit(accu, 2), 16); |
| accu = ixheaacd_sub32_sat( |
| ixheaacd_shl32_dir_sat_limit( |
| ixheaacd_mult32x16in32(ixheaacd_negate32(coef[size * 2 - 1 - i]), |
| window1), |
| q_shift), |
| ixheaacd_mac32x16in32_drc(rounding_fac, prev[i], window2)); |
| out[ch_fac * (size + i)] = |
| ixheaacd_shr32(ixheaacd_shl32_dir_sat_limit(accu, 2), 16); |
| } |
| } |
| |
| VOID ixheaacd_over_lap_add2_dec(WORD32 *coef, WORD32 *prev, WORD32 *out, |
| const WORD16 *window, WORD16 q_shift, |
| WORD16 size, WORD16 ch_fac) { |
| WORD32 accu; |
| WORD32 i; |
| |
| for (i = 0; i < size; i++) { |
| accu = ixheaacd_sub32_sat( |
| ixheaacd_mult32x16in32(coef[size + i], window[2 * i]), |
| ixheaacd_mult32x16in32(prev[size - 1 - i], window[2 * i + 1])); |
| out[ch_fac * i] = ixheaacd_shr32_drc(accu, 16 - (q_shift + 1)); |
| } |
| |
| for (i = 0; i < size; i++) { |
| accu = ixheaacd_sub32_sat( |
| ixheaacd_mult32x16in32(ixheaacd_negate32_sat(coef[size * 2 - 1 - i]), |
| window[2 * size - 2 * i - 1]), |
| ixheaacd_mult32x16in32(prev[i], window[2 * size - 2 * i - 2])); |
| out[ch_fac * (i + size)] = ixheaacd_shr32_drc(accu, 16 - (q_shift + 1)); |
| } |
| } |
| |
| VOID ixheaacd_process_single_scf(WORD32 scale_factor, WORD32 *x_invquant, |
| WORD32 width, WORD32 *ptr_scale_table, |
| WORD32 total_channels, WORD32 object_type, |
| WORD32 aac_sf_data_resil_flag) { |
| WORD32 j; |
| |
| WORD32 temp1; |
| WORD32 q_factor; |
| WORD32 buffer1; |
| WORD16 scale_short; |
| |
| object_type = 0; |
| aac_sf_data_resil_flag = 0; |
| |
| if (scale_factor < 24) { |
| for (j = width; j > 0; j--) { |
| *x_invquant++ = 0; |
| } |
| } else { |
| WORD32 shift; |
| |
| if (total_channels > 2) |
| q_factor = 34 - (scale_factor >> 2); |
| else |
| q_factor = 37 - (scale_factor >> 2); |
| |
| scale_short = ptr_scale_table[(scale_factor & 0x0003)]; |
| shift = q_factor; |
| if (shift > 0) { |
| if (scale_short == (WORD16)0x8000) { |
| for (j = width; j > 0; j--) { |
| temp1 = *x_invquant; |
| buffer1 = ixheaacd_mult32x16in32_shl_sat(temp1, scale_short); |
| buffer1 = ixheaacd_shr32(buffer1, shift); |
| *x_invquant++ = buffer1; |
| } |
| } else { |
| for (j = width; j > 0; j--) { |
| temp1 = *x_invquant; |
| buffer1 = ixheaacd_mult32x16in32_shl(temp1, scale_short); |
| buffer1 = ixheaacd_shr32(buffer1, shift); |
| *x_invquant++ = buffer1; |
| } |
| } |
| } else { |
| shift = -shift; |
| if (shift > 0) { |
| if (scale_short == (WORD16)0x8000) { |
| for (j = width; j > 0; j--) { |
| temp1 = *x_invquant; |
| temp1 = ixheaacd_shl32(temp1, shift - 1); |
| buffer1 = ixheaacd_mult32x16in32_shl_sat(temp1, scale_short); |
| buffer1 = ixheaacd_shl32(buffer1, 1); |
| *x_invquant++ = buffer1; |
| } |
| } else { |
| for (j = width; j > 0; j--) { |
| temp1 = *x_invquant; |
| temp1 = ixheaacd_shl32(temp1, shift - 1); |
| buffer1 = ixheaacd_mult32x16in32_shl(temp1, scale_short); |
| buffer1 = ixheaacd_shl32(buffer1, 1); |
| *x_invquant++ = buffer1; |
| } |
| } |
| |
| } else { |
| if (scale_short == (WORD16)0x8000) { |
| for (j = width; j > 0; j--) { |
| temp1 = *x_invquant; |
| buffer1 = ixheaacd_mult32x16in32_shl_sat(temp1, scale_short); |
| *x_invquant++ = buffer1; |
| } |
| } else { |
| for (j = width; j > 0; j--) { |
| temp1 = *x_invquant; |
| buffer1 = ixheaacd_mult32x16in32_shl(temp1, scale_short); |
| *x_invquant++ = buffer1; |
| } |
| } |
| } |
| } |
| } |
| } |
| |
| VOID ixheaacd_scale_factor_process_dec(WORD32 *x_invquant, WORD16 *scale_fact, |
| WORD no_band, WORD8 *width, |
| WORD32 *ptr_scale_table, |
| WORD32 total_channels, |
| WORD32 object_type, |
| WORD32 aac_sf_data_resil_flag) { |
| WORD32 i; |
| WORD16 scale_factor; |
| |
| for (i = no_band - 1; i >= 0; i--) { |
| scale_factor = *scale_fact++; |
| ixheaacd_process_single_scf(scale_factor, x_invquant, *width, |
| ptr_scale_table, total_channels, object_type, |
| aac_sf_data_resil_flag); |
| |
| x_invquant += *width; |
| width++; |
| } |
| } |
| |
| void ixheaacd_right_shift_block(WORD32 *p_spectrum, WORD32 length, |
| WORD32 shift_val) { |
| WORD32 i; |
| WORD32 temp1, temp2; |
| WORD32 *temp_ptr = &p_spectrum[0]; |
| length = length >> 2; |
| |
| for (i = length - 1; i >= 0; i--) { |
| temp1 = *temp_ptr; |
| temp2 = *(temp_ptr + 1); |
| *temp_ptr++ = temp1 >> shift_val; |
| temp1 = *(temp_ptr + 1); |
| *temp_ptr++ = temp2 >> shift_val; |
| temp2 = *(temp_ptr + 1); |
| *temp_ptr++ = temp1 >> shift_val; |
| *temp_ptr++ = temp2 >> shift_val; |
| } |
| } |
