[3/8] avfft: add AV prefix to FFTComplex.

Message ID 1300136301-5437-3-git-send-email-anton@khirnov.net
State Old
Headers show

Commit Message

Anton Khirnov March 14, 2011, 8:58 p.m.
---
 libavcodec/arm/fft_init_arm.c  |    4 ++--
 libavcodec/arm/fft_neon.S      |    4 ++--
 libavcodec/avfft.c             |    4 ++--
 libavcodec/avfft.h             |    9 +++++----
 libavcodec/fft-test.c          |   22 +++++++++++-----------
 libavcodec/fft.c               |   24 ++++++++++++------------
 libavcodec/fft.h               |   10 +++++-----
 libavcodec/imc.c               |    2 +-
 libavcodec/mdct.c              |    4 ++--
 libavcodec/ppc/fft_altivec.c   |    8 ++++----
 libavcodec/ppc/fft_altivec_s.S |    2 +-
 libavcodec/rdft.c              |   10 +++++-----
 libavcodec/x86/fft.h           |    8 ++++----
 libavcodec/x86/fft_3dn2.c      |    8 ++++----
 libavcodec/x86/fft_mmx.asm     |    2 +-
 libavcodec/x86/fft_sse.c       |   10 +++++-----
 16 files changed, 66 insertions(+), 65 deletions(-)

Patch

diff --git a/libavcodec/arm/fft_init_arm.c b/libavcodec/arm/fft_init_arm.c
index f6ed47c..5b01e3e 100644
--- a/libavcodec/arm/fft_init_arm.c
+++ b/libavcodec/arm/fft_init_arm.c
@@ -21,8 +21,8 @@ 
 #include "libavcodec/fft.h"
 #include "libavcodec/synth_filter.h"
 
-void ff_fft_permute_neon(FFTContext *s, FFTComplex *z);
-void ff_fft_calc_neon(FFTContext *s, FFTComplex *z);
+void ff_fft_permute_neon(FFTContext *s, AVFFTComplex *z);
+void ff_fft_calc_neon(FFTContext *s, AVFFTComplex *z);
 
 void ff_imdct_calc_neon(FFTContext *s, AVFFTSample *output, const AVFFTSample *input);
 void ff_imdct_half_neon(FFTContext *s, AVFFTSample *output, const AVFFTSample *input);
diff --git a/libavcodec/arm/fft_neon.S b/libavcodec/arm/fft_neon.S
index edbaf23..e48e4e8 100644
--- a/libavcodec/arm/fft_neon.S
+++ b/libavcodec/arm/fft_neon.S
@@ -207,8 +207,8 @@  function fft_pass_neon
         push            {r4-r6,lr}
         mov             r6,  r2                 @ n
         lsl             r5,  r2,  #3            @ 2 * n * sizeof AVFFTSample
-        lsl             r4,  r2,  #4            @ 2 * n * sizeof FFTComplex
-        lsl             r2,  r2,  #5            @ 4 * n * sizeof FFTComplex
+        lsl             r4,  r2,  #4            @ 2 * n * sizeof AVFFTComplex
+        lsl             r2,  r2,  #5            @ 4 * n * sizeof AVFFTComplex
         add             r3,  r2,  r4
         add             r4,  r4,  r0            @ &z[o1]
         add             r2,  r2,  r0            @ &z[o2]
diff --git a/libavcodec/avfft.c b/libavcodec/avfft.c
index 3cd472a..85db650 100644
--- a/libavcodec/avfft.c
+++ b/libavcodec/avfft.c
@@ -32,12 +32,12 @@  FFTContext *av_fft_init(int nbits, int inverse)
     return s;
 }
 
-void av_fft_permute(FFTContext *s, FFTComplex *z)
+void av_fft_permute(FFTContext *s, AVFFTComplex *z)
 {
     s->fft_permute(s, z);
 }
 
