Ticket #10079: aacfix-master.diff

File aacfix-master.diff, 27.1 KB (added by JYA, 8 years ago)
  • mythtv/external/FFmpeg/libavcodec/aac.h

    diff --git a/mythtv/external/FFmpeg/libavcodec/aac.h b/mythtv/external/FFmpeg/libavcodec/aac.h
    index a2bf70b..837f612 100644
    a b typedef struct { 
    130130#define SCALE_MAX_POS   255    ///< scalefactor index maximum value
    131131#define SCALE_MAX_DIFF   60    ///< maximum scalefactor difference allowed by standard
    132132#define SCALE_DIFF_ZERO  60    ///< codebook index corresponding to zero scalefactor indices difference
     133#define POW_SF2_ZERO    200    ///< ff_aac_pow2sf_tab index corresponding to pow(2, 0);
    133134
    134135/**
    135136 * Long Term Prediction
  • mythtv/external/FFmpeg/libavcodec/aacdec.c

    diff --git a/mythtv/external/FFmpeg/libavcodec/aacdec.c b/mythtv/external/FFmpeg/libavcodec/aacdec.c
    index a362d6a..214812d 100644
    a b static ChannelElement *get_che(AACContext *ac, int type, int elem_id) 
    178178 * @return  Returns error status. 0 - OK, !0 - error
    179179 */
    180180static av_cold int che_configure(AACContext *ac,
    181                          enum ChannelPosition che_pos[4][MAX_ELEM_ID],
    182                          int type, int id,
    183                          int *channels)
     181                                 enum ChannelPosition che_pos[4][MAX_ELEM_ID],
     182                                 int type, int id, int *channels)
    184183{
    185184    if (che_pos[type][id]) {
    186185        if (!ac->che[type][id] && !(ac->che[type][id] = av_mallocz(sizeof(ChannelElement))))
    static av_cold int che_configure(AACContext *ac, 
    210209 * @return  Returns error status. 0 - OK, !0 - error
    211210 */
    212211static av_cold int output_configure(AACContext *ac,
    213                             enum ChannelPosition che_pos[4][MAX_ELEM_ID],
    214                             enum ChannelPosition new_che_pos[4][MAX_ELEM_ID],
    215                             int channel_config, enum OCStatus oc_type)
     212                                    enum ChannelPosition che_pos[4][MAX_ELEM_ID],
     213                                    enum ChannelPosition new_che_pos[4][MAX_ELEM_ID],
     214                                    int channel_config, enum OCStatus oc_type)
    216215{
    217216    AVCodecContext *avctx = ac->avctx;
    218217    int i, type, channels = 0, ret;
    static av_cold int output_configure(AACContext *ac, 
    229228                return ret;
    230229        }
    231230
    232         memset(ac->tag_che_map, 0,       4 * MAX_ELEM_ID * sizeof(ac->che[0][0]));
     231        memset(ac->tag_che_map, 0, 4 * MAX_ELEM_ID * sizeof(ac->che[0][0]));
    233232
    234233        avctx->channel_layout = aac_channel_layout[channel_config - 1];
    235234    } else {
    static av_cold int output_configure(AACContext *ac, 
    250249        }
    251250
    252251        memcpy(ac->tag_che_map, ac->che, 4 * MAX_ELEM_ID * sizeof(ac->che[0][0]));
    253 
    254         avctx->channel_layout = 0;
    255252    }
    256253
    257254    avctx->channels = channels;
    static int decode_pce(AVCodecContext *avctx, MPEG4AudioConfig *m4ac, 
    314311    if (get_bits1(gb))
    315312        skip_bits(gb, 3); // mixdown_coeff_index and pseudo_surround
    316313
     314    if (get_bits_left(gb) < 4 * (num_front + num_side + num_back + num_lfe + num_assoc_data + num_cc)) {
     315        av_log(avctx, AV_LOG_ERROR, overread_err);
     316        return -1;
     317    }
    317318    decode_channel_map(new_che_pos[TYPE_CPE], new_che_pos[TYPE_SCE], AAC_CHANNEL_FRONT, gb, num_front);
    318319    decode_channel_map(new_che_pos[TYPE_CPE], new_che_pos[TYPE_SCE], AAC_CHANNEL_SIDE,  gb, num_side );
    319320    decode_channel_map(new_che_pos[TYPE_CPE], new_che_pos[TYPE_SCE], AAC_CHANNEL_BACK,  gb, num_back );
    static int decode_pce(AVCodecContext *avctx, MPEG4AudioConfig *m4ac, 
    344345 * @return  Returns error status. 0 - OK, !0 - error
    345346 */
    346347static av_cold int set_default_channel_config(AVCodecContext *avctx,
    347                                       enum ChannelPosition new_che_pos[4][MAX_ELEM_ID],
    348                                       int channel_config)
     348                                              enum ChannelPosition new_che_pos[4][MAX_ELEM_ID],
     349                                              int channel_config)
    349350{
    350351    if (channel_config < 1 || channel_config > 7) {
    351352        av_log(avctx, AV_LOG_ERROR, "invalid default channel configuration (%d)\n",
    static int decode_ga_specific_config(AACContext *ac, AVCodecContext *avctx, 
    457458static int decode_audio_specific_config(AACContext *ac,
    458459                                        AVCodecContext *avctx,
    459460                                        MPEG4AudioConfig *m4ac,
    460                                         const uint8_t *data, int data_size)
     461                                        const uint8_t *data, int data_size, int asclen)
    461462{
    462463    GetBitContext gb;
    463464    int i;
    464465
     466    av_dlog(avctx, "extradata size %d\n", avctx->extradata_size);
     467    for (i = 0; i < avctx->extradata_size; i++)
     468         av_dlog(avctx, "%02x ", avctx->extradata[i]);
     469    av_dlog(avctx, "\n");
     470
    465471    init_get_bits(&gb, data, data_size * 8);
    466472
    467     if ((i = ff_mpeg4audio_get_config(m4ac, data, data_size)) < 0)
     473    if ((i = ff_mpeg4audio_get_config(m4ac, data, asclen/8)) < 0)
    468474        return -1;
    469475    if (m4ac->sampling_index > 12) {
    470476        av_log(avctx, AV_LOG_ERROR, "invalid sampling rate index %d\n", m4ac->sampling_index);
    static int decode_audio_specific_config(AACContext *ac, 
    488494        return -1;
    489495    }
    490496
     497    av_dlog(avctx, "AOT %d chan config %d sampling index %d (%d) SBR %d PS %d\n",
     498            m4ac->object_type, m4ac->chan_config, m4ac->sampling_index,
     499            m4ac->sample_rate, m4ac->sbr, m4ac->ps);
     500
    491501    return get_bits_count(&gb);
    492502}
    493503
    static void reset_all_predictors(PredictorState *ps) 
    520530        reset_predict_state(&ps[i]);
    521531}
    522532
     533static int sample_rate_idx (int rate)
     534{
     535         if (92017 <= rate) return 0;
     536    else if (75132 <= rate) return 1;
     537    else if (55426 <= rate) return 2;
     538    else if (46009 <= rate) return 3;
     539    else if (37566 <= rate) return 4;
     540    else if (27713 <= rate) return 5;
     541    else if (23004 <= rate) return 6;
     542    else if (18783 <= rate) return 7;
     543    else if (13856 <= rate) return 8;
     544    else if (11502 <= rate) return 9;
     545    else if (9391  <= rate) return 10;
     546    else                    return 11;
     547}
     548
    523549static void reset_predictor_group(PredictorState *ps, int group_num)
    524550{
    525551    int i;
    static av_cold int aac_decode_init(AVCodecContext *avctx) 
    543569    if (avctx->extradata_size > 0) {
    544570        if (decode_audio_specific_config(ac, ac->avctx, &ac->m4ac,
    545571                                         avctx->extradata,
    546                                          avctx->extradata_size) < 0)
     572                                         avctx->extradata_size, 8*avctx->extradata_size) < 0)
    547573            return -1;
     574    } else {
     575        int sr, i;
     576        enum ChannelPosition new_che_pos[4][MAX_ELEM_ID];
     577
     578        sr = sample_rate_idx(avctx->sample_rate);
     579        ac->m4ac.sampling_index = sr;
     580        ac->m4ac.channels = avctx->channels;
     581        ac->m4ac.sbr = -1;
     582        ac->m4ac.ps = -1;
     583
     584        for (i = 0; i < FF_ARRAY_ELEMS(ff_mpeg4audio_channels); i++)
     585            if (ff_mpeg4audio_channels[i] == avctx->channels)
     586                break;
     587        if (i == FF_ARRAY_ELEMS(ff_mpeg4audio_channels)) {
     588            i = 0;
     589        }
     590        ac->m4ac.chan_config = i;
     591
     592        if (ac->m4ac.chan_config) {
     593            set_default_channel_config(avctx, new_che_pos, ac->m4ac.chan_config);
     594        }
    548595    }
    549596
    550597    avctx->sample_fmt = AV_SAMPLE_FMT_S16;
    static av_cold int aac_decode_init(AVCodecContext *avctx) 
    568615
    569616    ac->random_state = 0x1f2e3d4c;
    570617
    571     // -1024 - Compensate wrong IMDCT method.
    572     // 60    - Required to scale values to the correct range [-32768,32767]
    573     //         for float to int16 conversion. (1 << (60 / 4)) == 32768
    574     ac->sf_scale  = 1. / -1024.;
    575     ac->sf_offset = 60;
    576 
    577618    ff_aac_tableinit();
    578619
    579620    INIT_VLC_STATIC(&vlc_scalefactors,7,FF_ARRAY_ELEMS(ff_aac_scalefactor_code),
    static av_cold int aac_decode_init(AVCodecContext *avctx) 
    581622                    ff_aac_scalefactor_code, sizeof(ff_aac_scalefactor_code[0]), sizeof(ff_aac_scalefactor_code[0]),
    582623                    352);
    583624
    584     ff_mdct_init(&ac->mdct,       11, 1, 1.0);
    585     ff_mdct_init(&ac->mdct_small,  8, 1, 1.0);
    586     ff_mdct_init(&ac->mdct_ltp,   11, 0, 1.0);
     625    ff_mdct_init(&ac->mdct,       11, 1, 1.0/1024.0);
     626    ff_mdct_init(&ac->mdct_small,  8, 1, 1.0/128.0);
     627    ff_mdct_init(&ac->mdct_ltp,   11, 0, -2.0);
    587628    // window initialization
    588629    ff_kbd_window_init(ff_aac_kbd_long_1024, 4.0, 1024);
    589630    ff_kbd_window_init(ff_aac_kbd_short_128, 6.0, 128);
    static void decode_ltp(AACContext *ac, LongTermPrediction *ltp, 
    641682    int sfb;
    642683
    643684    ltp->lag  = get_bits(gb, 11);
    644     ltp->coef = ltp_coef[get_bits(gb, 3)] * ac->sf_scale;
     685    ltp->coef = ltp_coef[get_bits(gb, 3)];
    645686    for (sfb = 0; sfb < FFMIN(max_sfb, MAX_LTP_LONG_SFB); sfb++)
    646687        ltp->used[sfb] = get_bits1(gb);
    647688}
    static int decode_scalefactors(AACContext *ac, float sf[120], GetBitContext *gb, 
    779820                               enum BandType band_type[120],
    780821                               int band_type_run_end[120])
    781822{
    782     const int sf_offset = ac->sf_offset + (ics->window_sequence[0] == EIGHT_SHORT_SEQUENCE ? 12 : 0);
    783823    int g, i, idx = 0;
    784     int offset[3] = { global_gain, global_gain - 90, 100 };
     824    int offset[3] = { global_gain, global_gain - 90, 0 };
     825    int clipped_offset;
    785826    int noise_flag = 1;
    786827    static const char *sf_str[3] = { "Global gain", "Noise gain", "Intensity stereo position" };
    787828    for (g = 0; g < ics->num_window_groups; g++) {
    static int decode_scalefactors(AACContext *ac, float sf[120], GetBitContext *gb, 
    793834            } else if ((band_type[idx] == INTENSITY_BT) || (band_type[idx] == INTENSITY_BT2)) {
    794835                for (; i < run_end; i++, idx++) {
    795836                    offset[2] += get_vlc2(gb, vlc_scalefactors.table, 7, 3) - 60;
    796                     if (offset[2] > 255U) {
    797                         av_log(ac->avctx, AV_LOG_ERROR,
    798                                "%s (%d) out of range.\n", sf_str[2], offset[2]);
    799                         return -1;
     837                    clipped_offset = av_clip(offset[2], -155, 100);
     838                    if (offset[2] != clipped_offset) {
     839/*                        av_log_ask_for_sample(ac->avctx, "Intensity stereo "
     840                                "position clipped (%d -> %d).\nIf you heard an "
     841                                "audible artifact, there may be a bug in the "
     842                                "decoder. ", offset[2], clipped_offset);
     843*/
    800844                    }
    801                     sf[idx] = ff_aac_pow2sf_tab[-offset[2] + 300];
     845                    sf[idx] = ff_aac_pow2sf_tab[-clipped_offset + POW_SF2_ZERO];
    802846                }
    803847            } else if (band_type[idx] == NOISE_BT) {
    804848                for (; i < run_end; i++, idx++) {
    static int decode_scalefactors(AACContext *ac, float sf[120], GetBitContext *gb, 
    806850                        offset[1] += get_bits(gb, 9) - 256;
    807851                    else
    808852                        offset[1] += get_vlc2(gb, vlc_scalefactors.table, 7, 3) - 60;
    809                     if (offset[1] > 255U) {
    810                         av_log(ac->avctx, AV_LOG_ERROR,
    811                                "%s (%d) out of range.\n", sf_str[1], offset[1]);
    812                         return -1;
     853                    clipped_offset = av_clip(offset[1], -100, 155);
     854                    if (offset[1] != clipped_offset) {
     855/*                        av_log_ask_for_sample(ac->avctx, "Noise gain clipped "
     856                                "(%d -> %d).\nIf you heard an audible "
     857                                "artifact, there may be a bug in the decoder. ",
     858                                offset[1], clipped_offset);
     859*/
    813860                    }
    814                     sf[idx] = -ff_aac_pow2sf_tab[offset[1] + sf_offset + 100];
     861                    sf[idx] = -ff_aac_pow2sf_tab[clipped_offset + POW_SF2_ZERO];
    815862                }
    816863            } else {
    817864                for (; i < run_end; i++, idx++) {
    static int decode_scalefactors(AACContext *ac, float sf[120], GetBitContext *gb, 
    821868                               "%s (%d) out of range.\n", sf_str[0], offset[0]);
    822869                        return -1;
    823870                    }
    824                     sf[idx] = -ff_aac_pow2sf_tab[ offset[0] + sf_offset];
     871                    sf[idx] = -ff_aac_pow2sf_tab[offset[0] - 100 + POW_SF2_ZERO];
    825872                }
    826873            }
    827874        }
    static inline float *VMUL4S(float *dst, const float *v, unsigned idx, 
    9621009    union float754 s = { .f = *scale };
    9631010    union float754 t;
    9641011
    965     t.i = s.i ^ (sign & 1<<31);
     1012    t.i = s.i ^ (sign & 1U<<31);
    9661013    *dst++ = v[idx    & 3] * t.f;
    9671014
    9681015    sign <<= nz & 1; nz >>= 1;
    969     t.i = s.i ^ (sign & 1<<31);
     1016    t.i = s.i ^ (sign & 1U<<31);
    9701017    *dst++ = v[idx>>2 & 3] * t.f;
    9711018
    9721019    sign <<= nz & 1; nz >>= 1;
    973     t.i = s.i ^ (sign & 1<<31);
     1020    t.i = s.i ^ (sign & 1U<<31);
    9741021    *dst++ = v[idx>>4 & 3] * t.f;
    9751022
    9761023    sign <<= nz & 1; nz >>= 1;
    977     t.i = s.i ^ (sign & 1<<31);
     1024    t.i = s.i ^ (sign & 1U<<31);
    9781025    *dst++ = v[idx>>6 & 3] * t.f;
    9791026
    9801027    return dst;
    static int decode_spectrum_and_dequant(AACContext *ac, float coef[1024], 
    11671214                                    b += 4;
    11681215                                    n = (1 << b) + SHOW_UBITS(re, gb, b);
    11691216                                    LAST_SKIP_BITS(re, gb, b);
    1170                                     *icf++ = cbrt_tab[n] | (bits & 1<<31);
     1217                                    *icf++ = cbrt_tab[n] | (bits & 1U<<31);
    11711218                                    bits <<= 1;
    11721219                                } else {
    11731220                                    unsigned v = ((const uint32_t*)vq)[cb_idx & 15];
    1174                                     *icf++ = (bits & 1<<31) | v;
     1221                                    *icf++ = (bits & 1U<<31) | v;
    11751222                                    bits <<= !!v;
    11761223                                }
    11771224                                cb_idx >>= 4;
    static av_always_inline float flt16_trunc(float pf) 
    12321279}
    12331280
    12341281static av_always_inline void predict(PredictorState *ps, float *coef,
    1235                                      float sf_scale, float inv_sf_scale,
    1236                     int output_enable)
     1282                                     int output_enable)
    12371283{
    12381284    const float a     = 0.953125; // 61.0 / 64
    12391285    const float alpha = 0.90625;  // 29.0 / 32
    static av_always_inline void predict(PredictorState *ps, float *coef, 
    12491295
    12501296    pv = flt16_round(k1 * r0 + k2 * r1);
    12511297    if (output_enable)
    1252         *coef += pv * sf_scale;
     1298        *coef += pv;
    12531299
    1254     e0 = *coef * inv_sf_scale;
     1300    e0 = *coef;
    12551301    e1 = e0 - k1 * r0;
    12561302
    12571303    ps->cor1 = flt16_trunc(alpha * cor1 + r1 * e1);
    static av_always_inline void predict(PredictorState *ps, float *coef, 
    12691315static void apply_prediction(AACContext *ac, SingleChannelElement *sce)
    12701316{
    12711317    int sfb, k;
    1272     float sf_scale = ac->sf_scale, inv_sf_scale = 1 / ac->sf_scale;
    12731318
    12741319    if (!sce->ics.predictor_initialized) {
    12751320        reset_all_predictors(sce->predictor_state);
    static void apply_prediction(AACContext *ac, SingleChannelElement *sce) 
    12801325        for (sfb = 0; sfb < ff_aac_pred_sfb_max[ac->m4ac.sampling_index]; sfb++) {
    12811326            for (k = sce->ics.swb_offset[sfb]; k < sce->ics.swb_offset[sfb + 1]; k++) {
    12821327                predict(&sce->predictor_state[k], &sce->coeffs[k],
    1283                         sf_scale, inv_sf_scale,
    12841328                        sce->ics.predictor_present && sce->ics.prediction_used[sfb]);
    12851329            }
    12861330        }
    static void windowing_and_mdct_ltp(AACContext *ac, float *out, 
    17411785    } else {
    17421786        memset(in, 0, 448 * sizeof(float));
    17431787        ac->dsp.vector_fmul(in + 448, in + 448, swindow_prev, 128);
    1744         memcpy(in + 576, in + 576, 448 * sizeof(float));
    17451788    }
    17461789    if (ics->window_sequence[0] != LONG_START_SEQUENCE) {
    17471790        ac->dsp.vector_fmul_reverse(in + 1024, in + 1024, lwindow, 1024);
    17481791    } else {
    1749         memcpy(in + 1024, in + 1024, 448 * sizeof(float));
    17501792        ac->dsp.vector_fmul_reverse(in + 1024 + 448, in + 1024 + 448, swindow, 128);
    17511793        memset(in + 1024 + 576, 0, 448 * sizeof(float));
    17521794    }
    1753     ff_mdct_calc(&ac->mdct_ltp, out, in);
     1795    ac->mdct_ltp.mdct_calc(&ac->mdct_ltp, out, in);
    17541796}
    17551797
    17561798/**
    static void apply_ltp(AACContext *ac, SingleChannelElement *sce) 
    17631805    int i, sfb;
    17641806
    17651807    if (sce->ics.window_sequence[0] != EIGHT_SHORT_SEQUENCE) {
    1766         float *predTime = ac->buf_mdct;
    1767         float *predFreq = sce->ret;
     1808        float *predTime = sce->ret;
     1809        float *predFreq = ac->buf_mdct;
    17681810        int16_t num_samples = 2048;
    17691811
    17701812        if (ltp->lag < 1024)
    static void update_ltp(AACContext *ac, SingleChannelElement *sce) 
    17971839    const float *swindow = ics->use_kb_window[0] ? ff_aac_kbd_short_128 : ff_sine_128;
    17981840    int i;
    17991841
    1800     for (i = 0; i < 512; i++)
    1801         ac->buf_mdct[1535 - i] = ac->buf_mdct[512 + i];
    1802 
    18031842    if (ics->window_sequence[0] == EIGHT_SHORT_SEQUENCE) {
    18041843        memcpy(saved_ltp,       saved, 512 * sizeof(float));
    18051844        memset(saved_ltp + 576, 0,     448 * sizeof(float));
    1806         ac->dsp.vector_fmul_reverse(saved_ltp + 448, ac->buf_mdct + 960,     swindow,     128);
     1845        ac->dsp.vector_fmul_reverse(saved_ltp + 448, ac->buf_mdct + 960,     &swindow[64],      64);
     1846        for (i = 0; i < 64; i++)
     1847            saved_ltp[i + 512] = ac->buf_mdct[1023 - i] * swindow[63 - i];
    18071848    } else if (ics->window_sequence[0] == LONG_START_SEQUENCE) {
    18081849        memcpy(saved_ltp,       ac->buf_mdct + 512, 448 * sizeof(float));
    18091850        memset(saved_ltp + 576, 0,                  448 * sizeof(float));
    1810         ac->dsp.vector_fmul_reverse(saved_ltp + 448, ac->buf_mdct + 960,     swindow,     128);
     1851        ac->dsp.vector_fmul_reverse(saved_ltp + 448, ac->buf_mdct + 960,     &swindow[64],      64);
     1852        for (i = 0; i < 64; i++)
     1853            saved_ltp[i + 512] = ac->buf_mdct[1023 - i] * swindow[63 - i];
    18111854    } else { // LONG_STOP or ONLY_LONG
    1812         ac->dsp.vector_fmul_reverse(saved_ltp,       ac->buf_mdct + 512,     lwindow,     1024);
     1855        ac->dsp.vector_fmul_reverse(saved_ltp,       ac->buf_mdct + 512,     &lwindow[512],     512);
     1856        for (i = 0; i < 512; i++)
     1857            saved_ltp[i + 512] = ac->buf_mdct[1023 - i] * lwindow[511 - i];
    18131858    }
    18141859
    1815     memcpy(sce->ltp_state, &sce->ltp_state[1024], 1024 * sizeof(int16_t));
    1816     ac->fmt_conv.float_to_int16(&(sce->ltp_state[1024]), sce->ret,  1024);
    1817     ac->fmt_conv.float_to_int16(&(sce->ltp_state[2048]), saved_ltp, 1024);
     1860    memcpy(sce->ltp_state,      sce->ltp_state+1024, 1024 * sizeof(*sce->ltp_state));
     1861    memcpy(sce->ltp_state+1024, sce->ret,            1024 * sizeof(*sce->ltp_state));
     1862    memcpy(sce->ltp_state+2048, saved_ltp,           1024 * sizeof(*sce->ltp_state));
    18181863}
    18191864
    18201865/**
    static void imdct_and_windowing(AACContext *ac, SingleChannelElement *sce) 
    18361881    // imdct
    18371882    if (ics->window_sequence[0] == EIGHT_SHORT_SEQUENCE) {
    18381883        for (i = 0; i < 1024; i += 128)
    1839             ff_imdct_half(&ac->mdct_small, buf + i, in + i);
     1884            ac->mdct_small.imdct_half(&ac->mdct_small, buf + i, in + i);
    18401885    } else
    1841         ff_imdct_half(&ac->mdct, buf, in);
     1886        ac->mdct.imdct_half(&ac->mdct, buf, in);
    18421887
    18431888    /* window overlapping
    18441889     * NOTE: To simplify the overlapping code, all 'meaningless' short to long
    static int parse_adts_frame_header(AACContext *ac, GetBitContext *gb) 
    20232068
    20242069    size = ff_aac_parse_header(gb, &hdr_info);
    20252070    if (size > 0) {
    2026         if (ac->output_configured != OC_LOCKED && hdr_info.chan_config) {
     2071        if (hdr_info.chan_config) {
    20272072            enum ChannelPosition new_che_pos[4][MAX_ELEM_ID];
    20282073            memset(new_che_pos, 0, 4 * MAX_ELEM_ID * sizeof(new_che_pos[0][0]));
    20292074            ac->m4ac.chan_config = hdr_info.chan_config;
    static int parse_adts_frame_header(AACContext *ac, GetBitContext *gb) 
    20322077            if (output_configure(ac, ac->che_pos, new_che_pos, hdr_info.chan_config, OC_TRIAL_FRAME))
    20332078                return -7;
    20342079        } else if (ac->output_configured != OC_LOCKED) {
     2080            ac->m4ac.chan_config = 0;
    20352081            ac->output_configured = OC_NONE;
    20362082        }
    20372083        if (ac->output_configured != OC_LOCKED) {
    20382084            ac->m4ac.sbr = -1;
    20392085            ac->m4ac.ps  = -1;
     2086            ac->m4ac.sample_rate     = hdr_info.sample_rate;
     2087            ac->m4ac.sampling_index  = hdr_info.sampling_index;
     2088            ac->m4ac.object_type     = hdr_info.object_type;
    20402089        }
    2041         ac->m4ac.sample_rate     = hdr_info.sample_rate;
    2042         ac->m4ac.sampling_index  = hdr_info.sampling_index;
    2043         ac->m4ac.object_type     = hdr_info.object_type;
    20442090        if (!ac->avctx->sample_rate)
    20452091            ac->avctx->sample_rate = hdr_info.sample_rate;
    20462092        if (hdr_info.num_aac_frames == 1) {
    static int aac_decode_frame_int(AVCodecContext *avctx, void *data, 
    20612107    ChannelElement *che = NULL, *che_prev = NULL;
    20622108    enum RawDataBlockType elem_type, elem_type_prev = TYPE_END;
    20632109    int err, elem_id, data_size_tmp;
    2064     int samples = 0, multiplier;
     2110    int samples = 0, multiplier, audio_found = 0;
    20652111
    20662112    if (show_bits(gb, 12) == 0xfff) {
    20672113        if (parse_adts_frame_header(ac, gb) < 0) {
    static int aac_decode_frame_int(AVCodecContext *avctx, void *data, 
    20922138
    20932139        case TYPE_SCE:
    20942140            err = decode_ics(ac, &che->ch[0], gb, 0, 0);
     2141            audio_found = 1;
    20952142            break;
    20962143
    20972144        case TYPE_CPE:
    20982145            err = decode_cpe(ac, gb, che);
     2146            audio_found = 1;
    20992147            break;
    21002148
    21012149        case TYPE_CCE:
    static int aac_decode_frame_int(AVCodecContext *avctx, void *data, 
    21042152
    21052153        case TYPE_LFE:
    21062154            err = decode_ics(ac, &che->ch[0], gb, 0, 0);
     2155            audio_found = 1;
    21072156            break;
    21082157
    21092158        case TYPE_DSE:
    static int aac_decode_frame_int(AVCodecContext *avctx, void *data, 
    21732222    if (samples)
    21742223        ac->fmt_conv.float_to_int16_interleave(data, (const float **)ac->output_data, samples, avctx->channels);
    21752224
    2176     if (ac->output_configured)
     2225    if (ac->output_configured && audio_found)
    21772226        ac->output_configured = OC_LOCKED;
    21782227
    21792228    return 0;
    static inline uint32_t latm_get_value(GetBitContext *b) 
    22422291}
    22432292
    22442293static int latm_decode_audio_specific_config(struct LATMContext *latmctx,
    2245                                              GetBitContext *gb)
     2294                                             GetBitContext *gb, int asclen)
    22462295{
    22472296    AVCodecContext *avctx = latmctx->aac_ctx.avctx;
    22482297    MPEG4AudioConfig m4ac;
     2298    AACContext *ac= &latmctx->aac_ctx;
    22492299    int  config_start_bit = get_bits_count(gb);
    22502300    int     bits_consumed, esize;
    22512301
    static int latm_decode_audio_specific_config(struct LATMContext *latmctx, 
    22552305        return AVERROR_INVALIDDATA;
    22562306    } else {
    22572307        bits_consumed =
    2258             decode_audio_specific_config(NULL, avctx, &m4ac,
     2308            decode_audio_specific_config(ac, avctx, &m4ac,
    22592309                                         gb->buffer + (config_start_bit / 8),
    2260                                          get_bits_left(gb) / 8);
     2310                                         get_bits_left(gb) / 8, asclen);
    22612311
    22622312        if (bits_consumed < 0)
    22632313            return AVERROR_INVALIDDATA;
     2314        ac->m4ac= m4ac;
    22642315
    22652316        esize = (bits_consumed+7) / 8;
    22662317
    static int read_stream_mux_config(struct LATMContext *latmctx, 
    23152366
    23162367        // for all but first stream: use_same_config = get_bits(gb, 1);
    23172368        if (!audio_mux_version) {
    2318             if ((ret = latm_decode_audio_specific_config(latmctx, gb)) < 0)
     2369            if ((ret = latm_decode_audio_specific_config(latmctx, gb, 0)) < 0)
    23192370                return ret;
    23202371        } else {
    23212372            int ascLen = latm_get_value(gb);
    2322             if ((ret = latm_decode_audio_specific_config(latmctx, gb)) < 0)
     2373            if ((ret = latm_decode_audio_specific_config(latmctx, gb, ascLen)) < 0)
    23232374                return ret;
    23242375            ascLen -= ret;
    23252376            skip_bits_long(gb, ascLen);
    static int latm_decode_frame(AVCodecContext *avctx, void *out, int *out_size, 
    24422493            *out_size = 0;
    24432494            return avpkt->size;
    24442495        } else {
     2496            aac_decode_close(avctx);
    24452497            if ((err = aac_decode_init(avctx)) < 0)
    24462498                return err;
    24472499            latmctx->initialized = 1;
  • mythtv/external/FFmpeg/libavcodec/aacsbr.c

    diff --git a/mythtv/external/FFmpeg/libavcodec/aacsbr.c b/mythtv/external/FFmpeg/libavcodec/aacsbr.c
    index 237d51a..e2b37df 100644
    a b  
    3232#include "aacsbrdata.h"
    3333#include "fft.h"
    3434#include "aacps.h"
     35#include "libavutil/libm.h"
     36#include "libavutil/avassert.h"
    3537
    3638#include <stdint.h>
    3739#include <float.h>
     40#include <math.h>
    3841
    3942#define ENVELOPE_ADJUSTMENT_OFFSET 2
    4043#define NOISE_FLOOR_OFFSET 6.0f
    av_cold void ff_aac_sbr_init(void) 
    127130
    128131av_cold void ff_aac_sbr_ctx_init(SpectralBandReplication *sbr)
    129132{
     133    if(sbr->mdct.mdct_bits)
     134        return;
    130135    sbr->kx[0] = sbr->kx[1] = 32; //Typo in spec, kx' inits to 32
    131136    sbr->data[0].e_a[1] = sbr->data[1].e_a[1] = -1;
    132137    sbr->data[0].synthesis_filterbank_samples_offset = SBR_SYNTHESIS_BUF_SIZE - (1280 - 128);
    133138    sbr->data[1].synthesis_filterbank_samples_offset = SBR_SYNTHESIS_BUF_SIZE - (1280 - 128);
    134     ff_mdct_init(&sbr->mdct, 7, 1, 1.0/64);
     139    ff_mdct_init(&sbr->mdct,     7, 1, 1.0 / 64.0);
    135140    ff_mdct_init(&sbr->mdct_ana, 7, 1, -2.0);
    136141    ff_ps_ctx_init(&sbr->ps);
    137142}
    static void sbr_qmf_analysis(DSPContext *dsp, FFTContext *mdct, const float *in, 
    11551160        }
    11561161        z[64+63] = z[32];
    11571162
    1158         ff_imdct_half(mdct, z, z+64);
     1163        mdct->imdct_half(mdct, z, z+64);
    11591164        for (k = 0; k < 32; k++) {
    11601165            W[1][i][k][0] = -z[63-k];
    11611166            W[1][i][k][1] = z[k];
    static void sbr_qmf_synthesis(DSPContext *dsp, FFTContext *mdct, 
    11901195                X[0][i][   n] = -X[0][i][n];
    11911196                X[0][i][32+n] =  X[1][i][31-n];
    11921197            }
    1193             ff_imdct_half(mdct, mdct_buf[0], X[0][i]);
     1198            mdct->imdct_half(mdct, mdct_buf[0], X[0][i]);
    11941199            for (n = 0; n < 32; n++) {
    11951200                v[     n] =  mdct_buf[0][63 - 2*n];
    11961201                v[63 - n] = -mdct_buf[0][62 - 2*n];
    static void sbr_qmf_synthesis(DSPContext *dsp, FFTContext *mdct, 
    11991204            for (n = 1; n < 64; n+=2) {
    12001205                X[1][i][n] = -X[1][i][n];
    12011206            }
    1202             ff_imdct_half(mdct, mdct_buf[0], X[0][i]);
    1203             ff_imdct_half(mdct, mdct_buf[1], X[1][i]);
     1207            mdct->imdct_half(mdct, mdct_buf[0], X[0][i]);
     1208            mdct->imdct_half(mdct, mdct_buf[1], X[1][i]);
    12041209            for (n = 0; n < 64; n++) {
    12051210                v[      n] = -mdct_buf[0][63 -   n] + mdct_buf[1][  n    ];
    12061211                v[127 - n] =  mdct_buf[0][63 -   n] + mdct_buf[1][  n    ];
    static void sbr_mapping(AACContext *ac, SpectralBandReplication *sbr, 
    14501455        uint16_t *table = ch_data->bs_freq_res[e + 1] ? sbr->f_tablehigh : sbr->f_tablelow;
    14511456        int k;
    14521457
     1458        av_assert0(sbr->kx[1] <= table[0]);
    14531459        for (i = 0; i < ilim; i++)
    14541460            for (m = table[i]; m < table[i + 1]; m++)
    14551461                sbr->e_origmapped[e][m - sbr->kx[1]] = ch_data->env_facs[e+1][i];