| /****************************************************************************** |
| * * |
| * Copyright (C) 2023 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 "ixheaac_type_def.h" |
| #include "ixheaac_constants.h" |
| #include "ixheaace_psy_const.h" |
| #include "ixheaace_tns.h" |
| #include "ixheaace_tns_params.h" |
| #include "ixheaace_rom.h" |
| #include "ixheaace_common_rom.h" |
| #include "ixheaace_bitbuffer.h" |
| #include "ixheaace_aac_constants.h" |
| #include "ixheaace_write_adts_adif.h" |
| |
| #include "ixheaac_basic_ops32.h" |
| #include "ixheaac_basic_ops16.h" |
| #include "ixheaac_basic_ops40.h" |
| #include "ixheaac_basic_ops.h" |
| #include "ixheaace_common_utils.h" |
| |
| static VOID ia_enhaacplus_enc_putbit(ixheaace_bitstream_params *pstr_bitstream, UWORD32 data, |
| WORD32 num_bit) { |
| WORD32 num, max_num, curr_num; |
| WORD32 num_used, idx; |
| unsigned long bits; |
| WORD32 current_bitstream_bit; |
| UWORD8 *bitstream_data; |
| |
| if (num_bit == 0) return; |
| |
| current_bitstream_bit = pstr_bitstream->current_bit; |
| bitstream_data = pstr_bitstream->data; |
| |
| /* |
| Functionality of Writing bits to the bitstream is split into 3 stages. |
| */ |
| |
| /* |
| Stage #1: Write remainder bits to the partially filled byte |
| */ |
| |
| num = 0; |
| num_used = current_bitstream_bit & 7; |
| max_num = BYTE_NUMBIT - num_used; |
| curr_num = MIN(num_bit, max_num); |
| bits = data >> (num_bit - curr_num); |
| |
| idx = (current_bitstream_bit >> 3); |
| |
| if (num_used == 0) bitstream_data[idx] = 0; |
| |
| bitstream_data[idx] |= (bits & ((1 << curr_num) - 1)) << (max_num - curr_num); |
| current_bitstream_bit += curr_num; |
| num += curr_num; |
| |
| /* |
| Stage #2: |
| At this point, (num + num_used), will be a multiple of 8 |
| Now the bytes can be written directly to bitstream_data[], as long |
| as (num + 8) < num_bit |
| */ |
| |
| while ((num + 8) < num_bit) { |
| num += 8; |
| current_bitstream_bit += 8; |
| bits = data >> (num_bit - num); |
| bitstream_data[++idx] = (UWORD8)bits; |
| } |
| |
| /* |
| Stage #3: Write remainder bits from the data |
| */ |
| if (num < num_bit) { |
| curr_num = num_bit - num; |
| num_used = current_bitstream_bit & 7; |
| max_num = BYTE_NUMBIT - num_used; |
| idx = current_bitstream_bit >> 3; |
| if (num_used == 0) bitstream_data[idx] = 0; |
| bitstream_data[idx] |= (data & ((1 << curr_num) - 1)) << (max_num - curr_num); |
| current_bitstream_bit += curr_num; |
| } |
| |
| pstr_bitstream->current_bit = current_bitstream_bit; |
| pstr_bitstream->num_bit = current_bitstream_bit; |
| } |
| |
| static WORD16 ia_enhaacplus_enc_get_sample_rate_index(WORD32 sample_rate) { |
| if (92017 <= sample_rate) { |
| return 0; |
| } |
| if (75132 <= sample_rate) { |
| return 1; |
| } |
| if (55426 <= sample_rate) { |
| return 2; |
| } |
| if (46009 <= sample_rate) { |
| return 3; |
| } |
| if (37566 <= sample_rate) { |
| return 4; |
| } |
| if (27713 <= sample_rate) { |
| return 5; |
| } |
| if (23004 <= sample_rate) { |
| return 6; |
| } |
| if (18783 <= sample_rate) { |
| return 7; |
| } |
| if (13856 <= sample_rate) { |
| return 8; |
| } |
| if (11502 <= sample_rate) { |
| return 9; |
| } |
| if (9391 <= sample_rate) { |
| return 10; |
| } |
| return 11; |
| } |
| |
| WORD32 ia_enhaacplus_enc_write_pce(WORD32 samp_rate, WORD32 ch_mask, WORD32 num_core_coder_chans, |
| ixheaace_bit_buf_handle pstr_bit_stream_handle) { |
| UWORD32 object_type = 0; |
| UWORD8 buffer[200]; |
| ixheaace_bitstream_params bitstream_temp; |
| ixheaace_bitstream_params *pstr_bitstream = &bitstream_temp; |
| WORD32 write_flag = 1; |
| WORD32 start_bits = pstr_bit_stream_handle->cnt_bits, end_bits; |
| pstr_bitstream->data = buffer; |
| pstr_bitstream->num_bit = 8; |
| pstr_bitstream->current_bit = 0; |
| |
| object_type = 01; |
| |
| if (write_flag) { |
| WORD32 i; |
| WORD32 num_front_chan_ele, num_side_chan_ele, num_back_chan_ele, num_lfe_chan_ele; |
| |
| /* element instance tag can be anything... writing 0 */ |
| ixheaace_write_bits(pstr_bit_stream_handle, 0x00, 4); |
| |
| /* object type --> LC / LTP / any other */ |
| ixheaace_write_bits(pstr_bit_stream_handle, object_type, 2); |
| |
| /* sampling freq index */ |
| ixheaace_write_bits(pstr_bit_stream_handle, |
| ia_enhaacplus_enc_get_sample_rate_index(samp_rate), 4); |
| |
| /* num_front_channel_elements --> only this present for mono / stereo */ |
| num_front_chan_ele = 0; |
| |
| if (ch_mask & 0x3) { |
| num_front_chan_ele++; /*Front Left and Right Present*/ |
| } |
| if (ch_mask & 0x4) { |
| num_front_chan_ele++; /*Front Center Present*/ |
| } |
| ixheaace_write_bits(pstr_bit_stream_handle, num_front_chan_ele, 4); |
| |
| /* num_side_channel_elements 4 */ |
| num_side_chan_ele = 0; |
| |
| if (ch_mask & 0xC0) { |
| num_side_chan_ele++; /*Back Left and Right Present*/ |
| } |
| ixheaace_write_bits(pstr_bit_stream_handle, num_side_chan_ele, 4); |
| |
| /* num_back_channel_elements 4 */ |
| num_back_chan_ele = 0; |
| |
| if (ch_mask & 0x30) { |
| num_back_chan_ele++; /*Back Left and Right of center Present*/ |
| } |
| ixheaace_write_bits(pstr_bit_stream_handle, num_back_chan_ele, 4); |
| |
| /* num_lfe_channel_elements 2 */ |
| num_lfe_chan_ele = 0; |
| |
| if (ch_mask & 0x8) { |
| num_lfe_chan_ele++; /*LFE channel Present*/ |
| } |
| ixheaace_write_bits(pstr_bit_stream_handle, num_lfe_chan_ele, 2); |
| |
| /* num_assoc_data_elements 3 */ |
| ixheaace_write_bits(pstr_bit_stream_handle, 0x00, 3); |
| |
| /* num_valid_cc_elements 4 */ |
| ixheaace_write_bits(pstr_bit_stream_handle, num_core_coder_chans, 4); |
| |
| /* mono mix down is zero */ |
| ixheaace_write_bits(pstr_bit_stream_handle, 0x00, 1); |
| |
| /* mono_mixdown_element_number 4 if mono_mixdown_present == 1 */ |
| |
| /* stereo_mixdown_present is zero */ |
| ixheaace_write_bits(pstr_bit_stream_handle, 0x00, 1); |
| |
| /* stereo_mixdown_element_number 4 if stereo_mixdown_present == 1 */ |
| |
| /* matrix_mixdown_idx_present is zero */ |
| ixheaace_write_bits(pstr_bit_stream_handle, 0x00, 1); |
| |
| { |
| /* stereo --> 1 mono --> 0 */ |
| if (ch_mask & 0x4) { |
| ixheaace_write_bits(pstr_bit_stream_handle, 0x00, 1); |
| /* element tag select */ |
| ixheaace_write_bits(pstr_bit_stream_handle, 0x00, 4); |
| } |
| if (ch_mask & 0x3) { |
| if ((ch_mask & 0x3) == 0x3) { |
| /* stereo channel */ |
| ixheaace_write_bits(pstr_bit_stream_handle, 0x01, 1); |
| } else { |
| /* mono channel */ |
| ixheaace_write_bits(pstr_bit_stream_handle, 0x00, 1); |
| } |
| |
| /* element tag select */ |
| ixheaace_write_bits(pstr_bit_stream_handle, 0x00, 4); |
| } |
| } |
| |
| for (i = 0; i < num_side_chan_ele; i++) { |
| if ((ch_mask & 0xC0) == 0xC0) { |
| /* stereo channel */ |
| ixheaace_write_bits(pstr_bit_stream_handle, 0x01, 1); |
| } else { |
| /* mono channel */ |
| ixheaace_write_bits(pstr_bit_stream_handle, 0x00, 1); |
| } |
| |
| /* element tag select */ |
| ixheaace_write_bits(pstr_bit_stream_handle, 0x02, 4); |
| } |
| |
| for (i = 0; i < num_back_chan_ele; i++) { |
| if ((ch_mask & 0x30) == 0x30) { |
| /* stereo channel */ |
| ixheaace_write_bits(pstr_bit_stream_handle, 0x01, 1); |
| } else { |
| /* mono channel */ |
| ixheaace_write_bits(pstr_bit_stream_handle, 0x00, 1); |
| } |
| |
| /* element tag select */ |
| ixheaace_write_bits(pstr_bit_stream_handle, 0x01, 4); |
| } |
| |
| for (i = 0; i < num_lfe_chan_ele; i++) { |
| /* element tag select */ |
| ixheaace_write_bits(pstr_bit_stream_handle, 0x00, 4); |
| } |
| |
| /* loop for independent coupling elements */ |
| for (i = 0; i < num_core_coder_chans; i++) { |
| /* It is independent coupling channel */ |
| ixheaace_write_bits(pstr_bit_stream_handle, 0x01, 1); |
| |
| /* element tag select */ |
| ixheaace_write_bits(pstr_bit_stream_handle, num_core_coder_chans - i - 1, 4); |
| } |
| |
| /* byte align the stream */ |
| ixheaace_write_bits(pstr_bit_stream_handle, 0, |
| (UWORD8)((8 - (pstr_bit_stream_handle->cnt_bits % 8)) % 8)); |
| /* comment field types --> do not quite know what this is */ |
| ixheaace_write_bits(pstr_bit_stream_handle, 0x00, 8); |
| } |
| |
| end_bits = pstr_bit_stream_handle->cnt_bits; |
| |
| return (end_bits - start_bits); |
| } |
| |
| WORD32 ia_enhaacplus_enc_write_ADTS_header(pUWORD8 buffer, WORD32 bytes_used, WORD32 samp_rate, |
| WORD32 num_ch) { |
| WORD32 bits = 56; |
| UWORD32 object_type = 0; |
| ixheaace_bitstream_params bitstream_temp; |
| ixheaace_bitstream_params *pstr_bitstream = &bitstream_temp; |
| WORD32 write_flag = 1; |
| pstr_bitstream->data = buffer; |
| pstr_bitstream->num_bit = 8; |
| |
| pstr_bitstream->current_bit = 0; |
| ; |
| object_type = 01; |
| |
| if (write_flag) { |
| /* Fixed ADTS header */ |
| ia_enhaacplus_enc_putbit(pstr_bitstream, 0xFFFF, 12); /* 12 bit Syncword */ |
| ia_enhaacplus_enc_putbit(pstr_bitstream, 1 /*aacStateStruct->aacConfigSturct.mpegVersion*/, |
| 1); /* ID == 0 for MPEG4 AAC, 1 for MPEG2 AAC */ |
| ia_enhaacplus_enc_putbit(pstr_bitstream, 0, 2); /* layer == 0 */ |
| ia_enhaacplus_enc_putbit(pstr_bitstream, 1, 1); /* protection absent */ |
| ia_enhaacplus_enc_putbit(pstr_bitstream, object_type, 2); /* profile */ |
| ia_enhaacplus_enc_putbit( |
| pstr_bitstream, |
| ia_enhaacplus_enc_get_sample_rate_index(samp_rate) /*aacStateStruct->sampleRateIdx*/, |
| 4); /* sampling rate */ |
| ia_enhaacplus_enc_putbit(pstr_bitstream, 0, 1); /* private bit */ |
| ia_enhaacplus_enc_putbit(pstr_bitstream, num_ch /*aacStateStruct->aacConfigSturct.ch*/, |
| 3); /* ch. aacConfigSturct (must be > 0) */ |
| /* simply using num_channels only works for |
| 6 channels or less, else a channel |
| configuration should be written */ |
| ia_enhaacplus_enc_putbit(pstr_bitstream, 0, 1); /* original/copy */ |
| ia_enhaacplus_enc_putbit(pstr_bitstream, 0, 1); /* home */ |
| |
| /* Variable ADTS header */ |
| ia_enhaacplus_enc_putbit(pstr_bitstream, 0, 1); /* copyr. id. bit */ |
| ia_enhaacplus_enc_putbit(pstr_bitstream, 0, 1); /* copyr. id. start */ |
| ia_enhaacplus_enc_putbit(pstr_bitstream, /*aacStateStruct->*/ bytes_used + 7, 13); |
| ia_enhaacplus_enc_putbit(pstr_bitstream, 0x7FF, 11); /* buffer fullness (0x7FF for VBR) */ |
| |
| ia_enhaacplus_enc_putbit(pstr_bitstream, 0, 2); /* raw data blocks (0+1=1) */ |
| } |
| |
| /* |
| * MPEG2 says byte_aligment() here, but ADTS always is multiple of 8 bits |
| * MPEG4 has no byte_alignment() here |
| */ |
| return bits / 8; |
| } |