-void av_fft_calc(FFTContext *s, FFTComplex *z)
+void av_fft_calc(FFTContext *s, AVFFTComplex *z)
 {
     s->fft_calc(s, z);
 }
diff --git a/libavcodec/avfft.h b/libavcodec/avfft.h
index 21e3135..c178ea2 100644
--- a/libavcodec/avfft.h
+++ b/libavcodec/avfft.h
@@ -24,9 +24,9 @@ 
 
 typedef float AVFFTSample;
 
-typedef struct FFTComplex {
+typedef struct AVFFTComplex {
     AVFFTSample re, im;
-} FFTComplex;
+} AVFFTComplex;
 
 typedef struct FFTContext FFTContext;
 
@@ -40,13 +40,13 @@  FFTContext *av_fft_init(int nbits, int inverse);
 /**
  * Do the permutation needed BEFORE calling ff_fft_calc().
  */
-void av_fft_permute(FFTContext *s, FFTComplex *z);
+void av_fft_permute(FFTContext *s, AVFFTComplex *z);
 
 /**
  * Do a complex FFT with the parameters defined in av_fft_init(). The
  * input data must be permuted before. No 1.0/sqrt(n) normalization is done.
  */
-void av_fft_calc(FFTContext *s, FFTComplex *z);
+void av_fft_calc(FFTContext *s, AVFFTComplex *z);
 
 void av_fft_end(FFTContext *s);
 
@@ -101,6 +101,7 @@  void av_dct_end (DCTContext *s);
 
 #if FF_API_OLD_FFT
 typedef attribute_deprecated AVFFTSample FFTSample;
+typedef attribute_deprecated AVFFTComplex FFTComplex;
 #endif
 
 #endif /* AVCODEC_AVFFT_H */
diff --git a/libavcodec/fft-test.c b/libavcodec/fft-test.c
index 1c536d2..991bfd2 100644
--- a/libavcodec/fft-test.c
+++ b/libavcodec/fft-test.c
@@ -45,7 +45,7 @@ 
    pim += (MUL16(are, bim) + MUL16(bre, aim));\
 }
 
-FFTComplex *exptab;
+AVFFTComplex *exptab;
 
 static void fft_ref_init(int nbits, int inverse)
 {
@@ -53,7 +53,7 @@  static void fft_ref_init(int nbits, int inverse)
     double c1, s1, alpha;
 
     n = 1 << nbits;
-    exptab = av_malloc((n / 2) * sizeof(FFTComplex));
+    exptab = av_malloc((n / 2) * sizeof(AVFFTComplex));
 
     for (i = 0; i < (n/2); i++) {
         alpha = 2 * M_PI * (float)i / (float)n;
@@ -66,11 +66,11 @@  static void fft_ref_init(int nbits, int inverse)
     }
 }
 
