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 <string.h> 21 #include "ixheaacd_sbr_common.h" 22 #include <ixheaacd_type_def.h> 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_bitbuffer.h" 29 30 #include <ixheaacd_basic_op.h> 31 #include "ixheaacd_intrinsics.h" 32 33 #include "ixheaacd_defines.h" 34 35 #include "ixheaacd_aac_rom.h" 36 37 #include "ixheaacd_definitions.h" 38 39 #include "ixheaacd_error_codes.h" 40 41 #include "ixheaacd_pulsedata.h" 42 43 #include "ixheaacd_pns.h" 44 #include "ixheaacd_drc_data_struct.h" 45 46 #include "ixheaacd_lt_predict.h" 47 48 #include "ixheaacd_channelinfo.h" 49 #include "ixheaacd_drc_dec.h" 50 #include "ixheaacd_sbrdecoder.h" 51 #include "ixheaacd_block.h" 52 #include "ixheaacd_channel.h" 53 54 #include "ixheaacd_sbr_payload.h" 55 #include "ixheaacd_common_rom.h" 56 57 #include <ixheaacd_type_def.h> 58 59 #include "ixheaacd_sbrdecsettings.h" 60 #include "ixheaacd_sbr_scale.h" 61 #include "ixheaacd_env_extr_part.h" 62 #include "ixheaacd_sbr_rom.h" 63 #include "ixheaacd_stereo.h" 64 #include "ixheaacd_lpp_tran.h" 65 #include "ixheaacd_hybrid.h" 66 #include "ixheaacd_ps_dec.h" 67 68 #include "ixheaacd_env_extr.h" 69 #include "ixheaacd_adts.h" 70 #include "ixheaacd_audioobjtypes.h" 71 #include "ixheaacd_memory_standards.h" 72 73 #include "ixheaacd_latmdemux.h" 74 75 #include "ixheaacd_aacdec.h" 76 #include "ixheaacd_config.h" 77 #include "ixheaacd_mps_polyphase.h" 78 #include "ixheaacd_mps_dec.h" 79 #include "ixheaacd_struct_def.h" 80 81 #include "ixheaacd_multichannel.h" 82 #include "ixheaacd_headerdecode.h" 83 #include "ixheaacd_error_standards.h" 84 85 WORD32 ixheaacd_latm_au_chunk_length_info( 86 struct ia_bit_buf_struct *it_bit_buff) { 87 UWORD8 reading_done; 88 WORD32 len = 0; 89 90 do { 91 UWORD32 tmp = ixheaacd_read_bits_buf(it_bit_buff, 8); 92 reading_done = (tmp < 255); 93 94 len += tmp; 95 96 } while (reading_done == 0); 97 98 len <<= 3; 99 100 return len; 101 } 102 103 WORD32 ixheaacd_latm_payload_length_info(struct ia_bit_buf_struct *it_bit_buff, 104 ixheaacd_latm_struct *latm_element) { 105 WORD32 error_code = AAC_DEC_OK; 106 UWORD32 prog, lay; 107 108 if (latm_element->all_streams_same_time_framing == 1) { 109 for (prog = 0; prog < latm_element->num_program; prog++) { 110 for (lay = 0; lay < latm_element->num_layer; lay++) { 111 ixheaacd_latm_layer_info *layer_info = 112 &latm_element->layer_info[prog][lay]; 113 114 switch (layer_info->frame_len_type) { 115 case 0: 116 layer_info->frame_len_bits = 117 ixheaacd_latm_au_chunk_length_info(it_bit_buff); 118 if (layer_info->frame_len_bits % 8 != 0) { 119 error_code = IA_ENHAACPLUS_DEC_EXE_FATAL_INVALID_LOAS_HEADER; 120 return error_code; 121 } 122 123 latm_element->frame_length = layer_info->frame_len_bits >> 3; 124 latm_element->frame_length += 125 (it_bit_buff->size - it_bit_buff->cnt_bits) >> 3; 126 break; 127 128 default: 129 error_code = IA_ENHAACPLUS_DEC_EXE_FATAL_INVALID_LOAS_HEADER; 130 return error_code; 131 } 132 } 133 } 134 } else { 135 error_code = IA_ENHAACPLUS_DEC_EXE_FATAL_INVALID_LOAS_HEADER; 136 return error_code; 137 } 138 139 return (error_code); 140 } 141 142 static UWORD32 ixheaacd_latm_get_value(ia_bit_buf_struct *it_bit_buff) { 143 UWORD32 bytes_read; 144 145 bytes_read = ixheaacd_read_bits_buf(it_bit_buff, 2) + 1; 146 147 if (bytes_read <= 3) 148 return ixheaacd_read_bits_buf(it_bit_buff, 8 * bytes_read); 149 else 150 return (ixheaacd_read_bits_buf(it_bit_buff, 24) << 8) + 151 ixheaacd_read_bits_buf(it_bit_buff, 8); 152 } 153 154 IA_ERRORCODE ixheaacd_latm_stream_mux_config( 155 struct ia_bit_buf_struct *it_bit_buff, ixheaacd_latm_struct *latm_element, 156 ia_aac_dec_state_struct *aac_state_struct, 157 ia_sampling_rate_info_struct *sample_rate_info) { 158 UWORD32 prog; 159 UWORD32 lay; 160 WORD32 bytes_consumed; 161 WORD32 audio_mux_version_a; 162 UWORD32 tara_buf_fullness; 163 IA_ERRORCODE error_code = AAC_DEC_OK; 164 ixheaacd_latm_layer_info *layer_info = 0; 165 166 latm_element->audio_mux_version = ixheaacd_read_bits_buf(it_bit_buff, 1); 167 168 if (latm_element->audio_mux_version == 1) 169 audio_mux_version_a = ixheaacd_read_bits_buf(it_bit_buff, 1); 170 else 171 audio_mux_version_a = 0; 172 173 if (audio_mux_version_a == 0) { 174 if (latm_element->audio_mux_version == 1) { 175 tara_buf_fullness = ixheaacd_latm_get_value(it_bit_buff); 176 } 177 latm_element->all_streams_same_time_framing = 178 ixheaacd_read_bits_buf(it_bit_buff, 1); 179 180 latm_element->num_sub_frames = ixheaacd_read_bits_buf(it_bit_buff, 6) + 1; 181 182 if (latm_element->num_sub_frames != 1) 183 return IA_ENHAACPLUS_DEC_EXE_FATAL_INVALID_LOAS_HEADER; 184 185 latm_element->num_program = ixheaacd_read_bits_buf(it_bit_buff, 4) + 1; 186 187 if (latm_element->num_program > LATM_MAX_PROG) return IA_FATAL_ERROR; 188 189 for (prog = 0; prog < latm_element->num_program; prog++) { 190 latm_element->num_layer = ixheaacd_read_bits_buf(it_bit_buff, 3) + 1; 191 192 for (lay = 0; lay < latm_element->num_layer; lay++) { 193 layer_info = &latm_element->layer_info[prog][lay]; 194 layer_info->frame_len_bits = 0; 195 196 if ((prog == 0) && (lay == 0)) { 197 WORD32 asc_len, pos; 198 199 latm_element->use_same_config = 0; 200 201 asc_len = (latm_element->audio_mux_version == 1) 202 ? ixheaacd_latm_get_value(it_bit_buff) 203 : 0; 204 pos = it_bit_buff->size - it_bit_buff->cnt_bits; 205 206 if (asc_len > it_bit_buff->size - 106 || asc_len > 2592 || 207 asc_len < 0) { 208 return IA_ENHAACPLUS_DEC_INIT_FATAL_DEC_INIT_FAIL; 209 } 210 211 if ((error_code = ixheaacd_ga_hdr_dec( 212 aac_state_struct, it_bit_buff->cnt_bits, &bytes_consumed, 213 sample_rate_info, it_bit_buff))) 214 return (error_code); 215 216 if (asc_len) { 217 asc_len -= (it_bit_buff->size - it_bit_buff->cnt_bits) - pos; 218 ixheaacd_read_bidirection(it_bit_buff, asc_len); 219 } 220 221 layer_info->asc.aot = aac_state_struct->audio_object_type; 222 layer_info->asc.channel_config = aac_state_struct->ch_config; 223 layer_info->asc.samples_per_frame = aac_state_struct->frame_len_flag; 224 layer_info->asc.sampling_freq = aac_state_struct->sampling_rate; 225 layer_info->asc.samples_per_frame = aac_state_struct->frame_length; 226 } else { 227 latm_element->use_same_config = 228 ixheaacd_read_bits_buf(it_bit_buff, 1); 229 230 if (latm_element->use_same_config && (lay > 0)) { 231 layer_info->asc = latm_element->layer_info[prog][lay - 1].asc; 232 } else { 233 if ((error_code = ixheaacd_ga_hdr_dec( 234 aac_state_struct, it_bit_buff->cnt_bits, &bytes_consumed, 235 sample_rate_info, it_bit_buff))) 236 return (error_code); 237 } 238 } 239 240 layer_info->frame_len_type = ixheaacd_read_bits_buf(it_bit_buff, 3); 241 242 switch (layer_info->frame_len_type) { 243 case 0: 244 layer_info->buffer_fullness = 245 ixheaacd_read_bits_buf(it_bit_buff, 8); 246 247 if (!latm_element->all_streams_same_time_framing) { 248 if ((lay > 0) && layer_info->asc.aot == AOT_AAC_SCAL) { 249 } 250 } 251 break; 252 253 default: 254 return IA_ENHAACPLUS_DEC_EXE_FATAL_INVALID_LOAS_HEADER; 255 } 256 } 257 } 258 259 latm_element->other_data_present = ixheaacd_read_bits_buf(it_bit_buff, 1); 260 261 if (latm_element->other_data_present) { 262 if (latm_element->audio_mux_version == 1) { 263 latm_element->other_data_length = ixheaacd_latm_get_value(it_bit_buff); 264 } else { 265 UWORD32 other_data_len; 266 latm_element->other_data_length = 0; 267 do { 268 other_data_len = ixheaacd_read_bits_buf(it_bit_buff, 1); 269 latm_element->other_data_length <<= 8; 270 latm_element->other_data_length += 271 ixheaacd_read_bits_buf(it_bit_buff, 8); 272 if (latm_element->other_data_length > (UWORD32)it_bit_buff->cnt_bits) 273 return IA_FATAL_ERROR; 274 } while (other_data_len); 275 } 276 } 277 278 latm_element->crc_check_present = ixheaacd_read_bits_buf(it_bit_buff, 1); 279 280 if (latm_element->crc_check_present) { 281 latm_element->crc_check_sum = ixheaacd_read_bits_buf(it_bit_buff, 8); 282 } 283 } else { 284 error_code = IA_ENHAACPLUS_DEC_EXE_FATAL_INVALID_LOAS_HEADER; 285 } 286 return (error_code); 287 } 288 289 IA_ERRORCODE ixheaacd_latm_audio_mux_element( 290 struct ia_bit_buf_struct *it_bit_buff, ixheaacd_latm_struct *latm_element, 291 ia_aac_dec_state_struct *aac_state_struct, 292 ia_sampling_rate_info_struct *sample_rate_info) { 293 UWORD32 i; 294 IA_ERRORCODE error_code = AAC_DEC_OK; 295 296 ixheaacd_read_bits_buf(it_bit_buff, 13); 297 298 latm_element->use_same_stream_mux = ixheaacd_read_bits_buf(it_bit_buff, 1); 299 300 if (!latm_element->use_same_stream_mux) { 301 if ((error_code = ixheaacd_latm_stream_mux_config( 302 it_bit_buff, latm_element, aac_state_struct, sample_rate_info))) { 303 return (error_code); 304 } 305 } 306 307 for (i = 0; i < latm_element->num_sub_frames; i++) { 308 if ((error_code = 309 ixheaacd_latm_payload_length_info(it_bit_buff, latm_element))) { 310 if (error_code != 0) return (error_code); 311 } 312 } 313 314 return (error_code); 315 } 316
