* 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
*/
#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))
#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;
/**
#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;
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 add accumulate */
+#define MACS(rt, ra, rb) MAC16(rt, ra, rb)
- /* signed 16x16 -> 32 multiply */
-# define MULS(ra, rb) \
- ({ int __rt; asm ("mullhw %0, %1, %2" : "=r" (__rt) : "r" (ra), "r" (rb)); __rt; })
+/* signed 16x16 -> 32 multiply */
+#define MULS(ra, rb) MUL16(ra, rb)
-# elif defined(HAVE_ARMV5TE)
-
- /* signed 16x16 -> 32 multiply add accumulate */
-# define MACS(rt, ra, rb) \
- asm ("smlabb %0, %2, %3, %0" : "=r" (rt) : "0" (rt), "r" (ra), "r" (rb));
-
- /* signed 16x16 -> 32 multiply */
-# define MULS(ra, rb) \
- ({ int __rt; asm ("smulbb %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
#else
static inline int round_sample(int64_t *sum)
/* 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;
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;
s_index -= 4;
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;
}
// av_log(NULL, AV_LOG_ERROR, "pos2: %d %d %d %d\n", pos, end_pos, end_pos2, s_index);
}
s_index+=4;
}
- memset(&g->sb_hybrid[s_index], 0, sizeof(*g->sb_hybrid)*(576 - s_index));
-
/* 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) {
- dprintf("bits_left=%d\n", bits_left);
- return -1;
+ 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;
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 */
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);
/* now we get bits from the main_data_begin offset */
dprintf("seekback: %d\n", main_data_begin);
//av_log(NULL, AV_LOG_ERROR, "backstep:%d, lastbuf:%d\n", main_data_begin, s->last_buf_size);
- if(main_data_begin > s->last_buf_size){
- av_log(NULL, AV_LOG_ERROR, "backstep:%d, lastbuf:%d\n", main_data_begin, s->last_buf_size);
- s->last_buf_size= main_data_begin;
- }
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 - main_data_begin, main_data_begin*8);
+ 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;gr<nb_granules;gr++) {
for(ch=0;ch<s->nb_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);
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
#endif
}
} /* gr */
+ if(get_bits_count(&s->gb)<0)
+ skip_bits_long(&s->gb, -get_bits_count(&s->gb));
return nb_granules * 18;
}
}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);
if(ff_mpa_check_header(header) < 0){
buf++;
// buf_size--;
- av_log(avctx, AV_LOG_ERROR, "header missing skiping one byte\n");
+ av_log(avctx, AV_LOG_ERROR, "Header missing skipping one byte.\n");
goto retry;
}
return -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;
}
out_size = mp_decode_frame(s, out_samples, buf, buf_size);
- if(out_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
+ 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)
*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 */
*data_size = out_size;
return buf_size;
}
+#endif /* CONFIG_MP3ON4_DECODER */
-
+#ifdef CONFIG_MP2_DECODER
AVCodec mp2_decoder =
{
"mp2",
decode_frame,
CODEC_CAP_PARSE_ONLY,
};
-
+#endif
+#ifdef CONFIG_MP3_DECODER
AVCodec mp3_decoder =
{
"mp3",
NULL,
decode_frame,
CODEC_CAP_PARSE_ONLY,
+ .flush= flush,
};
-
+#endif
+#ifdef CONFIG_MP3ADU_DECODER
AVCodec mp3adu_decoder =
{
"mp3adu",
NULL,
decode_frame_adu,
CODEC_CAP_PARSE_ONLY,
+ .flush= flush,
};
-
+#endif
+#ifdef CONFIG_MP3ON4_DECODER
AVCodec mp3on4_decoder =
{
"mp3on4",
NULL,
decode_close_mp3on4,
decode_frame_mp3on4,
- 0
+ .flush= flush,
};
+#endif