* MPEG Audio decoder
*/
-#include "libavutil/audioconvert.h"
+#include "libavutil/channel_layout.h"
#include "avcodec.h"
#include "get_bits.h"
+#include "internal.h"
#include "mathops.h"
#include "mpegaudiodsp.h"
+#include "dsputil.h"
/*
* TODO:
#define BACKSTEP_SIZE 512
#define EXTRABYTES 24
+#define LAST_BUF_SIZE 2 * BACKSTEP_SIZE + EXTRABYTES
/* layer 3 "granule" */
typedef struct GranuleDef {
int preflag;
int short_start, long_end; /* long/short band indexes */
uint8_t scale_factors[40];
- INTFLOAT sb_hybrid[SBLIMIT * 18]; /* 576 samples */
+ DECLARE_ALIGNED(16, INTFLOAT, sb_hybrid)[SBLIMIT * 18]; /* 576 samples */
} GranuleDef;
typedef struct MPADecodeContext {
MPA_DECODE_HEADER
- uint8_t last_buf[2 * BACKSTEP_SIZE + EXTRABYTES];
+ uint8_t last_buf[LAST_BUF_SIZE];
int last_buf_size;
/* next header (used in free format parsing) */
uint32_t free_format_next_header;
int err_recognition;
AVCodecContext* avctx;
MPADSPContext mpadsp;
+ DSPContext dsp;
AVFrame frame;
} MPADecodeContext;
# define MULH3(x, y, s) ((s)*(y)*(x))
# define MULLx(x, y, s) ((y)*(x))
# define RENAME(a) a ## _float
-# define OUT_FMT AV_SAMPLE_FMT_FLT
+# define OUT_FMT AV_SAMPLE_FMT_FLT
+# define OUT_FMT_P AV_SAMPLE_FMT_FLTP
#else
# define SHR(a,b) ((a)>>(b))
/* WARNING: only correct for positive numbers */
# define MULH3(x, y, s) MULH((s)*(x), y)
# define MULLx(x, y, s) MULL(x,y,s)
# define RENAME(a) a ## _fixed
-# define OUT_FMT AV_SAMPLE_FMT_S16
+# define OUT_FMT AV_SAMPLE_FMT_S16
+# define OUT_FMT_P AV_SAMPLE_FMT_S16P
#endif
/****************/
static INTFLOAT is_table[2][16];
static INTFLOAT is_table_lsf[2][2][16];
static INTFLOAT csa_table[8][4];
-static INTFLOAT mdct_win[8][36];
static int16_t division_tab3[1<<6 ];
static int16_t division_tab5[1<<8 ];
static void ff_init_short_region(MPADecodeContext *s, GranuleDef *g)
{
- if (g->block_type == 2)
- g->region_size[0] = (36 / 2);
- else {
+ if (g->block_type == 2) {
+ if (s->sample_rate_index != 8)
+ g->region_size[0] = (36 / 2);
+ else
+ g->region_size[0] = (72 / 2);
+ } else {
if (s->sample_rate_index <= 2)
g->region_size[0] = (36 / 2);
else if (s->sample_rate_index != 8)
if (g->block_type == 2) {
if (g->switch_point) {
/* if switched mode, we handle the 36 first samples as
- long blocks. For 8000Hz, we handle the 48 first
- exponents as long blocks (XXX: check this!) */
+ long blocks. For 8000Hz, we handle the 72 first
+ exponents as long blocks */
if (s->sample_rate_index <= 2)
g->long_end = 8;
- else if (s->sample_rate_index != 8)
- g->long_end = 6;
else
- g->long_end = 4; /* 8000 Hz */
+ g->long_end = 6;
- g->short_start = 2 + (s->sample_rate_index != 8);
+ g->short_start = 3;
} else {
g->long_end = 0;
g->short_start = 0;
for (i = 1; i < 16; i++) {
const HuffTable *h = &mpa_huff_tables[i];
int xsize, x, y;
- uint8_t tmp_bits [512];
- uint16_t tmp_codes[512];
-
- memset(tmp_bits , 0, sizeof(tmp_bits ));
- memset(tmp_codes, 0, sizeof(tmp_codes));
+ uint8_t tmp_bits [512] = { 0 };
+ uint16_t tmp_codes[512] = { 0 };
xsize = h->xsize;
csa_table[i][3] = ca - cs;
#endif
}
-
- /* compute mdct windows */
- for (i = 0; i < 36; i++) {
- for (j = 0; j < 4; j++) {
- double d;
-
- if (j == 2 && i % 3 != 1)
- continue;
-
- d = sin(M_PI * (i + 0.5) / 36.0);
- if (j == 1) {
- if (i >= 30) d = 0;
- else if (i >= 24) d = sin(M_PI * (i - 18 + 0.5) / 12.0);
- else if (i >= 18) d = 1;
- } else if (j == 3) {
- if (i < 6) d = 0;
- else if (i < 12) d = sin(M_PI * (i - 6 + 0.5) / 12.0);
- else if (i < 18) d = 1;
- }
- //merge last stage of imdct into the window coefficients
- d *= 0.5 / cos(M_PI * (2 * i + 19) / 72);
-
- if (j == 2)
- mdct_win[j][i/3] = FIXHR((d / (1<<5)));
- else
- mdct_win[j][i ] = FIXHR((d / (1<<5)));
- }
- }
-
- /* NOTE: we do frequency inversion adter the MDCT by changing
- the sign of the right window coefs */
- for (j = 0; j < 4; j++) {
- for (i = 0; i < 36; i += 2) {
- mdct_win[j + 4][i ] = mdct_win[j][i ];
- mdct_win[j + 4][i + 1] = -mdct_win[j][i + 1];
- }
- }
}
static av_cold int decode_init(AVCodecContext * avctx)
s->avctx = avctx;
ff_mpadsp_init(&s->mpadsp);
+ ff_dsputil_init(&s->dsp, avctx);
- avctx->sample_fmt= OUT_FMT;
+ if (avctx->request_sample_fmt == OUT_FMT &&
+ avctx->codec_id != AV_CODEC_ID_MP3ON4)
+ avctx->sample_fmt = OUT_FMT;
+ else
+ avctx->sample_fmt = OUT_FMT_P;
s->err_recognition = avctx->err_recognition;
- if (avctx->codec_id == CODEC_ID_MP3ADU)
+ if (avctx->codec_id == AV_CODEC_ID_MP3ADU)
s->adu_mode = 1;
avcodec_get_frame_defaults(&s->frame);
}
#define C3 FIXHR(0.86602540378443864676/2)
-
-/* 0.5 / cos(pi*(2*i+1)/36) */
-static const INTFLOAT icos36[9] = {
- FIXR(0.50190991877167369479),
- FIXR(0.51763809020504152469), //0
- FIXR(0.55168895948124587824),
- FIXR(0.61038729438072803416),
- FIXR(0.70710678118654752439), //1
- FIXR(0.87172339781054900991),
- FIXR(1.18310079157624925896),
- FIXR(1.93185165257813657349), //2
- FIXR(5.73685662283492756461),
-};
-
-/* 0.5 / cos(pi*(2*i+1)/36) */
-static const INTFLOAT icos36h[9] = {
- FIXHR(0.50190991877167369479/2),
- FIXHR(0.51763809020504152469/2), //0
- FIXHR(0.55168895948124587824/2),
- FIXHR(0.61038729438072803416/2),
- FIXHR(0.70710678118654752439/2), //1
- FIXHR(0.87172339781054900991/2),
- FIXHR(1.18310079157624925896/4),
- FIXHR(1.93185165257813657349/4), //2
-// FIXHR(5.73685662283492756461),
-};
+#define C4 FIXHR(0.70710678118654752439/2) //0.5 / cos(pi*(9)/36)
+#define C5 FIXHR(0.51763809020504152469/2) //0.5 / cos(pi*(5)/36)
+#define C6 FIXHR(1.93185165257813657349/4) //0.5 / cos(pi*(15)/36)
/* 12 points IMDCT. We compute it "by hand" by factorizing obvious
cases. */
in3 = MULH3(in3, C3, 4);
t1 = in0 - in4;
- t2 = MULH3(in1 - in5, icos36h[4], 2);
+ t2 = MULH3(in1 - in5, C4, 2);
out[ 7] =
out[10] = t1 + t2;
in0 += SHR(in4, 1);
in4 = in0 + in2;
in5 += 2*in1;
- in1 = MULH3(in5 + in3, icos36h[1], 1);
+ in1 = MULH3(in5 + in3, C5, 1);
out[ 8] =
out[ 9] = in4 + in1;
out[ 2] =
out[ 3] = in4 - in1;
in0 -= in2;
- in5 = MULH3(in5 - in3, icos36h[7], 2);
+ in5 = MULH3(in5 - in3, C6, 2);
out[ 0] =
out[ 5] = in0 - in5;
out[ 6] =
out[11] = in0 + in5;
}
-/* cos(pi*i/18) */
-#define C1 FIXHR(0.98480775301220805936/2)
-#define C2 FIXHR(0.93969262078590838405/2)
-#define C3 FIXHR(0.86602540378443864676/2)
-#define C4 FIXHR(0.76604444311897803520/2)
-#define C5 FIXHR(0.64278760968653932632/2)
-#define C6 FIXHR(0.5/2)
-#define C7 FIXHR(0.34202014332566873304/2)
-#define C8 FIXHR(0.17364817766693034885/2)
-
-
-/* using Lee like decomposition followed by hand coded 9 points DCT */
-static void imdct36(INTFLOAT *out, INTFLOAT *buf, INTFLOAT *in, INTFLOAT *win)
-{
- int i, j;
- INTFLOAT t0, t1, t2, t3, s0, s1, s2, s3;
- INTFLOAT tmp[18], *tmp1, *in1;
-
- for (i = 17; i >= 1; i--)
- in[i] += in[i-1];
- for (i = 17; i >= 3; i -= 2)
- in[i] += in[i-2];
-
- for (j = 0; j < 2; j++) {
- tmp1 = tmp + j;
- in1 = in + j;
-
- t2 = in1[2*4] + in1[2*8] - in1[2*2];
-
- t3 = in1[2*0] + SHR(in1[2*6],1);
- t1 = in1[2*0] - in1[2*6];
- tmp1[ 6] = t1 - SHR(t2,1);
- tmp1[16] = t1 + t2;
-
- t0 = MULH3(in1[2*2] + in1[2*4] , C2, 2);
- t1 = MULH3(in1[2*4] - in1[2*8] , -2*C8, 1);
- t2 = MULH3(in1[2*2] + in1[2*8] , -C4, 2);
-
- tmp1[10] = t3 - t0 - t2;
- tmp1[ 2] = t3 + t0 + t1;
- tmp1[14] = t3 + t2 - t1;
-
- tmp1[ 4] = MULH3(in1[2*5] + in1[2*7] - in1[2*1], -C3, 2);
- t2 = MULH3(in1[2*1] + in1[2*5], C1, 2);
- t3 = MULH3(in1[2*5] - in1[2*7], -2*C7, 1);
- t0 = MULH3(in1[2*3], C3, 2);
-
- t1 = MULH3(in1[2*1] + in1[2*7], -C5, 2);
-
- tmp1[ 0] = t2 + t3 + t0;
- tmp1[12] = t2 + t1 - t0;
- tmp1[ 8] = t3 - t1 - t0;
- }
-
- i = 0;
- for (j = 0; j < 4; j++) {
- t0 = tmp[i];
- t1 = tmp[i + 2];
- s0 = t1 + t0;
- s2 = t1 - t0;
-
- t2 = tmp[i + 1];
- t3 = tmp[i + 3];
- s1 = MULH3(t3 + t2, icos36h[ j], 2);
- s3 = MULLx(t3 - t2, icos36 [8 - j], FRAC_BITS);
-
- t0 = s0 + s1;
- t1 = s0 - s1;
- out[(9 + j) * SBLIMIT] = MULH3(t1, win[ 9 + j], 1) + buf[4*(9 + j)];
- out[(8 - j) * SBLIMIT] = MULH3(t1, win[ 8 - j], 1) + buf[4*(8 - j)];
- buf[4 * ( 9 + j )] = MULH3(t0, win[18 + 9 + j], 1);
- buf[4 * ( 8 - j )] = MULH3(t0, win[18 + 8 - j], 1);
-
- t0 = s2 + s3;
- t1 = s2 - s3;
- out[(9 + 8 - j) * SBLIMIT] = MULH3(t1, win[ 9 + 8 - j], 1) + buf[4*(9 + 8 - j)];
- out[ j * SBLIMIT] = MULH3(t1, win[ j], 1) + buf[4*( j)];
- buf[4 * ( 9 + 8 - j )] = MULH3(t0, win[18 + 9 + 8 - j], 1);
- buf[4 * ( j )] = MULH3(t0, win[18 + j], 1);
- i += 4;
- }
-
- s0 = tmp[16];
- s1 = MULH3(tmp[17], icos36h[4], 2);
- t0 = s0 + s1;
- t1 = s0 - s1;
- out[(9 + 4) * SBLIMIT] = MULH3(t1, win[ 9 + 4], 1) + buf[4*(9 + 4)];
- out[(8 - 4) * SBLIMIT] = MULH3(t1, win[ 8 - 4], 1) + buf[4*(8 - 4)];
- buf[4 * ( 9 + 4 )] = MULH3(t0, win[18 + 9 + 4], 1);
- buf[4 * ( 8 - 4 )] = MULH3(t0, win[18 + 8 - 4], 1);
-}
-
/* return the number of decoded frames */
static int mp_decode_layer1(MPADecodeContext *s)
{
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);
switch_buffer(s, &pos, &end_pos, &end_pos2);
-// av_log(NULL, AV_LOG_ERROR, "new pos: %d %d\n", pos, end_pos);
if (pos >= end_pos)
break;
}
s_index=0;
break;
}
-// av_log(NULL, AV_LOG_ERROR, "pos2: %d %d %d %d\n", pos, end_pos, end_pos2, s_index);
switch_buffer(s, &pos, &end_pos, &end_pos2);
-// av_log(NULL, AV_LOG_ERROR, "new pos2: %d %d %d\n", pos, end_pos, s_index);
if (pos >= end_pos)
break;
}
}
/* skip extension bits */
bits_left = end_pos2 - 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 && (s->err_recognition & AV_EF_BITSTREAM)) {
+ if (bits_left < 0 && (s->err_recognition & AV_EF_BUFFER)) {
av_log(s->avctx, AV_LOG_ERROR, "bits_left=%d\n", bits_left);
s_index=0;
} else if (bits_left > 0 && (s->err_recognition & AV_EF_BUFFER)) {
if (s->sample_rate_index != 8)
ptr = g->sb_hybrid + 36;
else
- ptr = g->sb_hybrid + 48;
+ ptr = g->sb_hybrid + 72;
} else {
ptr = g->sb_hybrid;
}
/* ms stereo ONLY */
/* NOTE: the 1/sqrt(2) normalization factor is included in the
global gain */
+#if CONFIG_FLOAT
+ s-> dsp.butterflies_float(g0->sb_hybrid, g1->sb_hybrid, 576);
+#else
tab0 = g0->sb_hybrid;
tab1 = g1->sb_hybrid;
for (i = 0; i < 576; i++) {
tab0[i] = tmp0 + tmp1;
tab1[i] = tmp0 - tmp1;
}
+#endif
}
}
static void compute_imdct(MPADecodeContext *s, GranuleDef *g,
INTFLOAT *sb_samples, INTFLOAT *mdct_buf)
{
- INTFLOAT *win, *win1, *out_ptr, *ptr, *buf, *ptr1;
+ INTFLOAT *win, *out_ptr, *ptr, *buf, *ptr1;
INTFLOAT out2[12];
int i, j, mdct_long_end, sblimit;
mdct_long_end = sblimit;
}
- buf = mdct_buf;
- ptr = g->sb_hybrid;
- for (j = 0; j < mdct_long_end; j++) {
- /* apply window & overlap with previous buffer */
- out_ptr = sb_samples + j;
- /* select window */
- if (g->switch_point && j < 2)
- win1 = mdct_win[0];
- else
- win1 = mdct_win[g->block_type];
- /* select frequency inversion */
- win = win1 + ((4 * 36) & -(j & 1));
- imdct36(out_ptr, buf, ptr, win);
- out_ptr += 18 * SBLIMIT;
- ptr += 18;
- buf += (j&3) != 3 ? 1 : (4*18-3);
- }
+ s->mpadsp.RENAME(imdct36_blocks)(sb_samples, mdct_buf, g->sb_hybrid,
+ mdct_long_end, g->switch_point,
+ g->block_type);
+
+ buf = mdct_buf + 4*18*(mdct_long_end >> 2) + (mdct_long_end & 3);
+ ptr = g->sb_hybrid + 18 * mdct_long_end;
+
for (j = mdct_long_end; j < sblimit; j++) {
/* select frequency inversion */
- win = mdct_win[2 + (4 & -(j & 1))];
+ win = RENAME(ff_mdct_win)[2 + (4 & -(j & 1))];
out_ptr = sb_samples + j;
for (i = 0; i < 6; i++) {
if (!s->adu_mode) {
int skip;
const uint8_t *ptr = s->gb.buffer + (get_bits_count(&s->gb)>>3);
+ int extrasize = av_clip(get_bits_left(&s->gb) >> 3, 0,
+ FFMAX(0, LAST_BUF_SIZE - s->last_buf_size));
assert((get_bits_count(&s->gb) & 7) == 0);
/* now we get bits from the main_data_begin offset */
- av_dlog(s->avctx, "seekback: %d\n", main_data_begin);
- //av_log(NULL, AV_LOG_ERROR, "backstep:%d, lastbuf:%d\n", main_data_begin, s->last_buf_size);
+ av_dlog(s->avctx, "seekback:%d, lastbuf:%d\n",
+ main_data_begin, s->last_buf_size);
- memcpy(s->last_buf + s->last_buf_size, ptr, EXTRABYTES);
+ memcpy(s->last_buf + s->last_buf_size, ptr, extrasize);
s->in_gb = s->gb;
init_get_bits(&s->gb, s->last_buf, s->last_buf_size*8);
#if !UNCHECKED_BITSTREAM_READER
- s->gb.size_in_bits_plus8 += EXTRABYTES * 8;
+ s->gb.size_in_bits_plus8 += extrasize * 8;
#endif
s->last_buf_size <<= 3;
for (gr = 0; gr < nb_granules && (s->last_buf_size >> 3) < main_data_begin; gr++) {
g = &s->granules[ch][gr];
s->last_buf_size += g->part2_3_length;
memset(g->sb_hybrid, 0, sizeof(g->sb_hybrid));
+ compute_imdct(s, g, &s->sb_samples[ch][18 * gr][0], s->mdct_buf[ch]);
}
}
skip = s->last_buf_size - 8 * main_data_begin;
huffman_decode(s, g, exponents, bits_pos + g->part2_3_length);
} /* ch */
- if (s->nb_channels == 2)
+ if (s->mode == MPA_JSTEREO)
compute_stereo(s, &s->granules[0][gr], &s->granules[1][gr]);
for (ch = 0; ch < s->nb_channels; ch++) {
return nb_granules * 18;
}
-static int mp_decode_frame(MPADecodeContext *s, OUT_INT *samples,
+static int mp_decode_frame(MPADecodeContext *s, OUT_INT **samples,
const uint8_t *buf, int buf_size)
{
int i, nb_frames, ch, ret;
default:
nb_frames = mp_decode_layer3(s);
+ if (nb_frames < 0)
+ return nb_frames;
+
s->last_buf_size=0;
if (s->in_gb.buffer) {
align_get_bits(&s->gb);
/* get output buffer */
if (!samples) {
s->frame.nb_samples = s->avctx->frame_size;
- if ((ret = s->avctx->get_buffer(s->avctx, &s->frame)) < 0) {
+ if ((ret = ff_get_buffer(s->avctx, &s->frame)) < 0) {
av_log(s->avctx, AV_LOG_ERROR, "get_buffer() failed\n");
return ret;
}
- samples = (OUT_INT *)s->frame.data[0];
+ samples = (OUT_INT **)s->frame.extended_data;
}
/* apply the synthesis filter */
for (ch = 0; ch < s->nb_channels; ch++) {
- samples_ptr = samples + ch;
+ int sample_stride;
+ if (s->avctx->sample_fmt == OUT_FMT_P) {
+ samples_ptr = samples[ch];
+ sample_stride = 1;
+ } else {
+ samples_ptr = samples[0] + ch;
+ sample_stride = s->nb_channels;
+ }
for (i = 0; i < nb_frames; i++) {
- RENAME(ff_mpa_synth_filter)(
- &s->mpadsp,
- s->synth_buf[ch], &(s->synth_buf_offset[ch]),
- RENAME(ff_mpa_synth_window), &s->dither_state,
- samples_ptr, s->nb_channels,
- s->sb_samples[ch][i]);
- samples_ptr += 32 * s->nb_channels;
+ RENAME(ff_mpa_synth_filter)(&s->mpadsp, s->synth_buf[ch],
+ &(s->synth_buf_offset[ch]),
+ RENAME(ff_mpa_synth_window),
+ &s->dither_state, samples_ptr,
+ sample_stride, s->sb_samples[ch][i]);
+ samples_ptr += 32 * sample_stride;
}
}
int buf_size = avpkt->size;
MPADecodeContext *s = avctx->priv_data;
uint32_t header;
- int out_size;
+ int ret;
if (buf_size < HEADER_SIZE)
return AVERROR_INVALIDDATA;
avctx->channel_layout = s->nb_channels == 1 ? AV_CH_LAYOUT_MONO : AV_CH_LAYOUT_STEREO;
if (!avctx->bit_rate)
avctx->bit_rate = s->bit_rate;
- avctx->sub_id = s->layer;
if (s->frame_size <= 0 || s->frame_size > buf_size) {
av_log(avctx, AV_LOG_ERROR, "incomplete frame\n");
return AVERROR_INVALIDDATA;
} else if (s->frame_size < buf_size) {
- av_log(avctx, AV_LOG_ERROR, "incorrect frame size\n");
buf_size= s->frame_size;
}
- out_size = mp_decode_frame(s, NULL, buf, buf_size);
- if (out_size >= 0) {
+ ret = mp_decode_frame(s, NULL, buf, buf_size);
+ if (ret >= 0) {
*got_frame_ptr = 1;
*(AVFrame *)data = s->frame;
avctx->sample_rate = s->sample_rate;
//FIXME maybe move the other codec info stuff from above here too
} else {
av_log(avctx, AV_LOG_ERROR, "Error while decoding MPEG audio frame.\n");
- /* Only return an error if the bad frame makes up the whole packet.
- If there is more data in the packet, just consume the bad frame
- instead of returning an error, which would discard the whole
- packet. */
+ /* Only return an error if the bad frame makes up the whole packet or
+ * the error is related to buffer management.
+ * If there is more data in the packet, just consume the bad frame
+ * instead of returning an error, which would discard the whole
+ * packet. */
*got_frame_ptr = 0;
- if (buf_size == avpkt->size)
- return out_size;
+ if (buf_size == avpkt->size || ret != AVERROR_INVALIDDATA)
+ return ret;
}
s->frame_size = 0;
return buf_size;
}
+static void mp_flush(MPADecodeContext *ctx)
+{
+ memset(ctx->synth_buf, 0, sizeof(ctx->synth_buf));
+ ctx->last_buf_size = 0;
+}
+
static void flush(AVCodecContext *avctx)
{
- MPADecodeContext *s = avctx->priv_data;
- memset(s->synth_buf, 0, sizeof(s->synth_buf));
- s->last_buf_size = 0;
+ mp_flush(avctx->priv_data);
}
#if CONFIG_MP3ADU_DECODER || CONFIG_MP3ADUFLOAT_DECODER
int buf_size = avpkt->size;
MPADecodeContext *s = avctx->priv_data;
uint32_t header;
- int len, out_size;
+ int len, ret;
len = buf_size;
avctx->channels = s->nb_channels;
if (!avctx->bit_rate)
avctx->bit_rate = s->bit_rate;
- avctx->sub_id = s->layer;
s->frame_size = len;
-#if FF_API_PARSE_FRAME
- if (avctx->parse_only)
- out_size = buf_size;
- else
-#endif
- out_size = mp_decode_frame(s, NULL, buf, buf_size);
+ ret = mp_decode_frame(s, NULL, buf, buf_size);
+ if (ret < 0) {
+ av_log(avctx, AV_LOG_ERROR, "Error while decoding MPEG audio frame.\n");
+ return ret;
+ }
*got_frame_ptr = 1;
*(AVFrame *)data = s->frame;
int syncword; ///< syncword patch
const uint8_t *coff; ///< channel offsets in output buffer
MPADecodeContext *mp3decctx[5]; ///< MPADecodeContext for every decoder instance
- OUT_INT *decoded_buf; ///< output buffer for decoded samples
} MP3On4DecodeContext;
#include "mpeg4audio.h"
for (i = 0; i < s->frames; i++)
av_free(s->mp3decctx[i]);
- av_freep(&s->decoded_buf);
-
return 0;
}
s->mp3decctx[i]->mpadsp = s->mp3decctx[0]->mpadsp;
}
- /* Allocate buffer for multi-channel output if needed */
- if (s->frames > 1) {
- s->decoded_buf = av_malloc(MPA_FRAME_SIZE * MPA_MAX_CHANNELS *
- sizeof(*s->decoded_buf));
- if (!s->decoded_buf)
- goto alloc_fail;
- }
-
return 0;
alloc_fail:
decode_close_mp3on4(avctx);
int i;
MP3On4DecodeContext *s = avctx->priv_data;
- for (i = 0; i < s->frames; i++) {
- MPADecodeContext *m = s->mp3decctx[i];
- memset(m->synth_buf, 0, sizeof(m->synth_buf));
- m->last_buf_size = 0;
- }
+ for (i = 0; i < s->frames; i++)
+ mp_flush(s->mp3decctx[i]);
}
MPADecodeContext *m;
int fsize, len = buf_size, out_size = 0;
uint32_t header;
- OUT_INT *out_samples;
- OUT_INT *outptr, *bp;
- int fr, j, n, ch, ret;
+ OUT_INT **out_samples;
+ OUT_INT *outptr[2];
+ int fr, ch, ret;
/* get output buffer */
s->frame->nb_samples = MPA_FRAME_SIZE;
- if ((ret = avctx->get_buffer(avctx, s->frame)) < 0) {
+ if ((ret = ff_get_buffer(avctx, s->frame)) < 0) {
av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
return ret;
}
- out_samples = (OUT_INT *)s->frame->data[0];
+ out_samples = (OUT_INT **)s->frame->extended_data;
// Discard too short frames
if (buf_size < HEADER_SIZE)
return AVERROR_INVALIDDATA;
- // If only one decoder interleave is not needed
- outptr = s->frames == 1 ? out_samples : s->decoded_buf;
-
avctx->bit_rate = 0;
ch = 0;
m = s->mp3decctx[fr];
assert(m != NULL);
+ if (fsize < HEADER_SIZE) {
+ av_log(avctx, AV_LOG_ERROR, "Frame size smaller than header size\n");
+ return AVERROR_INVALIDDATA;
+ }
header = (AV_RB32(buf) & 0x000fffff) | s->syncword; // patch header
if (ff_mpa_check_header(header) < 0) // Bad header, discard block
}
ch += m->nb_channels;
- out_size += mp_decode_frame(m, outptr, buf, fsize);
+ outptr[0] = out_samples[s->coff[fr]];
+ if (m->nb_channels > 1)
+ outptr[1] = out_samples[s->coff[fr] + 1];
+
+ if ((ret = mp_decode_frame(m, outptr, buf, fsize)) < 0)
+ return ret;
+
+ out_size += ret;
buf += fsize;
len -= fsize;
- if (s->frames > 1) {
- n = m->avctx->frame_size*m->nb_channels;
- /* interleave output data */
- bp = out_samples + s->coff[fr];
- if (m->nb_channels == 1) {
- for (j = 0; j < n; j++) {
- *bp = s->decoded_buf[j];
- bp += avctx->channels;
- }
- } else {
- for (j = 0; j < n; j++) {
- bp[0] = s->decoded_buf[j++];
- bp[1] = s->decoded_buf[j];
- bp += avctx->channels;
- }
- }
- }
avctx->bit_rate += m->bit_rate;
}
AVCodec ff_mp1_decoder = {
.name = "mp1",
.type = AVMEDIA_TYPE_AUDIO,
- .id = CODEC_ID_MP1,
+ .id = AV_CODEC_ID_MP1,
.priv_data_size = sizeof(MPADecodeContext),
.init = decode_init,
.decode = decode_frame,
-#if FF_API_PARSE_FRAME
- .capabilities = CODEC_CAP_PARSE_ONLY | CODEC_CAP_DR1,
-#else
.capabilities = CODEC_CAP_DR1,
-#endif
.flush = flush,
.long_name = NULL_IF_CONFIG_SMALL("MP1 (MPEG audio layer 1)"),
+ .sample_fmts = (const enum AVSampleFormat[]) { AV_SAMPLE_FMT_S16P,
+ AV_SAMPLE_FMT_S16,
+ AV_SAMPLE_FMT_NONE },
};
#endif
#if CONFIG_MP2_DECODER
AVCodec ff_mp2_decoder = {
.name = "mp2",
.type = AVMEDIA_TYPE_AUDIO,
- .id = CODEC_ID_MP2,
+ .id = AV_CODEC_ID_MP2,
.priv_data_size = sizeof(MPADecodeContext),
.init = decode_init,
.decode = decode_frame,
-#if FF_API_PARSE_FRAME
- .capabilities = CODEC_CAP_PARSE_ONLY | CODEC_CAP_DR1,
-#else
.capabilities = CODEC_CAP_DR1,
-#endif
.flush = flush,
.long_name = NULL_IF_CONFIG_SMALL("MP2 (MPEG audio layer 2)"),
+ .sample_fmts = (const enum AVSampleFormat[]) { AV_SAMPLE_FMT_S16P,
+ AV_SAMPLE_FMT_S16,
+ AV_SAMPLE_FMT_NONE },
};
#endif
#if CONFIG_MP3_DECODER
AVCodec ff_mp3_decoder = {
.name = "mp3",
.type = AVMEDIA_TYPE_AUDIO,
- .id = CODEC_ID_MP3,
+ .id = AV_CODEC_ID_MP3,
.priv_data_size = sizeof(MPADecodeContext),
.init = decode_init,
.decode = decode_frame,
-#if FF_API_PARSE_FRAME
- .capabilities = CODEC_CAP_PARSE_ONLY | CODEC_CAP_DR1,
-#else
.capabilities = CODEC_CAP_DR1,
-#endif
.flush = flush,
.long_name = NULL_IF_CONFIG_SMALL("MP3 (MPEG audio layer 3)"),
+ .sample_fmts = (const enum AVSampleFormat[]) { AV_SAMPLE_FMT_S16P,
+ AV_SAMPLE_FMT_S16,
+ AV_SAMPLE_FMT_NONE },
};
#endif
#if CONFIG_MP3ADU_DECODER
AVCodec ff_mp3adu_decoder = {
.name = "mp3adu",
.type = AVMEDIA_TYPE_AUDIO,
- .id = CODEC_ID_MP3ADU,
+ .id = AV_CODEC_ID_MP3ADU,
.priv_data_size = sizeof(MPADecodeContext),
.init = decode_init,
.decode = decode_frame_adu,
-#if FF_API_PARSE_FRAME
- .capabilities = CODEC_CAP_PARSE_ONLY | CODEC_CAP_DR1,
-#else
.capabilities = CODEC_CAP_DR1,
-#endif
.flush = flush,
.long_name = NULL_IF_CONFIG_SMALL("ADU (Application Data Unit) MP3 (MPEG audio layer 3)"),
+ .sample_fmts = (const enum AVSampleFormat[]) { AV_SAMPLE_FMT_S16P,
+ AV_SAMPLE_FMT_S16,
+ AV_SAMPLE_FMT_NONE },
};
#endif
#if CONFIG_MP3ON4_DECODER
AVCodec ff_mp3on4_decoder = {
.name = "mp3on4",
.type = AVMEDIA_TYPE_AUDIO,
- .id = CODEC_ID_MP3ON4,
+ .id = AV_CODEC_ID_MP3ON4,
.priv_data_size = sizeof(MP3On4DecodeContext),
.init = decode_init_mp3on4,
.close = decode_close_mp3on4,
.capabilities = CODEC_CAP_DR1,
.flush = flush_mp3on4,
.long_name = NULL_IF_CONFIG_SMALL("MP3onMP4"),
+ .sample_fmts = (const enum AVSampleFormat[]) { AV_SAMPLE_FMT_S16P,
+ AV_SAMPLE_FMT_NONE },
};
#endif
#endif
projects / ffmpeg / blobdiff