X-Git-Url: https://git.sesse.net/?a=blobdiff_plain;f=libavcodec%2Fmpegaudiodec.c;h=54bcee3b08ff69f4fc0f2a0b446e3bad8863b607;hb=8e5606bfcd5a6d9d1666c1c59976e038d9a7320e;hp=7e27f75f50cf3ba8a20044bda6b09f642c2e5e98;hpb=bc2d2757bb532fa260c373adb00f4e47766e3449;p=ffmpeg diff --git a/libavcodec/mpegaudiodec.c b/libavcodec/mpegaudiodec.c index 7e27f75f50c..54bcee3b08f 100644 --- a/libavcodec/mpegaudiodec.c +++ b/libavcodec/mpegaudiodec.c @@ -2,18 +2,20 @@ * MPEG Audio decoder * Copyright (c) 2001, 2002 Fabrice Bellard. * - * This library is free software; you can redistribute it and/or + * This file is part of FFmpeg. + * + * FFmpeg is free software; you can redistribute it and/or * modify it under the terms of the GNU Lesser General Public * License as published by the Free Software Foundation; either - * version 2 of the License, or (at your option) any later version. + * version 2.1 of the License, or (at your option) any later version. * - * This library is distributed in the hope that it will be useful, + * FFmpeg is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU * Lesser General Public License for more details. * * You should have received a copy of the GNU Lesser General Public - * License along with this library; if not, write to the Free Software + * License along with FFmpeg; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA */ @@ -41,39 +43,10 @@ #include "mpegaudio.h" +#include "mathops.h" + #define FRAC_ONE (1 << FRAC_BITS) -#ifdef ARCH_X86 -# define MULL(ra, rb) \ - ({ int rt, dummy; asm (\ - "imull %3 \n\t"\ - "shrdl %4, %%edx, %%eax \n\t"\ - : "=a"(rt), "=d"(dummy)\ - : "a" (ra), "rm" (rb), "i"(FRAC_BITS));\ - rt; }) -# define MUL64(ra, rb) \ - ({ int64_t rt; asm ("imull %2\n\t" : "=A"(rt) : "a" (ra), "g" (rb)); rt; }) -# define MULH(ra, rb) \ - ({ int rt, dummy; asm ("imull %3\n\t" : "=d"(rt), "=a"(dummy): "a" (ra), "rm" (rb)); rt; }) -#elif defined(ARCH_ARMV4L) -# define MULL(a, b) \ - ({ int lo, hi;\ - asm("smull %0, %1, %2, %3 \n\t"\ - "mov %0, %0, lsr %4\n\t"\ - "add %1, %0, %1, lsl %5\n\t"\ - : "=&r"(lo), "=&r"(hi)\ - : "r"(b), "r"(a), "i"(FRAC_BITS), "i"(32-FRAC_BITS));\ - hi; }) -# define MUL64(a,b) ((int64_t)(a) * (int64_t)(b)) -# define MULH(a, b) ({ int lo, hi; asm ("smull %0, %1, %2, %3" : "=&r"(lo), "=&r"(hi) : "r"(b), "r"(a)); hi; }) -#else -# define MULL(a,b) (((int64_t)(a) * (int64_t)(b)) >> FRAC_BITS) -# define MUL64(a,b) ((int64_t)(a) * (int64_t)(b)) -//#define MULH(a,b) (((int64_t)(a) * (int64_t)(b))>>32) //gcc 3.4 creates an incredibly bloated mess out of this -static always_inline int MULH(int a, int b){ - return ((int64_t)(a) * (int64_t)(b))>>32; -} -#endif #define FIX(a) ((int)((a) * FRAC_ONE)) /* WARNING: only correct for posititive numbers */ #define FIXR(a) ((int)((a) * FRAC_ONE + 0.5)) @@ -85,16 +58,14 @@ static always_inline int MULH(int a, int b){ #define HEADER_SIZE 4 #define BACKSTEP_SIZE 512 +#define EXTRABYTES 24 struct GranuleDef; typedef struct MPADecodeContext { - uint8_t inbuf1[2][MPA_MAX_CODED_FRAME_SIZE + BACKSTEP_SIZE]; /* input buffer */ - int inbuf_index; - uint8_t *inbuf_ptr, *inbuf; + DECLARE_ALIGNED_8(uint8_t, last_buf[2*BACKSTEP_SIZE + EXTRABYTES]); + int last_buf_size; int frame_size; - int free_format_frame_size; /* frame size in case of free format - (zero if currently unknown) */ /* next header (used in free format parsing) */ uint32_t free_format_next_header; int error_protection; @@ -102,8 +73,8 @@ typedef struct MPADecodeContext { int sample_rate; int sample_rate_index; /* between 0 and 8 */ int bit_rate; - int old_frame_size; GetBitContext gb; + GetBitContext in_gb; int nb_channels; int mode; int mode_ext; @@ -117,7 +88,8 @@ typedef struct MPADecodeContext { #endif void (*compute_antialias)(struct MPADecodeContext *s, struct GranuleDef *g); int adu_mode; ///< 0 for standard mp3, 1 for adu formatted mp3 - unsigned int dither_state; + int dither_state; + int error_resilience; } MPADecodeContext; /** @@ -197,7 +169,6 @@ static const int32_t scale_factor_mult2[3][3] = { SCALE_GEN(4.0 / 9.0), /* 9 steps */ }; -void ff_mpa_synth_init(MPA_INT *window); static MPA_INT window[512] __attribute__((aligned(16))); /* layer 1 unscaling */ @@ -335,6 +306,7 @@ static int decode_init(AVCodecContext * avctx) #else avctx->sample_fmt= SAMPLE_FMT_S16; #endif + s->error_resilience= avctx->error_resilience; if(avctx->antialias_algo != FF_AA_FLOAT) s->compute_antialias= compute_antialias_integer; @@ -373,8 +345,8 @@ static int decode_init(AVCodecContext * avctx) const HuffTable *h = &mpa_huff_tables[i]; int xsize, x, y; unsigned int n; - uint8_t tmp_bits [256]; - uint16_t tmp_codes[256]; + uint8_t tmp_bits [512]; + uint16_t tmp_codes[512]; memset(tmp_bits , 0, sizeof(tmp_bits )); memset(tmp_codes, 0, sizeof(tmp_codes)); @@ -385,13 +357,13 @@ static int decode_init(AVCodecContext * avctx) j = 0; for(x=0;xbits [j ]; - tmp_codes[(x << 4) | y]= h->codes[j++]; + tmp_bits [(x << 5) | y | ((x&&y)<<4)]= h->bits [j ]; + tmp_codes[(x << 5) | y | ((x&&y)<<4)]= h->codes[j++]; } } /* XXX: fail test */ - init_vlc(&huff_vlc[i], 7, 256, + init_vlc(&huff_vlc[i], 7, 512, tmp_bits, 1, 1, tmp_codes, 2, 2, 1); } for(i=0;i<2;i++) { @@ -433,9 +405,9 @@ static int decode_init(AVCodecContext * avctx) for(i=0; i<512*16; i++){ int exponent= (i>>4); double f= pow(i&15, 4.0 / 3.0) * pow(2, (exponent-400)*0.25 + FRAC_BITS + 5); - expval_table[exponent][i&15]= lrintf(f); + expval_table[exponent][i&15]= llrint(f); if((i&15)==1) - exp_table[exponent]= lrintf(f); + exp_table[exponent]= llrint(f); } for(i=0;i<7;i++) { @@ -535,9 +507,6 @@ static int decode_init(AVCodecContext * avctx) init = 1; } - s->inbuf_index = 0; - s->inbuf = &s->inbuf1[s->inbuf_index][BACKSTEP_SIZE]; - s->inbuf_ptr = s->inbuf; #ifdef DEBUG s->frame_count = 0; #endif @@ -787,21 +756,12 @@ static inline int round_sample(int *sum) return sum1; } -# if defined(ARCH_POWERPC_405) - /* signed 16x16 -> 32 multiply add accumulate */ -# define MACS(rt, ra, rb) \ - asm ("maclhw %0, %2, %3" : "=r" (rt) : "0" (rt), "r" (ra), "r" (rb)); - - /* signed 16x16 -> 32 multiply */ -# define MULS(ra, rb) \ - ({ int __rt; asm ("mullhw %0, %1, %2" : "=r" (__rt) : "r" (ra), "r" (rb)); __rt; }) -# else - /* signed 16x16 -> 32 multiply add accumulate */ -# define MACS(rt, ra, rb) rt += (ra) * (rb) - - /* signed 16x16 -> 32 multiply */ -# define MULS(ra, rb) ((ra) * (rb)) -# endif +/* signed 16x16 -> 32 multiply add accumulate */ +#define MACS(rt, ra, rb) MAC16(rt, ra, rb) + +/* signed 16x16 -> 32 multiply */ +#define MULS(ra, rb) MUL16(ra, rb) + #else static inline int round_sample(int64_t *sum) @@ -1208,26 +1168,7 @@ static int decode_header(MPADecodeContext *s, uint32_t header) s->frame_size = frame_size; } else { /* if no frame size computed, signal it */ - if (!s->free_format_frame_size) - return 1; - /* free format: compute bitrate and real frame size from the - frame size we extracted by reading the bitstream */ - s->frame_size = s->free_format_frame_size; - switch(s->layer) { - case 1: - s->frame_size += padding * 4; - s->bit_rate = (s->frame_size * sample_rate) / 48000; - break; - case 2: - s->frame_size += padding; - s->bit_rate = (s->frame_size * sample_rate) / 144000; - break; - default: - case 3: - s->frame_size += padding; - s->bit_rate = (s->frame_size * (sample_rate << s->lsf)) / 144000; - break; - } + return 1; } #if defined(DEBUG) @@ -1251,10 +1192,9 @@ static int decode_header(MPADecodeContext *s, uint32_t header) /* useful helper to get mpeg audio stream infos. Return -1 if error in header, otherwise the coded frame size in bytes */ -int mpa_decode_header(AVCodecContext *avctx, uint32_t head) +int mpa_decode_header(AVCodecContext *avctx, uint32_t head, int *sample_rate) { MPADecodeContext s1, *s = &s1; - memset( s, 0, sizeof(MPADecodeContext) ); if (ff_mpa_check_header(head) != 0) return -1; @@ -1279,7 +1219,7 @@ int mpa_decode_header(AVCodecContext *avctx, uint32_t head) break; } - avctx->sample_rate = s->sample_rate; + *sample_rate = s->sample_rate; avctx->channels = s->nb_channels; avctx->bit_rate = s->bit_rate; avctx->sub_id = s->layer; @@ -1585,29 +1525,6 @@ static int mp_decode_layer2(MPADecodeContext *s) return 3 * 12; } -/* - * Seek back in the stream for backstep bytes (at most 511 bytes) - */ -static void seek_to_maindata(MPADecodeContext *s, unsigned int backstep) -{ - uint8_t *ptr; - - /* compute current position in stream */ - ptr = (uint8_t *)(s->gb.buffer + (get_bits_count(&s->gb)>>3)); - - /* copy old data before current one */ - ptr -= backstep; - memcpy(ptr, s->inbuf1[s->inbuf_index ^ 1] + - BACKSTEP_SIZE + s->old_frame_size - backstep, backstep); - /* init get bits again */ - init_get_bits(&s->gb, ptr, (s->frame_size + backstep)*8); - - /* prepare next buffer */ - s->inbuf_index ^= 1; - s->inbuf = &s->inbuf1[s->inbuf_index][BACKSTEP_SIZE]; - s->old_frame_size = s->frame_size; -} - static inline void lsf_sf_expand(int *slen, int sf, int n1, int n2, int n3) { @@ -1676,16 +1593,18 @@ static inline int get_bitsz(GetBitContext *s, int n) } static int huffman_decode(MPADecodeContext *s, GranuleDef *g, - int16_t *exponents, int end_pos) + int16_t *exponents, int end_pos2) { int s_index; - int linbits, code, x, y, l, v, i, j, k, pos; - int last_pos; + int i; + int last_pos, bits_left; VLC *vlc; + int end_pos= FFMIN(end_pos2, s->gb.size_in_bits); /* low frequencies (called big values) */ s_index = 0; for(i=0;i<3;i++) { + int j, k, l, linbits; j = g->region_size[i]; if (j == 0) continue; @@ -1696,17 +1615,31 @@ static int huffman_decode(MPADecodeContext *s, GranuleDef *g, vlc = &huff_vlc[l]; if(!l){ - memset(&g->sb_hybrid[s_index], 0, sizeof(*g->sb_hybrid)*j); + memset(&g->sb_hybrid[s_index], 0, sizeof(*g->sb_hybrid)*2*j); s_index += 2*j; continue; } /* read huffcode and compute each couple */ for(;j>0;j--) { - int exponent; - - if (get_bits_count(&s->gb) >= end_pos) - break; + int exponent, x, y, v; + int pos= get_bits_count(&s->gb); + + if (pos >= end_pos){ +// av_log(NULL, AV_LOG_ERROR, "pos: %d %d %d %d\n", pos, end_pos, end_pos2, s_index); + if(s->in_gb.buffer && pos >= s->gb.size_in_bits){ + s->gb= s->in_gb; + s->in_gb.buffer=NULL; + assert((get_bits_count(&s->gb) & 7) == 0); + skip_bits_long(&s->gb, pos - end_pos); + end_pos2= + end_pos= end_pos2 + get_bits_count(&s->gb) - pos; + pos= get_bits_count(&s->gb); + } +// av_log(NULL, AV_LOG_ERROR, "new pos: %d %d\n", pos, end_pos); + if(pos >= end_pos) + break; + } y = get_vlc2(&s->gb, vlc->table, 7, 3); if(!y){ @@ -1716,18 +1649,13 @@ static int huffman_decode(MPADecodeContext *s, GranuleDef *g, continue; } - x = y >> 4; - y = y & 0x0f; exponent= exponents[s_index]; dprintf("region=%d n=%d x=%d y=%d exp=%d\n", i, g->region_size[i] - j, x, y, exponent); - if (x) { -#if 0 - if (x == 15) - x += get_bitsz(&s->gb, linbits); - v = l3_unscale(x, exponent); -#else + if(y&16){ + x = y >> 5; + y = y & 0x0f; if (x < 15){ v = expval_table[ exponent ][ x ]; // v = expval_table[ (exponent&3) ][ x ] >> FFMIN(0 - (exponent>>2), 31); @@ -1735,32 +1663,34 @@ static int huffman_decode(MPADecodeContext *s, GranuleDef *g, x += get_bitsz(&s->gb, linbits); v = l3_unscale(x, exponent); } -#endif if (get_bits1(&s->gb)) v = -v; - } else { - v = 0; - } - g->sb_hybrid[s_index++] = v; - if (y) { -#if 0 - if (y == 15) - y += get_bitsz(&s->gb, linbits); - v = l3_unscale(y, exponent); -#else + g->sb_hybrid[s_index] = v; if (y < 15){ v = expval_table[ exponent ][ y ]; }else{ y += get_bitsz(&s->gb, linbits); v = l3_unscale(y, exponent); } -#endif if (get_bits1(&s->gb)) v = -v; - } else { - v = 0; + g->sb_hybrid[s_index+1] = v; + }else{ + x = y >> 5; + y = y & 0x0f; + x += y; + if (x < 15){ + v = expval_table[ exponent ][ x ]; + }else{ + x += get_bitsz(&s->gb, linbits); + v = l3_unscale(x, exponent); + } + if (get_bits1(&s->gb)) + v = -v; + g->sb_hybrid[s_index+!!y] = v; + g->sb_hybrid[s_index+ !y] = 0; } - g->sb_hybrid[s_index++] = v; + s_index+=2; } } @@ -1768,16 +1698,32 @@ static int huffman_decode(MPADecodeContext *s, GranuleDef *g, vlc = &huff_quad_vlc[g->count1table_select]; last_pos=0; while (s_index <= 572) { + int pos, code; pos = get_bits_count(&s->gb); if (pos >= end_pos) { - if (pos > end_pos && last_pos){ + if (pos > end_pos2 && last_pos){ /* some encoders generate an incorrect size for this part. We must go back into the data */ s_index -= 4; - init_get_bits(&s->gb, s->gb.buffer + 4*(last_pos>>5), s->gb.size_in_bits - (last_pos&(~31))); - skip_bits(&s->gb, last_pos&31); + skip_bits_long(&s->gb, last_pos - pos); + av_log(NULL, AV_LOG_INFO, "overread, skip %d enddists: %d %d\n", last_pos - pos, end_pos-pos, end_pos2-pos); + if(s->error_resilience >= FF_ER_COMPLIANT) + s_index=0; + break; } - break; +// av_log(NULL, AV_LOG_ERROR, "pos2: %d %d %d %d\n", pos, end_pos, end_pos2, s_index); + if(s->in_gb.buffer && pos >= s->gb.size_in_bits){ + s->gb= s->in_gb; + s->in_gb.buffer=NULL; + assert((get_bits_count(&s->gb) & 7) == 0); + skip_bits_long(&s->gb, pos - end_pos); + end_pos2= + end_pos= end_pos2 + get_bits_count(&s->gb) - pos; + pos= get_bits_count(&s->gb); + } +// av_log(NULL, AV_LOG_ERROR, "new pos2: %d %d %d\n", pos, end_pos, s_index); + if(pos >= end_pos) + break; } last_pos= pos; @@ -1789,6 +1735,7 @@ static int huffman_decode(MPADecodeContext *s, GranuleDef *g, g->sb_hybrid[s_index+3]= 0; while(code){ const static int idxtab[16]={3,3,2,2,1,1,1,1,0,0,0,0,0,0,0,0}; + int v; int pos= s_index+idxtab[code]; code ^= 8>>idxtab[code]; v = exp_table[ exponents[pos] ]; @@ -1799,7 +1746,19 @@ static int huffman_decode(MPADecodeContext *s, GranuleDef *g, } s_index+=4; } + /* skip extension bits */ + bits_left = end_pos - get_bits_count(&s->gb); +//av_log(NULL, AV_LOG_ERROR, "left:%d buf:%p\n", bits_left, s->in_gb.buffer); + if (bits_left < 0 || bits_left > 16) { + av_log(NULL, AV_LOG_ERROR, "bits_left=%d\n", bits_left); + s_index=0; + }else if(bits_left > 0 && s->error_resilience >= FF_ER_AGGRESSIVE){ + av_log(NULL, AV_LOG_ERROR, "bits_left=%d\n", bits_left); + s_index=0; + } memset(&g->sb_hybrid[s_index], 0, sizeof(*g->sb_hybrid)*(576 - s_index)); + skip_bits_long(&s->gb, bits_left); + return 0; } @@ -2185,7 +2144,7 @@ void sample_dump(int fnum, int32_t *tab, int n) static int mp_decode_layer3(MPADecodeContext *s) { int nb_granules, main_data_begin, private_bits; - int gr, ch, blocksplit_flag, i, j, k, n, bits_pos, bits_left; + int gr, ch, blocksplit_flag, i, j, k, n, bits_pos; GranuleDef granules[2][2], *g; int16_t exponents[576]; @@ -2213,6 +2172,11 @@ static int mp_decode_layer3(MPADecodeContext *s) g = &granules[ch][gr]; g->part2_3_length = get_bits(&s->gb, 12); g->big_values = get_bits(&s->gb, 9); + if(g->big_values > 288){ + av_log(NULL, AV_LOG_ERROR, "big_values too big\n"); + return -1; + } + g->global_gain = get_bits(&s->gb, 8); /* if MS stereo only is selected, we precompute the 1/sqrt(2) renormalization factor */ @@ -2226,8 +2190,10 @@ static int mp_decode_layer3(MPADecodeContext *s) blocksplit_flag = get_bits(&s->gb, 1); if (blocksplit_flag) { g->block_type = get_bits(&s->gb, 2); - if (g->block_type == 0) + if (g->block_type == 0){ + av_log(NULL, AV_LOG_ERROR, "invalid block type\n"); return -1; + } g->switch_point = get_bits(&s->gb, 1); for(i=0;i<2;i++) g->table_select[i] = get_bits(&s->gb, 5); @@ -2309,14 +2275,33 @@ static int mp_decode_layer3(MPADecodeContext *s) } if (!s->adu_mode) { + const uint8_t *ptr = s->gb.buffer + (get_bits_count(&s->gb)>>3); + assert((get_bits_count(&s->gb) & 7) == 0); /* now we get bits from the main_data_begin offset */ dprintf("seekback: %d\n", main_data_begin); - seek_to_maindata(s, main_data_begin); +//av_log(NULL, AV_LOG_ERROR, "backstep:%d, lastbuf:%d\n", main_data_begin, s->last_buf_size); + + memcpy(s->last_buf + s->last_buf_size, ptr, EXTRABYTES); + s->in_gb= s->gb; + init_get_bits(&s->gb, s->last_buf, s->last_buf_size*8); + skip_bits_long(&s->gb, 8*(s->last_buf_size - main_data_begin)); } for(gr=0;grnb_channels;ch++) { g = &granules[ch][gr]; + if(get_bits_count(&s->gb)<0){ + av_log(NULL, AV_LOG_ERROR, "mdb:%d, lastbuf:%d skiping granule %d\n", + main_data_begin, s->last_buf_size, gr); + skip_bits_long(&s->gb, g->part2_3_length); + memset(g->sb_hybrid, 0, sizeof(g->sb_hybrid)); + if(get_bits_count(&s->gb) >= s->gb.size_in_bits && s->in_gb.buffer){ + skip_bits_long(&s->in_gb, get_bits_count(&s->gb) - s->gb.size_in_bits); + s->gb= s->in_gb; + s->in_gb.buffer=NULL; + } + continue; + } bits_pos = get_bits_count(&s->gb); @@ -2447,25 +2432,10 @@ static int mp_decode_layer3(MPADecodeContext *s) exponents_from_scale_factors(s, g, exponents); /* read Huffman coded residue */ - if (huffman_decode(s, g, exponents, - bits_pos + g->part2_3_length) < 0) - return -1; + huffman_decode(s, g, exponents, bits_pos + g->part2_3_length); #if defined(DEBUG) sample_dump(0, g->sb_hybrid, 576); #endif - - /* skip extension bits */ - bits_left = g->part2_3_length - (get_bits_count(&s->gb) - bits_pos); - if (bits_left < 0) { - dprintf("bits_left=%d\n", bits_left); - return -1; - } - while (bits_left >= 16) { - skip_bits(&s->gb, 16); - bits_left -= 16; - } - if (bits_left > 0) - skip_bits(&s->gb, bits_left); } /* ch */ if (s->nb_channels == 2) @@ -2488,17 +2458,18 @@ static int mp_decode_layer3(MPADecodeContext *s) #endif } } /* gr */ + if(get_bits_count(&s->gb)<0) + skip_bits_long(&s->gb, -get_bits_count(&s->gb)); return nb_granules * 18; } static int mp_decode_frame(MPADecodeContext *s, - OUT_INT *samples) + OUT_INT *samples, const uint8_t *buf, int buf_size) { int i, nb_frames, ch; OUT_INT *samples_ptr; - init_get_bits(&s->gb, s->inbuf + HEADER_SIZE, - (s->inbuf_ptr - s->inbuf - HEADER_SIZE)*8); + init_get_bits(&s->gb, buf + HEADER_SIZE, (buf_size - HEADER_SIZE)*8); /* skip error protection field */ if (s->error_protection) @@ -2515,6 +2486,32 @@ static int mp_decode_frame(MPADecodeContext *s, case 3: default: nb_frames = mp_decode_layer3(s); + + s->last_buf_size=0; + if(s->in_gb.buffer){ + align_get_bits(&s->gb); + i= (s->gb.size_in_bits - get_bits_count(&s->gb))>>3; + if(i >= 0 && i <= BACKSTEP_SIZE){ + memmove(s->last_buf, s->gb.buffer + (get_bits_count(&s->gb)>>3), i); + s->last_buf_size=i; + }else + av_log(NULL, AV_LOG_ERROR, "invalid old backstep %d\n", i); + s->gb= s->in_gb; + s->in_gb.buffer= NULL; + } + + align_get_bits(&s->gb); + assert((get_bits_count(&s->gb) & 7) == 0); + i= (s->gb.size_in_bits - get_bits_count(&s->gb))>>3; + + if(i<0 || i > BACKSTEP_SIZE || nb_frames<0){ + av_log(NULL, AV_LOG_ERROR, "invalid new backstep %d\n", i); + i= FFMIN(BACKSTEP_SIZE, buf_size - HEADER_SIZE); + } + assert(i <= buf_size - HEADER_SIZE && i>= 0); + memcpy(s->last_buf + s->last_buf_size, s->gb.buffer + buf_size - HEADER_SIZE - i, i); + s->last_buf_size += i; + break; } #if defined(DEBUG) @@ -2551,162 +2548,69 @@ static int decode_frame(AVCodecContext * avctx, { MPADecodeContext *s = avctx->priv_data; uint32_t header; - uint8_t *buf_ptr; - int len, out_size; + int out_size; OUT_INT *out_samples = data; - buf_ptr = buf; - while (buf_size > 0) { - len = s->inbuf_ptr - s->inbuf; - if (s->frame_size == 0) { - /* special case for next header for first frame in free - format case (XXX: find a simpler method) */ - if (s->free_format_next_header != 0) { - s->inbuf[0] = s->free_format_next_header >> 24; - s->inbuf[1] = s->free_format_next_header >> 16; - s->inbuf[2] = s->free_format_next_header >> 8; - s->inbuf[3] = s->free_format_next_header; - s->inbuf_ptr = s->inbuf + 4; - s->free_format_next_header = 0; - goto got_header; - } - /* no header seen : find one. We need at least HEADER_SIZE - bytes to parse it */ - len = HEADER_SIZE - len; - if (len > buf_size) - len = buf_size; - if (len > 0) { - memcpy(s->inbuf_ptr, buf_ptr, len); - buf_ptr += len; - buf_size -= len; - s->inbuf_ptr += len; - } - if ((s->inbuf_ptr - s->inbuf) >= HEADER_SIZE) { - got_header: - header = (s->inbuf[0] << 24) | (s->inbuf[1] << 16) | - (s->inbuf[2] << 8) | s->inbuf[3]; - - if (ff_mpa_check_header(header) < 0) { - /* no sync found : move by one byte (inefficient, but simple!) */ - memmove(s->inbuf, s->inbuf + 1, s->inbuf_ptr - s->inbuf - 1); - s->inbuf_ptr--; - dprintf("skip %x\n", header); - /* reset free format frame size to give a chance - to get a new bitrate */ - s->free_format_frame_size = 0; - } else { - if (decode_header(s, header) == 1) { - /* free format: prepare to compute frame size */ - s->frame_size = -1; - } - /* update codec info */ - avctx->sample_rate = s->sample_rate; - avctx->channels = s->nb_channels; - avctx->bit_rate = s->bit_rate; - avctx->sub_id = s->layer; - switch(s->layer) { - case 1: - avctx->frame_size = 384; - break; - case 2: - avctx->frame_size = 1152; - break; - case 3: - if (s->lsf) - avctx->frame_size = 576; - else - avctx->frame_size = 1152; - break; - } - } - } - } else if (s->frame_size == -1) { - /* free format : find next sync to compute frame size */ - len = MPA_MAX_CODED_FRAME_SIZE - len; - if (len > buf_size) - len = buf_size; - if (len == 0) { - /* frame too long: resync */ - s->frame_size = 0; - memmove(s->inbuf, s->inbuf + 1, s->inbuf_ptr - s->inbuf - 1); - s->inbuf_ptr--; - } else { - uint8_t *p, *pend; - uint32_t header1; - int padding; - - memcpy(s->inbuf_ptr, buf_ptr, len); - /* check for header */ - p = s->inbuf_ptr - 3; - pend = s->inbuf_ptr + len - 4; - while (p <= pend) { - header = (p[0] << 24) | (p[1] << 16) | - (p[2] << 8) | p[3]; - header1 = (s->inbuf[0] << 24) | (s->inbuf[1] << 16) | - (s->inbuf[2] << 8) | s->inbuf[3]; - /* check with high probability that we have a - valid header */ - if ((header & SAME_HEADER_MASK) == - (header1 & SAME_HEADER_MASK)) { - /* header found: update pointers */ - len = (p + 4) - s->inbuf_ptr; - buf_ptr += len; - buf_size -= len; - s->inbuf_ptr = p; - /* compute frame size */ - s->free_format_next_header = header; - s->free_format_frame_size = s->inbuf_ptr - s->inbuf; - padding = (header1 >> 9) & 1; - if (s->layer == 1) - s->free_format_frame_size -= padding * 4; - else - s->free_format_frame_size -= padding; - dprintf("free frame size=%d padding=%d\n", - s->free_format_frame_size, padding); - decode_header(s, header1); - goto next_data; - } - p++; - } - /* not found: simply increase pointers */ - buf_ptr += len; - s->inbuf_ptr += len; - buf_size -= len; - } - } else if (len < s->frame_size) { - if (s->frame_size > MPA_MAX_CODED_FRAME_SIZE) - s->frame_size = MPA_MAX_CODED_FRAME_SIZE; - len = s->frame_size - len; - if (len > buf_size) - len = buf_size; - memcpy(s->inbuf_ptr, buf_ptr, len); - buf_ptr += len; - s->inbuf_ptr += len; - buf_size -= len; - } - next_data: - if (s->frame_size > 0 && - (s->inbuf_ptr - s->inbuf) >= s->frame_size) { - if (avctx->parse_only) { - /* simply return the frame data */ - *(uint8_t **)data = s->inbuf; - out_size = s->inbuf_ptr - s->inbuf; - } else { - out_size = mp_decode_frame(s, out_samples); - } - s->inbuf_ptr = s->inbuf; - s->frame_size = 0; - if(out_size>=0) - *data_size = out_size; - else - av_log(avctx, AV_LOG_DEBUG, "Error while decoding mpeg audio frame\n"); //FIXME return -1 / but also return the number of bytes consumed - break; - } +retry: + if(buf_size < HEADER_SIZE) + return -1; + + header = (buf[0] << 24) | (buf[1] << 16) | (buf[2] << 8) | buf[3]; + if(ff_mpa_check_header(header) < 0){ + buf++; +// buf_size--; + av_log(avctx, AV_LOG_ERROR, "Header missing skipping one byte.\n"); + goto retry; + } + + if (decode_header(s, header) == 1) { + /* free format: prepare to compute frame size */ + s->frame_size = -1; + return -1; + } + /* update codec info */ + avctx->channels = s->nb_channels; + avctx->bit_rate = s->bit_rate; + avctx->sub_id = s->layer; + switch(s->layer) { + case 1: + avctx->frame_size = 384; + break; + case 2: + avctx->frame_size = 1152; + break; + case 3: + if (s->lsf) + avctx->frame_size = 576; + else + avctx->frame_size = 1152; + break; } - return buf_ptr - buf; + + if(s->frame_size<=0 || s->frame_size > buf_size){ + av_log(avctx, AV_LOG_ERROR, "incomplete frame\n"); + return -1; + }else if(s->frame_size < buf_size){ + av_log(avctx, AV_LOG_ERROR, "incorrect frame size\n"); + } + + out_size = mp_decode_frame(s, out_samples, buf, buf_size); + if(out_size>=0){ + *data_size = out_size; + avctx->sample_rate = s->sample_rate; + //FIXME maybe move the other codec info stuff from above here too + }else + av_log(avctx, AV_LOG_DEBUG, "Error while decoding MPEG audio frame.\n"); //FIXME return -1 / but also return the number of bytes consumed + s->frame_size = 0; + return buf_size; } +static void flush(AVCodecContext *avctx){ + MPADecodeContext *s = avctx->priv_data; + s->last_buf_size= 0; +} +#ifdef CONFIG_MP3ADU_DECODER static int decode_frame_adu(AVCodecContext * avctx, void *data, int *data_size, uint8_t * buf, int buf_size) @@ -2728,12 +2632,8 @@ static int decode_frame_adu(AVCodecContext * avctx, if (len > MPA_MAX_CODED_FRAME_SIZE) len = MPA_MAX_CODED_FRAME_SIZE; - memcpy(s->inbuf, buf, len); - s->inbuf_ptr = s->inbuf + len; - // Get header and restore sync word - header = (s->inbuf[0] << 24) | (s->inbuf[1] << 16) | - (s->inbuf[2] << 8) | s->inbuf[3] | 0xffe00000; + header = (buf[0] << 24) | (buf[1] << 16) | (buf[2] << 8) | buf[3] | 0xffe00000; if (ff_mpa_check_header(header) < 0) { // Bad header, discard frame *data_size = 0; @@ -2750,18 +2650,17 @@ static int decode_frame_adu(AVCodecContext * avctx, avctx->frame_size=s->frame_size = len; if (avctx->parse_only) { - /* simply return the frame data */ - *(uint8_t **)data = s->inbuf; - out_size = s->inbuf_ptr - s->inbuf; + out_size = buf_size; } else { - out_size = mp_decode_frame(s, out_samples); + out_size = mp_decode_frame(s, out_samples, buf, buf_size); } *data_size = out_size; return buf_size; } +#endif /* CONFIG_MP3ADU_DECODER */ - +#ifdef CONFIG_MP3ON4_DECODER /* Next 3 arrays are indexed by channel config number (passed via codecdata) */ static int mp3Frames[16] = {0,1,1,2,3,3,4,5,2}; /* number of mp3 decoder instances */ static int mp3Channels[16] = {0,1,2,3,4,5,6,8,4}; /* total output channels */ @@ -2817,8 +2716,6 @@ static int decode_init_mp3on4(AVCodecContext * avctx) for (i = 1; i < s->frames; i++) { s->mp3decctx[i] = av_mallocz(sizeof(MPADecodeContext)); s->mp3decctx[i]->compute_antialias = s->mp3decctx[0]->compute_antialias; - s->mp3decctx[i]->inbuf = &s->mp3decctx[i]->inbuf1[0][BACKSTEP_SIZE]; - s->mp3decctx[i]->inbuf_ptr = s->mp3decctx[i]->inbuf; s->mp3decctx[i]->adu_mode = 1; } @@ -2878,13 +2775,9 @@ static int decode_frame_mp3on4(AVCodecContext * avctx, fsize = MPA_MAX_CODED_FRAME_SIZE; m = s->mp3decctx[fr]; assert (m != NULL); - /* copy original to new */ - m->inbuf_ptr = m->inbuf + fsize; - memcpy(m->inbuf, start, fsize); // Get header - header = (m->inbuf[0] << 24) | (m->inbuf[1] << 16) | - (m->inbuf[2] << 8) | m->inbuf[3] | 0xfff00000; + header = (start[0] << 24) | (start[1] << 16) | (start[2] << 8) | start[3] | 0xfff00000; if (ff_mpa_check_header(header) < 0) { // Bad header, discard block *data_size = 0; @@ -2892,7 +2785,7 @@ static int decode_frame_mp3on4(AVCodecContext * avctx, } decode_header(m, header); - mp_decode_frame(m, decoded_buf); + mp_decode_frame(m, decoded_buf, start, fsize); n = MPA_FRAME_SIZE * m->nb_channels; out_size += n * sizeof(OUT_INT); @@ -2924,8 +2817,9 @@ static int decode_frame_mp3on4(AVCodecContext * avctx, *data_size = out_size; return buf_size; } +#endif /* CONFIG_MP3ON4_DECODER */ - +#ifdef CONFIG_MP2_DECODER AVCodec mp2_decoder = { "mp2", @@ -2938,7 +2832,8 @@ AVCodec mp2_decoder = decode_frame, CODEC_CAP_PARSE_ONLY, }; - +#endif +#ifdef CONFIG_MP3_DECODER AVCodec mp3_decoder = { "mp3", @@ -2950,8 +2845,10 @@ AVCodec mp3_decoder = NULL, decode_frame, CODEC_CAP_PARSE_ONLY, + .flush= flush, }; - +#endif +#ifdef CONFIG_MP3ADU_DECODER AVCodec mp3adu_decoder = { "mp3adu", @@ -2963,8 +2860,10 @@ AVCodec mp3adu_decoder = NULL, decode_frame_adu, CODEC_CAP_PARSE_ONLY, + .flush= flush, }; - +#endif +#ifdef CONFIG_MP3ON4_DECODER AVCodec mp3on4_decoder = { "mp3on4", @@ -2975,5 +2874,6 @@ AVCodec mp3on4_decoder = NULL, decode_close_mp3on4, decode_frame_mp3on4, - 0 + .flush= flush, }; +#endif