@@ -36,6 +36,7 @@

 #include "get_bits.h"

 #include "dsputil.h"

 #include "fft.h"

+#include "fmtconvert.h"

 #include "sinewin.h"

 #include "atrac.h"

@@ -78,10 +79,11 @@ typedef struct {

     DECLARE_ALIGNED(32, float,  mid)[256];

     DECLARE_ALIGNED(32, float, high)[512];

     float*              bands[3];

-    DECLARE_ALIGNED(32, float, out_samples)[AT1_MAX_CHANNELS][AT1_SU_SAMPLES];

+    float              *out_samples[AT1_MAX_CHANNELS];

     FFTContext          mdct_ctx[3];

     int                 channels;

     DSPContext          dsp;

+    FmtConvertContext   fmt_conv;

 } AT1Ctx;

 /** size of the transform in samples in the long mode for each QMF band */

@@ -129,7 +131,7 @@ static int at1_imdct_block(AT1SUCtx* su, AT1Ctx *q)

             nbits = mdct_long_nbits[band_num] - log2_block_count;

             if (nbits != 5 && nbits != 7 && nbits != 8)

-                return -1;

+                return AVERROR_INVALIDDATA;

         } else {

             block_size = 32;

             nbits = 5;

@@ -173,14 +175,14 @@ static int at1_parse_bsm(GetBitContext* gb, int log2_block_cnt[AT1_QMF_BANDS])

         /* low and mid band */

         log2_block_count_tmp = get_bits(gb, 2);

         if (log2_block_count_tmp & 1)

-            return -1;

+            return AVERROR_INVALIDDATA;

         log2_block_cnt[i] = 2 - log2_block_count_tmp;

     }

     /* high band */

     log2_block_count_tmp = get_bits(gb, 2);

     if (log2_block_count_tmp != 0 && log2_block_count_tmp != 3)

-        return -1;

+        return AVERROR_INVALIDDATA;

     log2_block_cnt[IDX_HIGH_BAND] = 3 - log2_block_count_tmp;

     skip_bits(gb, 2);