-static void fft_ref(FFTComplex *tabr, FFTComplex *tab, int nbits)
+static void fft_ref(AVFFTComplex *tabr, AVFFTComplex *tab, int nbits)
 {
     int n, i, j, k, n2;
     double tmp_re, tmp_im, s, c;
-    FFTComplex *q;
+    AVFFTComplex *q;
 
     n = 1 << nbits;
     n2 = n >> 1;
@@ -222,7 +222,7 @@  enum tf_transform {
 
 int main(int argc, char **argv)
 {
-    FFTComplex *tab, *tab1, *tab_ref;
+    AVFFTComplex *tab, *tab1, *tab_ref;
     AVFFTSample *tab2;
     int it, i, c;
     int do_speed = 0;
@@ -273,9 +273,9 @@  int main(int argc, char **argv)
 
     fft_size = 1 << fft_nbits;
     fft_size_2 = fft_size >> 1;
-    tab = av_malloc(fft_size * sizeof(FFTComplex));
-    tab1 = av_malloc(fft_size * sizeof(FFTComplex));
-    tab_ref = av_malloc(fft_size * sizeof(FFTComplex));
+    tab = av_malloc(fft_size * sizeof(AVFFTComplex));
+    tab1 = av_malloc(fft_size * sizeof(AVFFTComplex));
+    tab_ref = av_malloc(fft_size * sizeof(AVFFTComplex));
     tab2 = av_malloc(fft_size * sizeof(AVFFTSample));
 
     switch (transform) {
@@ -338,7 +338,7 @@  int main(int argc, char **argv)
         }
         break;
     case TRANSFORM_FFT:
-        memcpy(tab, tab1, fft_size * sizeof(FFTComplex));
+        memcpy(tab, tab1, fft_size * sizeof(AVFFTComplex));
         ff_fft_permute(s, tab);
         ff_fft_calc(s, tab);
 
@@ -376,7 +376,7 @@  int main(int argc, char **argv)
         }
         break;
     case TRANSFORM_DCT:
-        memcpy(tab, tab1, fft_size * sizeof(FFTComplex));
+        memcpy(tab, tab1, fft_size * sizeof(AVFFTComplex));
         ff_dct_calc(d, tab);
         if (do_inverse) {
             idct_ref(tab_ref, tab1, fft_nbits);
@@ -408,7 +408,7 @@  int main(int argc, char **argv)
                     }
                     break;
                 case TRANSFORM_FFT:
-                    memcpy(tab, tab1, fft_size * sizeof(FFTComplex));
+                    memcpy(tab, tab1, fft_size * sizeof(AVFFTComplex));
                     ff_fft_calc(s, tab);
                     break;
                 case TRANSFORM_RDFT:
diff --git a/libavcodec/fft.c b/libavcodec/fft.c
index f6b9402..03d8376 100644
--- a/libavcodec/fft.c
+++ b/libavcodec/fft.c
@@ -53,8 +53,8 @@  COSTABLE_CONST AVFFTSample * const ff_cos_tabs[] = {
     ff_cos_2048, ff_cos_4096, ff_cos_8192, ff_cos_16384, ff_cos_32768, ff_cos_65536,
 };
 
-static void ff_fft_permute_c(FFTContext *s, FFTComplex *z);
-static void ff_fft_calc_c(FFTContext *s, FFTComplex *z);
+static void ff_fft_permute_c(FFTContext *s, AVFFTComplex *z);
+static void ff_fft_calc_c(FFTContext *s, AVFFTComplex *z);
 
 static int split_radix_permutation(int i, int n, int inverse)
 {
@@ -93,7 +93,7 @@  av_cold int ff_fft_init(FFTContext *s, int nbits, int inverse)
     s->revtab = av_malloc(n * sizeof(uint16_t));
     if (!s->revtab)
         goto fail;
-    s->tmp_buf = av_malloc(n * sizeof(FFTComplex));
+    s->tmp_buf = av_malloc(n * sizeof(AVFFTComplex));
     if (!s->tmp_buf)
         goto fail;
     s->inverse = inverse;
@@ -128,14 +128,14 @@  av_cold int ff_fft_init(FFTContext *s, int nbits, int inverse)
     return -1;
 }
 
-static void ff_fft_permute_c(FFTContext *s, FFTComplex *z)
+static void ff_fft_permute_c(FFTContext *s, AVFFTComplex *z)
 {
     int j, np;
     const uint16_t *revtab = s->revtab;
     np = 1 << s->nbits;
     /* TODO: handle split-radix permute in a more optimal way, probably in-place */
     for(j=0;j<np;j++) s->tmp_buf[revtab[j]] = z[j];
-    memcpy(z, s->tmp_buf, np * sizeof(FFTComplex));
+    memcpy(z, s->tmp_buf, np * sizeof(AVFFTComplex));
 }
 
 av_cold void ff_fft_end(FFTContext *s)
@@ -191,7 +191,7 @@  av_cold void ff_fft_end(FFTContext *s)
 
 /* z[0...8n-1], w[1...2n-1] */
 #define PASS(name)\
-static void name(FFTComplex *z, const AVFFTSample *wre, unsigned int n)\
+static void name(AVFFTComplex *z, const AVFFTSample *wre, unsigned int n)\
 {\
     AVFFTSample t1, t2, t3, t4, t5, t6;\
     int o1 = 2*n;\
@@ -217,7 +217,7 @@  PASS(pass)
 PASS(pass_big)
 
 #define DECL_FFT(n,n2,n4)\
-static void fft##n(FFTComplex *z)\
+static void fft##n(AVFFTComplex *z)\
 {\
     fft##n2(z);\
     fft##n4(z+n4*2);\
@@ -225,7 +225,7 @@  static void fft##n(FFTComplex *z)\
     pass(z,ff_cos_##n,n4/2);\
 }
 
-static void fft4(FFTComplex *z)
+static void fft4(AVFFTComplex *z)
 {
     AVFFTSample t1, t2, t3, t4, t5, t6, t7, t8;
 
@@ -239,7 +239,7 @@  static void fft4(FFTComplex *z)
     BF(z[2].im, z[0].im, t2, t5);
 }
 
-static void fft8(FFTComplex *z)
+static void fft8(AVFFTComplex *z)
 {
     AVFFTSample t1, t2, t3, t4, t5, t6, t7, t8;
 
@@ -260,7 +260,7 @@  static void fft8(FFTComplex *z)
 }
 
 #if !CONFIG_SMALL
-static void fft16(FFTComplex *z)
+static void fft16(AVFFTComplex *z)
 {
     AVFFTSample t1, t2, t3, t4, t5, t6;
 
@@ -292,12 +292,12 @@  DECL_FFT(16384,8192,4096)
 DECL_FFT(32768,16384,8192)
 DECL_FFT(65536,32768,16384)
 
-static void (* const fft_dispatch[])(FFTComplex*) = {
+static void (* const fft_dispatch[])(AVFFTComplex*) = {
     fft4, fft8, fft16, fft32, fft64, fft128, fft256, fft512, fft1024,
     fft2048, fft4096, fft8192, fft16384, fft32768, fft65536,
 };
 
-static void ff_fft_calc_c(FFTContext *s, FFTComplex *z)
+static void ff_fft_calc_c(FFTContext *s, AVFFTComplex *z)
 {
     fft_dispatch[s->nbits-2](z);
 }
diff --git a/libavcodec/fft.h b/libavcodec/fft.h
index 2f3b4a4..9f53170 100644
--- a/libavcodec/fft.h
+++ b/libavcodec/fft.h
@@ -33,14 +33,14 @@  struct FFTContext {
     int nbits;
     int inverse;
     uint16_t *revtab;
-    FFTComplex *tmp_buf;
+    AVFFTComplex *tmp_buf;
     int mdct_size; /* size of MDCT (i.e. number of input data * 2) */
     int mdct_bits; /* n = 2^nbits */
     /* pre/post rotation tables */
     AVFFTSample *tcos;
     AVFFTSample *tsin;
-    void (*fft_permute)(struct FFTContext *s, FFTComplex *z);
-    void (*fft_calc)(struct FFTContext *s, FFTComplex *z);
+    void (*fft_permute)(struct FFTContext *s, AVFFTComplex *z);
+    void (*fft_calc)(struct FFTContext *s, AVFFTComplex *z);
     void (*imdct_calc)(struct FFTContext *s, AVFFTSample *output, const AVFFTSample *input);
     void (*imdct_half)(struct FFTContext *s, AVFFTSample *output, const AVFFTSample *input);
     void (*mdct_calc)(struct FFTContext *s, AVFFTSample *output, const AVFFTSample *input);
@@ -118,7 +118,7 @@  void ff_dct_init_mmx(DCTContext *s);
 /**
  * Do the permutation needed BEFORE calling ff_fft_calc().
  */
-static inline void ff_fft_permute(FFTContext *s, FFTComplex *z)
+static inline void ff_fft_permute(FFTContext *s, AVFFTComplex *z)
 {
     s->fft_permute(s, z);
 }
@@ -126,7 +126,7 @@  static inline void ff_fft_permute(FFTContext *s, FFTComplex *z)
  * Do a complex FFT with the parameters defined in ff_fft_init(). The
  * input data must be permuted before. No 1.0/sqrt(n) normalization is done.
  */
-static inline void ff_fft_calc(FFTContext *s, FFTComplex *z)
+static inline void ff_fft_calc(FFTContext *s, AVFFTComplex *z)
 {
     s->fft_calc(s, z);
 }
diff --git a/libavcodec/imc.c b/libavcodec/imc.c
index 4cbb287..da03e6d 100644
--- a/libavcodec/imc.c
+++ b/libavcodec/imc.c
@@ -87,7 +87,7 @@  typedef struct {
 
     DSPContext dsp;
     FFTContext fft;
-    DECLARE_ALIGNED(16, FFTComplex, samples)[COEFFS/2];
+    DECLARE_ALIGNED(16, AVFFTComplex, samples)[COEFFS/2];
     float *out_samples;
 } IMCContext;
 
diff --git a/libavcodec/mdct.c b/libavcodec/mdct.c
index cf1821f..8b33ddf 100644
--- a/libavcodec/mdct.c
+++ b/libavcodec/mdct.c
@@ -130,7 +130,7 @@  void ff_imdct_half_c(FFTContext *s, AVFFTSample *output, const AVFFTSample *inpu
     const AVFFTSample *tcos = s->tcos;
     const AVFFTSample *tsin = s->tsin;
     const AVFFTSample *in1, *in2;
-    FFTComplex *z = (FFTComplex *)output;
+    AVFFTComplex *z = (AVFFTComplex *)output;
 
     n = 1 << s->mdct_bits;
     n2 = n >> 1;
@@ -192,7 +192,7 @@  void ff_mdct_calc_c(FFTContext *s, AVFFTSample *out, const AVFFTSample *input)
     const uint16_t *revtab = s->revtab;
     const AVFFTSample *tcos = s->tcos;
     const AVFFTSample *tsin = s->tsin;
-    FFTComplex *x = (FFTComplex *)out;
+    AVFFTComplex *x = (AVFFTComplex *)out;
 
     n = 1 << s->mdct_bits;
     n2 = n >> 1;
diff --git a/libavcodec/ppc/fft_altivec.c b/libavcodec/ppc/fft_altivec.c
index 01a2a06..25fd6da 100644
--- a/libavcodec/ppc/fft_altivec.c
+++ b/libavcodec/ppc/fft_altivec.c
@@ -29,11 +29,11 @@ 
  * 1.0/sqrt(n) normalization is done.
  * AltiVec-enabled
  * This code assumes that the 'z' pointer is 16 bytes-aligned
- * It also assumes all FFTComplex are 8 bytes-aligned pair of float
+ * It also assumes all AVFFTComplex are 8 bytes-aligned pair of float
  */
 
-void ff_fft_calc_altivec(FFTContext *s, FFTComplex *z);
-void ff_fft_calc_interleave_altivec(FFTContext *s, FFTComplex *z);
+void ff_fft_calc_altivec(FFTContext *s, AVFFTComplex *z);
+void ff_fft_calc_interleave_altivec(FFTContext *s, AVFFTComplex *z);
 
 #if HAVE_GNU_AS
 static void ff_imdct_half_altivec(FFTContext *s, AVFFTSample *output, const AVFFTSample *input)
@@ -90,7 +90,7 @@  static void ff_imdct_half_altivec(FFTContext *s, AVFFTSample *output, const AVFF
         k--;
     } while(k >= 0);
 
-    ff_fft_calc_altivec(s, (FFTComplex*)output);
+    ff_fft_calc_altivec(s, (AVFFTComplex*)output);
 
     /* post rotation + reordering */
     j = -n32;
diff --git a/libavcodec/ppc/fft_altivec_s.S b/libavcodec/ppc/fft_altivec_s.S
index 5d3c540..f115441 100644
--- a/libavcodec/ppc/fft_altivec_s.S
+++ b/libavcodec/ppc/fft_altivec_s.S
@@ -24,7 +24,7 @@ 
 
 /*
  * These functions are not individually interchangeable with the C versions.
- * While C takes arrays of FFTComplex, Altivec leaves intermediate results
+ * While C takes arrays of AVFFTComplex, Altivec leaves intermediate results
  * in blocks as convenient to the vector size.
  * i.e. {4x real, 4x imaginary, 4x real, ...}
  *
diff --git a/libavcodec/rdft.c b/libavcodec/rdft.c
index 9a48dd6..05c4830 100644
--- a/libavcodec/rdft.c
+++ b/libavcodec/rdft.c
@@ -57,7 +57,7 @@  static SINTABLE_CONST AVFFTSample * const ff_sin_tabs[] = {
 static void ff_rdft_calc_c(RDFTContext* s, AVFFTSample* data)
 {
     int i, i1, i2;
-    FFTComplex ev, od;
+    AVFFTComplex ev, od;
     const int n = 1 << s->nbits;
     const float k1 = 0.5;
     const float k2 = 0.5 - s->inverse;
@@ -65,8 +65,8 @@  static void ff_rdft_calc_c(RDFTContext* s, AVFFTSample* data)
     const AVFFTSample *tsin = s->tsin;
 
     if (!s->inverse) {
-        ff_fft_permute(&s->fft, (FFTComplex*)data);
-        ff_fft_calc(&s->fft, (FFTComplex*)data);
+        ff_fft_permute(&s->fft, (AVFFTComplex*)data);
+        ff_fft_calc(&s->fft, (AVFFTComplex*)data);
     }
     /* i=0 is a special case because of packing, the DC term is real, so we
        are going to throw the N/2 term (also real) in with it. */
@@ -91,8 +91,8 @@  static void ff_rdft_calc_c(RDFTContext* s, AVFFTSample* data)
     if (s->inverse) {
         data[0] *= k1;
         data[1] *= k1;
-        ff_fft_permute(&s->fft, (FFTComplex*)data);
-        ff_fft_calc(&s->fft, (FFTComplex*)data);
+        ff_fft_permute(&s->fft, (AVFFTComplex*)data);
+        ff_fft_calc(&s->fft, (AVFFTComplex*)data);
     }
 }
 
diff --git a/libavcodec/x86/fft.h b/libavcodec/x86/fft.h
index 706d431..65d2a3b 100644
--- a/libavcodec/x86/fft.h
+++ b/libavcodec/x86/fft.h
@@ -21,10 +21,10 @@ 
 
 #include "libavcodec/fft.h"
 
-void ff_fft_permute_sse(FFTContext *s, FFTComplex *z);
-void ff_fft_calc_sse(FFTContext *s, FFTComplex *z);
-void ff_fft_calc_3dn(FFTContext *s, FFTComplex *z);
-void ff_fft_calc_3dn2(FFTContext *s, FFTComplex *z);
+void ff_fft_permute_sse(FFTContext *s, AVFFTComplex *z);
+void ff_fft_calc_sse(FFTContext *s, AVFFTComplex *z);
+void ff_fft_calc_3dn(FFTContext *s, AVFFTComplex *z);
+void ff_fft_calc_3dn2(FFTContext *s, AVFFTComplex *z);
 
 void ff_imdct_calc_3dn(FFTContext *s, AVFFTSample *output, const AVFFTSample *input);
 void ff_imdct_half_3dn(FFTContext *s, AVFFTSample *output, const AVFFTSample *input);
diff --git a/libavcodec/x86/fft_3dn2.c b/libavcodec/x86/fft_3dn2.c
index cf5d0b5..2fc98e5 100644
--- a/libavcodec/x86/fft_3dn2.c
+++ b/libavcodec/x86/fft_3dn2.c
@@ -39,10 +39,10 @@  DECLARE_ALIGNED(8, static const int, m1m1)[2] = { 1<<31, 1<<31 };
 #define PSWAPD(s,d) "pswapd "#s","#d"\n"
 #endif
 
-void ff_fft_dispatch_3dn2(FFTComplex *z, int nbits);
-void ff_fft_dispatch_interleave_3dn2(FFTComplex *z, int nbits);
+void ff_fft_dispatch_3dn2(AVFFTComplex *z, int nbits);
+void ff_fft_dispatch_interleave_3dn2(AVFFTComplex *z, int nbits);
 
-void ff_fft_calc_3dn2(FFTContext *s, FFTComplex *z)
+void ff_fft_calc_3dn2(FFTContext *s, AVFFTComplex *z)
 {
     int n = 1<<s->nbits;
     int i;
@@ -64,7 +64,7 @@  void ff_imdct_half_3dn2(FFTContext *s, AVFFTSample *output, const AVFFTSample *i
     const AVFFTSample *tcos = s->tcos;
     const AVFFTSample *tsin = s->tsin;
     const AVFFTSample *in1, *in2;
-    FFTComplex *z = (FFTComplex *)output;
+    AVFFTComplex *z = (AVFFTComplex *)output;
 
     /* pre rotation */
     in1 = input;
diff --git a/libavcodec/x86/fft_mmx.asm b/libavcodec/x86/fft_mmx.asm
index f155cfa..2ccadf0 100644
--- a/libavcodec/x86/fft_mmx.asm
+++ b/libavcodec/x86/fft_mmx.asm
@@ -23,7 +23,7 @@ 
 ;******************************************************************************
 
 ; These functions are not individually interchangeable with the C versions.
-; While C takes arrays of FFTComplex, SSE/3DNow leave intermediate results
+; While C takes arrays of AVFFTComplex, SSE/3DNow leave intermediate results
 ; in blocks as conventient to the vector size.
 ; i.e. {4x real, 4x imaginary, 4x real, ...} (or 2x respectively)
 
diff --git a/libavcodec/x86/fft_sse.c b/libavcodec/x86/fft_sse.c
index 652dcac..41d617c 100644
--- a/libavcodec/x86/fft_sse.c
+++ b/libavcodec/x86/fft_sse.c
@@ -26,10 +26,10 @@ 
 DECLARE_ASM_CONST(16, int, ff_m1m1m1m1)[4] =
     { 1 << 31, 1 << 31, 1 << 31, 1 << 31 };
 
-void ff_fft_dispatch_sse(FFTComplex *z, int nbits);
-void ff_fft_dispatch_interleave_sse(FFTComplex *z, int nbits);
+void ff_fft_dispatch_sse(AVFFTComplex *z, int nbits);
+void ff_fft_dispatch_interleave_sse(AVFFTComplex *z, int nbits);
 
-void ff_fft_calc_sse(FFTContext *s, FFTComplex *z)
+void ff_fft_calc_sse(FFTContext *s, AVFFTComplex *z)
 {
     int n = 1 << s->nbits;
 
@@ -54,7 +54,7 @@  void ff_fft_calc_sse(FFTContext *s, FFTComplex *z)
     }
 }
 
-void ff_fft_permute_sse(FFTContext *s, FFTComplex *z)
+void ff_fft_permute_sse(FFTContext *s, AVFFTComplex *z)
 {
     int n = 1 << s->nbits;
     int i;
@@ -68,7 +68,7 @@  void ff_fft_permute_sse(FFTContext *s, FFTComplex *z)
             :"m"(z[i])
         );
     }
-    memcpy(z, s->tmp_buf, n*sizeof(FFTComplex));
+    memcpy(z, s->tmp_buf, n*sizeof(AVFFTComplex));
 }
 
 void ff_imdct_calc_sse(FFTContext *s, AVFFTSample *output, const AVFFTSample *input)