@@ -10,7 +10,7 @@ version <next>:

 - libxvid aspect pickiness fixed

 - Frame multithreaded decoding

 - Lots of deprecated API cruft removed

-

+- fft and imdct optimizations for AVX (Sandy Bridge) processors

 version 0.7_beta1:

@@ -13,6 +13,17 @@ libavutil:   2011-04-18

 API changes, most recent first:

+2011-04-XX - bebe72f - lavu 51.1.0 - avutil.h

+  Add AVPictureType enum and av_get_picture_type_char(), deprecate

+  FF_*_TYPE defines and av_get_pict_type_char() defined in

+  libavcodec/avcodec.h.

+

+2011-04-xx - 10d3940 - lavfi 2.3.0 - avfilter.h

+  Add pict_type and key_frame fields to AVFilterBufferRefVideo.

+

+2011-04-xx - 7a11c82 - lavfi 2.2.0 - vsrc_buffer

+  Add sample_aspect_ratio fields to vsrc_buffer arguments

+

 2011-04-21 - 94f7451 - lavc 53.1.0 - avcodec.h

   Add CODEC_CAP_SLICE_THREADS for codecs supporting sliced threading.

@@ -2908,6 +2908,10 @@ static void opt_frame_aspect_ratio(const char *arg)

         ffmpeg_exit(1);

     }

     frame_aspect_ratio = ar;

+

+    x = vfilters ? strlen(vfilters) : 0;

+    vfilters = av_realloc(vfilters, x+100);

+    snprintf(vfilters+x, x+100, "%csetdar=%f\n", x?',':' ', ar);

 }

 static int opt_metadata(const char *opt, const char *arg)

@@ -2185,10 +2185,8 @@ static int open_input_stream(HTTPContext *c, const char *info)

         }

     }

-#if 1

     if (c->fmt_in->iformat->read_seek)

         av_seek_frame(c->fmt_in, -1, stream_pos, 0);

-#endif

     /* set the start time (needed for maxtime and RTP packet timing) */

     c->start_time = cur_time;

     c->first_pts = AV_NOPTS_VALUE;

@@ -223,9 +223,9 @@ typedef struct {

     float sf[120];                                  ///< scalefactors

     int sf_idx[128];                                ///< scalefactor indices (used by encoder)

     uint8_t zeroes[128];                            ///< band is not coded (used by encoder)

-    DECLARE_ALIGNED(16, float,   coeffs)[1024];     ///< coefficients for IMDCT

-    DECLARE_ALIGNED(16, float,   saved)[1024];      ///< overlap

-    DECLARE_ALIGNED(16, float,   ret)[2048];        ///< PCM output

+    DECLARE_ALIGNED(32, float,   coeffs)[1024];     ///< coefficients for IMDCT

+    DECLARE_ALIGNED(32, float,   saved)[1024];      ///< overlap

+    DECLARE_ALIGNED(32, float,   ret)[2048];        ///< PCM output

     DECLARE_ALIGNED(16, int16_t, ltp_state)[3072];  ///< time signal for LTP

     PredictorState predictor_state[MAX_PREDICTORS];

 } SingleChannelElement;