@@ -229,7 +231,7 @@ static int at1_unpack_dequant(GetBitContext* gb, AT1SUCtx* su,

             /* check for bitstream overflow */

             if (bits_used > AT1_SU_MAX_BITS)

-                return -1;

+                return AVERROR_INVALIDDATA;

             /* get the position of the 1st spec according to the block size mode */

             pos = su->log2_block_count[band_num] ? bfu_start_short[bfu_num] : bfu_start_long[bfu_num];

@@ -276,14 +278,21 @@ static int atrac1_decode_frame(AVCodecContext *avctx, void *data,

     const uint8_t *buf = avpkt->data;

     int buf_size       = avpkt->size;

     AT1Ctx *q          = avctx->priv_data;

-    int ch, ret, i;

+    int ch, ret, out_size;

     GetBitContext gb;

     float* samples = data;

     if (buf_size < 212 * q->channels) {

-        av_log(avctx, AV_LOG_ERROR,"Not enought data to decode!\n");

-        return -1;

+        av_log(avctx,AV_LOG_ERROR,"Not enough data to decode!\n");

+        return AVERROR_INVALIDDATA;

+    }

+

+    out_size = q->channels * AT1_SU_SAMPLES *

+               av_get_bytes_per_sample(avctx->sample_fmt);

+    if (*data_size < out_size) {

+        av_log(avctx, AV_LOG_ERROR, "Output buffer is too small\n");

+        return AVERROR(EINVAL);

     }

     for (ch = 0; ch < q->channels; ch++) {

@@ -303,44 +312,72 @@ static int atrac1_decode_frame(AVCodecContext *avctx, void *data,

         ret = at1_imdct_block(su, q);

         if (ret < 0)

             return ret;

-        at1_subband_synthesis(q, su, q->out_samples[ch]);

+        at1_subband_synthesis(q, su, q->channels == 1 ? samples : q->out_samples[ch]);

     }

-    /* interleave; FIXME, should create/use a DSP function */

-    if (q->channels == 1) {

-        /* mono */

-        memcpy(samples, q->out_samples[0], AT1_SU_SAMPLES * 4);

-    } else {

-        /* stereo */

-        for (i = 0; i < AT1_SU_SAMPLES; i++) {

-            samples[i * 2]     = q->out_samples[0][i];

-            samples[i * 2 + 1] = q->out_samples[1][i];

-        }

+    /* interleave */

+    if (q->channels == 2) {

+        q->fmt_conv.float_interleave(samples, (const float **)q->out_samples,

+                                     AT1_SU_SAMPLES, 2);

     }

-    *data_size = q->channels * AT1_SU_SAMPLES * sizeof(*samples);

+    *data_size = out_size;

     return avctx->block_align;

 }

+static av_cold int atrac1_decode_end(AVCodecContext * avctx)

+{

+    AT1Ctx *q = avctx->priv_data;

+

+    av_freep(&q->out_samples[0]);

+

+    ff_mdct_end(&q->mdct_ctx[0]);

+    ff_mdct_end(&q->mdct_ctx[1]);

+    ff_mdct_end(&q->mdct_ctx[2]);

+

+    return 0;

+}

+

+

 static av_cold int atrac1_decode_init(AVCodecContext *avctx)

 {

     AT1Ctx *q = avctx->priv_data;

+    int ret;

     avctx->sample_fmt = AV_SAMPLE_FMT_FLT;

+    if (avctx->channels < 1 || avctx->channels > AT1_MAX_CHANNELS) {

+        av_log(avctx, AV_LOG_ERROR, "Unsupported number of channels: %d\n",

+               avctx->channels);

+        return AVERROR(EINVAL);

+    }

     q->channels = avctx->channels;

+    if (avctx->channels == 2) {

+        q->out_samples[0] = av_malloc(2 * AT1_SU_SAMPLES * sizeof(*q->out_samples[0]));

+        q->out_samples[1] = q->out_samples[0] + AT1_SU_SAMPLES;

+        if (!q->out_samples[0]) {

+            av_freep(&q->out_samples[0]);

+            return AVERROR(ENOMEM);

+        }

+    }

+

     /* Init the mdct transforms */

-    ff_mdct_init(&q->mdct_ctx[0], 6, 1, -1.0/ (1 << 15));

-    ff_mdct_init(&q->mdct_ctx[1], 8, 1, -1.0/ (1 << 15));

-    ff_mdct_init(&q->mdct_ctx[2], 9, 1, -1.0/ (1 << 15));

+    if ((ret = ff_mdct_init(&q->mdct_ctx[0], 6, 1, -1.0/ (1 << 15))) ||

+        (ret = ff_mdct_init(&q->mdct_ctx[1], 8, 1, -1.0/ (1 << 15))) ||

+        (ret = ff_mdct_init(&q->mdct_ctx[2], 9, 1, -1.0/ (1 << 15)))) {

+        av_log(avctx, AV_LOG_ERROR, "Error initializing MDCT\n");

+        atrac1_decode_end(avctx);

+        return ret;

+    }

     ff_init_ff_sine_windows(5);

     atrac_generate_tables();

     dsputil_init(&q->dsp, avctx);

+    ff_fmt_convert_init(&q->fmt_conv, avctx);

     q->bands[0] = q->low;

     q->bands[1] = q->mid;

@@ -356,16 +393,6 @@ static av_cold int atrac1_decode_init(AVCodecContext *avctx)

 }

-static av_cold int atrac1_decode_end(AVCodecContext * avctx) {

-    AT1Ctx *q = avctx->priv_data;

-

-    ff_mdct_end(&q->mdct_ctx[0]);

-    ff_mdct_end(&q->mdct_ctx[1]);

-    ff_mdct_end(&q->mdct_ctx[2]);

-    return 0;

-}

-

-

 AVCodec ff_atrac1_decoder = {

     .name = "atrac1",

     .type = AVMEDIA_TYPE_AUDIO,

@@ -41,6 +41,7 @@

 #include "dsputil.h"

 #include "bytestream.h"

 #include "fft.h"

+#include "fmtconvert.h"

 #include "atrac.h"

 #include "atrac3data.h"

@@ -48,6 +49,8 @@

 #define JOINT_STEREO    0x12

 #define STEREO          0x2

+#define SAMPLES_PER_FRAME 1024

+#define MDCT_SIZE          512

 /* These structures are needed to store the parsed gain control data. */

 typedef struct {

@@ -70,12 +73,12 @@ typedef struct {

     int               bandsCoded;

     int               numComponents;

     tonal_component   components[64];

-    float             prevFrame[1024];

+    float             prevFrame[SAMPLES_PER_FRAME];

     int               gcBlkSwitch;

     gain_block        gainBlock[2];

-    DECLARE_ALIGNED(32, float, spectrum)[1024];

-    DECLARE_ALIGNED(32, float, IMDCT_buf)[1024];

+    DECLARE_ALIGNED(32, float, spectrum)[SAMPLES_PER_FRAME];

+    DECLARE_ALIGNED(32, float, IMDCT_buf)[SAMPLES_PER_FRAME];

     float             delayBuf1[46]; ///<qmf delay buffers

     float             delayBuf2[46];

@@ -107,7 +110,7 @@ typedef struct {

     //@}

     //@{

     /** data buffers */

-    float               outSamples[2048];

+    float              *outSamples[2];

     uint8_t*            decoded_bytes_buffer;

     float               tempBuf[1070];

     //@}

@@ -120,9 +123,10 @@ typedef struct {

     //@}

     FFTContext          mdct_ctx;

+    FmtConvertContext   fmt_conv;

 } ATRAC3Context;

-static DECLARE_ALIGNED(32, float, mdct_window)[512];

+static DECLARE_ALIGNED(32, float, mdct_window)[MDCT_SIZE];

 static VLC              spectral_coeff_tab[7];

 static float            gain_tab1[16];

 static float            gain_tab2[31];

@@ -159,7 +163,7 @@ static void IMLT(ATRAC3Context *q, float *pInput, float *pOutput, int odd_band)

     q->mdct_ctx.imdct_calc(&q->mdct_ctx,pOutput,pInput);

     /* Perform windowing on the output. */

-    dsp.vector_fmul(pOutput, pOutput, mdct_window, 512);

+    dsp.vector_fmul(pOutput, pOutput, mdct_window, MDCT_SIZE);

 }

@@ -192,7 +196,7 @@ static int decode_bytes(const uint8_t* inbuffer, uint8_t* out, int bytes){

 }

-static av_cold void init_atrac3_transforms(ATRAC3Context *q) {

+static av_cold int init_atrac3_transforms(ATRAC3Context *q, int is_float) {

     float enc_window[256];

     int i;

@@ -208,7 +212,7 @@ static av_cold void init_atrac3_transforms(ATRAC3Context *q) {

         }

     /* Initialize the MDCT transform. */

-    ff_mdct_init(&q->mdct_ctx, 9, 1, 1.0);

+    return ff_mdct_init(&q->mdct_ctx, 9, 1, is_float ? 1.0 / 32768 : 1.0);

 }

 /**

@@ -221,6 +225,8 @@ static av_cold int atrac3_decode_close(AVCodecContext *avctx)

     av_free(q->pUnits);

     av_free(q->decoded_bytes_buffer);

+    av_freep(&q->outSamples[0]);

+

     ff_mdct_end(&q->mdct_ctx);

     return 0;

@@ -340,7 +346,7 @@ static int decodeSpectrum (GetBitContext *gb, float *pOut)

     /* Clear the subbands that were not coded. */

     first = subbandTab[cnt];

-    memset(pOut+first, 0, (1024 - first) * sizeof(float));

+    memset(pOut+first, 0, (SAMPLES_PER_FRAME - first) * sizeof(float));

     return numSubbands;

 }

@@ -370,7 +376,7 @@ static int decodeTonalComponents (GetBitContext *gb, tonal_component *pComponent

     coding_mode_selector = get_bits(gb,2);

     if (coding_mode_selector == 2)

-        return -1;

+        return AVERROR_INVALIDDATA;

     coding_mode = coding_mode_selector & 1;

@@ -382,7 +388,7 @@ static int decodeTonalComponents (GetBitContext *gb, tonal_component *pComponent

         quant_step_index = get_bits(gb,3);

         if (quant_step_index <= 1)

-            return -1;

+            return AVERROR_INVALIDDATA;

         if (coding_mode_selector == 3)

             coding_mode = get_bits1(gb);

@@ -396,7 +402,7 @@ static int decodeTonalComponents (GetBitContext *gb, tonal_component *pComponent

             for (k=0; k<coded_components; k++) {

                 sfIndx = get_bits(gb,6);

                 pComponent[component_count].pos = j * 64 + (get_bits(gb,6));

-                max_coded_values = 1024 - pComponent[component_count].pos;

+                max_coded_values = SAMPLES_PER_FRAME - pComponent[component_count].pos;

                 coded_values = coded_values_per_component + 1;

                 coded_values = FFMIN(max_coded_values,coded_values);

@@ -445,7 +451,7 @@ static int decodeGainControl (GetBitContext *gb, gain_block *pGb, int numBands)

             pLevel[cf]= get_bits(gb,4);

             pLoc  [cf]= get_bits(gb,5);

             if(cf && pLoc[cf] <= pLoc[cf-1])

-                return -1;

+                return AVERROR_INVALIDDATA;

         }

     }

@@ -662,12 +668,12 @@ static int decodeChannelSoundUnit (ATRAC3Context *q, GetBitContext *gb, channel_

     if (codingMode == JOINT_STEREO && channelNum == 1) {

         if (get_bits(gb,2) != 3) {

             av_log(NULL,AV_LOG_ERROR,"JS mono Sound Unit id != 3.\n");

-            return -1;

+            return AVERROR_INVALIDDATA;

         }

     } else {

         if (get_bits(gb,6) != 0x28) {

             av_log(NULL,AV_LOG_ERROR,"Sound Unit id != 0x28.\n");

-            return -1;

+            return AVERROR_INVALIDDATA;

         }

     }

@@ -719,7 +725,8 @@ static int decodeChannelSoundUnit (ATRAC3Context *q, GetBitContext *gb, channel_

  * @param databuf       the input data

  */

-static int decodeFrame(ATRAC3Context *q, const uint8_t* databuf)

+static int decodeFrame(ATRAC3Context *q, const uint8_t* databuf,

+                       float **out_samples)

 {

     int   result, i;

     float   *p1, *p2, *p3, *p4;

@@ -731,7 +738,7 @@ static int decodeFrame(ATRAC3Context *q, const uint8_t* databuf)

         /* decode Sound Unit 1 */

         init_get_bits(&q->gb,databuf,q->bits_per_frame);

-        result = decodeChannelSoundUnit(q,&q->gb, q->pUnits, q->outSamples, 0, JOINT_STEREO);

+        result = decodeChannelSoundUnit(q,&q->gb, q->pUnits, out_samples[0], 0, JOINT_STEREO);

         if (result != 0)

             return (result);

@@ -753,7 +760,7 @@ static int decodeFrame(ATRAC3Context *q, const uint8_t* databuf)

         ptr1 = q->decoded_bytes_buffer;

         for (i = 4; *ptr1 == 0xF8; i++, ptr1++) {

             if (i >= q->bytes_per_frame)

-                return -1;

+                return AVERROR_INVALIDDATA;

         }

@@ -772,14 +779,14 @@ static int decodeFrame(ATRAC3Context *q, const uint8_t* databuf)

         }

         /* Decode Sound Unit 2. */

-        result = decodeChannelSoundUnit(q,&q->gb, &q->pUnits[1], &q->outSamples[1024], 1, JOINT_STEREO);

+        result = decodeChannelSoundUnit(q,&q->gb, &q->pUnits[1], out_samples[1], 1, JOINT_STEREO);

         if (result != 0)

             return (result);

         /* Reconstruct the channel coefficients. */

-        reverseMatrixing(q->outSamples, &q->outSamples[1024], q->matrix_coeff_index_prev, q->matrix_coeff_index_now);

+        reverseMatrixing(out_samples[0], out_samples[1], q->matrix_coeff_index_prev, q->matrix_coeff_index_now);

-        channelWeighting(q->outSamples, &q->outSamples[1024], q->weighting_delay);

+        channelWeighting(out_samples[0], out_samples[1], q->weighting_delay);

     } else {

         /* normal stereo mode or mono */

@@ -789,22 +796,21 @@ static int decodeFrame(ATRAC3Context *q, const uint8_t* databuf)

             /* Set the bitstream reader at the start of a channel sound unit. */

             init_get_bits(&q->gb, databuf+((i*q->bytes_per_frame)/q->channels), (q->bits_per_frame)/q->channels);

-            result = decodeChannelSoundUnit(q,&q->gb, &q->pUnits[i], &q->outSamples[i*1024], i, q->codingMode);

+            result = decodeChannelSoundUnit(q,&q->gb, &q->pUnits[i], out_samples[i], i, q->codingMode);

             if (result != 0)

                 return (result);

         }

     }

     /* Apply the iQMF synthesis filter. */

-    p1= q->outSamples;

     for (i=0 ; i<q->channels ; i++) {

+        p1 = out_samples[i];

         p2= p1+256;

         p3= p2+256;

         p4= p3+256;

         atrac_iqmf (p1, p2, 256, p1, q->pUnits[i].delayBuf1, q->tempBuf);

         atrac_iqmf (p4, p3, 256, p3, q->pUnits[i].delayBuf2, q->tempBuf);

         atrac_iqmf (p1, p3, 512, p1, q->pUnits[i].delayBuf3, q->tempBuf);

-        p1 +=1024;

     }

     return 0;

@@ -823,15 +829,22 @@ static int atrac3_decode_frame(AVCodecContext *avctx,

     const uint8_t *buf = avpkt->data;

     int buf_size = avpkt->size;

     ATRAC3Context *q = avctx->priv_data;

-    int result = 0, i;

+    int result = 0, out_size;

     const uint8_t* databuf;

-    int16_t* samples = data;

+    float   *samples_flt = data;

+    int16_t *samples_s16 = data;

     if (buf_size < avctx->block_align) {

         av_log(avctx, AV_LOG_ERROR,

                "Frame too small (%d bytes). Truncated file?\n", buf_size);

-        *data_size = 0;

-        return buf_size;

+        return AVERROR_INVALIDDATA;

+    }

+

+    out_size = SAMPLES_PER_FRAME * q->channels *

+               av_get_bytes_per_sample(avctx->sample_fmt);

+    if (*data_size < out_size) {

+        av_log(avctx, AV_LOG_ERROR, "Output buffer is too small\n");

+        return AVERROR(EINVAL);

     }

     /* Check if we need to descramble and what buffer to pass on. */

@@ -842,26 +855,27 @@ static int atrac3_decode_frame(AVCodecContext *avctx,

         databuf = buf;

     }

-    result = decodeFrame(q, databuf);

+    if (q->channels == 1 && avctx->sample_fmt == AV_SAMPLE_FMT_FLT)

+        result = decodeFrame(q, databuf, &samples_flt);

+    else

+        result = decodeFrame(q, databuf, q->outSamples);

     if (result != 0) {

         av_log(NULL,AV_LOG_ERROR,"Frame decoding error!\n");

-        return -1;

+        return result;

     }

-    if (q->channels == 1) {

-        /* mono */

-        for (i = 0; i<1024; i++)

-            samples[i] = av_clip_int16(round(q->outSamples[i]));

-        *data_size = 1024 * sizeof(int16_t);

-    } else {

-        /* stereo */

-        for (i = 0; i < 1024; i++) {

-            samples[i*2] = av_clip_int16(round(q->outSamples[i]));

-            samples[i*2+1] = av_clip_int16(round(q->outSamples[1024+i]));

-        }

-        *data_size = 2048 * sizeof(int16_t);

+    /* interleave */

+    if (q->channels == 2 && avctx->sample_fmt == AV_SAMPLE_FMT_FLT) {

+        q->fmt_conv.float_interleave(samples_flt,

+                                     (const float **)q->outSamples,

+                                     SAMPLES_PER_FRAME, 2);

+    } else if (avctx->sample_fmt == AV_SAMPLE_FMT_S16) {

+        q->fmt_conv.float_to_int16_interleave(samples_s16,

+                                              (const float **)q->outSamples,

+                                              SAMPLES_PER_FRAME, q->channels);

     }

+    *data_size = out_size;

     return avctx->block_align;

 }

@@ -875,7 +889,7 @@ static int atrac3_decode_frame(AVCodecContext *avctx,

 static av_cold int atrac3_decode_init(AVCodecContext *avctx)

 {

-    int i;

+    int i, ret;

     const uint8_t *edata_ptr = avctx->extradata;

     ATRAC3Context *q = avctx->priv_data;

     static VLC_TYPE atrac3_vlc_table[4096][2];

@@ -899,7 +913,7 @@ static av_cold int atrac3_decode_init(AVCodecContext *avctx)

         av_log(avctx,AV_LOG_DEBUG,"[12-13] %d\n",bytestream_get_le16(&edata_ptr));  //Unknown always 0

         /* setup */

-        q->samples_per_frame = 1024 * q->channels;

+        q->samples_per_frame = SAMPLES_PER_FRAME * q->channels;

         q->atrac3version = 4;

         q->delay = 0x88E;

         if (q->codingMode)

@@ -912,7 +926,7 @@ static av_cold int atrac3_decode_init(AVCodecContext *avctx)

         if ((q->bytes_per_frame == 96*q->channels*q->frame_factor) || (q->bytes_per_frame == 152*q->channels*q->frame_factor) || (q->bytes_per_frame == 192*q->channels*q->frame_factor)) {

         } else {

             av_log(avctx,AV_LOG_ERROR,"Unknown frame/channel/frame_factor configuration %d/%d/%d\n", q->bytes_per_frame, q->channels, q->frame_factor);

-            return -1;

+            return AVERROR_INVALIDDATA;

         }

     } else if (avctx->extradata_size == 10) {

@@ -932,17 +946,17 @@ static av_cold int atrac3_decode_init(AVCodecContext *avctx)

     if (q->atrac3version != 4) {

         av_log(avctx,AV_LOG_ERROR,"Version %d != 4.\n",q->atrac3version);

-        return -1;

+        return AVERROR_INVALIDDATA;

     }

-    if (q->samples_per_frame != 1024 && q->samples_per_frame != 2048) {

+    if (q->samples_per_frame != SAMPLES_PER_FRAME && q->samples_per_frame != SAMPLES_PER_FRAME*2) {

         av_log(avctx,AV_LOG_ERROR,"Unknown amount of samples per frame %d.\n",q->samples_per_frame);

-        return -1;

+        return AVERROR_INVALIDDATA;

     }

     if (q->delay != 0x88E) {

         av_log(avctx,AV_LOG_ERROR,"Unknown amount of delay %x != 0x88E.\n",q->delay);

-        return -1;

+        return AVERROR_INVALIDDATA;

     }

     if (q->codingMode == STEREO) {

@@ -951,17 +965,17 @@ static av_cold int atrac3_decode_init(AVCodecContext *avctx)

         av_log(avctx,AV_LOG_DEBUG,"Joint stereo detected.\n");

     } else {

         av_log(avctx,AV_LOG_ERROR,"Unknown channel coding mode %x!\n",q->codingMode);

-        return -1;

+        return AVERROR_INVALIDDATA;

     }

     if (avctx->channels <= 0 || avctx->channels > 2 /*|| ((avctx->channels * 1024) != q->samples_per_frame)*/) {

         av_log(avctx,AV_LOG_ERROR,"Channel configuration error!\n");

-        return -1;

+        return AVERROR(EINVAL);

     }

     if(avctx->block_align >= UINT_MAX/2)

-        return -1;

+        return AVERROR(EINVAL);

     /* Pad the data buffer with FF_INPUT_BUFFER_PADDING_SIZE,

      * this is for the bitstream reader. */

@@ -981,7 +995,16 @@ static av_cold int atrac3_decode_init(AVCodecContext *avctx)

         vlcs_initialized = 1;

     }

-    init_atrac3_transforms(q);

+    if (avctx->request_sample_fmt == AV_SAMPLE_FMT_FLT)

+        avctx->sample_fmt = AV_SAMPLE_FMT_FLT;

+    else

+        avctx->sample_fmt = AV_SAMPLE_FMT_S16;

+

+    if ((ret = init_atrac3_transforms(q, avctx->sample_fmt == AV_SAMPLE_FMT_FLT))) {

+        av_log(avctx, AV_LOG_ERROR, "Error initializing MDCT\n");

+        av_freep(&q->decoded_bytes_buffer);

+        return ret;

+    }

     atrac_generate_tables();

@@ -1007,14 +1030,23 @@ static av_cold int atrac3_decode_init(AVCodecContext *avctx)

     }

     dsputil_init(&dsp, avctx);

+    ff_fmt_convert_init(&q->fmt_conv, avctx);

     q->pUnits = av_mallocz(sizeof(channel_unit)*q->channels);

     if (!q->pUnits) {

-        av_free(q->decoded_bytes_buffer);

+        atrac3_decode_close(avctx);

         return AVERROR(ENOMEM);

     }

-    avctx->sample_fmt = AV_SAMPLE_FMT_S16;

+    if (avctx->channels > 1 || avctx->sample_fmt == AV_SAMPLE_FMT_S16) {

+        q->outSamples[0] = av_mallocz(SAMPLES_PER_FRAME * avctx->channels * sizeof(*q->outSamples[0]));

+        q->outSamples[1] = q->outSamples[0] + SAMPLES_PER_FRAME;

+        if (!q->outSamples[0]) {

+            atrac3_decode_close(avctx);

+            return AVERROR(ENOMEM);

+        }

+    }

+

     return 0;

 }

@@ -1028,5 +1060,6 @@ AVCodec ff_atrac3_decoder =

     .init = atrac3_decode_init,

     .close = atrac3_decode_close,

     .decode = atrac3_decode_frame,

+    .capabilities = CODEC_CAP_SUBFRAMES,

     .long_name = NULL_IF_CONFIG_SMALL("Atrac 3 (Adaptive TRansform Acoustic Coding 3)"),

 };

@@ -39,6 +39,8 @@

 extern const uint16_t ff_wma_critical_freqs[25];

+static float quant_table[95];

+

 #define MAX_CHANNELS 2

 #define BINK_BLOCK_MAX_SIZE (MAX_CHANNELS << 11)

@@ -56,8 +58,11 @@ typedef struct {

     unsigned int *bands;

     float root;

     DECLARE_ALIGNED(32, FFTSample, coeffs)[BINK_BLOCK_MAX_SIZE];

-    DECLARE_ALIGNED(16, short, previous)[BINK_BLOCK_MAX_SIZE / 16];  ///< coeffs from previous audio block

+    DECLARE_ALIGNED(16, int16_t, previous)[BINK_BLOCK_MAX_SIZE / 16];  ///< coeffs from previous audio block

+    DECLARE_ALIGNED(16, int16_t, current)[BINK_BLOCK_MAX_SIZE / 16];

     float *coeffs_ptr[MAX_CHANNELS]; ///< pointers to the coeffs arrays for float_to_int16_interleave

+    float *prev_ptr[MAX_CHANNELS];   ///< pointers to the overlap points in the coeffs array

+    uint8_t *packet_buffer;

     union {

         RDFTContext rdft;

         DCTContext dct;

@@ -107,6 +112,10 @@ static av_cold int decode_init(AVCodecContext *avctx)

     s->block_size    = (s->frame_len - s->overlap_len) * s->channels;

     sample_rate_half = (sample_rate + 1) / 2;

     s->root          = 2.0 / sqrt(s->frame_len);

+    for (i = 0; i < 95; i++) {

+        /* constant is result of 0.066399999/log10(M_E) */

+        quant_table[i] = expf(i * 0.15289164787221953823f) * s->root;

+    }

     /* calculate number of bands */

     for (s->num_bands = 1; s->num_bands < 25; s->num_bands++)

@@ -126,8 +135,10 @@ static av_cold int decode_init(AVCodecContext *avctx)

     s->first = 1;

     avctx->sample_fmt = AV_SAMPLE_FMT_S16;

-    for (i = 0; i < s->channels; i++)

+    for (i = 0; i < s->channels; i++) {

         s->coeffs_ptr[i] = s->coeffs + i * s->frame_len;

+        s->prev_ptr[i]   = s->coeffs_ptr[i] + s->frame_len - s->overlap_len;

+    }

     if (CONFIG_BINKAUDIO_RDFT_DECODER && avctx->codec->id == CODEC_ID_BINKAUDIO_RDFT)

         ff_rdft_init(&s->trans.rdft, frame_len_bits, DFT_C2R);

@@ -152,11 +163,18 @@ static const uint8_t rle_length_tab[16] = {

     2, 3, 4, 5, 6, 8, 9, 10, 11, 12, 13, 14, 15, 16, 32, 64

 };

+#define GET_BITS_SAFE(out, nbits) do {  \

+    if (get_bits_left(gb) < nbits)      \

+        return AVERROR_INVALIDDATA;     \

+    out = get_bits(gb, nbits);          \

+} while (0)

+

 /**

  * Decode Bink Audio block

  * @param[out] out Output buffer (must contain s->block_size elements)

+ * @return 0 on success, negative error code on failure

  */

-static void decode_block(BinkAudioContext *s, short *out, int use_dct)

+static int decode_block(BinkAudioContext *s, int16_t *out, int use_dct)

 {

     int ch, i, j, k;

     float q, quant[25];

@@ -169,17 +187,22 @@ static void decode_block(BinkAudioContext *s, short *out, int use_dct)

     for (ch = 0; ch < s->channels; ch++) {

         FFTSample *coeffs = s->coeffs_ptr[ch];

         if (s->version_b) {

+            if (get_bits_left(gb) < 64)

+                return AVERROR_INVALIDDATA;

             coeffs[0] = av_int2flt(get_bits(gb, 32)) * s->root;

             coeffs[1] = av_int2flt(get_bits(gb, 32)) * s->root;

         } else {

+            if (get_bits_left(gb) < 58)

+                return AVERROR_INVALIDDATA;

             coeffs[0] = get_float(gb) * s->root;

             coeffs[1] = get_float(gb) * s->root;

         }

+        if (get_bits_left(gb) < s->num_bands * 8)

+            return AVERROR_INVALIDDATA;

         for (i = 0; i < s->num_bands; i++) {

-            /* constant is result of 0.066399999/log10(M_E) */

             int value = get_bits(gb, 8);

-            quant[i] = expf(FFMIN(value, 95) * 0.15289164787221953823f) * s->root;

+            quant[i]  = quant_table[FFMIN(value, 95)];

         }

         k = 0;

@@ -190,15 +213,20 @@ static void decode_block(BinkAudioContext *s, short *out, int use_dct)

         while (i < s->frame_len) {

             if (s->version_b) {

                 j = i + 16;

-            } else if (get_bits1(gb)) {

-                j = i + rle_length_tab[get_bits(gb, 4)] * 8;

             } else {

-                j = i + 8;

+                int v;

+                GET_BITS_SAFE(v, 1);

+                if (v) {

+                    GET_BITS_SAFE(v, 4);

+                    j = i + rle_length_tab[v] * 8;

+                } else {

+                    j = i + 8;

+                }

             }

             j = FFMIN(j, s->frame_len);

-            width = get_bits(gb, 4);

+            GET_BITS_SAFE(width, 4);

             if (width == 0) {

                 memset(coeffs + i, 0, (j - i) * sizeof(*coeffs));

                 i = j;

@@ -208,9 +236,11 @@ static void decode_block(BinkAudioContext *s, short *out, int use_dct)

                 while (i < j) {

                     if (s->bands[k] == i)

                         q = quant[k++];

-                    coeff = get_bits(gb, width);

+                    GET_BITS_SAFE(coeff, width);

                     if (coeff) {

-                        if (get_bits1(gb))

+                        int v;

+                        GET_BITS_SAFE(v, 1);

+                        if (v)

                             coeffs[i] = -q * coeff;

                         else

                             coeffs[i] =  q * coeff;

@@ -231,8 +261,12 @@ static void decode_block(BinkAudioContext *s, short *out, int use_dct)

             s->trans.rdft.rdft_calc(&s->trans.rdft, coeffs);

     }

+    s->fmt_conv.float_to_int16_interleave(s->current,

+                                          (const float **)s->prev_ptr,

+                                          s->overlap_len, s->channels);

     s->fmt_conv.float_to_int16_interleave(out, (const float **)s->coeffs_ptr,

-                                          s->frame_len, s->channels);

+                                          s->frame_len - s->overlap_len,

+                                          s->channels);

     if (!s->first) {

         int count = s->overlap_len * s->channels;

@@ -242,16 +276,19 @@ static void decode_block(BinkAudioContext *s, short *out, int use_dct)

         }

     }

-    memcpy(s->previous, out + s->block_size,

-           s->overlap_len * s->channels * sizeof(*out));

+    memcpy(s->previous, s->current,

+           s->overlap_len * s->channels * sizeof(*s->previous));

     s->first = 0;

+

+    return 0;

 }

 static av_cold int decode_end(AVCodecContext *avctx)

 {

     BinkAudioContext * s = avctx->priv_data;

     av_freep(&s->bands);

+    av_freep(&s->packet_buffer);

     if (CONFIG_BINKAUDIO_RDFT_DECODER && avctx->codec->id == CODEC_ID_BINKAUDIO_RDFT)

         ff_rdft_end(&s->trans.rdft);

     else if (CONFIG_BINKAUDIO_DCT_DECODER)

@@ -270,25 +307,47 @@ static int decode_frame(AVCodecContext *avctx,

                         AVPacket *avpkt)

 {

     BinkAudioContext *s = avctx->priv_data;

-    const uint8_t *buf  = avpkt->data;

-    int buf_size        = avpkt->size;

-    short *samples      = data;

-    short *samples_end  = (short*)((uint8_t*)data + *data_size);

-    int reported_size;

+    int16_t *samples      = data;

     GetBitContext *gb = &s->gb;

+    int out_size, consumed = 0;

+

+    if (!get_bits_left(gb)) {

+        uint8_t *buf;

+        /* handle end-of-stream */

+        if (!avpkt->size) {

+            *data_size = 0;

+            return 0;

+        }

+        if (avpkt->size < 4) {

+            av_log(avctx, AV_LOG_ERROR, "Packet is too small\n");

+            return AVERROR_INVALIDDATA;

+        }

+        buf = av_realloc(s->packet_buffer, avpkt->size + FF_INPUT_BUFFER_PADDING_SIZE);

+        if (!buf)

+            return AVERROR(ENOMEM);

+        s->packet_buffer = buf;

+        memcpy(s->packet_buffer, avpkt->data, avpkt->size);

+        init_get_bits(gb, s->packet_buffer, avpkt->size * 8);

+        consumed = avpkt->size;

+

+        /* skip reported size */

+        skip_bits_long(gb, 32);

+    }

-    init_get_bits(gb, buf, buf_size * 8);

+    out_size = s->block_size * av_get_bytes_per_sample(avctx->sample_fmt);

+    if (*data_size < out_size) {

+        av_log(avctx, AV_LOG_ERROR, "Output buffer is too small\n");

+        return AVERROR(EINVAL);

+    }

-    reported_size = get_bits_long(gb, 32);

-    while (get_bits_count(gb) / 8 < buf_size &&

-           samples + s->block_size <= samples_end) {

-        decode_block(s, samples, avctx->codec->id == CODEC_ID_BINKAUDIO_DCT);

-        samples += s->block_size;

-        get_bits_align32(gb);

+    if (decode_block(s, samples, avctx->codec->id == CODEC_ID_BINKAUDIO_DCT)) {

+        av_log(avctx, AV_LOG_ERROR, "Incomplete packet\n");

+        return AVERROR_INVALIDDATA;

     }

+    get_bits_align32(gb);

-    *data_size = FFMIN(reported_size, (uint8_t*)samples - (uint8_t*)data);

-    return buf_size;

+    *data_size = out_size;

+    return consumed;

 }

 AVCodec ff_binkaudio_rdft_decoder = {

@@ -299,6 +358,7 @@ AVCodec ff_binkaudio_rdft_decoder = {

     .init           = decode_init,

     .close          = decode_end,

     .decode         = decode_frame,

+    .capabilities   = CODEC_CAP_DELAY,

     .long_name = NULL_IF_CONFIG_SMALL("Bink Audio (RDFT)")

 };

@@ -310,5 +370,6 @@ AVCodec ff_binkaudio_dct_decoder = {

     .init           = decode_init,

     .close          = decode_end,

     .decode         = decode_frame,

+    .capabilities   = CODEC_CAP_DELAY,

     .long_name = NULL_IF_CONFIG_SMALL("Bink Audio (DCT)")

 };

@@ -42,12 +42,7 @@

  * available.

  */

-#include <math.h>

-#include <stddef.h>

-#include <stdio.h>

-

 #include "libavutil/lfg.h"

-#include "libavutil/random_seed.h"

 #include "avcodec.h"

 #include "get_bits.h"

 #include "dsputil.h"

@@ -124,7 +119,7 @@ typedef struct cook {

     void (* interpolate) (struct cook *q, float* buffer,

                           int gain_index, int gain_index_next);

-    void (* saturate_output) (struct cook *q, int chan, int16_t *out);

+    void (* saturate_output) (struct cook *q, int chan, float *out);

     AVCodecContext*     avctx;

     GetBitContext       gb;

@@ -217,11 +212,11 @@ static av_cold int init_cook_vlc_tables(COOKContext *q) {

 }

 static av_cold int init_cook_mlt(COOKContext *q) {

-    int j;

+    int j, ret;

     int mlt_size = q->samples_per_channel;

-    if ((q->mlt_window = av_malloc(sizeof(float)*mlt_size)) == 0)

-      return -1;

+    if ((q->mlt_window = av_malloc(mlt_size * sizeof(*q->mlt_window))) == 0)

+        return AVERROR(ENOMEM);

     /* Initialize the MLT window: simple sine window. */

     ff_sine_window_init(q->mlt_window, mlt_size);

@@ -229,9 +224,9 @@ static av_cold int init_cook_mlt(COOKContext *q) {

         q->mlt_window[j] *= sqrt(2.0 / q->samples_per_channel);

     /* Initialize the MDCT. */

-    if (ff_mdct_init(&q->mdct_ctx, av_log2(mlt_size)+1, 1, 1.0)) {

-      av_free(q->mlt_window);

-      return -1;

+    if ((ret = ff_mdct_init(&q->mdct_ctx, av_log2(mlt_size)+1, 1, 1.0/32768.0))) {

+        av_free(q->mlt_window);

+        return ret;

     }

     av_log(q->avctx,AV_LOG_DEBUG,"MDCT initialized, order = %d.\n",

            av_log2(mlt_size)+1);

@@ -410,9 +405,9 @@ static void categorize(COOKContext *q, COOKSubpacket *p, int* quant_index_table,

         //av_log(q->avctx, AV_LOG_ERROR, "bits_left = %d\n",bits_left);

     }

-    memset(&exp_index1,0,102*sizeof(int));