ffmpeg roll of source to mar 9 version...

patched-ffmpeg-mt/libavcodec/binkaudio.c

 /*
  * Bink Audio decoder
  * Copyright (c) 2007-2010 Peter Ross (pross@xvid.org)
  * Copyright (c) 2009 Daniel Verkamp (daniel@drv.nu)
  *
  * 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
@@ skipping 14 matching lines @@
  * Bink Audio decoder
  *
  * Technical details here:
  *  http://wiki.multimedia.cx/index.php?title=Bink_Audio
  */
 
 #include "avcodec.h"
 #define ALT_BITSTREAM_READER_LE
 #include "get_bits.h"
 #include "dsputil.h"
+#include "fft.h"
+
 extern const uint16_t ff_wma_critical_freqs[25];
 
 #define MAX_CHANNELS 2
 #define BINK_BLOCK_MAX_SIZE (MAX_CHANNELS << 11)
 
 typedef struct {
     AVCodecContext *avctx;
     GetBitContext gb;
     DSPContext dsp;
     int first;
     int channels;
     int frame_len;          ///< transform size (samples)
     int overlap_len;        ///< overlap size (samples)
     int block_size;
     int num_bands;
     unsigned int *bands;
     float root;
-    DECLARE_ALIGNED_16(FFTSample, coeffs)[BINK_BLOCK_MAX_SIZE];
-    DECLARE_ALIGNED_16(short, previous)[BINK_BLOCK_MAX_SIZE / 16];  ///< coeffs from previous audio block
+    DECLARE_ALIGNED(16, FFTSample, coeffs)[BINK_BLOCK_MAX_SIZE];
+    DECLARE_ALIGNED(16, short, previous)[BINK_BLOCK_MAX_SIZE / 16];  ///< coeffs from previous audio block
     float *coeffs_ptr[MAX_CHANNELS]; ///< pointers to the coeffs arrays for float_to_int16_interleave
     union {
         RDFTContext rdft;
         DCTContext dct;
     } trans;
 } BinkAudioContext;
 
 
 static av_cold int decode_init(AVCodecContext *avctx)
 {
@@ skipping 51 matching lines @@
     for (i = 1; i < s->num_bands; i++)
         s->bands[i] = ff_wma_critical_freqs[i - 1] * (s->frame_len / 2) / sample_rate_half;
     s->bands[s->num_bands] = s->frame_len / 2;
 
     s->first = 1;
     avctx->sample_fmt = SAMPLE_FMT_S16;
 
     for (i = 0; i < s->channels; i++)
         s->coeffs_ptr[i] = s->coeffs + i * s->frame_len;
 
-    if (avctx->codec->id == CODEC_ID_BINKAUDIO_RDFT)
-        ff_rdft_init(&s->trans.rdft, frame_len_bits, IRIDFT);
+    if (CONFIG_BINKAUDIO_RDFT_DECODER && avctx->codec->id == CODEC_ID_BINKAUDIO_RDFT)
+        ff_rdft_init(&s->trans.rdft, frame_len_bits, DFT_C2R);
+    else if (CONFIG_BINKAUDIO_DCT_DECODER)
+        ff_dct_init(&s->trans.dct, frame_len_bits, 1);
     else
-        ff_dct_init(&s->trans.dct, frame_len_bits, 0);
+        return -1;
 
     return 0;
 }
 
 static float get_float(GetBitContext *gb)
 {
     int power = get_bits(gb, 5);
     float f = ldexpf(get_bits_long(gb, 23), power - 23);
     if (get_bits1(gb))
         f = -f;
@@ skipping 63 matching lines @@
                         else
                             coeffs[i] =  q * coeff;
                     } else {
                         coeffs[i] = 0.0f;
                     }
                     i++;
                 }
             }
         }
 
-        if (use_dct)
+        if (CONFIG_BINKAUDIO_DCT_DECODER && use_dct) {
+            coeffs[0] /= 0.5;
             ff_dct_calc (&s->trans.dct,  coeffs);
-        else
+            s->dsp.vector_fmul_scalar(coeffs, coeffs, s->frame_len / 2, s->frame_len);
+        }
+        else if (CONFIG_BINKAUDIO_RDFT_DECODER)
             ff_rdft_calc(&s->trans.rdft, coeffs);
     }
 
     s->dsp.float_to_int16_interleave(out, (const float **)s->coeffs_ptr, s->frame_len, s->channels);
 
     if (!s->first) {
         int count = s->overlap_len * s->channels;
         int shift = av_log2(count);
         for (i = 0; i < count; i++) {
             out[i] = (s->previous[i] * (count - i) + out[i] * i) >> shift;
         }
     }
 
     memcpy(s->previous, out + s->block_size,
            s->overlap_len * s->channels * sizeof(*out));
 
     s->first = 0;
 }
 
 static av_cold int decode_end(AVCodecContext *avctx)
 {
     BinkAudioContext * s = avctx->priv_data;
     av_freep(&s->bands);
-    if (avctx->codec->id == CODEC_ID_BINKAUDIO_RDFT)
+    if (CONFIG_BINKAUDIO_RDFT_DECODER && avctx->codec->id == CODEC_ID_BINKAUDIO_RDFT)
         ff_rdft_end(&s->trans.rdft);
-    else
+    else if (CONFIG_BINKAUDIO_DCT_DECODER)
         ff_dct_end(&s->trans.dct);
     return 0;
 }
 
 static void get_bits_align32(GetBitContext *s)
 {
     int n = (-get_bits_count(s)) & 31;
     if (n) skip_bits(s, n);
 }
 
@@ skipping 12 matching lines @@
     init_get_bits(gb, buf, buf_size * 8);
 
     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);
     }
 
-    *data_size = (uint8_t*)samples - (uint8_t*)data;
-    if (reported_size != *data_size) {
-        av_log(avctx, AV_LOG_WARNING, "reported data size (%d) does not match output data size (%d)\n",
-             reported_size, *data_size);
-    }
+    *data_size = FFMIN(reported_size, (uint8_t*)samples - (uint8_t*)data);
     return buf_size;
 }
 
 AVCodec binkaudio_rdft_decoder = {
     "binkaudio_rdft",
     CODEC_TYPE_AUDIO,
     CODEC_ID_BINKAUDIO_RDFT,
     sizeof(BinkAudioContext),
     decode_init,
     NULL,
     decode_end,
     decode_frame,
     .long_name = NULL_IF_CONFIG_SMALL("Bink Audio (RDFT)")
 };
 
 AVCodec binkaudio_dct_decoder = {
     "binkaudio_dct",
     CODEC_TYPE_AUDIO,
     CODEC_ID_BINKAUDIO_DCT,
     sizeof(BinkAudioContext),
     decode_init,
     NULL,
     decode_end,
     decode_frame,
     .long_name = NULL_IF_CONFIG_SMALL("Bink Audio (DCT)")
 };