#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))
struct GranuleDef;
typedef struct MPADecodeContext {
- DECLARE_ALIGNED_8(uint8_t, last_buf[BACKSTEP_SIZE + EXTRABYTES + MPA_MAX_CODED_FRAME_SIZE]); //FIXME we dont need that much
+ 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;
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;
#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;
} MPADecodeContext;
/**
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 */
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++) {
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)
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)
int mpa_decode_header(AVCodecContext *avctx, uint32_t head)
{
MPADecodeContext s1, *s = &s1;
- memset( s, 0, sizeof(MPADecodeContext) );
if (ff_mpa_check_header(head) != 0)
return -1;
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;
}
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);
}
if (get_bits1(&s->gb))
v = -v;
g->sb_hybrid[s_index+!!y] = v;
+ g->sb_hybrid[s_index+ !y] = 0;
}
s_index+=2;
}
int pos, code;
pos = get_bits_count(&s->gb);
if (pos >= end_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;
+ 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);
+ 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 && last_pos){ //FIXME last_pos is messed if we switch buffers
- /* some encoders generate an incorrect size for this
- part. We must go back into the data */
- s_index -= 4;
- skip_bits_long(&s->gb, last_pos - pos);
- av_log(NULL, AV_LOG_ERROR, "overread, skip %d\n", last_pos&7);
- }
if(pos >= end_pos)
break;
}
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);
//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)
+ 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);
- /* prepare next buffer */
- s->old_frame_size = s->frame_size;
}
for(gr=0;gr<nb_granules;gr++) {
default:
nb_frames = mp_decode_layer3(s);
- if(s->in_gb.buffer)
+ 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;
+ }
+
align_get_bits(&s->gb);
assert((get_bits_count(&s->gb) & 7) == 0);
- s->last_buf_size= (s->gb.size_in_bits - get_bits_count(&s->gb))>>3;
- memcpy(s->last_buf, s->gb.buffer + (get_bits_count(&s->gb)>>3), s->last_buf_size);
+ 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(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;
}
break;
}
- if(s->frame_size<=0 || s->frame_size < buf_size){
+ 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;
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
+ 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;
}
-
+#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",
decode_frame,
CODEC_CAP_PARSE_ONLY,
};
-
+#endif
+#ifdef CONFIG_MP3ADU_DECODER
AVCodec mp3adu_decoder =
{
"mp3adu",
decode_frame_adu,
CODEC_CAP_PARSE_ONLY,
};
-
+#endif
+#ifdef CONFIG_MP3ON4_DECODER
AVCodec mp3on4_decoder =
{
"mp3on4",
decode_frame_mp3on4,
0
};
+#endif