X-Git-Url: https://git.sesse.net/?a=blobdiff_plain;f=libavcodec%2Faac.c;h=c4636015a7ead4d7dbc9d3452857899af7073a57;hb=0fb49b597be60efb84bb39c09576baecc1471eeb;hp=25c74b8157cd50180245512d32f8d1a2a6e60ccd;hpb=7d485f165f7f6313002da1fe67c2742f0fbb16c9;p=ffmpeg diff --git a/libavcodec/aac.c b/libavcodec/aac.c index 25c74b8157c..c4636015a7e 100644 --- a/libavcodec/aac.c +++ b/libavcodec/aac.c @@ -62,7 +62,7 @@ * N MIDI * N Harmonic and Individual Lines plus Noise * N Text-To-Speech Interface - * N (in progress) Spectral Band Replication + * Y Spectral Band Replication * Y (not in this code) Layer-1 * Y (not in this code) Layer-2 * Y (not in this code) Layer-3 @@ -80,11 +80,15 @@ #include "internal.h" #include "get_bits.h" #include "dsputil.h" +#include "fft.h" #include "lpc.h" #include "aac.h" #include "aactab.h" #include "aacdectab.h" +#include "cbrt_tablegen.h" +#include "sbr.h" +#include "aacsbr.h" #include "mpeg4audio.h" #include "aac_parser.h" @@ -93,14 +97,22 @@ #include #include -union float754 { float f; uint32_t i; }; +#if ARCH_ARM +# include "arm/aac.h" +#endif + +union float754 { + float f; + uint32_t i; +}; static VLC vlc_scalefactors; static VLC vlc_spectral[11]; +static const char overread_err[] = "Input buffer exhausted before END element found\n"; -static ChannelElement* get_che(AACContext *ac, int type, int elem_id) { - static const int8_t tags_per_config[16] = { 0, 1, 1, 2, 3, 3, 4, 5, 0, 0, 0, 0, 0, 0, 0, 0 }; +static ChannelElement *get_che(AACContext *ac, int type, int elem_id) +{ if (ac->tag_che_map[type][elem_id]) { return ac->tag_che_map[type][elem_id]; } @@ -108,45 +120,80 @@ static ChannelElement* get_che(AACContext *ac, int type, int elem_id) { return NULL; } switch (ac->m4ac.chan_config) { - case 7: - if (ac->tags_mapped == 3 && type == TYPE_CPE) { - ac->tags_mapped++; - return ac->tag_che_map[TYPE_CPE][elem_id] = ac->che[TYPE_CPE][2]; - } - case 6: - /* Some streams incorrectly code 5.1 audio as SCE[0] CPE[0] CPE[1] SCE[1] - instead of SCE[0] CPE[0] CPE[0] LFE[0]. If we seem to have - encountered such a stream, transfer the LFE[0] element to SCE[1] */ - if (ac->tags_mapped == tags_per_config[ac->m4ac.chan_config] - 1 && (type == TYPE_LFE || type == TYPE_SCE)) { - ac->tags_mapped++; - return ac->tag_che_map[type][elem_id] = ac->che[TYPE_LFE][0]; - } - case 5: - if (ac->tags_mapped == 2 && type == TYPE_CPE) { - ac->tags_mapped++; - return ac->tag_che_map[TYPE_CPE][elem_id] = ac->che[TYPE_CPE][1]; - } - case 4: - if (ac->tags_mapped == 2 && ac->m4ac.chan_config == 4 && type == TYPE_SCE) { - ac->tags_mapped++; - return ac->tag_che_map[TYPE_SCE][elem_id] = ac->che[TYPE_SCE][1]; - } - case 3: - case 2: - if (ac->tags_mapped == (ac->m4ac.chan_config != 2) && type == TYPE_CPE) { - ac->tags_mapped++; - return ac->tag_che_map[TYPE_CPE][elem_id] = ac->che[TYPE_CPE][0]; - } else if (ac->m4ac.chan_config == 2) { - return NULL; - } - case 1: - if (!ac->tags_mapped && type == TYPE_SCE) { - ac->tags_mapped++; - return ac->tag_che_map[TYPE_SCE][elem_id] = ac->che[TYPE_SCE][0]; - } - default: + case 7: + if (ac->tags_mapped == 3 && type == TYPE_CPE) { + ac->tags_mapped++; + return ac->tag_che_map[TYPE_CPE][elem_id] = ac->che[TYPE_CPE][2]; + } + case 6: + /* Some streams incorrectly code 5.1 audio as SCE[0] CPE[0] CPE[1] SCE[1] + instead of SCE[0] CPE[0] CPE[0] LFE[0]. If we seem to have + encountered such a stream, transfer the LFE[0] element to SCE[1] */ + if (ac->tags_mapped == tags_per_config[ac->m4ac.chan_config] - 1 && (type == TYPE_LFE || type == TYPE_SCE)) { + ac->tags_mapped++; + return ac->tag_che_map[type][elem_id] = ac->che[TYPE_LFE][0]; + } + case 5: + if (ac->tags_mapped == 2 && type == TYPE_CPE) { + ac->tags_mapped++; + return ac->tag_che_map[TYPE_CPE][elem_id] = ac->che[TYPE_CPE][1]; + } + case 4: + if (ac->tags_mapped == 2 && ac->m4ac.chan_config == 4 && type == TYPE_SCE) { + ac->tags_mapped++; + return ac->tag_che_map[TYPE_SCE][elem_id] = ac->che[TYPE_SCE][1]; + } + case 3: + case 2: + if (ac->tags_mapped == (ac->m4ac.chan_config != 2) && type == TYPE_CPE) { + ac->tags_mapped++; + return ac->tag_che_map[TYPE_CPE][elem_id] = ac->che[TYPE_CPE][0]; + } else if (ac->m4ac.chan_config == 2) { return NULL; + } + case 1: + if (!ac->tags_mapped && type == TYPE_SCE) { + ac->tags_mapped++; + return ac->tag_che_map[TYPE_SCE][elem_id] = ac->che[TYPE_SCE][0]; + } + default: + return NULL; + } +} + +/** + * Check for the channel element in the current channel position configuration. + * If it exists, make sure the appropriate element is allocated and map the + * channel order to match the internal FFmpeg channel layout. + * + * @param che_pos current channel position configuration + * @param type channel element type + * @param id channel element id + * @param channels count of the number of channels in the configuration + * + * @return Returns error status. 0 - OK, !0 - error + */ +static av_cold int che_configure(AACContext *ac, + enum ChannelPosition che_pos[4][MAX_ELEM_ID], + int type, int id, + int *channels) +{ + if (che_pos[type][id]) { + if (!ac->che[type][id] && !(ac->che[type][id] = av_mallocz(sizeof(ChannelElement)))) + return AVERROR(ENOMEM); + ff_aac_sbr_ctx_init(&ac->che[type][id]->sbr); + if (type != TYPE_CCE) { + ac->output_data[(*channels)++] = ac->che[type][id]->ch[0].ret; + if (type == TYPE_CPE) { + ac->output_data[(*channels)++] = ac->che[type][id]->ch[1].ret; + } + } + } else { + if (ac->che[type][id]) + ff_aac_sbr_ctx_close(&ac->che[type][id]->sbr); + av_freep(&ac->che[type][id]); } + return 0; } /** @@ -157,48 +204,56 @@ static ChannelElement* get_che(AACContext *ac, int type, int elem_id) { * * @return Returns error status. 0 - OK, !0 - error */ -static int output_configure(AACContext *ac, enum ChannelPosition che_pos[4][MAX_ELEM_ID], - enum ChannelPosition new_che_pos[4][MAX_ELEM_ID], int channel_config) { +static av_cold int output_configure(AACContext *ac, + enum ChannelPosition che_pos[4][MAX_ELEM_ID], + enum ChannelPosition new_che_pos[4][MAX_ELEM_ID], + int channel_config, enum OCStatus oc_type) +{ AVCodecContext *avctx = ac->avccontext; - int i, type, channels = 0; + int i, type, channels = 0, ret; memcpy(che_pos, new_che_pos, 4 * MAX_ELEM_ID * sizeof(new_che_pos[0][0])); - /* Allocate or free elements depending on if they are in the - * current program configuration. - * - * Set up default 1:1 output mapping. - * - * For a 5.1 stream the output order will be: - * [ Center ] [ Front Left ] [ Front Right ] [ LFE ] [ Surround Left ] [ Surround Right ] - */ - - for(i = 0; i < MAX_ELEM_ID; i++) { - for(type = 0; type < 4; type++) { - if(che_pos[type][i]) { - if(!ac->che[type][i] && !(ac->che[type][i] = av_mallocz(sizeof(ChannelElement)))) - return AVERROR(ENOMEM); - if(type != TYPE_CCE) { - ac->output_data[channels++] = ac->che[type][i]->ch[0].ret; - if(type == TYPE_CPE) { - ac->output_data[channels++] = ac->che[type][i]->ch[1].ret; - } - } - } else - av_freep(&ac->che[type][i]); + if (channel_config) { + for (i = 0; i < tags_per_config[channel_config]; i++) { + if ((ret = che_configure(ac, che_pos, + aac_channel_layout_map[channel_config - 1][i][0], + aac_channel_layout_map[channel_config - 1][i][1], + &channels))) + return ret; } - } - if (channel_config) { memset(ac->tag_che_map, 0, 4 * MAX_ELEM_ID * sizeof(ac->che[0][0])); ac->tags_mapped = 0; + + avctx->channel_layout = aac_channel_layout[channel_config - 1]; } else { + /* Allocate or free elements depending on if they are in the + * current program configuration. + * + * Set up default 1:1 output mapping. + * + * For a 5.1 stream the output order will be: + * [ Center ] [ Front Left ] [ Front Right ] [ LFE ] [ Surround Left ] [ Surround Right ] + */ + + for (i = 0; i < MAX_ELEM_ID; i++) { + for (type = 0; type < 4; type++) { + if ((ret = che_configure(ac, che_pos, type, i, &channels))) + return ret; + } + } + memcpy(ac->tag_che_map, ac->che, 4 * MAX_ELEM_ID * sizeof(ac->che[0][0])); - ac->tags_mapped = 4*MAX_ELEM_ID; + ac->tags_mapped = 4 * MAX_ELEM_ID; + + avctx->channel_layout = 0; } avctx->channels = channels; + ac->output_configured = oc_type; + return 0; } @@ -210,8 +265,11 @@ static int output_configure(AACContext *ac, enum ChannelPosition che_pos[4][MAX_ * @param type speaker type/position for these channels */ static void decode_channel_map(enum ChannelPosition *cpe_map, - enum ChannelPosition *sce_map, enum ChannelPosition type, GetBitContext * gb, int n) { - while(n--) { + enum ChannelPosition *sce_map, + enum ChannelPosition type, + GetBitContext *gb, int n) +{ + while (n--) { enum ChannelPosition *map = cpe_map && get_bits1(gb) ? cpe_map : sce_map; // stereo or mono map map[get_bits(gb, 4)] = type; } @@ -224,19 +282,18 @@ static void decode_channel_map(enum ChannelPosition *cpe_map, * * @return Returns error status. 0 - OK, !0 - error */ -static int decode_pce(AACContext * ac, enum ChannelPosition new_che_pos[4][MAX_ELEM_ID], - GetBitContext * gb) { +static int decode_pce(AACContext *ac, enum ChannelPosition new_che_pos[4][MAX_ELEM_ID], + GetBitContext *gb) +{ int num_front, num_side, num_back, num_lfe, num_assoc_data, num_cc, sampling_index; + int comment_len; skip_bits(gb, 2); // object_type sampling_index = get_bits(gb, 4); - if(sampling_index > 12) { - av_log(ac->avccontext, AV_LOG_ERROR, "invalid sampling rate index %d\n", ac->m4ac.sampling_index); - return -1; - } - ac->m4ac.sampling_index = sampling_index; - ac->m4ac.sample_rate = ff_mpeg4audio_sample_rates[ac->m4ac.sampling_index]; + if (ac->m4ac.sampling_index != sampling_index) + av_log(ac->avccontext, AV_LOG_WARNING, "Sample rate index in program config element does not match the sample rate index configured by the container.\n"); + num_front = get_bits(gb, 4); num_side = get_bits(gb, 4); num_back = get_bits(gb, 4); @@ -264,7 +321,12 @@ static int decode_pce(AACContext * ac, enum ChannelPosition new_che_pos[4][MAX_E align_get_bits(gb); /* comment field, first byte is length */ - skip_bits_long(gb, 8 * get_bits(gb, 8)); + comment_len = get_bits(gb, 8) * 8; + if (get_bits_left(gb) < comment_len) { + av_log(ac->avccontext, AV_LOG_ERROR, overread_err); + return -1; + } + skip_bits_long(gb, comment_len); return 0; } @@ -276,10 +338,11 @@ static int decode_pce(AACContext * ac, enum ChannelPosition new_che_pos[4][MAX_E * * @return Returns error status. 0 - OK, !0 - error */ -static int set_default_channel_config(AACContext *ac, enum ChannelPosition new_che_pos[4][MAX_ELEM_ID], - int channel_config) +static av_cold int set_default_channel_config(AACContext *ac, + enum ChannelPosition new_che_pos[4][MAX_ELEM_ID], + int channel_config) { - if(channel_config < 1 || channel_config > 7) { + if (channel_config < 1 || channel_config > 7) { av_log(ac->avccontext, AV_LOG_ERROR, "invalid default channel configuration (%d)\n", channel_config); return -1; @@ -296,18 +359,18 @@ static int set_default_channel_config(AACContext *ac, enum ChannelPosition new_c * 7ch : front center + L + R + outer front left + outer front right + back stereo + LFE */ - if(channel_config != 2) + if (channel_config != 2) new_che_pos[TYPE_SCE][0] = AAC_CHANNEL_FRONT; // front center (or mono) - if(channel_config > 1) + if (channel_config > 1) new_che_pos[TYPE_CPE][0] = AAC_CHANNEL_FRONT; // L + R (or stereo) - if(channel_config == 4) + if (channel_config == 4) new_che_pos[TYPE_SCE][1] = AAC_CHANNEL_BACK; // back center - if(channel_config > 4) + if (channel_config > 4) new_che_pos[TYPE_CPE][(channel_config == 7) + 1] - = AAC_CHANNEL_BACK; // back stereo - if(channel_config > 5) + = AAC_CHANNEL_BACK; // back stereo + if (channel_config > 5) new_che_pos[TYPE_LFE][0] = AAC_CHANNEL_LFE; // LFE - if(channel_config == 7) + if (channel_config == 7) new_che_pos[TYPE_CPE][1] = AAC_CHANNEL_FRONT; // outer front left + outer front right return 0; @@ -318,12 +381,14 @@ static int set_default_channel_config(AACContext *ac, enum ChannelPosition new_c * * @return Returns error status. 0 - OK, !0 - error */ -static int decode_ga_specific_config(AACContext * ac, GetBitContext * gb, int channel_config) { +static int decode_ga_specific_config(AACContext *ac, GetBitContext *gb, + int channel_config) +{ enum ChannelPosition new_che_pos[4][MAX_ELEM_ID]; int extension_flag, ret; - if(get_bits1(gb)) { // frameLengthFlag - ff_log_missing_feature(ac->avccontext, "960/120 MDCT window is", 1); + if (get_bits1(gb)) { // frameLengthFlag + av_log_missing_feature(ac->avccontext, "960/120 MDCT window is", 1); return -1; } @@ -331,37 +396,37 @@ static int decode_ga_specific_config(AACContext * ac, GetBitContext * gb, int ch skip_bits(gb, 14); // coreCoderDelay extension_flag = get_bits1(gb); - if(ac->m4ac.object_type == AOT_AAC_SCALABLE || - ac->m4ac.object_type == AOT_ER_AAC_SCALABLE) + if (ac->m4ac.object_type == AOT_AAC_SCALABLE || + ac->m4ac.object_type == AOT_ER_AAC_SCALABLE) skip_bits(gb, 3); // layerNr memset(new_che_pos, 0, 4 * MAX_ELEM_ID * sizeof(new_che_pos[0][0])); if (channel_config == 0) { skip_bits(gb, 4); // element_instance_tag - if((ret = decode_pce(ac, new_che_pos, gb))) + if ((ret = decode_pce(ac, new_che_pos, gb))) return ret; } else { - if((ret = set_default_channel_config(ac, new_che_pos, channel_config))) + if ((ret = set_default_channel_config(ac, new_che_pos, channel_config))) return ret; } - if((ret = output_configure(ac, ac->che_pos, new_che_pos, channel_config))) + if ((ret = output_configure(ac, ac->che_pos, new_che_pos, channel_config, OC_GLOBAL_HDR))) return ret; if (extension_flag) { switch (ac->m4ac.object_type) { - case AOT_ER_BSAC: - skip_bits(gb, 5); // numOfSubFrame - skip_bits(gb, 11); // layer_length - break; - case AOT_ER_AAC_LC: - case AOT_ER_AAC_LTP: - case AOT_ER_AAC_SCALABLE: - case AOT_ER_AAC_LD: - skip_bits(gb, 3); /* aacSectionDataResilienceFlag + case AOT_ER_BSAC: + skip_bits(gb, 5); // numOfSubFrame + skip_bits(gb, 11); // layer_length + break; + case AOT_ER_AAC_LC: + case AOT_ER_AAC_LTP: + case AOT_ER_AAC_SCALABLE: + case AOT_ER_AAC_LD: + skip_bits(gb, 3); /* aacSectionDataResilienceFlag * aacScalefactorDataResilienceFlag * aacSpectralDataResilienceFlag */ - break; + break; } skip_bits1(gb); // extensionFlag3 (TBD in version 3) } @@ -376,15 +441,17 @@ static int decode_ga_specific_config(AACContext * ac, GetBitContext * gb, int ch * * @return Returns error status. 0 - OK, !0 - error */ -static int decode_audio_specific_config(AACContext * ac, void *data, int data_size) { +static int decode_audio_specific_config(AACContext *ac, void *data, + int data_size) +{ GetBitContext gb; int i; init_get_bits(&gb, data, data_size * 8); - if((i = ff_mpeg4audio_get_config(&ac->m4ac, data, data_size)) < 0) + if ((i = ff_mpeg4audio_get_config(&ac->m4ac, data, data_size)) < 0) return -1; - if(ac->m4ac.sampling_index > 12) { + if (ac->m4ac.sampling_index > 12) { av_log(ac->avccontext, AV_LOG_ERROR, "invalid sampling rate index %d\n", ac->m4ac.sampling_index); return -1; } @@ -412,65 +479,63 @@ static int decode_audio_specific_config(AACContext * ac, void *data, int data_si * * @return Returns a 32-bit pseudorandom integer */ -static av_always_inline int lcg_random(int previous_val) { +static av_always_inline int lcg_random(int previous_val) +{ return previous_val * 1664525 + 1013904223; } -static void reset_predict_state(PredictorState * ps) { - ps->r0 = 0.0f; - ps->r1 = 0.0f; +static av_always_inline void reset_predict_state(PredictorState *ps) +{ + ps->r0 = 0.0f; + ps->r1 = 0.0f; ps->cor0 = 0.0f; ps->cor1 = 0.0f; ps->var0 = 1.0f; ps->var1 = 1.0f; } -static void reset_all_predictors(PredictorState * ps) { +static void reset_all_predictors(PredictorState *ps) +{ int i; for (i = 0; i < MAX_PREDICTORS; i++) reset_predict_state(&ps[i]); } -static void reset_predictor_group(PredictorState * ps, int group_num) { +static void reset_predictor_group(PredictorState *ps, int group_num) +{ int i; - for (i = group_num-1; i < MAX_PREDICTORS; i+=30) + for (i = group_num - 1; i < MAX_PREDICTORS; i += 30) reset_predict_state(&ps[i]); } -static av_cold int aac_decode_init(AVCodecContext * avccontext) { - AACContext * ac = avccontext->priv_data; +static av_cold int aac_decode_init(AVCodecContext *avccontext) +{ + AACContext *ac = avccontext->priv_data; int i; ac->avccontext = avccontext; + ac->m4ac.sample_rate = avccontext->sample_rate; if (avccontext->extradata_size > 0) { - if(decode_audio_specific_config(ac, avccontext->extradata, avccontext->extradata_size)) + if (decode_audio_specific_config(ac, avccontext->extradata, avccontext->extradata_size)) return -1; - avccontext->sample_rate = ac->m4ac.sample_rate; - } else if (avccontext->channels > 0) { - enum ChannelPosition new_che_pos[4][MAX_ELEM_ID]; - memset(new_che_pos, 0, 4 * MAX_ELEM_ID * sizeof(new_che_pos[0][0])); - if(set_default_channel_config(ac, new_che_pos, avccontext->channels - (avccontext->channels == 8))) - return -1; - if(output_configure(ac, ac->che_pos, new_che_pos, 1)) - return -1; - ac->m4ac.sample_rate = avccontext->sample_rate; } - avccontext->sample_fmt = SAMPLE_FMT_S16; - avccontext->frame_size = 1024; - - AAC_INIT_VLC_STATIC( 0, 144); - AAC_INIT_VLC_STATIC( 1, 114); - AAC_INIT_VLC_STATIC( 2, 188); - AAC_INIT_VLC_STATIC( 3, 180); - AAC_INIT_VLC_STATIC( 4, 172); - AAC_INIT_VLC_STATIC( 5, 140); - AAC_INIT_VLC_STATIC( 6, 168); - AAC_INIT_VLC_STATIC( 7, 114); - AAC_INIT_VLC_STATIC( 8, 262); - AAC_INIT_VLC_STATIC( 9, 248); - AAC_INIT_VLC_STATIC(10, 384); + avccontext->sample_fmt = SAMPLE_FMT_S16; + + AAC_INIT_VLC_STATIC( 0, 304); + AAC_INIT_VLC_STATIC( 1, 270); + AAC_INIT_VLC_STATIC( 2, 550); + AAC_INIT_VLC_STATIC( 3, 300); + AAC_INIT_VLC_STATIC( 4, 328); + AAC_INIT_VLC_STATIC( 5, 294); + AAC_INIT_VLC_STATIC( 6, 306); + AAC_INIT_VLC_STATIC( 7, 268); + AAC_INIT_VLC_STATIC( 8, 510); + AAC_INIT_VLC_STATIC( 9, 366); + AAC_INIT_VLC_STATIC(10, 462); + + ff_aac_sbr_init(); dsputil_init(&ac->dsp, avccontext); @@ -480,33 +545,35 @@ static av_cold int aac_decode_init(AVCodecContext * avccontext) { // 32768 - Required to scale values to the correct range for the bias method // for float to int16 conversion. - if(ac->dsp.float_to_int16 == ff_float_to_int16_c) { - ac->add_bias = 385.0f; - ac->sf_scale = 1. / (-1024. * 32768.); + if (ac->dsp.float_to_int16_interleave == ff_float_to_int16_interleave_c) { + ac->add_bias = 385.0f; + ac->sf_scale = 1. / (-1024. * 32768.); ac->sf_offset = 0; } else { - ac->add_bias = 0.0f; - ac->sf_scale = 1. / -1024.; + ac->add_bias = 0.0f; + ac->sf_scale = 1. / -1024.; ac->sf_offset = 60; } #if !CONFIG_HARDCODED_TABLES for (i = 0; i < 428; i++) - ff_aac_pow2sf_tab[i] = pow(2, (i - 200)/4.); + ff_aac_pow2sf_tab[i] = pow(2, (i - 200) / 4.); #endif /* CONFIG_HARDCODED_TABLES */ INIT_VLC_STATIC(&vlc_scalefactors,7,FF_ARRAY_ELEMS(ff_aac_scalefactor_code), - ff_aac_scalefactor_bits, sizeof(ff_aac_scalefactor_bits[0]), sizeof(ff_aac_scalefactor_bits[0]), - ff_aac_scalefactor_code, sizeof(ff_aac_scalefactor_code[0]), sizeof(ff_aac_scalefactor_code[0]), - 352); + ff_aac_scalefactor_bits, sizeof(ff_aac_scalefactor_bits[0]), sizeof(ff_aac_scalefactor_bits[0]), + ff_aac_scalefactor_code, sizeof(ff_aac_scalefactor_code[0]), sizeof(ff_aac_scalefactor_code[0]), + 352); ff_mdct_init(&ac->mdct, 11, 1, 1.0); ff_mdct_init(&ac->mdct_small, 8, 1, 1.0); // window initialization ff_kbd_window_init(ff_aac_kbd_long_1024, 4.0, 1024); ff_kbd_window_init(ff_aac_kbd_short_128, 6.0, 128); - ff_sine_window_init(ff_sine_1024, 1024); - ff_sine_window_init(ff_sine_128, 128); + ff_init_ff_sine_windows(10); + ff_init_ff_sine_windows( 7); + + cbrt_tableinit(); return 0; } @@ -514,17 +581,26 @@ static av_cold int aac_decode_init(AVCodecContext * avccontext) { /** * Skip data_stream_element; reference: table 4.10. */ -static void skip_data_stream_element(GetBitContext * gb) { +static int skip_data_stream_element(AACContext *ac, GetBitContext *gb) +{ int byte_align = get_bits1(gb); int count = get_bits(gb, 8); if (count == 255) count += get_bits(gb, 8); if (byte_align) align_get_bits(gb); + + if (get_bits_left(gb) < 8 * count) { + av_log(ac->avccontext, AV_LOG_ERROR, overread_err); + return -1; + } skip_bits_long(gb, 8 * count); + return 0; } -static int decode_prediction(AACContext * ac, IndividualChannelStream * ics, GetBitContext * gb) { +static int decode_prediction(AACContext *ac, IndividualChannelStream *ics, + GetBitContext *gb) +{ int sfb; if (get_bits1(gb)) { ics->predictor_reset_group = get_bits(gb, 5); @@ -544,7 +620,9 @@ static int decode_prediction(AACContext * ac, IndividualChannelStream * ics, Get * * @param common_window Channels have independent [0], or shared [1], Individual Channel Stream information. */ -static int decode_ics_info(AACContext * ac, IndividualChannelStream * ics, GetBitContext * gb, int common_window) { +static int decode_ics_info(AACContext *ac, IndividualChannelStream *ics, + GetBitContext *gb, int common_window) +{ if (get_bits1(gb)) { av_log(ac->avccontext, AV_LOG_ERROR, "Reserved bit set.\n"); memset(ics, 0, sizeof(IndividualChannelStream)); @@ -552,33 +630,33 @@ static int decode_ics_info(AACContext * ac, IndividualChannelStream * ics, GetBi } ics->window_sequence[1] = ics->window_sequence[0]; ics->window_sequence[0] = get_bits(gb, 2); - ics->use_kb_window[1] = ics->use_kb_window[0]; - ics->use_kb_window[0] = get_bits1(gb); - ics->num_window_groups = 1; - ics->group_len[0] = 1; + ics->use_kb_window[1] = ics->use_kb_window[0]; + ics->use_kb_window[0] = get_bits1(gb); + ics->num_window_groups = 1; + ics->group_len[0] = 1; if (ics->window_sequence[0] == EIGHT_SHORT_SEQUENCE) { int i; ics->max_sfb = get_bits(gb, 4); for (i = 0; i < 7; i++) { if (get_bits1(gb)) { - ics->group_len[ics->num_window_groups-1]++; + ics->group_len[ics->num_window_groups - 1]++; } else { ics->num_window_groups++; - ics->group_len[ics->num_window_groups-1] = 1; + ics->group_len[ics->num_window_groups - 1] = 1; } } - ics->num_windows = 8; - ics->swb_offset = swb_offset_128[ac->m4ac.sampling_index]; - ics->num_swb = ff_aac_num_swb_128[ac->m4ac.sampling_index]; - ics->tns_max_bands = tns_max_bands_128[ac->m4ac.sampling_index]; + ics->num_windows = 8; + ics->swb_offset = ff_swb_offset_128[ac->m4ac.sampling_index]; + ics->num_swb = ff_aac_num_swb_128[ac->m4ac.sampling_index]; + ics->tns_max_bands = ff_tns_max_bands_128[ac->m4ac.sampling_index]; ics->predictor_present = 0; } else { - ics->max_sfb = get_bits(gb, 6); - ics->num_windows = 1; - ics->swb_offset = swb_offset_1024[ac->m4ac.sampling_index]; - ics->num_swb = ff_aac_num_swb_1024[ac->m4ac.sampling_index]; - ics->tns_max_bands = tns_max_bands_1024[ac->m4ac.sampling_index]; - ics->predictor_present = get_bits1(gb); + ics->max_sfb = get_bits(gb, 6); + ics->num_windows = 1; + ics->swb_offset = ff_swb_offset_1024[ac->m4ac.sampling_index]; + ics->num_swb = ff_aac_num_swb_1024[ac->m4ac.sampling_index]; + ics->tns_max_bands = ff_tns_max_bands_1024[ac->m4ac.sampling_index]; + ics->predictor_present = get_bits1(gb); ics->predictor_reset_group = 0; if (ics->predictor_present) { if (ac->m4ac.object_type == AOT_AAC_MAIN) { @@ -591,17 +669,17 @@ static int decode_ics_info(AACContext * ac, IndividualChannelStream * ics, GetBi memset(ics, 0, sizeof(IndividualChannelStream)); return -1; } else { - ff_log_missing_feature(ac->avccontext, "Predictor bit set but LTP is", 1); + av_log_missing_feature(ac->avccontext, "Predictor bit set but LTP is", 1); memset(ics, 0, sizeof(IndividualChannelStream)); return -1; } } } - if(ics->max_sfb > ics->num_swb) { + if (ics->max_sfb > ics->num_swb) { av_log(ac->avccontext, AV_LOG_ERROR, - "Number of scalefactor bands in group (%d) exceeds limit (%d).\n", - ics->max_sfb, ics->num_swb); + "Number of scalefactor bands in group (%d) exceeds limit (%d).\n", + ics->max_sfb, ics->num_swb); memset(ics, 0, sizeof(IndividualChannelStream)); return -1; } @@ -617,32 +695,38 @@ static int decode_ics_info(AACContext * ac, IndividualChannelStream * ics, GetBi * * @return Returns error status. 0 - OK, !0 - error */ -static int decode_band_types(AACContext * ac, enum BandType band_type[120], - int band_type_run_end[120], GetBitContext * gb, IndividualChannelStream * ics) { +static int decode_band_types(AACContext *ac, enum BandType band_type[120], + int band_type_run_end[120], GetBitContext *gb, + IndividualChannelStream *ics) +{ int g, idx = 0; const int bits = (ics->window_sequence[0] == EIGHT_SHORT_SEQUENCE) ? 3 : 5; for (g = 0; g < ics->num_window_groups; g++) { int k = 0; while (k < ics->max_sfb) { - uint8_t sect_len = k; + uint8_t sect_end = k; int sect_len_incr; int sect_band_type = get_bits(gb, 4); if (sect_band_type == 12) { av_log(ac->avccontext, AV_LOG_ERROR, "invalid band type\n"); return -1; } - while ((sect_len_incr = get_bits(gb, bits)) == (1 << bits)-1) - sect_len += sect_len_incr; - sect_len += sect_len_incr; - if (sect_len > ics->max_sfb) { + while ((sect_len_incr = get_bits(gb, bits)) == (1 << bits) - 1) + sect_end += sect_len_incr; + sect_end += sect_len_incr; + if (get_bits_left(gb) < 0) { + av_log(ac->avccontext, AV_LOG_ERROR, overread_err); + return -1; + } + if (sect_end > ics->max_sfb) { av_log(ac->avccontext, AV_LOG_ERROR, - "Number of bands (%d) exceeds limit (%d).\n", - sect_len, ics->max_sfb); + "Number of bands (%d) exceeds limit (%d).\n", + sect_end, ics->max_sfb); return -1; } - for (; k < sect_len; k++) { + for (; k < sect_end; k++) { band_type [idx] = sect_band_type; - band_type_run_end[idx++] = sect_len; + band_type_run_end[idx++] = sect_end; } } } @@ -659,9 +743,12 @@ static int decode_band_types(AACContext * ac, enum BandType band_type[120], * * @return Returns error status. 0 - OK, !0 - error */ -static int decode_scalefactors(AACContext * ac, float sf[120], GetBitContext * gb, - unsigned int global_gain, IndividualChannelStream * ics, - enum BandType band_type[120], int band_type_run_end[120]) { +static int decode_scalefactors(AACContext *ac, float sf[120], GetBitContext *gb, + unsigned int global_gain, + IndividualChannelStream *ics, + enum BandType band_type[120], + int band_type_run_end[120]) +{ const int sf_offset = ac->sf_offset + (ics->window_sequence[0] == EIGHT_SHORT_SEQUENCE ? 12 : 0); int g, i, idx = 0; int offset[3] = { global_gain, global_gain - 90, 100 }; @@ -671,37 +758,37 @@ static int decode_scalefactors(AACContext * ac, float sf[120], GetBitContext * g for (i = 0; i < ics->max_sfb;) { int run_end = band_type_run_end[idx]; if (band_type[idx] == ZERO_BT) { - for(; i < run_end; i++, idx++) + for (; i < run_end; i++, idx++) sf[idx] = 0.; - }else if((band_type[idx] == INTENSITY_BT) || (band_type[idx] == INTENSITY_BT2)) { - for(; i < run_end; i++, idx++) { + } else if ((band_type[idx] == INTENSITY_BT) || (band_type[idx] == INTENSITY_BT2)) { + for (; i < run_end; i++, idx++) { offset[2] += get_vlc2(gb, vlc_scalefactors.table, 7, 3) - 60; - if(offset[2] > 255U) { + if (offset[2] > 255U) { av_log(ac->avccontext, AV_LOG_ERROR, - "%s (%d) out of range.\n", sf_str[2], offset[2]); + "%s (%d) out of range.\n", sf_str[2], offset[2]); return -1; } - sf[idx] = ff_aac_pow2sf_tab[-offset[2] + 300]; + sf[idx] = ff_aac_pow2sf_tab[-offset[2] + 300]; } - }else if(band_type[idx] == NOISE_BT) { - for(; i < run_end; i++, idx++) { - if(noise_flag-- > 0) + } else if (band_type[idx] == NOISE_BT) { + for (; i < run_end; i++, idx++) { + if (noise_flag-- > 0) offset[1] += get_bits(gb, 9) - 256; else offset[1] += get_vlc2(gb, vlc_scalefactors.table, 7, 3) - 60; - if(offset[1] > 255U) { + if (offset[1] > 255U) { av_log(ac->avccontext, AV_LOG_ERROR, - "%s (%d) out of range.\n", sf_str[1], offset[1]); + "%s (%d) out of range.\n", sf_str[1], offset[1]); return -1; } - sf[idx] = -ff_aac_pow2sf_tab[ offset[1] + sf_offset + 100]; + sf[idx] = -ff_aac_pow2sf_tab[offset[1] + sf_offset + 100]; } - }else { - for(; i < run_end; i++, idx++) { + } else { + for (; i < run_end; i++, idx++) { offset[0] += get_vlc2(gb, vlc_scalefactors.table, 7, 3) - 60; - if(offset[0] > 255U) { + if (offset[0] > 255U) { av_log(ac->avccontext, AV_LOG_ERROR, - "%s (%d) out of range.\n", sf_str[0], offset[0]); + "%s (%d) out of range.\n", sf_str[0], offset[0]); return -1; } sf[idx] = -ff_aac_pow2sf_tab[ offset[0] + sf_offset]; @@ -715,7 +802,9 @@ static int decode_scalefactors(AACContext * ac, float sf[120], GetBitContext * g /** * Decode pulse data; reference: table 4.7. */ -static int decode_pulses(Pulse * pulse, GetBitContext * gb, const uint16_t * swb_offset, int num_swb) { +static int decode_pulses(Pulse *pulse, GetBitContext *gb, + const uint16_t *swb_offset, int num_swb) +{ int i, pulse_swb; pulse->num_pulse = get_bits(gb, 2) + 1; pulse_swb = get_bits(gb, 6); @@ -727,7 +816,7 @@ static int decode_pulses(Pulse * pulse, GetBitContext * gb, const uint16_t * swb return -1; pulse->amp[0] = get_bits(gb, 4); for (i = 1; i < pulse->num_pulse; i++) { - pulse->pos[i] = get_bits(gb, 5) + pulse->pos[i-1]; + pulse->pos[i] = get_bits(gb, 5) + pulse->pos[i - 1]; if (pulse->pos[i] > 1023) return -1; pulse->amp[i] = get_bits(gb, 4); @@ -740,8 +829,9 @@ static int decode_pulses(Pulse * pulse, GetBitContext * gb, const uint16_t * swb * * @return Returns error status. 0 - OK, !0 - error */ -static int decode_tns(AACContext * ac, TemporalNoiseShaping * tns, - GetBitContext * gb, const IndividualChannelStream * ics) { +static int decode_tns(AACContext *ac, TemporalNoiseShaping *tns, + GetBitContext *gb, const IndividualChannelStream *ics) +{ int w, filt, i, coef_len, coef_res, coef_compress; const int is8 = ics->window_sequence[0] == EIGHT_SHORT_SEQUENCE; const int tns_max_order = is8 ? 7 : ac->m4ac.object_type == AOT_AAC_MAIN ? 20 : 12; @@ -751,10 +841,10 @@ static int decode_tns(AACContext * ac, TemporalNoiseShaping * tns, for (filt = 0; filt < tns->n_filt[w]; filt++) { int tmp2_idx; - tns->length[w][filt] = get_bits(gb, 6 - 2*is8); + tns->length[w][filt] = get_bits(gb, 6 - 2 * is8); - if ((tns->order[w][filt] = get_bits(gb, 5 - 2*is8)) > tns_max_order) { - av_log(ac->avccontext, AV_LOG_ERROR, "TNS filter order %d is greater than maximum %d.", + if ((tns->order[w][filt] = get_bits(gb, 5 - 2 * is8)) > tns_max_order) { + av_log(ac->avccontext, AV_LOG_ERROR, "TNS filter order %d is greater than maximum %d.\n", tns->order[w][filt], tns_max_order); tns->order[w][filt] = 0; return -1; @@ -763,7 +853,7 @@ static int decode_tns(AACContext * ac, TemporalNoiseShaping * tns, tns->direction[w][filt] = get_bits1(gb); coef_compress = get_bits1(gb); coef_len = coef_res + 3 - coef_compress; - tmp2_idx = 2*coef_compress + coef_res; + tmp2_idx = 2 * coef_compress + coef_res; for (i = 0; i < tns->order[w][filt]; i++) tns->coef[w][filt][i] = tns_tmp2_map[tmp2_idx][get_bits(gb, coef_len)]; @@ -781,8 +871,9 @@ static int decode_tns(AACContext * ac, TemporalNoiseShaping * tns, * [1] mask is decoded from bitstream; [2] mask is all 1s; * [3] reserved for scalable AAC */ -static void decode_mid_side_stereo(ChannelElement * cpe, GetBitContext * gb, - int ms_present) { +static void decode_mid_side_stereo(ChannelElement *cpe, GetBitContext *gb, + int ms_present) +{ int idx; if (ms_present == 1) { for (idx = 0; idx < cpe->ch[0].ics.num_window_groups * cpe->ch[0].ics.max_sfb; idx++) @@ -792,6 +883,74 @@ static void decode_mid_side_stereo(ChannelElement * cpe, GetBitContext * gb, } } +#ifndef VMUL2 +static inline float *VMUL2(float *dst, const float *v, unsigned idx, + const float *scale) +{ + float s = *scale; + *dst++ = v[idx & 15] * s; + *dst++ = v[idx>>4 & 15] * s; + return dst; +} +#endif + +#ifndef VMUL4 +static inline float *VMUL4(float *dst, const float *v, unsigned idx, + const float *scale) +{ + float s = *scale; + *dst++ = v[idx & 3] * s; + *dst++ = v[idx>>2 & 3] * s; + *dst++ = v[idx>>4 & 3] * s; + *dst++ = v[idx>>6 & 3] * s; + return dst; +} +#endif + +#ifndef VMUL2S +static inline float *VMUL2S(float *dst, const float *v, unsigned idx, + unsigned sign, const float *scale) +{ + union float754 s0, s1; + + s0.f = s1.f = *scale; + s0.i ^= sign >> 1 << 31; + s1.i ^= sign << 31; + + *dst++ = v[idx & 15] * s0.f; + *dst++ = v[idx>>4 & 15] * s1.f; + + return dst; +} +#endif + +#ifndef VMUL4S +static inline float *VMUL4S(float *dst, const float *v, unsigned idx, + unsigned sign, const float *scale) +{ + unsigned nz = idx >> 12; + union float754 s = { .f = *scale }; + union float754 t; + + t.i = s.i ^ (sign & 1<<31); + *dst++ = v[idx & 3] * t.f; + + sign <<= nz & 1; nz >>= 1; + t.i = s.i ^ (sign & 1<<31); + *dst++ = v[idx>>2 & 3] * t.f; + + sign <<= nz & 1; nz >>= 1; + t.i = s.i ^ (sign & 1<<31); + *dst++ = v[idx>>4 & 3] * t.f; + + sign <<= nz & 1; nz >>= 1; + t.i = s.i ^ (sign & 1<<31); + *dst++ = v[idx>>6 & 3] * t.f; + + return dst; +} +#endif + /** * Decode spectral data; reference: table 4.50. * Dequantize and scale spectral data; reference: 4.6.3.3. @@ -804,113 +963,245 @@ static void decode_mid_side_stereo(ChannelElement * cpe, GetBitContext * gb, * * @return Returns error status. 0 - OK, !0 - error */ -static int decode_spectrum_and_dequant(AACContext * ac, float coef[1024], GetBitContext * gb, float sf[120], - int pulse_present, const Pulse * pulse, const IndividualChannelStream * ics, enum BandType band_type[120]) { +static int decode_spectrum_and_dequant(AACContext *ac, float coef[1024], + GetBitContext *gb, const float sf[120], + int pulse_present, const Pulse *pulse, + const IndividualChannelStream *ics, + enum BandType band_type[120]) +{ int i, k, g, idx = 0; - const int c = 1024/ics->num_windows; - const uint16_t * offsets = ics->swb_offset; + const int c = 1024 / ics->num_windows; + const uint16_t *offsets = ics->swb_offset; float *coef_base = coef; - static const float sign_lookup[] = { 1.0f, -1.0f }; + int err_idx; for (g = 0; g < ics->num_windows; g++) - memset(coef + g * 128 + offsets[ics->max_sfb], 0, sizeof(float)*(c - offsets[ics->max_sfb])); + memset(coef + g * 128 + offsets[ics->max_sfb], 0, sizeof(float) * (c - offsets[ics->max_sfb])); for (g = 0; g < ics->num_window_groups; g++) { + unsigned g_len = ics->group_len[g]; + for (i = 0; i < ics->max_sfb; i++, idx++) { - const int cur_band_type = band_type[idx]; - const int dim = cur_band_type >= FIRST_PAIR_BT ? 2 : 4; - const int is_cb_unsigned = IS_CODEBOOK_UNSIGNED(cur_band_type); + const unsigned cbt_m1 = band_type[idx] - 1; + float *cfo = coef + offsets[i]; + int off_len = offsets[i + 1] - offsets[i]; int group; - if (cur_band_type == ZERO_BT || cur_band_type == INTENSITY_BT2 || cur_band_type == INTENSITY_BT) { - for (group = 0; group < ics->group_len[g]; group++) { - memset(coef + group * 128 + offsets[i], 0, (offsets[i+1] - offsets[i])*sizeof(float)); + + if (cbt_m1 >= INTENSITY_BT2 - 1) { + for (group = 0; group < g_len; group++, cfo+=128) { + memset(cfo, 0, off_len * sizeof(float)); } - }else if (cur_band_type == NOISE_BT) { - for (group = 0; group < ics->group_len[g]; group++) { + } else if (cbt_m1 == NOISE_BT - 1) { + for (group = 0; group < g_len; group++, cfo+=128) { float scale; - float band_energy = 0; - for (k = offsets[i]; k < offsets[i+1]; k++) { + float band_energy; + + for (k = 0; k < off_len; k++) { ac->random_state = lcg_random(ac->random_state); - coef[group*128+k] = ac->random_state; - band_energy += coef[group*128+k]*coef[group*128+k]; + cfo[k] = ac->random_state; } + + band_energy = ac->dsp.scalarproduct_float(cfo, cfo, off_len); scale = sf[idx] / sqrtf(band_energy); - for (k = offsets[i]; k < offsets[i+1]; k++) { - coef[group*128+k] *= scale; - } + ac->dsp.vector_fmul_scalar(cfo, cfo, scale, off_len); } - }else { - for (group = 0; group < ics->group_len[g]; group++) { - for (k = offsets[i]; k < offsets[i+1]; k += dim) { - const int index = get_vlc2(gb, vlc_spectral[cur_band_type - 1].table, 6, 3); - const int coef_tmp_idx = (group << 7) + k; - const float *vq_ptr; - int j; - if(index >= ff_aac_spectral_sizes[cur_band_type - 1]) { - av_log(ac->avccontext, AV_LOG_ERROR, - "Read beyond end of ff_aac_codebook_vectors[%d][]. index %d >= %d\n", - cur_band_type - 1, index, ff_aac_spectral_sizes[cur_band_type - 1]); - return -1; - } - vq_ptr = &ff_aac_codebook_vectors[cur_band_type - 1][index * dim]; - if (is_cb_unsigned) { - if (vq_ptr[0]) coef[coef_tmp_idx ] = sign_lookup[get_bits1(gb)]; - if (vq_ptr[1]) coef[coef_tmp_idx + 1] = sign_lookup[get_bits1(gb)]; - if (dim == 4) { - if (vq_ptr[2]) coef[coef_tmp_idx + 2] = sign_lookup[get_bits1(gb)]; - if (vq_ptr[3]) coef[coef_tmp_idx + 3] = sign_lookup[get_bits1(gb)]; + } else { + const float *vq = ff_aac_codebook_vector_vals[cbt_m1]; + const uint16_t *cb_vector_idx = ff_aac_codebook_vector_idx[cbt_m1]; + VLC_TYPE (*vlc_tab)[2] = vlc_spectral[cbt_m1].table; + const int cb_size = ff_aac_spectral_sizes[cbt_m1]; + OPEN_READER(re, gb); + + switch (cbt_m1 >> 1) { + case 0: + for (group = 0; group < g_len; group++, cfo+=128) { + float *cf = cfo; + int len = off_len; + + do { + int code; + unsigned cb_idx; + + UPDATE_CACHE(re, gb); + GET_VLC(code, re, gb, vlc_tab, 8, 2); + + if (code >= cb_size) { + err_idx = code; + goto err_cb_overflow; } - if (cur_band_type == ESC_BT) { - for (j = 0; j < 2; j++) { - if (vq_ptr[j] == 64.0f) { - int n = 4; - /* The total length of escape_sequence must be < 22 bits according - to the specification (i.e. max is 11111111110xxxxxxxxxx). */ - while (get_bits1(gb) && n < 15) n++; - if(n == 15) { - av_log(ac->avccontext, AV_LOG_ERROR, "error in spectral data, ESC overflow\n"); - return -1; - } - n = (1<= cb_size) { + err_idx = code; + goto err_cb_overflow; + } + +#if MIN_CACHE_BITS < 20 + UPDATE_CACHE(re, gb); +#endif + cb_idx = cb_vector_idx[code]; + nnz = cb_idx >> 8 & 15; + bits = SHOW_UBITS(re, gb, nnz) << (32-nnz); + LAST_SKIP_BITS(re, gb, nnz); + cf = VMUL4S(cf, vq, cb_idx, bits, sf + idx); + } while (len -= 4); + } + break; + + case 2: + for (group = 0; group < g_len; group++, cfo+=128) { + float *cf = cfo; + int len = off_len; + + do { + int code; + unsigned cb_idx; + + UPDATE_CACHE(re, gb); + GET_VLC(code, re, gb, vlc_tab, 8, 2); + + if (code >= cb_size) { + err_idx = code; + goto err_cb_overflow; } - }else { - coef[coef_tmp_idx ] = vq_ptr[0]; - coef[coef_tmp_idx + 1] = vq_ptr[1]; - if (dim == 4) { - coef[coef_tmp_idx + 2] = vq_ptr[2]; - coef[coef_tmp_idx + 3] = vq_ptr[3]; + + cb_idx = cb_vector_idx[code]; + cf = VMUL2(cf, vq, cb_idx, sf + idx); + } while (len -= 2); + } + break; + + case 3: + case 4: + for (group = 0; group < g_len; group++, cfo+=128) { + float *cf = cfo; + int len = off_len; + + do { + int code; + unsigned nnz; + unsigned cb_idx; + unsigned sign; + + UPDATE_CACHE(re, gb); + GET_VLC(code, re, gb, vlc_tab, 8, 2); + + if (code >= cb_size) { + err_idx = code; + goto err_cb_overflow; } - } - coef[coef_tmp_idx ] *= sf[idx]; - coef[coef_tmp_idx + 1] *= sf[idx]; - if (dim == 4) { - coef[coef_tmp_idx + 2] *= sf[idx]; - coef[coef_tmp_idx + 3] *= sf[idx]; - } + + cb_idx = cb_vector_idx[code]; + nnz = cb_idx >> 8 & 15; + sign = SHOW_UBITS(re, gb, nnz) << (cb_idx >> 12); + LAST_SKIP_BITS(re, gb, nnz); + cf = VMUL2S(cf, vq, cb_idx, sign, sf + idx); + } while (len -= 2); + } + break; + + default: + for (group = 0; group < g_len; group++, cfo+=128) { + float *cf = cfo; + uint32_t *icf = (uint32_t *) cf; + int len = off_len; + + do { + int code; + unsigned nzt, nnz; + unsigned cb_idx; + uint32_t bits; + int j; + + UPDATE_CACHE(re, gb); + GET_VLC(code, re, gb, vlc_tab, 8, 2); + + if (!code) { + *icf++ = 0; + *icf++ = 0; + continue; + } + + if (code >= cb_size) { + err_idx = code; + goto err_cb_overflow; + } + + cb_idx = cb_vector_idx[code]; + nnz = cb_idx >> 12; + nzt = cb_idx >> 8; + bits = SHOW_UBITS(re, gb, nnz) << (32-nnz); + LAST_SKIP_BITS(re, gb, nnz); + + for (j = 0; j < 2; j++) { + if (nzt & 1< 8) { + av_log(ac->avccontext, AV_LOG_ERROR, "error in spectral data, ESC overflow\n"); + return -1; + } + +#if MIN_CACHE_BITS < 21 + LAST_SKIP_BITS(re, gb, b + 1); + UPDATE_CACHE(re, gb); +#else + SKIP_BITS(re, gb, b + 1); +#endif + b += 4; + n = (1 << b) + SHOW_UBITS(re, gb, b); + LAST_SKIP_BITS(re, gb, b); + *icf++ = cbrt_tab[n] | (bits & 1<<31); + bits <<= 1; + } else { + unsigned v = ((const uint32_t*)vq)[cb_idx & 15]; + *icf++ = (bits & 1<<31) | v; + bits <<= !!v; + } + cb_idx >>= 4; + } + } while (len -= 2); + + ac->dsp.vector_fmul_scalar(cfo, cfo, sf[idx], off_len); } } + + CLOSE_READER(re, gb); } } - coef += ics->group_len[g]<<7; + coef += g_len << 7; } if (pulse_present) { idx = 0; - for(i = 0; i < pulse->num_pulse; i++){ - float co = coef_base[ pulse->pos[i] ]; - while(offsets[idx + 1] <= pulse->pos[i]) + for (i = 0; i < pulse->num_pulse; i++) { + float co = coef_base[ pulse->pos[i] ]; + while (offsets[idx + 1] <= pulse->pos[i]) idx++; if (band_type[idx] != NOISE_BT && sf[idx]) { float ico = -pulse->amp[i]; @@ -923,32 +1214,43 @@ static int decode_spectrum_and_dequant(AACContext * ac, float coef[1024], GetBit } } return 0; + +err_cb_overflow: + av_log(ac->avccontext, AV_LOG_ERROR, + "Read beyond end of ff_aac_codebook_vectors[%d][]. index %d >= %d\n", + band_type[idx], err_idx, ff_aac_spectral_sizes[band_type[idx]]); + return -1; } -static av_always_inline float flt16_round(float pf) { +static av_always_inline float flt16_round(float pf) +{ union float754 tmp; tmp.f = pf; tmp.i = (tmp.i + 0x00008000U) & 0xFFFF0000U; return tmp.f; } -static av_always_inline float flt16_even(float pf) { +static av_always_inline float flt16_even(float pf) +{ union float754 tmp; tmp.f = pf; - tmp.i = (tmp.i + 0x00007FFFU + (tmp.i & 0x00010000U>>16)) & 0xFFFF0000U; + tmp.i = (tmp.i + 0x00007FFFU + (tmp.i & 0x00010000U >> 16)) & 0xFFFF0000U; return tmp.f; } -static av_always_inline float flt16_trunc(float pf) { +static av_always_inline float flt16_trunc(float pf) +{ union float754 pun; pun.f = pf; pun.i &= 0xFFFF0000U; return pun.f; } -static void predict(AACContext * ac, PredictorState * ps, float* coef, int output_enable) { - const float a = 0.953125; // 61.0/64 - const float alpha = 0.90625; // 29.0/32 +static av_always_inline void predict(AACContext *ac, PredictorState *ps, float *coef, + int output_enable) +{ + const float a = 0.953125; // 61.0 / 64 + const float alpha = 0.90625; // 29.0 / 32 float e0, e1; float pv; float k1, k2; @@ -975,7 +1277,8 @@ static void predict(AACContext * ac, PredictorState * ps, float* coef, int outpu /** * Apply AAC-Main style frequency domain prediction. */ -static void apply_prediction(AACContext * ac, SingleChannelElement * sce) { +static void apply_prediction(AACContext *ac, SingleChannelElement *sce) +{ int sfb, k; if (!sce->ics.predictor_initialized) { @@ -987,7 +1290,7 @@ static void apply_prediction(AACContext * ac, SingleChannelElement * sce) { for (sfb = 0; sfb < ff_aac_pred_sfb_max[ac->m4ac.sampling_index]; sfb++) { for (k = sce->ics.swb_offset[sfb]; k < sce->ics.swb_offset[sfb + 1]; k++) { predict(ac, &sce->predictor_state[k], &sce->coeffs[k], - sce->ics.predictor_present && sce->ics.prediction_used[sfb]); + sce->ics.predictor_present && sce->ics.prediction_used[sfb]); } } if (sce->ics.predictor_reset_group) @@ -1004,11 +1307,13 @@ static void apply_prediction(AACContext * ac, SingleChannelElement * sce) { * * @return Returns error status. 0 - OK, !0 - error */ -static int decode_ics(AACContext * ac, SingleChannelElement * sce, GetBitContext * gb, int common_window, int scale_flag) { +static int decode_ics(AACContext *ac, SingleChannelElement *sce, + GetBitContext *gb, int common_window, int scale_flag) +{ Pulse pulse; - TemporalNoiseShaping * tns = &sce->tns; - IndividualChannelStream * ics = &sce->ics; - float * out = sce->coeffs; + TemporalNoiseShaping *tns = &sce->tns; + IndividualChannelStream *ics = &sce->ics; + float *out = sce->coeffs; int global_gain, pulse_present = 0; /* This assignment is to silence a GCC warning about the variable being used @@ -1043,7 +1348,7 @@ static int decode_ics(AACContext * ac, SingleChannelElement * sce, GetBitContext if ((tns->present = get_bits1(gb)) && decode_tns(ac, tns, gb, ics)) return -1; if (get_bits1(gb)) { - ff_log_missing_feature(ac->avccontext, "SSR", 1); + av_log_missing_feature(ac->avccontext, "SSR", 1); return -1; } } @@ -1051,7 +1356,7 @@ static int decode_ics(AACContext * ac, SingleChannelElement * sce, GetBitContext if (decode_spectrum_and_dequant(ac, out, gb, sce->sf, pulse_present, &pulse, ics, sce->band_type) < 0) return -1; - if(ac->m4ac.object_type == AOT_AAC_MAIN && !common_window) + if (ac->m4ac.object_type == AOT_AAC_MAIN && !common_window) apply_prediction(ac, sce); return 0; @@ -1060,27 +1365,26 @@ static int decode_ics(AACContext * ac, SingleChannelElement * sce, GetBitContext /** * Mid/Side stereo decoding; reference: 4.6.8.1.3. */ -static void apply_mid_side_stereo(ChannelElement * cpe) { - const IndividualChannelStream * ics = &cpe->ch[0].ics; +static void apply_mid_side_stereo(AACContext *ac, ChannelElement *cpe) +{ + const IndividualChannelStream *ics = &cpe->ch[0].ics; float *ch0 = cpe->ch[0].coeffs; float *ch1 = cpe->ch[1].coeffs; - int g, i, k, group, idx = 0; - const uint16_t * offsets = ics->swb_offset; + int g, i, group, idx = 0; + const uint16_t *offsets = ics->swb_offset; for (g = 0; g < ics->num_window_groups; g++) { for (i = 0; i < ics->max_sfb; i++, idx++) { if (cpe->ms_mask[idx] && - cpe->ch[0].band_type[idx] < NOISE_BT && cpe->ch[1].band_type[idx] < NOISE_BT) { + cpe->ch[0].band_type[idx] < NOISE_BT && cpe->ch[1].band_type[idx] < NOISE_BT) { for (group = 0; group < ics->group_len[g]; group++) { - for (k = offsets[i]; k < offsets[i+1]; k++) { - float tmp = ch0[group*128 + k] - ch1[group*128 + k]; - ch0[group*128 + k] += ch1[group*128 + k]; - ch1[group*128 + k] = tmp; - } + ac->dsp.butterflies_float(ch0 + group * 128 + offsets[i], + ch1 + group * 128 + offsets[i], + offsets[i+1] - offsets[i]); } } } - ch0 += ics->group_len[g]*128; - ch1 += ics->group_len[g]*128; + ch0 += ics->group_len[g] * 128; + ch1 += ics->group_len[g] * 128; } } @@ -1091,11 +1395,12 @@ static void apply_mid_side_stereo(ChannelElement * cpe) { * [1] mask is decoded from bitstream; [2] mask is all 1s; * [3] reserved for scalable AAC */ -static void apply_intensity_stereo(ChannelElement * cpe, int ms_present) { - const IndividualChannelStream * ics = &cpe->ch[1].ics; - SingleChannelElement * sce1 = &cpe->ch[1]; +static void apply_intensity_stereo(ChannelElement *cpe, int ms_present) +{ + const IndividualChannelStream *ics = &cpe->ch[1].ics; + SingleChannelElement *sce1 = &cpe->ch[1]; float *coef0 = cpe->ch[0].coeffs, *coef1 = cpe->ch[1].coeffs; - const uint16_t * offsets = ics->swb_offset; + const uint16_t *offsets = ics->swb_offset; int g, group, i, k, idx = 0; int c; float scale; @@ -1109,8 +1414,8 @@ static void apply_intensity_stereo(ChannelElement * cpe, int ms_present) { c *= 1 - 2 * cpe->ms_mask[idx]; scale = c * sce1->sf[idx]; for (group = 0; group < ics->group_len[g]; group++) - for (k = offsets[i]; k < offsets[i+1]; k++) - coef1[group*128 + k] = scale * coef0[group*128 + k]; + for (k = offsets[i]; k < offsets[i + 1]; k++) + coef1[group * 128 + k] = scale * coef0[group * 128 + k]; } } else { int bt_run_end = sce1->band_type_run_end[idx]; @@ -1118,8 +1423,8 @@ static void apply_intensity_stereo(ChannelElement * cpe, int ms_present) { i = bt_run_end; } } - coef0 += ics->group_len[g]*128; - coef1 += ics->group_len[g]*128; + coef0 += ics->group_len[g] * 128; + coef1 += ics->group_len[g] * 128; } } @@ -1130,7 +1435,8 @@ static void apply_intensity_stereo(ChannelElement * cpe, int ms_present) { * * @return Returns error status. 0 - OK, !0 - error */ -static int decode_cpe(AACContext * ac, GetBitContext * gb, ChannelElement * cpe) { +static int decode_cpe(AACContext *ac, GetBitContext *gb, ChannelElement *cpe) +{ int i, ret, common_window, ms_present = 0; common_window = get_bits1(gb); @@ -1141,10 +1447,10 @@ static int decode_cpe(AACContext * ac, GetBitContext * gb, ChannelElement * cpe) cpe->ch[1].ics = cpe->ch[0].ics; cpe->ch[1].ics.use_kb_window[1] = i; ms_present = get_bits(gb, 2); - if(ms_present == 3) { + if (ms_present == 3) { av_log(ac->avccontext, AV_LOG_ERROR, "ms_present = 3 is reserved.\n"); return -1; - } else if(ms_present) + } else if (ms_present) decode_mid_side_stereo(cpe, gb, ms_present); } if ((ret = decode_ics(ac, &cpe->ch[0], gb, common_window, 0))) @@ -1154,7 +1460,7 @@ static int decode_cpe(AACContext * ac, GetBitContext * gb, ChannelElement * cpe) if (common_window) { if (ms_present) - apply_mid_side_stereo(cpe); + apply_mid_side_stereo(ac, cpe); if (ac->m4ac.object_type == AOT_AAC_MAIN) { apply_prediction(ac, &cpe->ch[0]); apply_prediction(ac, &cpe->ch[1]); @@ -1172,15 +1478,16 @@ static int decode_cpe(AACContext * ac, GetBitContext * gb, ChannelElement * cpe) * * @return Returns error status. 0 - OK, !0 - error */ -static int decode_cce(AACContext * ac, GetBitContext * gb, ChannelElement * che) { +static int decode_cce(AACContext *ac, GetBitContext *gb, ChannelElement *che) +{ int num_gain = 0; int c, g, sfb, ret; int sign; float scale; - SingleChannelElement * sce = &che->ch[0]; - ChannelCoupling * coup = &che->coup; + SingleChannelElement *sce = &che->ch[0]; + ChannelCoupling *coup = &che->coup; - coup->coupling_point = 2*get_bits1(gb); + coup->coupling_point = 2 * get_bits1(gb); coup->num_coupled = get_bits(gb, 3); for (c = 0; c <= coup->num_coupled; c++) { num_gain++; @@ -1193,17 +1500,17 @@ static int decode_cce(AACContext * ac, GetBitContext * gb, ChannelElement * che) } else coup->ch_select[c] = 2; } - coup->coupling_point += get_bits1(gb) || (coup->coupling_point>>1); + coup->coupling_point += get_bits1(gb) || (coup->coupling_point >> 1); - sign = get_bits(gb, 1); + sign = get_bits(gb, 1); scale = pow(2., pow(2., (int)get_bits(gb, 2) - 3)); if ((ret = decode_ics(ac, sce, gb, 0, 0))) return ret; for (c = 0; c < num_gain; c++) { - int idx = 0; - int cge = 1; + int idx = 0; + int cge = 1; int gain = 0; float gain_cache = 1.; if (c) { @@ -1219,7 +1526,7 @@ static int decode_cce(AACContext * ac, GetBitContext * gb, ChannelElement * che) if (sce->band_type[idx] != ZERO_BT) { if (!cge) { int t = get_vlc2(gb, vlc_scalefactors.table, 7, 3) - 60; - if (t) { + if (t) { int s = 1; t = gain += t; if (sign) { @@ -1238,27 +1545,14 @@ static int decode_cce(AACContext * ac, GetBitContext * gb, ChannelElement * che) return 0; } -/** - * Decode Spectral Band Replication extension data; reference: table 4.55. - * - * @param crc flag indicating the presence of CRC checksum - * @param cnt length of TYPE_FIL syntactic element in bytes - * - * @return Returns number of bytes consumed from the TYPE_FIL element. - */ -static int decode_sbr_extension(AACContext * ac, GetBitContext * gb, int crc, int cnt) { - // TODO : sbr_extension implementation - ff_log_missing_feature(ac->avccontext, "SBR", 0); - skip_bits_long(gb, 8*cnt - 4); // -4 due to reading extension type - return cnt; -} - /** * Parse whether channels are to be excluded from Dynamic Range Compression; reference: table 4.53. * * @return Returns number of bytes consumed. */ -static int decode_drc_channel_exclusions(DynamicRangeControl *che_drc, GetBitContext * gb) { +static int decode_drc_channel_exclusions(DynamicRangeControl *che_drc, + GetBitContext *gb) +{ int i; int num_excl_chan = 0; @@ -1277,20 +1571,22 @@ static int decode_drc_channel_exclusions(DynamicRangeControl *che_drc, GetBitCon * * @return Returns number of bytes consumed. */ -static int decode_dynamic_range(DynamicRangeControl *che_drc, GetBitContext * gb, int cnt) { - int n = 1; +static int decode_dynamic_range(DynamicRangeControl *che_drc, + GetBitContext *gb, int cnt) +{ + int n = 1; int drc_num_bands = 1; int i; /* pce_tag_present? */ - if(get_bits1(gb)) { + if (get_bits1(gb)) { che_drc->pce_instance_tag = get_bits(gb, 4); skip_bits(gb, 4); // tag_reserved_bits n++; } /* excluded_chns_present? */ - if(get_bits1(gb)) { + if (get_bits1(gb)) { n += decode_drc_channel_exclusions(che_drc, gb); } @@ -1329,24 +1625,40 @@ static int decode_dynamic_range(DynamicRangeControl *che_drc, GetBitContext * gb * * @return Returns number of bytes consumed */ -static int decode_extension_payload(AACContext * ac, GetBitContext * gb, int cnt) { +static int decode_extension_payload(AACContext *ac, GetBitContext *gb, int cnt, + ChannelElement *che, enum RawDataBlockType elem_type) +{ int crc_flag = 0; int res = cnt; switch (get_bits(gb, 4)) { // extension type - case EXT_SBR_DATA_CRC: - crc_flag++; - case EXT_SBR_DATA: - res = decode_sbr_extension(ac, gb, crc_flag, cnt); - break; - case EXT_DYNAMIC_RANGE: - res = decode_dynamic_range(&ac->che_drc, gb, cnt); - break; - case EXT_FILL: - case EXT_FILL_DATA: - case EXT_DATA_ELEMENT: - default: - skip_bits_long(gb, 8*cnt - 4); - break; + case EXT_SBR_DATA_CRC: + crc_flag++; + case EXT_SBR_DATA: + if (!che) { + av_log(ac->avccontext, AV_LOG_ERROR, "SBR was found before the first channel element.\n"); + return res; + } else if (!ac->m4ac.sbr) { + av_log(ac->avccontext, AV_LOG_ERROR, "SBR signaled to be not-present but was found in the bitstream.\n"); + skip_bits_long(gb, 8 * cnt - 4); + return res; + } else if (ac->m4ac.sbr == -1 && ac->output_configured == OC_LOCKED) { + av_log(ac->avccontext, AV_LOG_ERROR, "Implicit SBR was found with a first occurrence after the first frame.\n"); + skip_bits_long(gb, 8 * cnt - 4); + return res; + } else { + ac->m4ac.sbr = 1; + } + res = ff_decode_sbr_extension(ac, &che->sbr, gb, crc_flag, cnt, elem_type); + break; + case EXT_DYNAMIC_RANGE: + res = decode_dynamic_range(&ac->che_drc, gb, cnt); + break; + case EXT_FILL: + case EXT_FILL_DATA: + case EXT_DATA_ELEMENT: + default: + skip_bits_long(gb, 8 * cnt - 4); + break; }; return res; } @@ -1357,8 +1669,10 @@ static int decode_extension_payload(AACContext * ac, GetBitContext * gb, int cnt * @param decode 1 if tool is used normally, 0 if tool is used in LTP. * @param coef spectral coefficients */ -static void apply_tns(float coef[1024], TemporalNoiseShaping * tns, IndividualChannelStream * ics, int decode) { - const int mmm = FFMIN(ics->tns_max_bands, ics->max_sfb); +static void apply_tns(float coef[1024], TemporalNoiseShaping *tns, + IndividualChannelStream *ics, int decode) +{ + const int mmm = FFMIN(ics->tns_max_bands, ics->max_sfb); int w, filt, m, i; int bottom, top, order, start, end, size, inc; float lpc[TNS_MAX_ORDER]; @@ -1380,7 +1694,8 @@ static void apply_tns(float coef[1024], TemporalNoiseShaping * tns, IndividualCh if ((size = end - start) <= 0) continue; if (tns->direction[w][filt]) { - inc = -1; start = end - 1; + inc = -1; + start = end - 1; } else { inc = 1; } @@ -1389,7 +1704,7 @@ static void apply_tns(float coef[1024], TemporalNoiseShaping * tns, IndividualCh // ar filter for (m = 0; m < size; m++, start += inc) for (i = 1; i <= FFMIN(m, order); i++) - coef[start] -= coef[start - i*inc] * lpc[i-1]; + coef[start] -= coef[start - i * inc] * lpc[i - 1]; } } } @@ -1397,16 +1712,17 @@ static void apply_tns(float coef[1024], TemporalNoiseShaping * tns, IndividualCh /** * Conduct IMDCT and windowing. */ -static void imdct_and_windowing(AACContext * ac, SingleChannelElement * sce) { - IndividualChannelStream * ics = &sce->ics; - float * in = sce->coeffs; - float * out = sce->ret; - float * saved = sce->saved; - const float * swindow = ics->use_kb_window[0] ? ff_aac_kbd_short_128 : ff_sine_128; - const float * lwindow_prev = ics->use_kb_window[1] ? ff_aac_kbd_long_1024 : ff_sine_1024; - const float * swindow_prev = ics->use_kb_window[1] ? ff_aac_kbd_short_128 : ff_sine_128; - float * buf = ac->buf_mdct; - float * temp = ac->temp; +static void imdct_and_windowing(AACContext *ac, SingleChannelElement *sce, float bias) +{ + IndividualChannelStream *ics = &sce->ics; + float *in = sce->coeffs; + float *out = sce->ret; + float *saved = sce->saved; + const float *swindow = ics->use_kb_window[0] ? ff_aac_kbd_short_128 : ff_sine_128; + const float *lwindow_prev = ics->use_kb_window[1] ? ff_aac_kbd_long_1024 : ff_sine_1024; + const float *swindow_prev = ics->use_kb_window[1] ? ff_aac_kbd_short_128 : ff_sine_128; + float *buf = ac->buf_mdct; + float *temp = ac->temp; int i; // imdct @@ -1427,30 +1743,30 @@ static void imdct_and_windowing(AACContext * ac, SingleChannelElement * sce) { * with a little special sauce for EIGHT_SHORT_SEQUENCE. */ if ((ics->window_sequence[1] == ONLY_LONG_SEQUENCE || ics->window_sequence[1] == LONG_STOP_SEQUENCE) && - (ics->window_sequence[0] == ONLY_LONG_SEQUENCE || ics->window_sequence[0] == LONG_START_SEQUENCE)) { - ac->dsp.vector_fmul_window( out, saved, buf, lwindow_prev, ac->add_bias, 512); + (ics->window_sequence[0] == ONLY_LONG_SEQUENCE || ics->window_sequence[0] == LONG_START_SEQUENCE)) { + ac->dsp.vector_fmul_window( out, saved, buf, lwindow_prev, bias, 512); } else { for (i = 0; i < 448; i++) - out[i] = saved[i] + ac->add_bias; + out[i] = saved[i] + bias; if (ics->window_sequence[0] == EIGHT_SHORT_SEQUENCE) { - ac->dsp.vector_fmul_window(out + 448 + 0*128, saved + 448, buf + 0*128, swindow_prev, ac->add_bias, 64); - ac->dsp.vector_fmul_window(out + 448 + 1*128, buf + 0*128 + 64, buf + 1*128, swindow, ac->add_bias, 64); - ac->dsp.vector_fmul_window(out + 448 + 2*128, buf + 1*128 + 64, buf + 2*128, swindow, ac->add_bias, 64); - ac->dsp.vector_fmul_window(out + 448 + 3*128, buf + 2*128 + 64, buf + 3*128, swindow, ac->add_bias, 64); - ac->dsp.vector_fmul_window(temp, buf + 3*128 + 64, buf + 4*128, swindow, ac->add_bias, 64); + ac->dsp.vector_fmul_window(out + 448 + 0*128, saved + 448, buf + 0*128, swindow_prev, bias, 64); + ac->dsp.vector_fmul_window(out + 448 + 1*128, buf + 0*128 + 64, buf + 1*128, swindow, bias, 64); + ac->dsp.vector_fmul_window(out + 448 + 2*128, buf + 1*128 + 64, buf + 2*128, swindow, bias, 64); + ac->dsp.vector_fmul_window(out + 448 + 3*128, buf + 2*128 + 64, buf + 3*128, swindow, bias, 64); + ac->dsp.vector_fmul_window(temp, buf + 3*128 + 64, buf + 4*128, swindow, bias, 64); memcpy( out + 448 + 4*128, temp, 64 * sizeof(float)); } else { - ac->dsp.vector_fmul_window(out + 448, saved + 448, buf, swindow_prev, ac->add_bias, 64); + ac->dsp.vector_fmul_window(out + 448, saved + 448, buf, swindow_prev, bias, 64); for (i = 576; i < 1024; i++) - out[i] = buf[i-512] + ac->add_bias; + out[i] = buf[i-512] + bias; } } // buffer update if (ics->window_sequence[0] == EIGHT_SHORT_SEQUENCE) { for (i = 0; i < 64; i++) - saved[i] = temp[64 + i] - ac->add_bias; + saved[i] = temp[64 + i] - bias; ac->dsp.vector_fmul_window(saved + 64, buf + 4*128 + 64, buf + 5*128, swindow, 0, 64); ac->dsp.vector_fmul_window(saved + 192, buf + 5*128 + 64, buf + 6*128, swindow, 0, 64); ac->dsp.vector_fmul_window(saved + 320, buf + 6*128 + 64, buf + 7*128, swindow, 0, 64); @@ -1468,13 +1784,16 @@ static void imdct_and_windowing(AACContext * ac, SingleChannelElement * sce) { * * @param index index into coupling gain array */ -static void apply_dependent_coupling(AACContext * ac, SingleChannelElement * target, ChannelElement * cce, int index) { - IndividualChannelStream * ics = &cce->ch[0].ics; - const uint16_t * offsets = ics->swb_offset; - float * dest = target->coeffs; - const float * src = cce->ch[0].coeffs; +static void apply_dependent_coupling(AACContext *ac, + SingleChannelElement *target, + ChannelElement *cce, int index) +{ + IndividualChannelStream *ics = &cce->ch[0].ics; + const uint16_t *offsets = ics->swb_offset; + float *dest = target->coeffs; + const float *src = cce->ch[0].coeffs; int g, i, group, k, idx = 0; - if(ac->m4ac.object_type == AOT_AAC_LTP) { + if (ac->m4ac.object_type == AOT_AAC_LTP) { av_log(ac->avccontext, AV_LOG_ERROR, "Dependent coupling is not supported together with LTP\n"); return; @@ -1484,15 +1803,15 @@ static void apply_dependent_coupling(AACContext * ac, SingleChannelElement * tar if (cce->ch[0].band_type[idx] != ZERO_BT) { const float gain = cce->coup.gain[index][idx]; for (group = 0; group < ics->group_len[g]; group++) { - for (k = offsets[i]; k < offsets[i+1]; k++) { + for (k = offsets[i]; k < offsets[i + 1]; k++) { // XXX dsputil-ize - dest[group*128+k] += gain * src[group*128+k]; + dest[group * 128 + k] += gain * src[group * 128 + k]; } } } } - dest += ics->group_len[g]*128; - src += ics->group_len[g]*128; + dest += ics->group_len[g] * 128; + src += ics->group_len[g] * 128; } } @@ -1501,14 +1820,18 @@ static void apply_dependent_coupling(AACContext * ac, SingleChannelElement * tar * * @param index index into coupling gain array */ -static void apply_independent_coupling(AACContext * ac, SingleChannelElement * target, ChannelElement * cce, int index) { +static void apply_independent_coupling(AACContext *ac, + SingleChannelElement *target, + ChannelElement *cce, int index) +{ int i; const float gain = cce->coup.gain[index][0]; const float bias = ac->add_bias; - const float* src = cce->ch[0].ret; - float* dest = target->ret; + const float *src = cce->ch[0].ret; + float *dest = target->ret; + const int len = 1024 << (ac->m4ac.sbr == 1); - for (i = 0; i < 1024; i++) + for (i = 0; i < len; i++) dest[i] += gain * (src[i] - bias); } @@ -1518,9 +1841,10 @@ static void apply_independent_coupling(AACContext * ac, SingleChannelElement * t * @param index index into coupling gain array * @param apply_coupling_method pointer to (in)dependent coupling function */ -static void apply_channel_coupling(AACContext * ac, ChannelElement * cc, - enum RawDataBlockType type, int elem_id, enum CouplingPoint coupling_point, - void (*apply_coupling_method)(AACContext * ac, SingleChannelElement * target, ChannelElement * cce, int index)) +static void apply_channel_coupling(AACContext *ac, ChannelElement *cc, + enum RawDataBlockType type, int elem_id, + enum CouplingPoint coupling_point, + void (*apply_coupling_method)(AACContext *ac, SingleChannelElement *target, ChannelElement *cce, int index)) { int i, c; @@ -1529,7 +1853,7 @@ static void apply_channel_coupling(AACContext * ac, ChannelElement * cc, int index = 0; if (cce && cce->coup.coupling_point == coupling_point) { - ChannelCoupling * coup = &cce->coup; + ChannelCoupling *coup = &cce->coup; for (c = 0; c <= coup->num_coupled; c++) { if (coup->type[c] == type && coup->id_select[c] == elem_id) { @@ -1550,64 +1874,91 @@ static void apply_channel_coupling(AACContext * ac, ChannelElement * cc, /** * Convert spectral data to float samples, applying all supported tools as appropriate. */ -static void spectral_to_sample(AACContext * ac) { +static void spectral_to_sample(AACContext *ac) +{ int i, type; - for(type = 3; type >= 0; type--) { + float imdct_bias = (ac->m4ac.sbr <= 0) ? ac->add_bias : 0.0f; + for (type = 3; type >= 0; type--) { for (i = 0; i < MAX_ELEM_ID; i++) { ChannelElement *che = ac->che[type][i]; - if(che) { - if(type <= TYPE_CPE) + if (che) { + if (type <= TYPE_CPE) apply_channel_coupling(ac, che, type, i, BEFORE_TNS, apply_dependent_coupling); - if(che->ch[0].tns.present) + if (che->ch[0].tns.present) apply_tns(che->ch[0].coeffs, &che->ch[0].tns, &che->ch[0].ics, 1); - if(che->ch[1].tns.present) + if (che->ch[1].tns.present) apply_tns(che->ch[1].coeffs, &che->ch[1].tns, &che->ch[1].ics, 1); - if(type <= TYPE_CPE) + if (type <= TYPE_CPE) apply_channel_coupling(ac, che, type, i, BETWEEN_TNS_AND_IMDCT, apply_dependent_coupling); - if(type != TYPE_CCE || che->coup.coupling_point == AFTER_IMDCT) - imdct_and_windowing(ac, &che->ch[0]); - if(type == TYPE_CPE) - imdct_and_windowing(ac, &che->ch[1]); - if(type <= TYPE_CCE) + if (type != TYPE_CCE || che->coup.coupling_point == AFTER_IMDCT) { + imdct_and_windowing(ac, &che->ch[0], imdct_bias); + if (ac->m4ac.sbr > 0) { + ff_sbr_dequant(ac, &che->sbr, type == TYPE_CPE ? TYPE_CPE : TYPE_SCE); + ff_sbr_apply(ac, &che->sbr, 0, che->ch[0].ret, che->ch[0].ret); + } + } + if (type == TYPE_CPE) { + imdct_and_windowing(ac, &che->ch[1], imdct_bias); + if (ac->m4ac.sbr > 0) + ff_sbr_apply(ac, &che->sbr, 1, che->ch[1].ret, che->ch[1].ret); + } + if (type <= TYPE_CCE) apply_channel_coupling(ac, che, type, i, AFTER_IMDCT, apply_independent_coupling); } } } } -static int parse_adts_frame_header(AACContext * ac, GetBitContext * gb) { - +static int parse_adts_frame_header(AACContext *ac, GetBitContext *gb) +{ int size; AACADTSHeaderInfo hdr_info; size = ff_aac_parse_header(gb, &hdr_info); if (size > 0) { - if (hdr_info.chan_config) + if (ac->output_configured != OC_LOCKED && hdr_info.chan_config) { + enum ChannelPosition new_che_pos[4][MAX_ELEM_ID]; + memset(new_che_pos, 0, 4 * MAX_ELEM_ID * sizeof(new_che_pos[0][0])); ac->m4ac.chan_config = hdr_info.chan_config; + if (set_default_channel_config(ac, new_che_pos, hdr_info.chan_config)) + return -7; + if (output_configure(ac, ac->che_pos, new_che_pos, hdr_info.chan_config, OC_TRIAL_FRAME)) + return -7; + } else if (ac->output_configured != OC_LOCKED) { + ac->output_configured = OC_NONE; + } + if (ac->output_configured != OC_LOCKED) + ac->m4ac.sbr = -1; ac->m4ac.sample_rate = hdr_info.sample_rate; ac->m4ac.sampling_index = hdr_info.sampling_index; ac->m4ac.object_type = hdr_info.object_type; + if (!ac->avccontext->sample_rate) + ac->avccontext->sample_rate = hdr_info.sample_rate; if (hdr_info.num_aac_frames == 1) { if (!hdr_info.crc_absent) skip_bits(gb, 16); } else { - ff_log_missing_feature(ac->avccontext, "More than one AAC RDB per ADTS frame is", 0); + av_log_missing_feature(ac->avccontext, "More than one AAC RDB per ADTS frame is", 0); return -1; } } return size; } -static int aac_decode_frame(AVCodecContext * avccontext, void * data, int * data_size, AVPacket *avpkt) { +static int aac_decode_frame(AVCodecContext *avccontext, void *data, + int *data_size, AVPacket *avpkt) +{ const uint8_t *buf = avpkt->data; int buf_size = avpkt->size; - AACContext * ac = avccontext->priv_data; - ChannelElement * che = NULL; + AACContext *ac = avccontext->priv_data; + ChannelElement *che = NULL, *che_prev = NULL; GetBitContext gb; - enum RawDataBlockType elem_type; + enum RawDataBlockType elem_type, elem_type_prev = TYPE_END; int err, elem_id, data_size_tmp; + int buf_consumed; + int samples = 1024, multiplier; - init_get_bits(&gb, buf, buf_size*8); + init_get_bits(&gb, buf, buf_size * 8); if (show_bits(&gb, 12) == 0xfff) { if (parse_adts_frame_header(ac, &gb) < 0) { @@ -1624,7 +1975,7 @@ static int aac_decode_frame(AVCodecContext * avccontext, void * data, int * data while ((elem_type = get_bits(&gb, 3)) != TYPE_END) { elem_id = get_bits(&gb, 4); - if(elem_type < TYPE_DSE && !(che=get_che(ac, elem_type, elem_id))) { + if (elem_type < TYPE_DSE && !(che=get_che(ac, elem_type, elem_id))) { av_log(ac->avccontext, AV_LOG_ERROR, "channel element %d.%d is not allocated\n", elem_type, elem_id); return -1; } @@ -1648,25 +1999,31 @@ static int aac_decode_frame(AVCodecContext * avccontext, void * data, int * data break; case TYPE_DSE: - skip_data_stream_element(&gb); - err = 0; + err = skip_data_stream_element(ac, &gb); break; - case TYPE_PCE: - { + case TYPE_PCE: { enum ChannelPosition new_che_pos[4][MAX_ELEM_ID]; memset(new_che_pos, 0, 4 * MAX_ELEM_ID * sizeof(new_che_pos[0][0])); - if((err = decode_pce(ac, new_che_pos, &gb))) + if ((err = decode_pce(ac, new_che_pos, &gb))) break; - err = output_configure(ac, ac->che_pos, new_che_pos, 0); + if (ac->output_configured > OC_TRIAL_PCE) + av_log(avccontext, AV_LOG_ERROR, + "Not evaluating a further program_config_element as this construct is dubious at best.\n"); + else + err = output_configure(ac, ac->che_pos, new_che_pos, 0, OC_TRIAL_PCE); break; } case TYPE_FIL: if (elem_id == 15) elem_id += get_bits(&gb, 8) - 1; + if (get_bits_left(&gb) < 8 * elem_id) { + av_log(avccontext, AV_LOG_ERROR, overread_err); + return -1; + } while (elem_id > 0) - elem_id -= decode_extension_payload(ac, &gb, elem_id); + elem_id -= decode_extension_payload(ac, &gb, elem_id, che_prev, elem_type_prev); err = 0; /* FIXME */ break; @@ -1675,20 +2032,29 @@ static int aac_decode_frame(AVCodecContext * avccontext, void * data, int * data break; } - if(err) + che_prev = che; + elem_type_prev = elem_type; + + if (err) return err; + + if (get_bits_left(&gb) < 3) { + av_log(avccontext, AV_LOG_ERROR, overread_err); + return -1; + } } spectral_to_sample(ac); - if (!ac->is_saved) { - ac->is_saved = 1; - *data_size = 0; - return buf_size; + multiplier = (ac->m4ac.sbr == 1) ? ac->m4ac.ext_sample_rate > ac->m4ac.sample_rate : 0; + samples <<= multiplier; + if (ac->output_configured < OC_LOCKED) { + avccontext->sample_rate = ac->m4ac.sample_rate << multiplier; + avccontext->frame_size = samples; } - data_size_tmp = 1024 * avccontext->channels * sizeof(int16_t); - if(*data_size < data_size_tmp) { + data_size_tmp = samples * avccontext->channels * sizeof(int16_t); + if (*data_size < data_size_tmp) { av_log(avccontext, AV_LOG_ERROR, "Output buffer too small (%d) or trying to output too many samples (%d) for this frame.\n", *data_size, data_size_tmp); @@ -1696,28 +2062,36 @@ static int aac_decode_frame(AVCodecContext * avccontext, void * data, int * data } *data_size = data_size_tmp; - ac->dsp.float_to_int16_interleave(data, (const float **)ac->output_data, 1024, avccontext->channels); + ac->dsp.float_to_int16_interleave(data, (const float **)ac->output_data, samples, avccontext->channels); + + if (ac->output_configured) + ac->output_configured = OC_LOCKED; - return buf_size; + buf_consumed = (get_bits_count(&gb) + 7) >> 3; + return buf_size > buf_consumed ? buf_consumed : buf_size; } -static av_cold int aac_decode_close(AVCodecContext * avccontext) { - AACContext * ac = avccontext->priv_data; +static av_cold int aac_decode_close(AVCodecContext *avccontext) +{ + AACContext *ac = avccontext->priv_data; int i, type; for (i = 0; i < MAX_ELEM_ID; i++) { - for(type = 0; type < 4; type++) + for (type = 0; type < 4; type++) { + if (ac->che[type][i]) + ff_aac_sbr_ctx_close(&ac->che[type][i]->sbr); av_freep(&ac->che[type][i]); + } } ff_mdct_end(&ac->mdct); ff_mdct_end(&ac->mdct_small); - return 0 ; + return 0; } AVCodec aac_decoder = { "aac", - CODEC_TYPE_AUDIO, + AVMEDIA_TYPE_AUDIO, CODEC_ID_AAC, sizeof(AACContext), aac_decode_init, @@ -1725,5 +2099,8 @@ AVCodec aac_decoder = { aac_decode_close, aac_decode_frame, .long_name = NULL_IF_CONFIG_SMALL("Advanced Audio Coding"), - .sample_fmts = (enum SampleFormat[]){SAMPLE_FMT_S16,SAMPLE_FMT_NONE}, + .sample_fmts = (const enum SampleFormat[]) { + SAMPLE_FMT_S16,SAMPLE_FMT_NONE + }, + .channel_layouts = aac_channel_layout, };