@@ -272,7 +272,7 @@ typedef struct {

      * @defgroup temporary aligned temporary buffers (We do not want to have these on the stack.)

      * @{

      */

-    DECLARE_ALIGNED(16, float, buf_mdct)[1024];

+    DECLARE_ALIGNED(32, float, buf_mdct)[1024];

     /** @} */

     /**

@@ -296,7 +296,7 @@ typedef struct {

     int sf_offset;                                    ///< offset into pow2sf_tab as appropriate for dsp.float_to_int16

     /** @} */

-    DECLARE_ALIGNED(16, float, temp)[128];

+    DECLARE_ALIGNED(32, float, temp)[128];

     enum OCStatus output_configured;

 } AACContext;

@@ -37,6 +37,7 @@

 #include "aac.h"

 #include "aacenc.h"

 #include "aactab.h"

+#include "libavutil/libm.h"

 /** bits needed to code codebook run value for long windows */

 static const uint8_t run_value_bits_long[64] = {

@@ -64,7 +64,7 @@ typedef struct AACEncContext {

     int last_frame;

     float lambda;

     DECLARE_ALIGNED(16, int,   qcoefs)[96];      ///< quantized coefficients

-    DECLARE_ALIGNED(16, float, scoefs)[1024];    ///< scaled coefficients

+    DECLARE_ALIGNED(32, float, scoefs)[1024];    ///< scaled coefficients

 } AACEncContext;

 #endif /* AVCODEC_AACENC_H */

@@ -32,6 +32,7 @@

 #include "aacsbrdata.h"

 #include "fft.h"

 #include "aacps.h"

+#include "libavutil/libm.h"

 #include <stdint.h>

 #include <float.h>

@@ -201,13 +201,13 @@ typedef struct {

 ///@}

 ///@defgroup arrays aligned arrays

-    DECLARE_ALIGNED(16, int,   fixed_coeffs)[AC3_MAX_CHANNELS][AC3_MAX_COEFS];       ///< fixed-point transform coefficients

-    DECLARE_ALIGNED(16, float, transform_coeffs)[AC3_MAX_CHANNELS][AC3_MAX_COEFS];   ///< transform coefficients

-    DECLARE_ALIGNED(16, float, delay)[AC3_MAX_CHANNELS][AC3_BLOCK_SIZE];             ///< delay - added to the next block

-    DECLARE_ALIGNED(16, float, window)[AC3_BLOCK_SIZE];                              ///< window coefficients

-    DECLARE_ALIGNED(16, float, tmp_output)[AC3_BLOCK_SIZE];                          ///< temporary storage for output before windowing

-    DECLARE_ALIGNED(16, float, output)[AC3_MAX_CHANNELS][AC3_BLOCK_SIZE];            ///< output after imdct transform and windowing

-    DECLARE_ALIGNED(16, uint8_t, input_buffer)[AC3_FRAME_BUFFER_SIZE + FF_INPUT_BUFFER_PADDING_SIZE]; ///< temp buffer to prevent overread

+    DECLARE_ALIGNED(16, int,   fixed_coeffs)[AC3_MAX_CHANNELS][AC3_MAX_COEFS];       ///> fixed-point transform coefficients

+    DECLARE_ALIGNED(32, float, transform_coeffs)[AC3_MAX_CHANNELS][AC3_MAX_COEFS];   ///< transform coefficients

+    DECLARE_ALIGNED(32, float, delay)[AC3_MAX_CHANNELS][AC3_BLOCK_SIZE];             ///< delay - added to the next block

+    DECLARE_ALIGNED(32, float, window)[AC3_BLOCK_SIZE];                              ///< window coefficients

+    DECLARE_ALIGNED(32, float, tmp_output)[AC3_BLOCK_SIZE];                          ///< temporary storage for output before windowing

+    DECLARE_ALIGNED(32, float, output)[AC3_MAX_CHANNELS][AC3_BLOCK_SIZE];            ///< output after imdct transform and windowing

+    DECLARE_ALIGNED(32, uint8_t, input_buffer)[AC3_FRAME_BUFFER_SIZE + FF_INPUT_BUFFER_PADDING_SIZE]; ///< temp buffer to prevent overread

 ///@}

 } AC3DecodeContext;

@@ -171,7 +171,7 @@ typedef struct AC3EncodeContext {

     uint8_t exp_strategy[AC3_MAX_CHANNELS][AC3_MAX_BLOCKS]; ///< exponent strategies

-    DECLARE_ALIGNED(16, SampleType, windowed_samples)[AC3_WINDOW_SIZE];

+    DECLARE_ALIGNED(32, SampleType, windowed_samples)[AC3_WINDOW_SIZE];

 } AC3EncodeContext;

 typedef struct AC3Mant {

@@ -47,7 +47,7 @@ static av_cold void mdct_end(AC3MDCTContext *mdct)

 static av_cold int mdct_init(AVCodecContext *avctx, AC3MDCTContext *mdct,

                              int nbits)

 {

-    int ret = ff_mdct_init(&mdct->fft, nbits, 0, 1.0);

+    int ret = ff_mdct_init(&mdct->fft, nbits, 0, -1.0);

     mdct->window = ff_ac3_window;

     return ret;

 }

@@ -60,11 +60,11 @@ typedef struct {

     int                 log2_block_count[AT1_QMF_BANDS];    ///< log2 number of blocks in a band

     int                 num_bfus;                           ///< number of Block Floating Units

     float*              spectrum[2];

-    DECLARE_ALIGNED(16, float, spec1)[AT1_SU_SAMPLES];     ///< mdct buffer

-    DECLARE_ALIGNED(16, float, spec2)[AT1_SU_SAMPLES];     ///< mdct buffer

-    DECLARE_ALIGNED(16, float, fst_qmf_delay)[46];         ///< delay line for the 1st stacked QMF filter

-    DECLARE_ALIGNED(16, float, snd_qmf_delay)[46];         ///< delay line for the 2nd stacked QMF filter

-    DECLARE_ALIGNED(16, float, last_qmf_delay)[256+23];    ///< delay line for the last stacked QMF filter

+    DECLARE_ALIGNED(32, float, spec1)[AT1_SU_SAMPLES];     ///< mdct buffer

+    DECLARE_ALIGNED(32, float, spec2)[AT1_SU_SAMPLES];     ///< mdct buffer

+    DECLARE_ALIGNED(32, float, fst_qmf_delay)[46];         ///< delay line for the 1st stacked QMF filter

+    DECLARE_ALIGNED(32, float, snd_qmf_delay)[46];         ///< delay line for the 2nd stacked QMF filter

+    DECLARE_ALIGNED(32, float, last_qmf_delay)[256+23];    ///< delay line for the last stacked QMF filter

 } AT1SUCtx;

 /**

@@ -72,13 +72,13 @@ typedef struct {

  */

 typedef struct {

     AT1SUCtx            SUs[AT1_MAX_CHANNELS];              ///< channel sound unit

-    DECLARE_ALIGNED(16, float, spec)[AT1_SU_SAMPLES];      ///< the mdct spectrum buffer

+    DECLARE_ALIGNED(32, float, spec)[AT1_SU_SAMPLES];      ///< the mdct spectrum buffer

-    DECLARE_ALIGNED(16, float,  low)[256];

-    DECLARE_ALIGNED(16, float,  mid)[256];

-    DECLARE_ALIGNED(16, float, high)[512];

+    DECLARE_ALIGNED(32, float,  low)[256];

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

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

     float*              bands[3];

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

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

     FFTContext          mdct_ctx[3];

     int                 channels;

     DSPContext          dsp;

@@ -74,8 +74,8 @@ typedef struct {

     int               gcBlkSwitch;

     gain_block        gainBlock[2];

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

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

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

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

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

     float             delayBuf2[46];

@@ -122,7 +122,7 @@ typedef struct {

     FFTContext          mdct_ctx;

 } ATRAC3Context;

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

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

 static VLC              spectral_coeff_tab[7];

 static float            gain_tab1[16];

 static float            gain_tab2[31];

@@ -766,7 +766,7 @@ typedef struct AVPanScan{

      * - encoding: Set by libavcodec. for coded_picture (and set by user for input).\

      * - decoding: Set by libavcodec.\

      */\

-    int pict_type;\

+    enum AVPictureType pict_type;\

 \

     /**\

      * presentation timestamp in time_base units (time when frame should be shown to user)\

@@ -1016,14 +1016,16 @@ typedef struct AVPanScan{

 #define FF_BUFFER_TYPE_SHARED   4 ///< Buffer from somewhere else; don't deallocate image (data/base), all other tables are not shared.

 #define FF_BUFFER_TYPE_COPY     8 ///< Just a (modified) copy of some other buffer, don't deallocate anything.

-

-#define FF_I_TYPE  1 ///< Intra

-#define FF_P_TYPE  2 ///< Predicted

-#define FF_B_TYPE  3 ///< Bi-dir predicted

-#define FF_S_TYPE  4 ///< S(GMC)-VOP MPEG4

-#define FF_SI_TYPE 5 ///< Switching Intra

-#define FF_SP_TYPE 6 ///< Switching Predicted

-#define FF_BI_TYPE 7

+#if FF_API_OLD_FF_PICT_TYPES

+/* DEPRECATED, directly use the AV_PICTURE_TYPE_* enum values */

+#define FF_I_TYPE  AV_PICTURE_TYPE_I  ///< Intra

+#define FF_P_TYPE  AV_PICTURE_TYPE_P  ///< Predicted

+#define FF_B_TYPE  AV_PICTURE_TYPE_B  ///< Bi-dir predicted

+#define FF_S_TYPE  AV_PICTURE_TYPE_S  ///< S(GMC)-VOP MPEG4

+#define FF_SI_TYPE AV_PICTURE_TYPE_SI ///< Switching Intra

+#define FF_SP_TYPE AV_PICTURE_TYPE_SP ///< Switching Predicted

+#define FF_BI_TYPE AV_PICTURE_TYPE_BI

+#endif

 #define FF_BUFFER_HINTS_VALID    0x01 // Buffer hints value is meaningful (if 0 ignore).

 #define FF_BUFFER_HINTS_READABLE 0x02 // Codec will read from buffer.

@@ -1215,16 +1217,6 @@ typedef struct AVCodecContext {

      */

     enum PixelFormat pix_fmt;

-#if FF_API_RATE_EMU

-    /**

-     * Frame rate emulation. If not zero, the lower layer (i.e. format handler)

-     * has to read frames at native frame rate.

-     * - encoding: Set by user.

-     * - decoding: unused

-     */

-    attribute_deprecated int rate_emu;

-#endif

-

     /**

      * If non NULL, 'draw_horiz_band' is called by the libavcodec

      * decoder to draw a horizontal band. It improves cache usage. Not

@@ -1326,16 +1318,6 @@ typedef struct AVCodecContext {

     int b_frame_strategy;

-#if FF_API_HURRY_UP

-    /**

-     * hurry up amount

-     * - encoding: unused

-     * - decoding: Set by user. 1-> Skip B-frames, 2-> Skip IDCT/dequant too, 5-> Skip everything except header

-     * @deprecated Deprecated in favor of skip_idct and skip_frame.

-     */

-    attribute_deprecated int hurry_up;

-#endif

-

     struct AVCodec *codec;

     void *priv_data;

@@ -1800,22 +1782,6 @@ typedef struct AVCodecContext {

      */

     uint64_t error[4];

-#if FF_API_MB_Q

-    /**

-     * minimum MB quantizer

-     * - encoding: unused

-     * - decoding: unused

-     */

-    attribute_deprecated int mb_qmin;

-

-    /**

-     * maximum MB quantizer

-     * - encoding: unused

-     * - decoding: unused

-     */

-    attribute_deprecated int mb_qmax;

-#endif

-

     /**

      * motion estimation comparison function

      * - encoding: Set by user.

@@ -3866,13 +3832,17 @@ void avcodec_default_free_buffers(AVCodecContext *s);

 /* misc useful functions */

+#if FF_API_OLD_FF_PICT_TYPES

 /**

  * Return a single letter to describe the given picture type pict_type.

  *

  * @param[in] pict_type the picture type

  * @return A single character representing the picture type.

+ * @deprecated Use av_get_picture_type_char() instead.

  */

+attribute_deprecated

 char av_get_pict_type_char(int pict_type);

+#endif

 /**

  * Return codec bits per sample.

@@ -55,7 +55,7 @@ typedef struct {

     int num_bands;

     unsigned int *bands;

     float root;

-    DECLARE_ALIGNED(16, FFTSample, coeffs)[BINK_BLOCK_MAX_SIZE];

+    DECLARE_ALIGNED(32, 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 {

@@ -153,7 +153,7 @@ typedef struct cook {

     /* data buffers */

     uint8_t*            decoded_bytes_buffer;

-    DECLARE_ALIGNED(16, float,mono_mdct_output)[2048];

+    DECLARE_ALIGNED(32, float, mono_mdct_output)[2048];

     float               decode_buffer_1[1024];

     float               decode_buffer_2[1024];

     float               decode_buffer_0[1060]; /* static allocation for joint decode */

@@ -321,16 +321,16 @@ typedef struct {

     /* Subband samples history (for ADPCM) */

     float subband_samples_hist[DCA_PRIM_CHANNELS_MAX][DCA_SUBBANDS][4];

-    DECLARE_ALIGNED(16, float, subband_fir_hist)[DCA_PRIM_CHANNELS_MAX][512];

-    DECLARE_ALIGNED(16, float, subband_fir_noidea)[DCA_PRIM_CHANNELS_MAX][32];

+    DECLARE_ALIGNED(32, float, subband_fir_hist)[DCA_PRIM_CHANNELS_MAX][512];

+    DECLARE_ALIGNED(32, float, subband_fir_noidea)[DCA_PRIM_CHANNELS_MAX][32];

     int hist_index[DCA_PRIM_CHANNELS_MAX];

-    DECLARE_ALIGNED(16, float, raXin)[32];

+    DECLARE_ALIGNED(32, float, raXin)[32];

     int output;                 ///< type of output

     float scale_bias;           ///< output scale

-    DECLARE_ALIGNED(16, float, subband_samples)[DCA_BLOCKS_MAX][DCA_PRIM_CHANNELS_MAX][DCA_SUBBANDS][8];

-    DECLARE_ALIGNED(16, float, samples)[(DCA_PRIM_CHANNELS_MAX+1)*256];

+    DECLARE_ALIGNED(32, float, subband_samples)[DCA_BLOCKS_MAX][DCA_PRIM_CHANNELS_MAX][DCA_SUBBANDS][8];

+    DECLARE_ALIGNED(32, float, samples)[(DCA_PRIM_CHANNELS_MAX+1)*256];

     const float *samples_chanptr[DCA_PRIM_CHANNELS_MAX+1];

     uint8_t dca_buffer[DCA_MAX_FRAME_SIZE + DCA_MAX_EXSS_HEADER_SIZE + DCA_BUFFER_PADDING_SIZE];

@@ -312,18 +312,16 @@ static void dct_error(const char *name, int is_idct,

     }

     for(i=0; i<64; i++) sysErrMax= FFMAX(sysErrMax, FFABS(sysErr[i]));

-#if 1 // dump systematic errors

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

         if(i%8==0) printf("\n");

         printf("%7d ", (int)sysErr[i]);

     }

     printf("\n");

-#endif

     printf("%s %s: err_inf=%d err2=%0.8f syserr=%0.8f maxout=%d blockSumErr=%d\n",

            is_idct ? "IDCT" : "DCT",

            name, err_inf, (double)err2 / NB_ITS / 64.0, (double)sysErrMax / NB_ITS, maxout, blockSumErrMax);

-#if 1 //Speed test

+

     /* speed test */

     for(i=0;i<64;i++)

         block1[i] = 0;

@@ -376,7 +374,6 @@ static void dct_error(const char *name, int is_idct,

     printf("%s %s: %0.1f kdct/s\n",

            is_idct ? "IDCT" : "DCT",

            name, (double)it1 * 1000.0 / (double)ti1);

-#endif

 }

 DECLARE_ALIGNED(8, static uint8_t, img_dest)[64];

@@ -786,7 +786,6 @@ void ff_er_frame_end(MpegEncContext *s){

         }

     }

-#if 1

     /* handle overlapping slices */

     for(error_type=1; error_type<=3; error_type++){

         int end_ok=0;

@@ -807,8 +806,7 @@ void ff_er_frame_end(MpegEncContext *s){

                 end_ok=0;

         }

     }

-#endif

-#if 1

+

     /* handle slices with partitions of different length */

     if(s->partitioned_frame){

         int end_ok=0;

@@ -829,7 +827,7 @@ void ff_er_frame_end(MpegEncContext *s){

                 end_ok=0;

         }

     }

-#endif

+

     /* handle missing slices */

     if(s->error_recognition>=4){

         int end_ok=1;

@@ -853,7 +851,6 @@ void ff_er_frame_end(MpegEncContext *s){

         }

     }

-#if 1

     /* backward mark errors */

     distance=9999999;

     for(error_type=1; error_type<=3; error_type++){

@@ -878,7 +875,6 @@ void ff_er_frame_end(MpegEncContext *s){

                 distance= 9999999;

         }

     }

-#endif

     /* forward mark errors */

     error=0;

@@ -893,7 +889,7 @@ void ff_er_frame_end(MpegEncContext *s){

             s->error_status_table[mb_xy]|= error;

         }

     }

-#if 1

+

     /* handle not partitioned case */

     if(!s->partitioned_frame){

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

@@ -904,7 +900,6 @@ void ff_er_frame_end(MpegEncContext *s){

             s->error_status_table[mb_xy]= error;

         }

     }

-#endif

     dc_error= ac_error= mv_error=0;

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

@@ -1065,16 +1060,15 @@ void ff_er_frame_end(MpegEncContext *s){

             s->dc_val[2][mb_x + mb_y*s->mb_stride]= (dcv+4)>>3;

         }

     }

-#if 1

+

     /* guess DC for damaged blocks */

     guess_dc(s, s->dc_val[0], s->mb_width*2, s->mb_height*2, s->b8_stride, 1);

     guess_dc(s, s->dc_val[1], s->mb_width  , s->mb_height  , s->mb_stride, 0);

     guess_dc(s, s->dc_val[2], s->mb_width  , s->mb_height  , s->mb_stride, 0);

-#endif

+

     /* filter luma DC */

     filter181(s->dc_val[0], s->mb_width*2, s->mb_height*2, s->b8_stride);

-#if 1

     /* render DC only intra */

     for(mb_y=0; mb_y<s->mb_height; mb_y++){

         for(mb_x=0; mb_x<s->mb_width; mb_x++){

@@ -1094,7 +1088,6 @@ void ff_er_frame_end(MpegEncContext *s){

             put_dc(s, dest_y, dest_cb, dest_cr, mb_x, mb_y);

         }

     }

-#endif

     if(s->avctx->error_concealment&FF_EC_DEBLOCK){

         /* filter horizontal block boundaries */

@@ -93,6 +93,44 @@ av_cold void ff_init_ff_cos_tabs(int index)

 #endif

 }

+static const int avx_tab[] = {

+    0, 4, 1, 5, 8, 12, 9, 13, 2, 6, 3, 7, 10, 14, 11, 15

+};

+

+static int is_second_half_of_fft32(int i, int n)

+{

+    if (n <= 32)

+        return i >= 16;

+    else if (i < n/2)

+        return is_second_half_of_fft32(i, n/2);

+    else if (i < 3*n/4)

+        return is_second_half_of_fft32(i - n/2, n/4);

+    else

+        return is_second_half_of_fft32(i - 3*n/4, n/4);

+}

+

+static av_cold void fft_perm_avx(FFTContext *s)

+{

+    int i;

+    int n = 1 << s->nbits;

+

+    for (i = 0; i < n; i += 16) {

+        int k;

+        if (is_second_half_of_fft32(i, n)) {

+            for (k = 0; k < 16; k++)

+                s->revtab[-split_radix_permutation(i + k, n, s->inverse) & (n - 1)] =

+                    i + avx_tab[k];

+

+        } else {

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

+                int j = i + k;

+                j = (j & ~7) | ((j >> 1) & 3) | ((j << 2) & 4);

+                s->revtab[-split_radix_permutation(i + k, n, s->inverse) & (n - 1)] = j;

+            }

+        }

+    }

+}

+

 av_cold int ff_fft_init(FFTContext *s, int nbits, int inverse)

 {

     int i, j, n;

@@ -132,11 +170,16 @@ av_cold int ff_fft_init(FFTContext *s, int nbits, int inverse)

     for(j=4; j<=nbits; j++) {

         ff_init_ff_cos_tabs(j);

     }

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

-        int j = i;

-        if (s->fft_permutation == FF_FFT_PERM_SWAP_LSBS)

-            j = (j&~3) | ((j>>1)&1) | ((j<<1)&2);

-        s->revtab[-split_radix_permutation(i, n, s->inverse) & (n-1)] = j;

+

+    if (s->fft_permutation == FF_FFT_PERM_AVX) {

+        fft_perm_avx(s);

+    } else {

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

+            int j = i;

+            if (s->fft_permutation == FF_FFT_PERM_SWAP_LSBS)

+                j = (j&~3) | ((j>>1)&1) | ((j<<1)&2);

+            s->revtab[-split_radix_permutation(i, n, s->inverse) & (n-1)] = j;

+        }

     }

     return 0;

@@ -85,6 +85,7 @@ struct FFTContext {

     int fft_permutation;

 #define FF_FFT_PERM_DEFAULT   0

 #define FF_FFT_PERM_SWAP_LSBS 1

+#define FF_FFT_PERM_AVX       2

     int mdct_permutation;

 #define FF_MDCT_PERM_NONE       0

 #define FF_MDCT_PERM_INTERLEAVE 1

@@ -97,7 +98,7 @@ struct FFTContext {

 #endif

 #define COSTABLE(size) \

-    COSTABLE_CONST DECLARE_ALIGNED(16, FFTSample, FFT_NAME(ff_cos_##size))[size/2]

+    COSTABLE_CONST DECLARE_ALIGNED(32, FFTSample, FFT_NAME(ff_cos_##size))[size/2]

 extern COSTABLE(16);

 extern COSTABLE(32);

@@ -599,10 +599,6 @@ retry:

     s->current_picture.pict_type= s->pict_type;

     s->current_picture.key_frame= s->pict_type == FF_I_TYPE;

-#if FF_API_HURRY_UP

-    /* skip everything if we are in a hurry>=5 */

-    if(avctx->hurry_up>=5) return get_consumed_bytes(s, buf_size);

-#endif

     if(  (avctx->skip_frame >= AVDISCARD_NONREF && s->pict_type==FF_B_TYPE)

        ||(avctx->skip_frame >= AVDISCARD_NONKEY && s->pict_type!=FF_I_TYPE)

        || avctx->skip_frame >= AVDISCARD_ALL)

@@ -612,18 +612,10 @@ retry:

     /* skip B-frames if we don't have reference frames */

     if(s->last_picture_ptr==NULL && (s->pict_type==FF_B_TYPE || s->dropable)) return get_consumed_bytes(s, buf_size);

-#if FF_API_HURRY_UP

-    /* skip b frames if we are in a hurry */

-    if(avctx->hurry_up && s->pict_type==FF_B_TYPE) return get_consumed_bytes(s, buf_size);

-#endif

     if(   (avctx->skip_frame >= AVDISCARD_NONREF && s->pict_type==FF_B_TYPE)

        || (avctx->skip_frame >= AVDISCARD_NONKEY && s->pict_type!=FF_I_TYPE)

        ||  avctx->skip_frame >= AVDISCARD_ALL)

         return get_consumed_bytes(s, buf_size);

-#if FF_API_HURRY_UP

-    /* skip everything if we are in a hurry>=5 */

-    if(avctx->hurry_up>=5) return get_consumed_bytes(s, buf_size);

-#endif

     if(s->next_p_frame_damaged){

         if(s->pict_type==FF_B_TYPE)

@@ -2966,11 +2966,7 @@ static int decode_nal_units(H264Context *h, const uint8_t *buf, int buf_size){

         buf_index += consumed;

         //FIXME do not discard SEI id

-        if(

-#if FF_API_HURRY_UP

-           (s->hurry_up == 1 && h->nal_ref_idc  == 0) ||

-#endif

-           (avctx->skip_frame >= AVDISCARD_NONREF && h->nal_ref_idc  == 0))

+        if(avctx->skip_frame >= AVDISCARD_NONREF && h->nal_ref_idc  == 0)

             continue;

       again:

@@ -3007,9 +3003,6 @@ static int decode_nal_units(H264Context *h, const uint8_t *buf, int buf_size){

             }

             if(hx->redundant_pic_count==0

-#if FF_API_HURRY_UP

-               && hx->s.hurry_up < 5

-#endif

                && (avctx->skip_frame < AVDISCARD_NONREF || hx->nal_ref_idc)

                && (avctx->skip_frame < AVDISCARD_BIDIR  || hx->slice_type_nos!=FF_B_TYPE)

                && (avctx->skip_frame < AVDISCARD_NONKEY || hx->slice_type_nos==FF_I_TYPE)

@@ -3047,9 +3040,6 @@ static int decode_nal_units(H264Context *h, const uint8_t *buf, int buf_size){

             if(hx->redundant_pic_count==0 && hx->intra_gb_ptr && hx->s.data_partitioning

                && s->context_initialized

-#if FF_API_HURRY_UP

-               && s->hurry_up < 5

-#endif

                && (avctx->skip_frame < AVDISCARD_NONREF || hx->nal_ref_idc)

                && (avctx->skip_frame < AVDISCARD_BIDIR  || hx->slice_type_nos!=FF_B_TYPE)

                && (avctx->skip_frame < AVDISCARD_NONKEY || hx->slice_type_nos==FF_I_TYPE)

@@ -3186,11 +3176,7 @@ static int decode_frame(AVCodecContext *avctx,

     }

     if(!(s->flags2 & CODEC_FLAG2_CHUNKS) && !s->current_picture_ptr){

-        if (avctx->skip_frame >= AVDISCARD_NONREF

-#if FF_API_HURRY_UP

-                || s->hurry_up

-#endif

-           )

+        if (avctx->skip_frame >= AVDISCARD_NONREF)

             return 0;

         av_log(avctx, AV_LOG_ERROR, "no frame!\n");

         return -1;

@@ -1007,7 +1007,6 @@ static void fill_decode_caches(H264Context *h, int mb_type){

     }

     }

-#if 1

     if(IS_INTER(mb_type) || (IS_DIRECT(mb_type) && h->direct_spatial_mv_pred)){

         int list;

         for(list=0; list<h->list_count; list++){

@@ -1182,7 +1181,6 @@ static void fill_decode_caches(H264Context *h, int mb_type){

             }

         }

     }

-#endif

         h->neighbor_transform_size= !!IS_8x8DCT(top_type) + !!IS_8x8DCT(left_type[0]);

 }

@@ -88,7 +88,7 @@ typedef struct {

     DSPContext dsp;

     FFTContext fft;

-    DECLARE_ALIGNED(16, FFTComplex, samples)[COEFFS/2];

+    DECLARE_ALIGNED(32, FFTComplex, samples)[COEFFS/2];

     float *out_samples;

 } IMCContext;

@@ -158,7 +158,6 @@ static int hpel_motion_search(MpegEncContext * s,

         const int b= score_map[(index+(1<<ME_MAP_SHIFT))&(ME_MAP_SIZE-1)]

                      + (mv_penalty[bx   - pred_x] + mv_penalty[by+2 - pred_y])*c->penalty_factor;

-#if 1

         int key;

         int map_generation= c->map_generation;

 #ifndef NDEBUG

@@ -172,7 +171,6 @@ static int hpel_motion_search(MpegEncContext * s,

         assert(map[(index+1)&(ME_MAP_SIZE-1)] == key);

         key= ((my)<<ME_MAP_MV_BITS) + (mx-1) + map_generation;

         assert(map[(index-1)&(ME_MAP_SIZE-1)] == key);

-#endif

         if(t<=b){

             CHECK_HALF_MV(0, 1, mx  ,my-1)

             if(l<=r){

@@ -2476,18 +2476,10 @@ static int decode_chunks(AVCodecContext *avctx,

                 /* Skip P-frames if we do not have a reference frame or we have an invalid header. */

                     if(s2->pict_type==FF_P_TYPE && !s->sync) break;

                 }

-#if FF_API_HURRY_UP

-                /* Skip B-frames if we are in a hurry. */

-                if(avctx->hurry_up && s2->pict_type==FF_B_TYPE) break;

-#endif

                 if(  (avctx->skip_frame >= AVDISCARD_NONREF && s2->pict_type==FF_B_TYPE)

                     ||(avctx->skip_frame >= AVDISCARD_NONKEY && s2->pict_type!=FF_I_TYPE)

                     || avctx->skip_frame >= AVDISCARD_ALL)

                     break;

-#if FF_API_HURRY_UP

-                /* Skip everything if we are in a hurry>=5. */

-                if(avctx->hurry_up>=5) break;

-#endif

                 if (!s->mpeg_enc_ctx_allocated) break;

@@ -1131,9 +1131,6 @@ int MPV_frame_start(MpegEncContext *s, AVCodecContext *avctx)

         }

     }

-#if FF_API_HURRY_UP

-    s->hurry_up= s->avctx->hurry_up;

-#endif

     s->error_recognition= avctx->error_recognition;

     /* set dequantizer, we can't do it during init as it might change for mpeg4

@@ -2125,9 +2122,6 @@ void MPV_decode_mb_internal(MpegEncContext *s, DCTELEM block[12][64],

             }

             /* skip dequant / idct if we are really late ;) */

-#if FF_API_HURRY_UP

-            if(s->hurry_up>1) goto skip_idct;

-#endif

             if(s->avctx->skip_idct){

                 if(  (s->avctx->skip_idct >= AVDISCARD_NONREF && s->pict_type == FF_B_TYPE)

                    ||(s->avctx->skip_idct >= AVDISCARD_NONKEY && s->pict_type != FF_I_TYPE)

@@ -391,11 +391,6 @@ typedef struct MpegEncContext {

     int no_rounding;  /**< apply no rounding to motion compensation (MPEG4, msmpeg4, ...)

                         for b-frames rounding mode is always 0 */

-#if FF_API_HURRY_UP

-    int hurry_up;     /**< when set to 1 during decoding, b frames will be skipped

-                         when set to 2 idct/dequant will be skipped too */

-#endif

-

     /* macroblock layer */

     int mb_x, mb_y;

     int mb_skip_run;

@@ -985,10 +985,9 @@ void ff_msmpeg4_encode_block(MpegEncContext * s, DCTELEM * block, int n)

             if(level<=MAX_LEVEL && run<=MAX_RUN){

                 s->ac_stats[s->mb_intra][n>3][level][run][last]++;

             }

-#if 0

-else

-    s->ac_stats[s->mb_intra][n>3][40][63][0]++; //esc3 like

-#endif

+

+            s->ac_stats[s->mb_intra][n > 3][40][63][0]++; //esc3 like

+

             code = get_rl_index(rl, last, run, level);

             put_bits(&s->pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);

             if (code == rl->n) {

@@ -47,7 +47,7 @@

 typedef struct NellyMoserDecodeContext {

     AVCodecContext* avctx;

-    DECLARE_ALIGNED(16, float,float_buf)[NELLY_SAMPLES];

+    DECLARE_ALIGNED(32, float, float_buf)[NELLY_SAMPLES];

     float           state[128];

     AVLFG           random_state;

     GetBitContext   gb;

@@ -55,7 +55,7 @@ typedef struct NellyMoserDecodeContext {

     DSPContext      dsp;

     FFTContext      imdct_ctx;

     FmtConvertContext fmt_conv;

-    DECLARE_ALIGNED(16, float,imdct_out)[NELLY_BUF_LEN * 2];

+    DECLARE_ALIGNED(32, float, imdct_out)[NELLY_BUF_LEN * 2];

 } NellyMoserDecodeContext;

 static void overlap_and_window(NellyMoserDecodeContext *s, float *state, float *audio, float *a_in)

@@ -55,9 +55,9 @@ typedef struct NellyMoserEncodeContext {

     int             have_saved;

     DSPContext      dsp;

     FFTContext      mdct_ctx;

-    DECLARE_ALIGNED(16, float, mdct_out)[NELLY_SAMPLES];

-    DECLARE_ALIGNED(16, float, in_buff)[NELLY_SAMPLES];

-    DECLARE_ALIGNED(16, float, buf)[2][3 * NELLY_BUF_LEN];     ///< sample buffer

+    DECLARE_ALIGNED(32, float, mdct_out)[NELLY_SAMPLES];

+    DECLARE_ALIGNED(32, float, in_buff)[NELLY_SAMPLES];

+    DECLARE_ALIGNED(32, float, buf)[2][3 * NELLY_BUF_LEN];     ///< sample buffer

     float           (*opt )[NELLY_BANDS];

     uint8_t         (*path)[NELLY_BANDS];

 } NellyMoserEncodeContext;

@@ -105,9 +105,6 @@ static const AVOption options[]={

 {"extradata_size", NULL, OFFSET(extradata_size), FF_OPT_TYPE_INT, DEFAULT, INT_MIN, INT_MAX},

 {"time_base", NULL, OFFSET(time_base), FF_OPT_TYPE_RATIONAL, DEFAULT, INT_MIN, INT_MAX},

 {"g", "set the group of picture size", OFFSET(gop_size), FF_OPT_TYPE_INT, 12, INT_MIN, INT_MAX, V|E},

-#if FF_API_RATE_EMU

-{"rate_emu", "frame rate emulation", OFFSET(rate_emu), FF_OPT_TYPE_INT, DEFAULT, INT_MIN, INT_MAX},

-#endif

 {"ar", "set audio sampling rate (in Hz)", OFFSET(sample_rate), FF_OPT_TYPE_INT, DEFAULT, INT_MIN, INT_MAX},

 {"ac", "set number of audio channels", OFFSET(channels), FF_OPT_TYPE_INT, DEFAULT, INT_MIN, INT_MAX},

 {"cutoff", "set cutoff bandwidth", OFFSET(cutoff), FF_OPT_TYPE_INT, DEFAULT, INT_MIN, INT_MAX, A|E},

@@ -124,9 +121,6 @@ static const AVOption options[]={

 {"rc_strategy", "ratecontrol method", OFFSET(rc_strategy), FF_OPT_TYPE_INT, DEFAULT, INT_MIN, INT_MAX, V|E},

 {"b_strategy", "strategy to choose between I/P/B-frames", OFFSET(b_frame_strategy), FF_OPT_TYPE_INT, 0, INT_MIN, INT_MAX, V|E},

 {"wpredp", "weighted prediction analysis method", OFFSET(weighted_p_pred), FF_OPT_TYPE_INT, 0, INT_MIN, INT_MAX, V|E},

-#if FF_API_HURRY_UP

-{"hurry_up", "deprecated, use skip_idct/skip_frame instead", OFFSET(hurry_up), FF_OPT_TYPE_INT, DEFAULT, INT_MIN, INT_MAX, V|D},

-#endif

 {"ps", "rtp payload size in bytes", OFFSET(rtp_payload_size), FF_OPT_TYPE_INT, DEFAULT, INT_MIN, INT_MAX, V|E},

 {"mv_bits", NULL, OFFSET(mv_bits), FF_OPT_TYPE_INT, DEFAULT, INT_MIN, INT_MAX},

 {"header_bits", NULL, OFFSET(header_bits), FF_OPT_TYPE_INT, DEFAULT, INT_MIN, INT_MAX},

@@ -253,10 +247,6 @@ static const AVOption options[]={

 {"pf", "forward predicted MVs of P-frames", 0, FF_OPT_TYPE_CONST, FF_DEBUG_VIS_MV_P_FOR, INT_MIN, INT_MAX, V|D, "debug_mv"},

 {"bf", "forward predicted MVs of B-frames", 0, FF_OPT_TYPE_CONST, FF_DEBUG_VIS_MV_B_FOR, INT_MIN, INT_MAX, V|D, "debug_mv"},

 {"bb", "backward predicted MVs of B-frames", 0, FF_OPT_TYPE_CONST, FF_DEBUG_VIS_MV_B_BACK, INT_MIN, INT_MAX, V|D, "debug_mv"},

-#if FF_API_MB_Q

-{"mb_qmin", "obsolete, use qmin", OFFSET(mb_qmin), FF_OPT_TYPE_INT, DEFAULT, INT_MIN, INT_MAX, V|E},

-{"mb_qmax", "obsolete, use qmax", OFFSET(mb_qmax), FF_OPT_TYPE_INT, DEFAULT, INT_MIN, INT_MAX, V|E},

-#endif

 {"cmp", "full pel me compare function", OFFSET(me_cmp), FF_OPT_TYPE_INT, DEFAULT, INT_MIN, INT_MAX, V|E, "cmp_func"},

 {"subcmp", "sub pel me compare function", OFFSET(me_sub_cmp), FF_OPT_TYPE_INT, DEFAULT, INT_MIN, INT_MAX, V|E, "cmp_func"},

 {"mbcmp", "macroblock compare function", OFFSET(mb_cmp), FF_OPT_TYPE_INT, DEFAULT, INT_MIN, INT_MAX, V|E, "cmp_func"},

@@ -380,9 +380,6 @@ static void update_context_from_user(AVCodecContext *dst, AVCodecContext *src)

     dst->release_buffer = src->release_buffer;

     dst->opaque   = src->opaque;

-#if FF_API_HURRY_UP

-    dst->hurry_up = src->hurry_up;

-#endif

     dst->dsp_mask = src->dsp_mask;

     dst->debug    = src->debug;

     dst->debug_mv = src->debug_mv;

@@ -120,7 +120,7 @@ typedef struct {

 } FFTCoefficient;

 typedef struct {

-    DECLARE_ALIGNED(16, QDM2Complex, complex)[MPA_MAX_CHANNELS][256];

+    DECLARE_ALIGNED(32, QDM2Complex, complex)[MPA_MAX_CHANNELS][256];

 } QDM2FFT;

 /**

@@ -1454,19 +1454,10 @@ int ff_rv34_decode_frame(AVCodecContext *avctx,

     }

     if((!s->last_picture_ptr || !s->last_picture_ptr->data[0]) && si.type == FF_B_TYPE)

         return -1;

-#if FF_API_HURRY_UP

-    /* skip b frames if we are in a hurry */

-    if(avctx->hurry_up && si.type==FF_B_TYPE) return buf_size;

-#endif

     if(   (avctx->skip_frame >= AVDISCARD_NONREF && si.type==FF_B_TYPE)

        || (avctx->skip_frame >= AVDISCARD_NONKEY && si.type!=FF_I_TYPE)

        ||  avctx->skip_frame >= AVDISCARD_ALL)

         return buf_size;

-#if FF_API_HURRY_UP