Merge commit '9a9e2f1c8aa4539a261625145e5c1f46a8106ac2'
authorMichael Niedermayer <michaelni@gmx.at>
Sun, 22 Jun 2014 15:58:28 +0000 (17:58 +0200)
committerMichael Niedermayer <michaelni@gmx.at>
Sun, 22 Jun 2014 15:58:28 +0000 (17:58 +0200)
* commit '9a9e2f1c8aa4539a261625145e5c1f46a8106ac2':
  dsputil: Split audio operations off into a separate context

Conflicts:
configure
libavcodec/takdec.c
libavcodec/x86/Makefile
libavcodec/x86/dsputil.asm
libavcodec/x86/dsputil_init.c
libavcodec/x86/dsputil_mmx.c
libavcodec/x86/dsputil_x86.h

Merged-by: Michael Niedermayer <michaelni@gmx.at>
41 files changed:
1  2 
configure
libavcodec/Makefile
libavcodec/ac3enc.c
libavcodec/ac3enc.h
libavcodec/ac3enc_fixed.c
libavcodec/ac3enc_float.c
libavcodec/ac3enc_template.c
libavcodec/acelp_pitch_delay.c
libavcodec/acelp_pitch_delay.h
libavcodec/arm/Makefile
libavcodec/arm/audiodsp_arm.h
libavcodec/arm/audiodsp_init_arm.c
libavcodec/arm/audiodsp_init_neon.c
libavcodec/arm/audiodsp_neon.S
libavcodec/arm/dsputil_init_neon.c
libavcodec/arm/dsputil_neon.S
libavcodec/audiodsp.c
libavcodec/audiodsp.h
libavcodec/cook.c
libavcodec/dsputil.c
libavcodec/dsputil.h
libavcodec/g729dec.c
libavcodec/g729postfilter.c
libavcodec/g729postfilter.h
libavcodec/ppc/Makefile
libavcodec/ppc/audiodsp.c
libavcodec/ppc/dsputil_altivec.h
libavcodec/ppc/dsputil_ppc.c
libavcodec/ra144.c
libavcodec/ra144.h
libavcodec/ra144dec.c
libavcodec/ra144enc.c
libavcodec/takdec.c
libavcodec/x86/Makefile
libavcodec/x86/audiodsp.asm
libavcodec/x86/audiodsp.h
libavcodec/x86/audiodsp_init.c
libavcodec/x86/dsputil.asm
libavcodec/x86/dsputil_init.c
libavcodec/x86/dsputil_mmx.c
libavcodec/x86/dsputil_x86.h

diff --cc configure
+++ b/configure
@@@ -2003,9 -1714,8 +2004,9 @@@ aac_decoder_select="mdct sinewin
  aac_encoder_select="audio_frame_queue mdct sinewin"
  aac_latm_decoder_select="aac_decoder aac_latm_parser"
  ac3_decoder_select="mdct ac3dsp ac3_parser dsputil"
- ac3_encoder_select="mdct ac3dsp dsputil"
- ac3_fixed_encoder_select="mdct ac3dsp dsputil"
 +ac3_fixed_decoder_select="mdct ac3dsp ac3_parser dsputil"
+ ac3_encoder_select="ac3dsp audiodsp dsputil mdct"
+ ac3_fixed_encoder_select="ac3dsp audiodsp dsputil mdct"
  aic_decoder_select="dsputil golomb"
  alac_encoder_select="lpc"
  als_decoder_select="dsputil"
@@@ -33,9 -28,9 +33,10 @@@ OBJS = allcodecs.
  OBJS-$(CONFIG_AANDCTTABLES)            += aandcttab.o
  OBJS-$(CONFIG_AC3DSP)                  += ac3dsp.o
  OBJS-$(CONFIG_AUDIO_FRAME_QUEUE)       += audio_frame_queue.o
+ OBJS-$(CONFIG_AUDIODSP)                += audiodsp.o
  OBJS-$(CONFIG_BLOCKDSP)                += blockdsp.o
  OBJS-$(CONFIG_CABAC)                   += cabac.o
 +OBJS-$(CONFIG_CRYSTALHD)               += crystalhd.o
  OBJS-$(CONFIG_DCT)                     += dct.o dct32_fixed.o dct32_float.o
  OBJS-$(CONFIG_DXVA2)                   += dxva2.o
  OBJS-$(CONFIG_DSPUTIL)                 += dsputil.o faanidct.o          \
Simple merge
Simple merge
Simple merge
Simple merge
Simple merge
@@@ -107,20 -107,9 +108,20 @@@ int16_t ff_acelp_decode_gain_code
      for(i=0; i<ma_pred_order; i++)
          mr_energy += quant_energy[i] * ma_prediction_coeff[i];
  
 +#ifdef G729_BITEXACT
 +    mr_energy += (((-6165LL * ff_log2(dsp->scalarproduct_int16(fc_v, fc_v, subframe_size, 0))) >> 3) & ~0x3ff);
 +
 +    mr_energy = (5439 * (mr_energy >> 15)) >> 8;           // (0.15) = (0.15) * (7.23)
 +
 +    return bidir_sal(
 +               ((ff_exp2(mr_energy & 0x7fff) + 16) >> 5) * (gain_corr_factor >> 1),
 +               (mr_energy >> 15) - 25
 +           );
 +#else
      mr_energy = gain_corr_factor * exp(M_LN10 / (20 << 23) * mr_energy) /
-                 sqrt(dsp->scalarproduct_int16(fc_v, fc_v, subframe_size));
+                 sqrt(adsp->scalarproduct_int16(fc_v, fc_v, subframe_size));
      return mr_energy >> 12;
 +#endif
  }
  
  float ff_amr_set_fixed_gain(float fixed_gain_factor, float fixed_mean_energy,
Simple merge
Simple merge
index 0000000,e97e804..213660d
mode 000000,100644..100644
--- /dev/null
@@@ -1,0 -1,26 +1,26 @@@
 - * This file is part of Libav.
+ /*
 - * Libav is free software; you can redistribute it and/or
++ * This file is part of FFmpeg.
+  *
 - * Libav is distributed in the hope that it will be useful,
++ * 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
+  * version 2.1 of the License, or (at your option) any later version.
+  *
 - * License along with Libav; if not, write to the Free Software
++ * FFmpeg is distributed in the hope that it will be useful,
+  * but WITHOUT ANY WARRANTY; without even the implied warranty of
+  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+  * Lesser General Public License for more details.
+  *
+  * You should have received a copy of the GNU Lesser General Public
++ * License along with FFmpeg; if not, write to the Free Software
+  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+  */
+ #ifndef AVCODEC_ARM_AUDIODSP_ARM_H
+ #define AVCODEC_ARM_AUDIODSP_ARM_H
+ #include "libavcodec/audiodsp.h"
+ void ff_audiodsp_init_neon(AudioDSPContext *c);
+ #endif /* AVCODEC_ARM_AUDIODSP_ARM_H */
index 0000000,ea9ec3c..74aa52a
mode 000000,100644..100644
--- /dev/null
@@@ -1,0 -1,33 +1,33 @@@
 - * This file is part of Libav.
+ /*
+  * ARM optimized audio functions
+  *
 - * Libav is free software; you can redistribute it and/or
++ * This file is part of FFmpeg.
+  *
 - * Libav is distributed in the hope that it will be useful,
++ * 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
+  * version 2.1 of the License, or (at your option) any later version.
+  *
 - * License along with Libav; if not, write to the Free Software
++ * FFmpeg is distributed in the hope that it will be useful,
+  * but WITHOUT ANY WARRANTY; without even the implied warranty of
+  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+  * Lesser General Public License for more details.
+  *
+  * You should have received a copy of the GNU Lesser General Public
++ * License along with FFmpeg; if not, write to the Free Software
+  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+  */
+ #include "libavutil/attributes.h"
+ #include "libavutil/cpu.h"
+ #include "libavutil/arm/cpu.h"
+ #include "libavcodec/audiodsp.h"
+ #include "audiodsp_arm.h"
+ av_cold void ff_audiodsp_init_arm(AudioDSPContext *c)
+ {
+     int cpu_flags = av_get_cpu_flags();
+     if (have_neon(cpu_flags))
+         ff_audiodsp_init_neon(c);
+ }
index 0000000,af53272..f7bd162
mode 000000,100644..100644
--- /dev/null
@@@ -1,0 -1,41 +1,41 @@@
 - * This file is part of Libav.
+ /*
+  * ARM NEON optimised audio functions
+  * Copyright (c) 2008 Mans Rullgard <mans@mansr.com>
+  *
 - * Libav is free software; you can redistribute it and/or
++ * This file is part of FFmpeg.
+  *
 - * Libav is distributed in the hope that it will be useful,
++ * 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
+  * version 2.1 of the License, or (at your option) any later version.
+  *
 - * License along with Libav; if not, write to the Free Software
++ * FFmpeg is distributed in the hope that it will be useful,
+  * but WITHOUT ANY WARRANTY; without even the implied warranty of
+  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+  * Lesser General Public License for more details.
+  *
+  * You should have received a copy of the GNU Lesser General Public
++ * License along with FFmpeg; if not, write to the Free Software
+  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+  */
+ #include <stdint.h>
+ #include "libavutil/attributes.h"
+ #include "libavcodec/audiodsp.h"
+ #include "audiodsp_arm.h"
+ void ff_vector_clipf_neon(float *dst, const float *src, float min, float max,
+                           int len);
+ void ff_vector_clip_int32_neon(int32_t *dst, const int32_t *src, int32_t min,
+                                int32_t max, unsigned int len);
+ int32_t ff_scalarproduct_int16_neon(const int16_t *v1, const int16_t *v2, int len);
+ av_cold void ff_audiodsp_init_neon(AudioDSPContext *c)
+ {
+     c->vector_clip_int32 = ff_vector_clip_int32_neon;
+     c->vector_clipf      = ff_vector_clipf_neon;
+     c->scalarproduct_int16 = ff_scalarproduct_int16_neon;
+ }
index 0000000,dfb998d..ab32cef
mode 000000,100644..100644
--- /dev/null
@@@ -1,0 -1,64 +1,64 @@@
 - * This file is part of Libav.
+ /*
+  * ARM NEON optimised audio functions
+  * Copyright (c) 2008 Mans Rullgard <mans@mansr.com>
+  *
 - * Libav is free software; you can redistribute it and/or
++ * This file is part of FFmpeg.
+  *
 - * Libav is distributed in the hope that it will be useful,
++ * 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
+  * version 2.1 of the License, or (at your option) any later version.
+  *
 - * License along with Libav; if not, write to the Free Software
++ * FFmpeg is distributed in the hope that it will be useful,
+  * but WITHOUT ANY WARRANTY; without even the implied warranty of
+  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+  * Lesser General Public License for more details.
+  *
+  * You should have received a copy of the GNU Lesser General Public
++ * License along with FFmpeg; if not, write to the Free Software
+  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+  */
+ #include "libavutil/arm/asm.S"
+ function ff_vector_clipf_neon, export=1
+ VFP     vdup.32         q1,  d0[1]
+ VFP     vdup.32         q0,  d0[0]
+ NOVFP   vdup.32         q0,  r2
+ NOVFP   vdup.32         q1,  r3
+ NOVFP   ldr             r2,  [sp]
+         vld1.f32        {q2},[r1,:128]!
+         vmin.f32        q10, q2,  q1
+         vld1.f32        {q3},[r1,:128]!
+         vmin.f32        q11, q3,  q1
+ 1:      vmax.f32        q8,  q10, q0
+         vmax.f32        q9,  q11, q0
+         subs            r2,  r2,  #8
+         beq             2f
+         vld1.f32        {q2},[r1,:128]!
+         vmin.f32        q10, q2,  q1
+         vld1.f32        {q3},[r1,:128]!
+         vmin.f32        q11, q3,  q1
+         vst1.f32        {q8},[r0,:128]!
+         vst1.f32        {q9},[r0,:128]!
+         b               1b
+ 2:      vst1.f32        {q8},[r0,:128]!
+         vst1.f32        {q9},[r0,:128]!
+         bx              lr
+ endfunc
+ function ff_vector_clip_int32_neon, export=1
+         vdup.32         q0,  r2
+         vdup.32         q1,  r3
+         ldr             r2,  [sp]
+ 1:
+         vld1.32         {q2-q3},  [r1,:128]!
+         vmin.s32        q2,  q2,  q1
+         vmin.s32        q3,  q3,  q1
+         vmax.s32        q2,  q2,  q0
+         vmax.s32        q3,  q3,  q0
+         vst1.32         {q2-q3},  [r0,:128]!
+         subs            r2,  r2,  #8
+         bgt             1b
+         bx              lr
+ endfunc
Simple merge
Simple merge
index 0000000,f7e6167..85b5a74
mode 000000,100644..100644
--- /dev/null
@@@ -1,0 -1,118 +1,118 @@@
 - * This file is part of Libav.
+ /*
 - * Libav is free software; you can redistribute it and/or
++ * This file is part of FFmpeg.
+  *
 - * Libav is distributed in the hope that it will be useful,
++ * 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
+  * version 2.1 of the License, or (at your option) any later version.
+  *
 - * License along with Libav; if not, write to the Free Software
++ * FFmpeg is distributed in the hope that it will be useful,
+  * but WITHOUT ANY WARRANTY; without even the implied warranty of
+  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+  * Lesser General Public License for more details.
+  *
+  * You should have received a copy of the GNU Lesser General Public
++ * License along with FFmpeg; if not, write to the Free Software
+  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+  */
+ #include <stdint.h>
+ #include "libavutil/attributes.h"
+ #include "libavutil/common.h"
+ #include "audiodsp.h"
+ static inline uint32_t clipf_c_one(uint32_t a, uint32_t mini,
+                                    uint32_t maxi, uint32_t maxisign)
+ {
+     if (a > mini)
+         return mini;
+     else if ((a ^ (1U << 31)) > maxisign)
+         return maxi;
+     else
+         return a;
+ }
+ static void vector_clipf_c_opposite_sign(float *dst, const float *src,
+                                          float *min, float *max, int len)
+ {
+     int i;
+     uint32_t mini        = *(uint32_t *) min;
+     uint32_t maxi        = *(uint32_t *) max;
+     uint32_t maxisign    = maxi ^ (1U << 31);
+     uint32_t *dsti       = (uint32_t *) dst;
+     const uint32_t *srci = (const uint32_t *) src;
+     for (i = 0; i < len; i += 8) {
+         dsti[i + 0] = clipf_c_one(srci[i + 0], mini, maxi, maxisign);
+         dsti[i + 1] = clipf_c_one(srci[i + 1], mini, maxi, maxisign);
+         dsti[i + 2] = clipf_c_one(srci[i + 2], mini, maxi, maxisign);
+         dsti[i + 3] = clipf_c_one(srci[i + 3], mini, maxi, maxisign);
+         dsti[i + 4] = clipf_c_one(srci[i + 4], mini, maxi, maxisign);
+         dsti[i + 5] = clipf_c_one(srci[i + 5], mini, maxi, maxisign);
+         dsti[i + 6] = clipf_c_one(srci[i + 6], mini, maxi, maxisign);
+         dsti[i + 7] = clipf_c_one(srci[i + 7], mini, maxi, maxisign);
+     }
+ }
+ static void vector_clipf_c(float *dst, const float *src,
+                            float min, float max, int len)
+ {
+     int i;
+     if (min < 0 && max > 0) {
+         vector_clipf_c_opposite_sign(dst, src, &min, &max, len);
+     } else {
+         for (i = 0; i < len; i += 8) {
+             dst[i]     = av_clipf(src[i], min, max);
+             dst[i + 1] = av_clipf(src[i + 1], min, max);
+             dst[i + 2] = av_clipf(src[i + 2], min, max);
+             dst[i + 3] = av_clipf(src[i + 3], min, max);
+             dst[i + 4] = av_clipf(src[i + 4], min, max);
+             dst[i + 5] = av_clipf(src[i + 5], min, max);
+             dst[i + 6] = av_clipf(src[i + 6], min, max);
+             dst[i + 7] = av_clipf(src[i + 7], min, max);
+         }
+     }
+ }
+ static int32_t scalarproduct_int16_c(const int16_t *v1, const int16_t *v2,
+                                      int order)
+ {
+     int res = 0;
+     while (order--)
+         res += *v1++ **v2++;
+     return res;
+ }
+ static void vector_clip_int32_c(int32_t *dst, const int32_t *src, int32_t min,
+                                 int32_t max, unsigned int len)
+ {
+     do {
+         *dst++ = av_clip(*src++, min, max);
+         *dst++ = av_clip(*src++, min, max);
+         *dst++ = av_clip(*src++, min, max);
+         *dst++ = av_clip(*src++, min, max);
+         *dst++ = av_clip(*src++, min, max);
+         *dst++ = av_clip(*src++, min, max);
+         *dst++ = av_clip(*src++, min, max);
+         *dst++ = av_clip(*src++, min, max);
+         len   -= 8;
+     } while (len > 0);
+ }
+ av_cold void ff_audiodsp_init(AudioDSPContext *c)
+ {
+     c->scalarproduct_int16 = scalarproduct_int16_c;
+     c->vector_clip_int32   = vector_clip_int32_c;
+     c->vector_clipf        = vector_clipf_c;
+     if (ARCH_ARM)
+         ff_audiodsp_init_arm(c);
+     if (ARCH_PPC)
+         ff_audiodsp_init_ppc(c);
+     if (ARCH_X86)
+         ff_audiodsp_init_x86(c);
+ }
index 0000000,58205a1..b55bf85
mode 000000,100644..100644
--- /dev/null
@@@ -1,0 -1,59 +1,59 @@@
 - * This file is part of Libav.
+ /*
 - * Libav is free software; you can redistribute it and/or
++ * This file is part of FFmpeg.
+  *
 - * Libav is distributed in the hope that it will be useful,
++ * 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
+  * version 2.1 of the License, or (at your option) any later version.
+  *
 - * License along with Libav; if not, write to the Free Software
++ * FFmpeg is distributed in the hope that it will be useful,
+  * but WITHOUT ANY WARRANTY; without even the implied warranty of
+  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+  * Lesser General Public License for more details.
+  *
+  * You should have received a copy of the GNU Lesser General Public
++ * License along with FFmpeg; if not, write to the Free Software
+  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+  */
+ #ifndef AVCODEC_AUDIODSP_H
+ #define AVCODEC_AUDIODSP_H
+ #include <stdint.h>
+ typedef struct AudioDSPContext {
+     /**
+      * Calculate scalar product of two vectors.
+      * @param len length of vectors, should be multiple of 16
+      */
+     int32_t (*scalarproduct_int16)(const int16_t *v1,
+                                    const int16_t *v2 /* align 16 */, int len);
+     /**
+      * Clip each element in an array of int32_t to a given minimum and
+      * maximum value.
+      * @param dst  destination array
+      *             constraints: 16-byte aligned
+      * @param src  source array
+      *             constraints: 16-byte aligned
+      * @param min  minimum value
+      *             constraints: must be in the range [-(1 << 24), 1 << 24]
+      * @param max  maximum value
+      *             constraints: must be in the range [-(1 << 24), 1 << 24]
+      * @param len  number of elements in the array
+      *             constraints: multiple of 32 greater than zero
+      */
+     void (*vector_clip_int32)(int32_t *dst, const int32_t *src, int32_t min,
+                               int32_t max, unsigned int len);
+     /* assume len is a multiple of 8, and arrays are 16-byte aligned */
+     void (*vector_clipf)(float *dst /* align 16 */,
+                          const float *src /* align 16 */,
+                          float min, float max, int len /* align 16 */);
+ } AudioDSPContext;
+ void ff_audiodsp_init(AudioDSPContext *c);
+ void ff_audiodsp_init_arm(AudioDSPContext *c);
+ void ff_audiodsp_init_ppc(AudioDSPContext *c);
+ void ff_audiodsp_init_x86(AudioDSPContext *c);
+ #endif /* AVCODEC_AUDIODSP_H */
Simple merge
Simple merge
Simple merge
index d29ad1f,0000000..6eb057f
mode 100644,000000..100644
--- /dev/null
@@@ -1,726 -1,0 +1,726 @@@
- #include "dsputil.h"
 +/*
 + * G.729, G729 Annex D decoders
 + * Copyright (c) 2008 Vladimir Voroshilov
 + *
 + * 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
 + * version 2.1 of the License, or (at your option) any later version.
 + *
 + * FFmpeg is distributed in the hope that it will be useful,
 + * but WITHOUT ANY WARRANTY; without even the implied warranty of
 + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 + * Lesser General Public License for more details.
 + *
 + * You should have received a copy of the GNU Lesser General Public
 + * License along with FFmpeg; if not, write to the Free Software
 + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 + */
 +
 +#include <inttypes.h>
 +#include <string.h>
 +
 +#include "avcodec.h"
 +#include "libavutil/avutil.h"
 +#include "get_bits.h"
-     DSPContext dsp;
++#include "audiodsp.h"
 +#include "internal.h"
 +
 +
 +#include "g729.h"
 +#include "lsp.h"
 +#include "celp_math.h"
 +#include "celp_filters.h"
 +#include "acelp_filters.h"
 +#include "acelp_pitch_delay.h"
 +#include "acelp_vectors.h"
 +#include "g729data.h"
 +#include "g729postfilter.h"
 +
 +/**
 + * minimum quantized LSF value (3.2.4)
 + * 0.005 in Q13
 + */
 +#define LSFQ_MIN                   40
 +
 +/**
 + * maximum quantized LSF value (3.2.4)
 + * 3.135 in Q13
 + */
 +#define LSFQ_MAX                   25681
 +
 +/**
 + * minimum LSF distance (3.2.4)
 + * 0.0391 in Q13
 + */
 +#define LSFQ_DIFF_MIN              321
 +
 +/// interpolation filter length
 +#define INTERPOL_LEN              11
 +
 +/**
 + * minimum gain pitch value (3.8, Equation 47)
 + * 0.2 in (1.14)
 + */
 +#define SHARP_MIN                  3277
 +
 +/**
 + * maximum gain pitch value (3.8, Equation 47)
 + * (EE) This does not comply with the specification.
 + * Specification says about 0.8, which should be
 + * 13107 in (1.14), but reference C code uses
 + * 13017 (equals to 0.7945) instead of it.
 + */
 +#define SHARP_MAX                  13017
 +
 +/**
 + * MR_ENERGY (mean removed energy) = mean_energy + 10 * log10(2^26  * subframe_size) in (7.13)
 + */
 +#define MR_ENERGY 1018156
 +
 +#define DECISION_NOISE        0
 +#define DECISION_INTERMEDIATE 1
 +#define DECISION_VOICE        2
 +
 +typedef enum {
 +    FORMAT_G729_8K = 0,
 +    FORMAT_G729D_6K4,
 +    FORMAT_COUNT,
 +} G729Formats;
 +
 +typedef struct {
 +    uint8_t ac_index_bits[2];   ///< adaptive codebook index for second subframe (size in bits)
 +    uint8_t parity_bit;         ///< parity bit for pitch delay
 +    uint8_t gc_1st_index_bits;  ///< gain codebook (first stage) index (size in bits)
 +    uint8_t gc_2nd_index_bits;  ///< gain codebook (second stage) index (size in bits)
 +    uint8_t fc_signs_bits;      ///< number of pulses in fixed-codebook vector
 +    uint8_t fc_indexes_bits;    ///< size (in bits) of fixed-codebook index entry
 +} G729FormatDescription;
 +
 +typedef struct {
-     ff_dsputil_init(&ctx->dsp, avctx);
-     ctx->dsp.scalarproduct_int16 = scalarproduct_int16_c;
++    AudioDSPContext adsp;
 +
 +    /// past excitation signal buffer
 +    int16_t exc_base[2*SUBFRAME_SIZE+PITCH_DELAY_MAX+INTERPOL_LEN];
 +
 +    int16_t* exc;               ///< start of past excitation data in buffer
 +    int pitch_delay_int_prev;   ///< integer part of previous subframe's pitch delay (4.1.3)
 +
 +    /// (2.13) LSP quantizer outputs
 +    int16_t  past_quantizer_output_buf[MA_NP + 1][10];
 +    int16_t* past_quantizer_outputs[MA_NP + 1];
 +
 +    int16_t lsfq[10];           ///< (2.13) quantized LSF coefficients from previous frame
 +    int16_t lsp_buf[2][10];     ///< (0.15) LSP coefficients (previous and current frames) (3.2.5)
 +    int16_t *lsp[2];            ///< pointers to lsp_buf
 +
 +    int16_t quant_energy[4];    ///< (5.10) past quantized energy
 +
 +    /// previous speech data for LP synthesis filter
 +    int16_t syn_filter_data[10];
 +
 +
 +    /// residual signal buffer (used in long-term postfilter)
 +    int16_t residual[SUBFRAME_SIZE + RES_PREV_DATA_SIZE];
 +
 +    /// previous speech data for residual calculation filter
 +    int16_t res_filter_data[SUBFRAME_SIZE+10];
 +
 +    /// previous speech data for short-term postfilter
 +    int16_t pos_filter_data[SUBFRAME_SIZE+10];
 +
 +    /// (1.14) pitch gain of current and five previous subframes
 +    int16_t past_gain_pitch[6];
 +
 +    /// (14.1) gain code from current and previous subframe
 +    int16_t past_gain_code[2];
 +
 +    /// voice decision on previous subframe (0-noise, 1-intermediate, 2-voice), G.729D
 +    int16_t voice_decision;
 +
 +    int16_t onset;              ///< detected onset level (0-2)
 +    int16_t was_periodic;       ///< whether previous frame was declared as periodic or not (4.4)
 +    int16_t ht_prev_data;       ///< previous data for 4.2.3, equation 86
 +    int gain_coeff;             ///< (1.14) gain coefficient (4.2.4)
 +    uint16_t rand_value;        ///< random number generator value (4.4.4)
 +    int ma_predictor_prev;      ///< switched MA predictor of LSP quantizer from last good frame
 +
 +    /// (14.14) high-pass filter data (past input)
 +    int hpf_f[2];
 +
 +    /// high-pass filter data (past output)
 +    int16_t hpf_z[2];
 +}  G729Context;
 +
 +static const G729FormatDescription format_g729_8k = {
 +    .ac_index_bits     = {8,5},
 +    .parity_bit        = 1,
 +    .gc_1st_index_bits = GC_1ST_IDX_BITS_8K,
 +    .gc_2nd_index_bits = GC_2ND_IDX_BITS_8K,
 +    .fc_signs_bits     = 4,
 +    .fc_indexes_bits   = 13,
 +};
 +
 +static const G729FormatDescription format_g729d_6k4 = {
 +    .ac_index_bits     = {8,4},
 +    .parity_bit        = 0,
 +    .gc_1st_index_bits = GC_1ST_IDX_BITS_6K4,
 +    .gc_2nd_index_bits = GC_2ND_IDX_BITS_6K4,
 +    .fc_signs_bits     = 2,
 +    .fc_indexes_bits   = 9,
 +};
 +
 +/**
 + * @brief pseudo random number generator
 + */
 +static inline uint16_t g729_prng(uint16_t value)
 +{
 +    return 31821 * value + 13849;
 +}
 +
 +/**
 + * Get parity bit of bit 2..7
 + */
 +static inline int get_parity(uint8_t value)
 +{
 +   return (0x6996966996696996ULL >> (value >> 2)) & 1;
 +}
 +
 +/**
 + * Decodes LSF (Line Spectral Frequencies) from L0-L3 (3.2.4).
 + * @param[out] lsfq (2.13) quantized LSF coefficients
 + * @param[in,out] past_quantizer_outputs (2.13) quantizer outputs from previous frames
 + * @param ma_predictor switched MA predictor of LSP quantizer
 + * @param vq_1st first stage vector of quantizer
 + * @param vq_2nd_low second stage lower vector of LSP quantizer
 + * @param vq_2nd_high second stage higher vector of LSP quantizer
 + */
 +static void lsf_decode(int16_t* lsfq, int16_t* past_quantizer_outputs[MA_NP + 1],
 +                       int16_t ma_predictor,
 +                       int16_t vq_1st, int16_t vq_2nd_low, int16_t vq_2nd_high)
 +{
 +    int i,j;
 +    static const uint8_t min_distance[2]={10, 5}; //(2.13)
 +    int16_t* quantizer_output = past_quantizer_outputs[MA_NP];
 +
 +    for (i = 0; i < 5; i++) {
 +        quantizer_output[i]     = cb_lsp_1st[vq_1st][i    ] + cb_lsp_2nd[vq_2nd_low ][i    ];
 +        quantizer_output[i + 5] = cb_lsp_1st[vq_1st][i + 5] + cb_lsp_2nd[vq_2nd_high][i + 5];
 +    }
 +
 +    for (j = 0; j < 2; j++) {
 +        for (i = 1; i < 10; i++) {
 +            int diff = (quantizer_output[i - 1] - quantizer_output[i] + min_distance[j]) >> 1;
 +            if (diff > 0) {
 +                quantizer_output[i - 1] -= diff;
 +                quantizer_output[i    ] += diff;
 +            }
 +        }
 +    }
 +
 +    for (i = 0; i < 10; i++) {
 +        int sum = quantizer_output[i] * cb_ma_predictor_sum[ma_predictor][i];
 +        for (j = 0; j < MA_NP; j++)
 +            sum += past_quantizer_outputs[j][i] * cb_ma_predictor[ma_predictor][j][i];
 +
 +        lsfq[i] = sum >> 15;
 +    }
 +
 +    ff_acelp_reorder_lsf(lsfq, LSFQ_DIFF_MIN, LSFQ_MIN, LSFQ_MAX, 10);
 +}
 +
 +/**
 + * Restores past LSP quantizer output using LSF from previous frame
 + * @param[in,out] lsfq (2.13) quantized LSF coefficients
 + * @param[in,out] past_quantizer_outputs (2.13) quantizer outputs from previous frames
 + * @param ma_predictor_prev MA predictor from previous frame
 + * @param lsfq_prev (2.13) quantized LSF coefficients from previous frame
 + */
 +static void lsf_restore_from_previous(int16_t* lsfq,
 +                                      int16_t* past_quantizer_outputs[MA_NP + 1],
 +                                      int ma_predictor_prev)
 +{
 +    int16_t* quantizer_output = past_quantizer_outputs[MA_NP];
 +    int i,k;
 +
 +    for (i = 0; i < 10; i++) {
 +        int tmp = lsfq[i] << 15;
 +
 +        for (k = 0; k < MA_NP; k++)
 +            tmp -= past_quantizer_outputs[k][i] * cb_ma_predictor[ma_predictor_prev][k][i];
 +
 +        quantizer_output[i] = ((tmp >> 15) * cb_ma_predictor_sum_inv[ma_predictor_prev][i]) >> 12;
 +    }
 +}
 +
 +/**
 + * Constructs new excitation signal and applies phase filter to it
 + * @param[out] out constructed speech signal
 + * @param in original excitation signal
 + * @param fc_cur (2.13) original fixed-codebook vector
 + * @param gain_code (14.1) gain code
 + * @param subframe_size length of the subframe
 + */
 +static void g729d_get_new_exc(
 +        int16_t* out,
 +        const int16_t* in,
 +        const int16_t* fc_cur,
 +        int dstate,
 +        int gain_code,
 +        int subframe_size)
 +{
 +    int i;
 +    int16_t fc_new[SUBFRAME_SIZE];
 +
 +    ff_celp_convolve_circ(fc_new, fc_cur, phase_filter[dstate], subframe_size);
 +
 +    for(i=0; i<subframe_size; i++)
 +    {
 +        out[i]  = in[i];
 +        out[i] -= (gain_code * fc_cur[i] + 0x2000) >> 14;
 +        out[i] += (gain_code * fc_new[i] + 0x2000) >> 14;
 +    }
 +}
 +
 +/**
 + * Makes decision about onset in current subframe
 + * @param past_onset decision result of previous subframe
 + * @param past_gain_code gain code of current and previous subframe
 + *
 + * @return onset decision result for current subframe
 + */
 +static int g729d_onset_decision(int past_onset, const int16_t* past_gain_code)
 +{
 +    if((past_gain_code[0] >> 1) > past_gain_code[1])
 +        return 2;
 +    else
 +        return FFMAX(past_onset-1, 0);
 +}
 +
 +/**
 + * Makes decision about voice presence in current subframe
 + * @param onset onset level
 + * @param prev_voice_decision voice decision result from previous subframe
 + * @param past_gain_pitch pitch gain of current and previous subframes
 + *
 + * @return voice decision result for current subframe
 + */
 +static int16_t g729d_voice_decision(int onset, int prev_voice_decision, const int16_t* past_gain_pitch)
 +{
 +    int i, low_gain_pitch_cnt, voice_decision;
 +
 +    if(past_gain_pitch[0] >= 14745)      // 0.9
 +        voice_decision = DECISION_VOICE;
 +    else if (past_gain_pitch[0] <= 9830) // 0.6
 +        voice_decision = DECISION_NOISE;
 +    else
 +        voice_decision = DECISION_INTERMEDIATE;
 +
 +    for(i=0, low_gain_pitch_cnt=0; i<6; i++)
 +        if(past_gain_pitch[i] < 9830)
 +            low_gain_pitch_cnt++;
 +
 +    if(low_gain_pitch_cnt > 2 && !onset)
 +        voice_decision = DECISION_NOISE;
 +
 +    if(!onset && voice_decision > prev_voice_decision + 1)
 +        voice_decision--;
 +
 +    if(onset && voice_decision < DECISION_VOICE)
 +        voice_decision++;
 +
 +    return voice_decision;
 +}
 +
 +static int32_t scalarproduct_int16_c(const int16_t * v1, const int16_t * v2, int order)
 +{
 +    int res = 0;
 +
 +    while (order--)
 +        res += *v1++ * *v2++;
 +
 +    return res;
 +}
 +
 +static av_cold int decoder_init(AVCodecContext * avctx)
 +{
 +    G729Context* ctx = avctx->priv_data;
 +    int i,k;
 +
 +    if (avctx->channels != 1) {
 +        av_log(avctx, AV_LOG_ERROR, "Only mono sound is supported (requested channels: %d).\n", avctx->channels);
 +        return AVERROR(EINVAL);
 +    }
 +    avctx->sample_fmt = AV_SAMPLE_FMT_S16;
 +
 +    /* Both 8kbit/s and 6.4kbit/s modes uses two subframes per frame. */
 +    avctx->frame_size = SUBFRAME_SIZE << 1;
 +
 +    ctx->gain_coeff = 16384; // 1.0 in (1.14)
 +
 +    for (k = 0; k < MA_NP + 1; k++) {
 +        ctx->past_quantizer_outputs[k] = ctx->past_quantizer_output_buf[k];
 +        for (i = 1; i < 11; i++)
 +            ctx->past_quantizer_outputs[k][i - 1] = (18717 * i) >> 3;
 +    }
 +
 +    ctx->lsp[0] = ctx->lsp_buf[0];
 +    ctx->lsp[1] = ctx->lsp_buf[1];
 +    memcpy(ctx->lsp[0], lsp_init, 10 * sizeof(int16_t));
 +
 +    ctx->exc = &ctx->exc_base[PITCH_DELAY_MAX+INTERPOL_LEN];
 +
 +    ctx->pitch_delay_int_prev = PITCH_DELAY_MIN;
 +
 +    /* random seed initialization */
 +    ctx->rand_value = 21845;
 +
 +    /* quantized prediction error */
 +    for(i=0; i<4; i++)
 +        ctx->quant_energy[i] = -14336; // -14 in (5.10)
 +
-             ctx->past_gain_code[0] = ff_acelp_decode_gain_code(&ctx->dsp, gain_corr_factor,
++    ff_audiodsp_init(&ctx->adsp);
++    ctx->adsp.scalarproduct_int16 = scalarproduct_int16_c;
 +
 +    return 0;
 +}
 +
 +static int decode_frame(AVCodecContext *avctx, void *data, int *got_frame_ptr,
 +                        AVPacket *avpkt)
 +{
 +    const uint8_t *buf = avpkt->data;
 +    int buf_size       = avpkt->size;
 +    int16_t *out_frame;
 +    GetBitContext gb;
 +    const G729FormatDescription *format;
 +    int frame_erasure = 0;    ///< frame erasure detected during decoding
 +    int bad_pitch = 0;        ///< parity check failed
 +    int i;
 +    int16_t *tmp;
 +    G729Formats packet_type;
 +    G729Context *ctx = avctx->priv_data;
 +    int16_t lp[2][11];           // (3.12)
 +    uint8_t ma_predictor;     ///< switched MA predictor of LSP quantizer
 +    uint8_t quantizer_1st;    ///< first stage vector of quantizer
 +    uint8_t quantizer_2nd_lo; ///< second stage lower vector of quantizer (size in bits)
 +    uint8_t quantizer_2nd_hi; ///< second stage higher vector of quantizer (size in bits)
 +
 +    int pitch_delay_int[2];      // pitch delay, integer part
 +    int pitch_delay_3x;          // pitch delay, multiplied by 3
 +    int16_t fc[SUBFRAME_SIZE];   // fixed-codebook vector
 +    int16_t synth[SUBFRAME_SIZE+10]; // fixed-codebook vector
 +    int j, ret;
 +    int gain_before, gain_after;
 +    int is_periodic = 0;         // whether one of the subframes is declared as periodic or not
 +    AVFrame *frame = data;
 +
 +    frame->nb_samples = SUBFRAME_SIZE<<1;
 +    if ((ret = ff_get_buffer(avctx, frame, 0)) < 0)
 +        return ret;
 +    out_frame = (int16_t*) frame->data[0];
 +
 +    if (buf_size == 10) {
 +        packet_type = FORMAT_G729_8K;
 +        format = &format_g729_8k;
 +        //Reset voice decision
 +        ctx->onset = 0;
 +        ctx->voice_decision = DECISION_VOICE;
 +        av_log(avctx, AV_LOG_DEBUG, "Packet type: %s\n", "G.729 @ 8kbit/s");
 +    } else if (buf_size == 8) {
 +        packet_type = FORMAT_G729D_6K4;
 +        format = &format_g729d_6k4;
 +        av_log(avctx, AV_LOG_DEBUG, "Packet type: %s\n", "G.729D @ 6.4kbit/s");
 +    } else {
 +        av_log(avctx, AV_LOG_ERROR, "Packet size %d is unknown.\n", buf_size);
 +        return AVERROR_INVALIDDATA;
 +    }
 +
 +    for (i=0; i < buf_size; i++)
 +        frame_erasure |= buf[i];
 +    frame_erasure = !frame_erasure;
 +
 +    init_get_bits(&gb, buf, 8*buf_size);
 +
 +    ma_predictor     = get_bits(&gb, 1);
 +    quantizer_1st    = get_bits(&gb, VQ_1ST_BITS);
 +    quantizer_2nd_lo = get_bits(&gb, VQ_2ND_BITS);
 +    quantizer_2nd_hi = get_bits(&gb, VQ_2ND_BITS);
 +
 +    if(frame_erasure)
 +        lsf_restore_from_previous(ctx->lsfq, ctx->past_quantizer_outputs,
 +                                  ctx->ma_predictor_prev);
 +    else {
 +        lsf_decode(ctx->lsfq, ctx->past_quantizer_outputs,
 +                   ma_predictor,
 +                   quantizer_1st, quantizer_2nd_lo, quantizer_2nd_hi);
 +        ctx->ma_predictor_prev = ma_predictor;
 +    }
 +
 +    tmp = ctx->past_quantizer_outputs[MA_NP];
 +    memmove(ctx->past_quantizer_outputs + 1, ctx->past_quantizer_outputs,
 +            MA_NP * sizeof(int16_t*));
 +    ctx->past_quantizer_outputs[0] = tmp;
 +
 +    ff_acelp_lsf2lsp(ctx->lsp[1], ctx->lsfq, 10);
 +
 +    ff_acelp_lp_decode(&lp[0][0], &lp[1][0], ctx->lsp[1], ctx->lsp[0], 10);
 +
 +    FFSWAP(int16_t*, ctx->lsp[1], ctx->lsp[0]);
 +
 +    for (i = 0; i < 2; i++) {
 +        int gain_corr_factor;
 +
 +        uint8_t ac_index;      ///< adaptive codebook index
 +        uint8_t pulses_signs;  ///< fixed-codebook vector pulse signs
 +        int fc_indexes;        ///< fixed-codebook indexes
 +        uint8_t gc_1st_index;  ///< gain codebook (first stage) index
 +        uint8_t gc_2nd_index;  ///< gain codebook (second stage) index
 +
 +        ac_index      = get_bits(&gb, format->ac_index_bits[i]);
 +        if(!i && format->parity_bit)
 +            bad_pitch = get_parity(ac_index) == get_bits1(&gb);
 +        fc_indexes    = get_bits(&gb, format->fc_indexes_bits);
 +        pulses_signs  = get_bits(&gb, format->fc_signs_bits);
 +        gc_1st_index  = get_bits(&gb, format->gc_1st_index_bits);
 +        gc_2nd_index  = get_bits(&gb, format->gc_2nd_index_bits);
 +
 +        if (frame_erasure)
 +            pitch_delay_3x   = 3 * ctx->pitch_delay_int_prev;
 +        else if(!i) {
 +            if (bad_pitch)
 +                pitch_delay_3x   = 3 * ctx->pitch_delay_int_prev;
 +            else
 +                pitch_delay_3x = ff_acelp_decode_8bit_to_1st_delay3(ac_index);
 +        } else {
 +            int pitch_delay_min = av_clip(ctx->pitch_delay_int_prev - 5,
 +                                          PITCH_DELAY_MIN, PITCH_DELAY_MAX - 9);
 +
 +            if(packet_type == FORMAT_G729D_6K4)
 +                pitch_delay_3x = ff_acelp_decode_4bit_to_2nd_delay3(ac_index, pitch_delay_min);
 +            else
 +                pitch_delay_3x = ff_acelp_decode_5_6_bit_to_2nd_delay3(ac_index, pitch_delay_min);
 +        }
 +
 +        /* Round pitch delay to nearest (used everywhere except ff_acelp_interpolate). */
 +        pitch_delay_int[i]  = (pitch_delay_3x + 1) / 3;
 +        if (pitch_delay_int[i] > PITCH_DELAY_MAX) {
 +            av_log(avctx, AV_LOG_WARNING, "pitch_delay_int %d is too large\n", pitch_delay_int[i]);
 +            pitch_delay_int[i] = PITCH_DELAY_MAX;
 +        }
 +
 +        if (frame_erasure) {
 +            ctx->rand_value = g729_prng(ctx->rand_value);
 +            fc_indexes   = ctx->rand_value & ((1 << format->fc_indexes_bits) - 1);
 +
 +            ctx->rand_value = g729_prng(ctx->rand_value);
 +            pulses_signs = ctx->rand_value;
 +        }
 +
 +
 +        memset(fc, 0, sizeof(int16_t) * SUBFRAME_SIZE);
 +        switch (packet_type) {
 +            case FORMAT_G729_8K:
 +                ff_acelp_fc_pulse_per_track(fc, ff_fc_4pulses_8bits_tracks_13,
 +                                            ff_fc_4pulses_8bits_track_4,
 +                                            fc_indexes, pulses_signs, 3, 3);
 +                break;
 +            case FORMAT_G729D_6K4:
 +                ff_acelp_fc_pulse_per_track(fc, ff_fc_2pulses_9bits_track1_gray,
 +                                            ff_fc_2pulses_9bits_track2_gray,
 +                                            fc_indexes, pulses_signs, 1, 4);
 +                break;
 +        }
 +
 +        /*
 +          This filter enhances harmonic components of the fixed-codebook vector to
 +          improve the quality of the reconstructed speech.
 +
 +                     / fc_v[i],                                    i < pitch_delay
 +          fc_v[i] = <
 +                     \ fc_v[i] + gain_pitch * fc_v[i-pitch_delay], i >= pitch_delay
 +        */
 +        ff_acelp_weighted_vector_sum(fc + pitch_delay_int[i],
 +                                     fc + pitch_delay_int[i],
 +                                     fc, 1 << 14,
 +                                     av_clip(ctx->past_gain_pitch[0], SHARP_MIN, SHARP_MAX),
 +                                     0, 14,
 +                                     SUBFRAME_SIZE - pitch_delay_int[i]);
 +
 +        memmove(ctx->past_gain_pitch+1, ctx->past_gain_pitch, 5 * sizeof(int16_t));
 +        ctx->past_gain_code[1] = ctx->past_gain_code[0];
 +
 +        if (frame_erasure) {
 +            ctx->past_gain_pitch[0] = (29491 * ctx->past_gain_pitch[0]) >> 15; // 0.90 (0.15)
 +            ctx->past_gain_code[0]  = ( 2007 * ctx->past_gain_code[0] ) >> 11; // 0.98 (0.11)
 +
 +            gain_corr_factor = 0;
 +        } else {
 +            if (packet_type == FORMAT_G729D_6K4) {
 +                ctx->past_gain_pitch[0]  = cb_gain_1st_6k4[gc_1st_index][0] +
 +                                           cb_gain_2nd_6k4[gc_2nd_index][0];
 +                gain_corr_factor = cb_gain_1st_6k4[gc_1st_index][1] +
 +                                   cb_gain_2nd_6k4[gc_2nd_index][1];
 +
 +                /* Without check below overflow can occur in ff_acelp_update_past_gain.
 +                   It is not issue for G.729, because gain_corr_factor in it's case is always
 +                   greater than 1024, while in G.729D it can be even zero. */
 +                gain_corr_factor = FFMAX(gain_corr_factor, 1024);
 +#ifndef G729_BITEXACT
 +                gain_corr_factor >>= 1;
 +#endif
 +            } else {
 +                ctx->past_gain_pitch[0]  = cb_gain_1st_8k[gc_1st_index][0] +
 +                                           cb_gain_2nd_8k[gc_2nd_index][0];
 +                gain_corr_factor = cb_gain_1st_8k[gc_1st_index][1] +
 +                                   cb_gain_2nd_8k[gc_2nd_index][1];
 +            }
 +
 +            /* Decode the fixed-codebook gain. */
-                 &ctx->dsp,
++            ctx->past_gain_code[0] = ff_acelp_decode_gain_code(&ctx->adsp, gain_corr_factor,
 +                                                               fc, MR_ENERGY,
 +                                                               ctx->quant_energy,
 +                                                               ma_prediction_coeff,
 +                                                               SUBFRAME_SIZE, 4);
 +#ifdef G729_BITEXACT
 +            /*
 +              This correction required to get bit-exact result with
 +              reference code, because gain_corr_factor in G.729D is
 +              two times larger than in original G.729.
 +
 +              If bit-exact result is not issue then gain_corr_factor
 +              can be simpler divided by 2 before call to g729_get_gain_code
 +              instead of using correction below.
 +            */
 +            if (packet_type == FORMAT_G729D_6K4) {
 +                gain_corr_factor >>= 1;
 +                ctx->past_gain_code[0] >>= 1;
 +            }
 +#endif
 +        }
 +        ff_acelp_update_past_gain(ctx->quant_energy, gain_corr_factor, 2, frame_erasure);
 +
 +        /* Routine requires rounding to lowest. */
 +        ff_acelp_interpolate(ctx->exc + i * SUBFRAME_SIZE,
 +                             ctx->exc + i * SUBFRAME_SIZE - pitch_delay_3x / 3,
 +                             ff_acelp_interp_filter, 6,
 +                             (pitch_delay_3x % 3) << 1,
 +                             10, SUBFRAME_SIZE);
 +
 +        ff_acelp_weighted_vector_sum(ctx->exc + i * SUBFRAME_SIZE,
 +                                     ctx->exc + i * SUBFRAME_SIZE, fc,
 +                                     (!ctx->was_periodic && frame_erasure) ? 0 : ctx->past_gain_pitch[0],
 +                                     ( ctx->was_periodic && frame_erasure) ? 0 : ctx->past_gain_code[0],
 +                                     1 << 13, 14, SUBFRAME_SIZE);
 +
 +        memcpy(synth, ctx->syn_filter_data, 10 * sizeof(int16_t));
 +
 +        if (ff_celp_lp_synthesis_filter(
 +            synth+10,
 +            &lp[i][1],
 +            ctx->exc  + i * SUBFRAME_SIZE,
 +            SUBFRAME_SIZE,
 +            10,
 +            1,
 +            0,
 +            0x800))
 +            /* Overflow occurred, downscale excitation signal... */
 +            for (j = 0; j < 2 * SUBFRAME_SIZE + PITCH_DELAY_MAX + INTERPOL_LEN; j++)
 +                ctx->exc_base[j] >>= 2;
 +
 +        /* ... and make synthesis again. */
 +        if (packet_type == FORMAT_G729D_6K4) {
 +            int16_t exc_new[SUBFRAME_SIZE];
 +
 +            ctx->onset = g729d_onset_decision(ctx->onset, ctx->past_gain_code);
 +            ctx->voice_decision = g729d_voice_decision(ctx->onset, ctx->voice_decision, ctx->past_gain_pitch);
 +
 +            g729d_get_new_exc(exc_new, ctx->exc  + i * SUBFRAME_SIZE, fc, ctx->voice_decision, ctx->past_gain_code[0], SUBFRAME_SIZE);
 +
 +            ff_celp_lp_synthesis_filter(
 +                    synth+10,
 +                    &lp[i][1],
 +                    exc_new,
 +                    SUBFRAME_SIZE,
 +                    10,
 +                    0,
 +                    0,
 +                    0x800);
 +        } else {
 +            ff_celp_lp_synthesis_filter(
 +                    synth+10,
 +                    &lp[i][1],
 +                    ctx->exc  + i * SUBFRAME_SIZE,
 +                    SUBFRAME_SIZE,
 +                    10,
 +                    0,
 +                    0,
 +                    0x800);
 +        }
 +        /* Save data (without postfilter) for use in next subframe. */
 +        memcpy(ctx->syn_filter_data, synth+SUBFRAME_SIZE, 10 * sizeof(int16_t));
 +
 +        /* Calculate gain of unfiltered signal for use in AGC. */
 +        gain_before = 0;
 +        for (j = 0; j < SUBFRAME_SIZE; j++)
 +            gain_before += FFABS(synth[j+10]);
 +
 +        /* Call postfilter and also update voicing decision for use in next frame. */
 +        ff_g729_postfilter(
++                &ctx->adsp,
 +                &ctx->ht_prev_data,
 +                &is_periodic,
 +                &lp[i][0],
 +                pitch_delay_int[0],
 +                ctx->residual,
 +                ctx->res_filter_data,
 +                ctx->pos_filter_data,
 +                synth+10,
 +                SUBFRAME_SIZE);
 +
 +        /* Calculate gain of filtered signal for use in AGC. */
 +        gain_after = 0;
 +        for(j=0; j<SUBFRAME_SIZE; j++)
 +            gain_after += FFABS(synth[j+10]);
 +
 +        ctx->gain_coeff = ff_g729_adaptive_gain_control(
 +                gain_before,
 +                gain_after,
 +                synth+10,
 +                SUBFRAME_SIZE,
 +                ctx->gain_coeff);
 +
 +        if (frame_erasure)
 +            ctx->pitch_delay_int_prev = FFMIN(ctx->pitch_delay_int_prev + 1, PITCH_DELAY_MAX);
 +        else
 +            ctx->pitch_delay_int_prev = pitch_delay_int[i];
 +
 +        memcpy(synth+8, ctx->hpf_z, 2*sizeof(int16_t));
 +        ff_acelp_high_pass_filter(
 +                out_frame + i*SUBFRAME_SIZE,
 +                ctx->hpf_f,
 +                synth+10,
 +                SUBFRAME_SIZE);
 +        memcpy(ctx->hpf_z, synth+8+SUBFRAME_SIZE, 2*sizeof(int16_t));
 +    }
 +
 +    ctx->was_periodic = is_periodic;
 +
 +    /* Save signal for use in next frame. */
 +    memmove(ctx->exc_base, ctx->exc_base + 2 * SUBFRAME_SIZE, (PITCH_DELAY_MAX+INTERPOL_LEN)*sizeof(int16_t));
 +
 +    *got_frame_ptr = 1;
 +    return buf_size;
 +}
 +
 +AVCodec ff_g729_decoder = {
 +    .name           = "g729",
 +    .long_name      = NULL_IF_CONFIG_SMALL("G.729"),
 +    .type           = AVMEDIA_TYPE_AUDIO,
 +    .id             = AV_CODEC_ID_G729,
 +    .priv_data_size = sizeof(G729Context),
 +    .init           = decoder_init,
 +    .decode         = decode_frame,
 +    .capabilities   = CODEC_CAP_DR1,
 +};
index bcf509c,0000000..9a775c4
mode 100644,000000..100644
--- /dev/null
@@@ -1,610 -1,0 +1,610 @@@
- static int16_t long_term_filter(DSPContext *dsp, int pitch_delay_int,
 +/*
 + * G.729, G729 Annex D postfilter
 + * Copyright (c) 2008 Vladimir Voroshilov
 + *
 + * 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
 + * version 2.1 of the License, or (at your option) any later version.
 + *
 + * FFmpeg is distributed in the hope that it will be useful,
 + * but WITHOUT ANY WARRANTY; without even the implied warranty of
 + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 + * Lesser General Public License for more details.
 + *
 + * You should have received a copy of the GNU Lesser General Public
 + * License along with FFmpeg; if not, write to the Free Software
 + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 + */
 +#include <inttypes.h>
 +#include <limits.h>
 +
 +#include "avcodec.h"
 +#include "g729.h"
 +#include "acelp_pitch_delay.h"
 +#include "g729postfilter.h"
 +#include "celp_math.h"
 +#include "acelp_filters.h"
 +#include "acelp_vectors.h"
 +#include "celp_filters.h"
 +
 +#define FRAC_BITS 15
 +#include "mathops.h"
 +
 +/**
 + * short interpolation filter (of length 33, according to spec)
 + * for computing signal with non-integer delay
 + */
 +static const int16_t ff_g729_interp_filt_short[(ANALYZED_FRAC_DELAYS+1)*SHORT_INT_FILT_LEN] = {
 +      0, 31650, 28469, 23705, 18050, 12266,  7041,  2873,
 +      0, -1597, -2147, -1992, -1492,  -933,  -484,  -188,
 +};
 +
 +/**
 + * long interpolation filter (of length 129, according to spec)
 + * for computing signal with non-integer delay
 + */
 +static const int16_t ff_g729_interp_filt_long[(ANALYZED_FRAC_DELAYS+1)*LONG_INT_FILT_LEN] = {
 +   0, 31915, 29436, 25569, 20676, 15206,  9639,  4439,
 +   0, -3390, -5579, -6549, -6414, -5392, -3773, -1874,
 +   0,  1595,  2727,  3303,  3319,  2850,  2030,  1023,
 +   0,  -887, -1527, -1860, -1876, -1614, -1150,  -579,
 +   0,   501,   859,  1041,  1044,   892,   631,   315,
 +   0,  -266,  -453,  -543,  -538,  -455,  -317,  -156,
 +   0,   130,   218,   258,   253,   212,   147,    72,
 +   0,   -59,  -101,  -122,  -123,  -106,   -77,   -40,
 +};
 +
 +/**
 + * formant_pp_factor_num_pow[i] = FORMANT_PP_FACTOR_NUM^(i+1)
 + */
 +static const int16_t formant_pp_factor_num_pow[10]= {
 +  /* (0.15) */
 +  18022, 9912, 5451, 2998, 1649, 907, 499, 274, 151, 83
 +};
 +
 +/**
 + * formant_pp_factor_den_pow[i] = FORMANT_PP_FACTOR_DEN^(i+1)
 + */
 +static const int16_t formant_pp_factor_den_pow[10] = {
 +  /* (0.15) */
 +  22938, 16057, 11240, 7868, 5508, 3856, 2699, 1889, 1322, 925
 +};
 +
 +/**
 + * \brief Residual signal calculation (4.2.1 if G.729)
 + * \param out [out] output data filtered through A(z/FORMANT_PP_FACTOR_NUM)
 + * \param filter_coeffs (3.12) A(z/FORMANT_PP_FACTOR_NUM) filter coefficients
 + * \param in input speech data to process
 + * \param subframe_size size of one subframe
 + *
 + * \note in buffer must contain 10 items of previous speech data before top of the buffer
 + * \remark It is safe to pass the same buffer for input and output.
 + */
 +static void residual_filter(int16_t* out, const int16_t* filter_coeffs, const int16_t* in,
 +                            int subframe_size)
 +{
 +    int i, n;
 +
 +    for (n = subframe_size - 1; n >= 0; n--) {
 +        int sum = 0x800;
 +        for (i = 0; i < 10; i++)
 +            sum += filter_coeffs[i] * in[n - i - 1];
 +
 +        out[n] = in[n] + (sum >> 12);
 +    }
 +}
 +
 +/**
 + * \brief long-term postfilter (4.2.1)
 + * \param dsp initialized DSP context
 + * \param pitch_delay_int integer part of the pitch delay in the first subframe
 + * \param residual filtering input data
 + * \param residual_filt [out] speech signal with applied A(z/FORMANT_PP_FACTOR_NUM) filter
 + * \param subframe_size size of subframe
 + *
 + * \return 0 if long-term prediction gain is less than 3dB, 1 -  otherwise
 + */
-     ener = dsp->scalarproduct_int16(sig_scaled + RES_PREV_DATA_SIZE,
++static int16_t long_term_filter(AudioDSPContext *adsp, int pitch_delay_int,
 +                                const int16_t* residual, int16_t *residual_filt,
 +                                int subframe_size)
 +{
 +    int i, k, tmp, tmp2;
 +    int sum;
 +    int L_temp0;
 +    int L_temp1;
 +    int64_t L64_temp0;
 +    int64_t L64_temp1;
 +    int16_t shift;
 +    int corr_int_num, corr_int_den;
 +
 +    int ener;
 +    int16_t sh_ener;
 +
 +    int16_t gain_num,gain_den; //selected signal's gain numerator and denominator
 +    int16_t sh_gain_num, sh_gain_den;
 +    int gain_num_square;
 +
 +    int16_t gain_long_num,gain_long_den; //filtered through long interpolation filter signal's gain numerator and denominator
 +    int16_t sh_gain_long_num, sh_gain_long_den;
 +
 +    int16_t best_delay_int, best_delay_frac;
 +
 +    int16_t delayed_signal_offset;
 +    int lt_filt_factor_a, lt_filt_factor_b;
 +
 +    int16_t * selected_signal;
 +    const int16_t * selected_signal_const; //Necessary to avoid compiler warning
 +
 +    int16_t sig_scaled[SUBFRAME_SIZE + RES_PREV_DATA_SIZE];
 +    int16_t delayed_signal[ANALYZED_FRAC_DELAYS][SUBFRAME_SIZE+1];
 +    int corr_den[ANALYZED_FRAC_DELAYS][2];
 +
 +    tmp = 0;
 +    for(i=0; i<subframe_size + RES_PREV_DATA_SIZE; i++)
 +        tmp |= FFABS(residual[i]);
 +
 +    if(!tmp)
 +        shift = 3;
 +    else
 +        shift = av_log2(tmp) - 11;
 +
 +    if (shift > 0)
 +        for (i = 0; i < subframe_size + RES_PREV_DATA_SIZE; i++)
 +            sig_scaled[i] = residual[i] >> shift;
 +    else
 +        for (i = 0; i < subframe_size + RES_PREV_DATA_SIZE; i++)
 +            sig_scaled[i] = residual[i] << -shift;
 +
 +    /* Start of best delay searching code */
 +    gain_num = 0;
 +
-             sum = dsp->scalarproduct_int16(sig_scaled + RES_PREV_DATA_SIZE,
++    ener = adsp->scalarproduct_int16(sig_scaled + RES_PREV_DATA_SIZE,
 +                                    sig_scaled + RES_PREV_DATA_SIZE,
 +                                    subframe_size);
 +    if (ener) {
 +        sh_ener = FFMAX(av_log2(ener) - 14, 0);
 +        ener >>= sh_ener;
 +        /* Search for best pitch delay.
 +
 +                       sum{ r(n) * r(k,n) ] }^2
 +           R'(k)^2 := -------------------------
 +                       sum{ r(k,n) * r(k,n) }
 +
 +
 +           R(T)    :=  sum{ r(n) * r(n-T) ] }
 +
 +
 +           where
 +           r(n-T) is integer delayed signal with delay T
 +           r(k,n) is non-integer delayed signal with integer delay best_delay
 +           and fractional delay k */
 +
 +        /* Find integer delay best_delay which maximizes correlation R(T).
 +
 +           This is also equals to numerator of R'(0),
 +           since the fine search (second step) is done with 1/8
 +           precision around best_delay. */
 +        corr_int_num = 0;
 +        best_delay_int = pitch_delay_int - 1;
 +        for (i = pitch_delay_int - 1; i <= pitch_delay_int + 1; i++) {
-             corr_int_den = dsp->scalarproduct_int16(sig_scaled - best_delay_int + RES_PREV_DATA_SIZE,
++            sum = adsp->scalarproduct_int16(sig_scaled + RES_PREV_DATA_SIZE,
 +                                           sig_scaled + RES_PREV_DATA_SIZE - i,
 +                                           subframe_size);
 +            if (sum > corr_int_num) {
 +                corr_int_num = sum;
 +                best_delay_int = i;
 +            }
 +        }
 +        if (corr_int_num) {
 +            /* Compute denominator of pseudo-normalized correlation R'(0). */
-                 sum = dsp->scalarproduct_int16(&delayed_signal[k][1],
++            corr_int_den = adsp->scalarproduct_int16(sig_scaled - best_delay_int + RES_PREV_DATA_SIZE,
 +                                                    sig_scaled - best_delay_int + RES_PREV_DATA_SIZE,
 +                                                    subframe_size);
 +
 +            /* Compute signals with non-integer delay k (with 1/8 precision),
 +               where k is in [0;6] range.
 +               Entire delay is qual to best_delay+(k+1)/8
 +               This is archieved by applying an interpolation filter of
 +               legth 33 to source signal. */
 +            for (k = 0; k < ANALYZED_FRAC_DELAYS; k++) {
 +                ff_acelp_interpolate(&delayed_signal[k][0],
 +                                     &sig_scaled[RES_PREV_DATA_SIZE - best_delay_int],
 +                                     ff_g729_interp_filt_short,
 +                                     ANALYZED_FRAC_DELAYS+1,
 +                                     8 - k - 1,
 +                                     SHORT_INT_FILT_LEN,
 +                                     subframe_size + 1);
 +            }
 +
 +            /* Compute denominator of pseudo-normalized correlation R'(k).
 +
 +                 corr_den[k][0] is square root of R'(k) denominator, for int(T) == int(T0)
 +                 corr_den[k][1] is square root of R'(k) denominator, for int(T) == int(T0)+1
 +
 +              Also compute maximum value of above denominators over all k. */
 +            tmp = corr_int_den;
 +            for (k = 0; k < ANALYZED_FRAC_DELAYS; k++) {
-                         sum = dsp->scalarproduct_int16(&delayed_signal[k][i],
++                sum = adsp->scalarproduct_int16(&delayed_signal[k][1],
 +                                               &delayed_signal[k][1],
 +                                               subframe_size - 1);
 +                corr_den[k][0] = sum + delayed_signal[k][0            ] * delayed_signal[k][0            ];
 +                corr_den[k][1] = sum + delayed_signal[k][subframe_size] * delayed_signal[k][subframe_size];
 +
 +                tmp = FFMAX3(tmp, corr_den[k][0], corr_den[k][1]);
 +            }
 +
 +            sh_gain_den = av_log2(tmp) - 14;
 +            if (sh_gain_den >= 0) {
 +
 +                sh_gain_num =  FFMAX(sh_gain_den, sh_ener);
 +                /* Loop through all k and find delay that maximizes
 +                   R'(k) correlation.
 +                   Search is done in [int(T0)-1; intT(0)+1] range
 +                   with 1/8 precision. */
 +                delayed_signal_offset = 1;
 +                best_delay_frac = 0;
 +                gain_den = corr_int_den >> sh_gain_den;
 +                gain_num = corr_int_num >> sh_gain_num;
 +                gain_num_square = gain_num * gain_num;
 +                for (k = 0; k < ANALYZED_FRAC_DELAYS; k++) {
 +                    for (i = 0; i < 2; i++) {
 +                        int16_t gain_num_short, gain_den_short;
 +                        int gain_num_short_square;
 +                        /* Compute numerator of pseudo-normalized
 +                           correlation R'(k). */
-         sum = dsp->scalarproduct_int16(residual_filt,
++                        sum = adsp->scalarproduct_int16(&delayed_signal[k][i],
 +                                                       sig_scaled + RES_PREV_DATA_SIZE,
 +                                                       subframe_size);
 +                        gain_num_short = FFMAX(sum >> sh_gain_num, 0);
 +
 +                        /*
 +                                      gain_num_short_square                gain_num_square
 +                           R'(T)^2 = -----------------------, max R'(T)^2= --------------
 +                                           den                                 gain_den
 +                        */
 +                        gain_num_short_square = gain_num_short * gain_num_short;
 +                        gain_den_short = corr_den[k][i] >> sh_gain_den;
 +
 +                        tmp = MULL(gain_num_short_square, gain_den, FRAC_BITS);
 +                        tmp2 = MULL(gain_num_square, gain_den_short, FRAC_BITS);
 +
 +                        // R'(T)^2 > max R'(T)^2
 +                        if (tmp > tmp2) {
 +                            gain_num = gain_num_short;
 +                            gain_den = gain_den_short;
 +                            gain_num_square = gain_num_short_square;
 +                            delayed_signal_offset = i;
 +                            best_delay_frac = k + 1;
 +                        }
 +                    }
 +                }
 +
 +                /*
 +                       R'(T)^2
 +                  2 * --------- < 1
 +                        R(0)
 +                */
 +                L64_temp0 =  (int64_t)gain_num_square  << ((sh_gain_num << 1) + 1);
 +                L64_temp1 = ((int64_t)gain_den * ener) << (sh_gain_den + sh_ener);
 +                if (L64_temp0 < L64_temp1)
 +                    gain_num = 0;
 +            } // if(sh_gain_den >= 0)
 +        } // if(corr_int_num)
 +    } // if(ener)
 +    /* End of best delay searching code  */
 +
 +    if (!gain_num) {
 +        memcpy(residual_filt, residual + RES_PREV_DATA_SIZE, subframe_size * sizeof(int16_t));
 +
 +        /* Long-term prediction gain is less than 3dB. Long-term postfilter is disabled. */
 +        return 0;
 +    }
 +    if (best_delay_frac) {
 +        /* Recompute delayed signal with an interpolation filter of length 129. */
 +        ff_acelp_interpolate(residual_filt,
 +                             &sig_scaled[RES_PREV_DATA_SIZE - best_delay_int + delayed_signal_offset],
 +                             ff_g729_interp_filt_long,
 +                             ANALYZED_FRAC_DELAYS + 1,
 +                             8 - best_delay_frac,
 +                             LONG_INT_FILT_LEN,
 +                             subframe_size + 1);
 +        /* Compute R'(k) correlation's numerator. */
-         sum = dsp->scalarproduct_int16(residual_filt, residual_filt, subframe_size);
++        sum = adsp->scalarproduct_int16(residual_filt,
 +                                       sig_scaled + RES_PREV_DATA_SIZE,
 +                                       subframe_size);
 +
 +        if (sum < 0) {
 +            gain_long_num = 0;
 +            sh_gain_long_num = 0;
 +        } else {
 +            tmp = FFMAX(av_log2(sum) - 14, 0);
 +            sum >>= tmp;
 +            gain_long_num = sum;
 +            sh_gain_long_num = tmp;
 +        }
 +
 +        /* Compute R'(k) correlation's denominator. */
- static int16_t get_tilt_comp(DSPContext *dsp, int16_t *lp_gn,
++        sum = adsp->scalarproduct_int16(residual_filt, residual_filt, subframe_size);
 +
 +        tmp = FFMAX(av_log2(sum) - 14, 0);
 +        sum >>= tmp;
 +        gain_long_den = sum;
 +        sh_gain_long_den = tmp;
 +
 +        /* Select between original and delayed signal.
 +           Delayed signal will be selected if it increases R'(k)
 +           correlation. */
 +        L_temp0 = gain_num * gain_num;
 +        L_temp0 = MULL(L_temp0, gain_long_den, FRAC_BITS);
 +
 +        L_temp1 = gain_long_num * gain_long_num;
 +        L_temp1 = MULL(L_temp1, gain_den, FRAC_BITS);
 +
 +        tmp = ((sh_gain_long_num - sh_gain_num) << 1) - (sh_gain_long_den - sh_gain_den);
 +        if (tmp > 0)
 +            L_temp0 >>= tmp;
 +        else
 +            L_temp1 >>= -tmp;
 +
 +        /* Check if longer filter increases the values of R'(k). */
 +        if (L_temp1 > L_temp0) {
 +            /* Select long filter. */
 +            selected_signal = residual_filt;
 +            gain_num = gain_long_num;
 +            gain_den = gain_long_den;
 +            sh_gain_num = sh_gain_long_num;
 +            sh_gain_den = sh_gain_long_den;
 +        } else
 +            /* Select short filter. */
 +            selected_signal = &delayed_signal[best_delay_frac-1][delayed_signal_offset];
 +
 +        /* Rescale selected signal to original value. */
 +        if (shift > 0)
 +            for (i = 0; i < subframe_size; i++)
 +                selected_signal[i] <<= shift;
 +        else
 +            for (i = 0; i < subframe_size; i++)
 +                selected_signal[i] >>= -shift;
 +
 +        /* necessary to avoid compiler warning */
 +        selected_signal_const = selected_signal;
 +    } // if(best_delay_frac)
 +    else
 +        selected_signal_const = residual + RES_PREV_DATA_SIZE - (best_delay_int + 1 - delayed_signal_offset);
 +#ifdef G729_BITEXACT
 +    tmp = sh_gain_num - sh_gain_den;
 +    if (tmp > 0)
 +        gain_den >>= tmp;
 +    else
 +        gain_num >>= -tmp;
 +
 +    if (gain_num > gain_den)
 +        lt_filt_factor_a = MIN_LT_FILT_FACTOR_A;
 +    else {
 +        gain_num >>= 2;
 +        gain_den >>= 1;
 +        lt_filt_factor_a = (gain_den << 15) / (gain_den + gain_num);
 +    }
 +#else
 +    L64_temp0 = (((int64_t)gain_num) << sh_gain_num) >> 1;
 +    L64_temp1 = ((int64_t)gain_den) << sh_gain_den;
 +    lt_filt_factor_a = FFMAX((L64_temp1 << 15) / (L64_temp1 + L64_temp0), MIN_LT_FILT_FACTOR_A);
 +#endif
 +
 +    /* Filter through selected filter. */
 +    lt_filt_factor_b = 32767 - lt_filt_factor_a + 1;
 +
 +    ff_acelp_weighted_vector_sum(residual_filt, residual + RES_PREV_DATA_SIZE,
 +                                 selected_signal_const,
 +                                 lt_filt_factor_a, lt_filt_factor_b,
 +                                 1<<14, 15, subframe_size);
 +
 +    // Long-term prediction gain is larger than 3dB.
 +    return 1;
 +}
 +
 +/**
 + * \brief Calculate reflection coefficient for tilt compensation filter (4.2.3).
 + * \param dsp initialized DSP context
 + * \param lp_gn (3.12) coefficients of A(z/FORMANT_PP_FACTOR_NUM) filter
 + * \param lp_gd (3.12) coefficients of A(z/FORMANT_PP_FACTOR_DEN) filter
 + * \param speech speech to update
 + * \param subframe_size size of subframe
 + *
 + * \return (3.12) reflection coefficient
 + *
 + * \remark The routine also calculates the gain term for the short-term
 + *         filter (gf) and multiplies the speech data by 1/gf.
 + *
 + * \note All members of lp_gn, except 10-19 must be equal to zero.
 + */
-     rh0 = dsp->scalarproduct_int16(lp_gn + 10, lp_gn + 10, 20);
-     rh1 = dsp->scalarproduct_int16(lp_gn + 10, lp_gn + 11, 20);
++static int16_t get_tilt_comp(AudioDSPContext *adsp, int16_t *lp_gn,
 +                             const int16_t *lp_gd, int16_t* speech,
 +                             int subframe_size)
 +{
 +    int rh1,rh0; // (3.12)
 +    int temp;
 +    int i;
 +    int gain_term;
 +
 +    lp_gn[10] = 4096; //1.0 in (3.12)
 +
 +    /* Apply 1/A(z/FORMANT_PP_FACTOR_DEN) filter to hf. */
 +    ff_celp_lp_synthesis_filter(lp_gn + 11, lp_gd + 1, lp_gn + 11, 22, 10, 0, 0, 0x800);
 +    /* Now lp_gn (starting with 10) contains impulse response
 +       of A(z/FORMANT_PP_FACTOR_NUM)/A(z/FORMANT_PP_FACTOR_DEN) filter. */
 +
- void ff_g729_postfilter(DSPContext *dsp, int16_t* ht_prev_data, int* voicing,
++    rh0 = adsp->scalarproduct_int16(lp_gn + 10, lp_gn + 10, 20);
++    rh1 = adsp->scalarproduct_int16(lp_gn + 10, lp_gn + 11, 20);
 +
 +    /* downscale to avoid overflow */
 +    temp = av_log2(rh0) - 14;
 +    if (temp > 0) {
 +        rh0 >>= temp;
 +        rh1 >>= temp;
 +    }
 +
 +    if (FFABS(rh1) > rh0 || !rh0)
 +        return 0;
 +
 +    gain_term = 0;
 +    for (i = 0; i < 20; i++)
 +        gain_term += FFABS(lp_gn[i + 10]);
 +    gain_term >>= 2; // (3.12) -> (5.10)
 +
 +    if (gain_term > 0x400) { // 1.0 in (5.10)
 +        temp = 0x2000000 / gain_term; // 1.0/gain_term in (0.15)
 +        for (i = 0; i < subframe_size; i++)
 +            speech[i] = (speech[i] * temp + 0x4000) >> 15;
 +    }
 +
 +    return -(rh1 << 15) / rh0;
 +}
 +
 +/**
 + * \brief Apply tilt compensation filter (4.2.3).
 + * \param res_pst [in/out] residual signal (partially filtered)
 + * \param k1 (3.12) reflection coefficient
 + * \param subframe_size size of subframe
 + * \param ht_prev_data previous data for 4.2.3, equation 86
 + *
 + * \return new value for ht_prev_data
 +*/
 +static int16_t apply_tilt_comp(int16_t* out, int16_t* res_pst, int refl_coeff,
 +                               int subframe_size, int16_t ht_prev_data)
 +{
 +    int tmp, tmp2;
 +    int i;
 +    int gt, ga;
 +    int fact, sh_fact;
 +
 +    if (refl_coeff > 0) {
 +        gt = (refl_coeff * G729_TILT_FACTOR_PLUS + 0x4000) >> 15;
 +        fact = 0x4000; // 0.5 in (0.15)
 +        sh_fact = 15;
 +    } else {
 +        gt = (refl_coeff * G729_TILT_FACTOR_MINUS + 0x4000) >> 15;
 +        fact = 0x800; // 0.5 in (3.12)
 +        sh_fact = 12;
 +    }
 +    ga = (fact << 15) / av_clip_int16(32768 - FFABS(gt));
 +    gt >>= 1;
 +
 +    /* Apply tilt compensation filter to signal. */
 +    tmp = res_pst[subframe_size - 1];
 +
 +    for (i = subframe_size - 1; i >= 1; i--) {
 +        tmp2 = (res_pst[i] << 15) + ((gt * res_pst[i-1]) << 1);
 +        tmp2 = (tmp2 + 0x4000) >> 15;
 +
 +        tmp2 = (tmp2 * ga * 2 + fact) >> sh_fact;
 +        out[i] = tmp2;
 +    }
 +    tmp2 = (res_pst[0] << 15) + ((gt * ht_prev_data) << 1);
 +    tmp2 = (tmp2 + 0x4000) >> 15;
 +    tmp2 = (tmp2 * ga * 2 + fact) >> sh_fact;
 +    out[0] = tmp2;
 +
 +    return tmp;
 +}
 +
-     *voicing = FFMAX(*voicing, long_term_filter(dsp, pitch_delay_int,
++void ff_g729_postfilter(AudioDSPContext *adsp, int16_t* ht_prev_data, int* voicing,
 +                     const int16_t *lp_filter_coeffs, int pitch_delay_int,
 +                     int16_t* residual, int16_t* res_filter_data,
 +                     int16_t* pos_filter_data, int16_t *speech, int subframe_size)
 +{
 +    int16_t residual_filt_buf[SUBFRAME_SIZE+11];
 +    int16_t lp_gn[33]; // (3.12)
 +    int16_t lp_gd[11]; // (3.12)
 +    int tilt_comp_coeff;
 +    int i;
 +
 +    /* Zero-filling is necessary for tilt-compensation filter. */
 +    memset(lp_gn, 0, 33 * sizeof(int16_t));
 +
 +    /* Calculate A(z/FORMANT_PP_FACTOR_NUM) filter coefficients. */
 +    for (i = 0; i < 10; i++)
 +        lp_gn[i + 11] = (lp_filter_coeffs[i + 1] * formant_pp_factor_num_pow[i] + 0x4000) >> 15;
 +
 +    /* Calculate A(z/FORMANT_PP_FACTOR_DEN) filter coefficients. */
 +    for (i = 0; i < 10; i++)
 +        lp_gd[i + 1] = (lp_filter_coeffs[i + 1] * formant_pp_factor_den_pow[i] + 0x4000) >> 15;
 +
 +    /* residual signal calculation (one-half of short-term postfilter) */
 +    memcpy(speech - 10, res_filter_data, 10 * sizeof(int16_t));
 +    residual_filter(residual + RES_PREV_DATA_SIZE, lp_gn + 11, speech, subframe_size);
 +    /* Save data to use it in the next subframe. */
 +    memcpy(res_filter_data, speech + subframe_size - 10, 10 * sizeof(int16_t));
 +
 +    /* long-term filter. If long-term prediction gain is larger than 3dB (returned value is
 +       nonzero) then declare current subframe as periodic. */
-     tilt_comp_coeff = get_tilt_comp(dsp, lp_gn, lp_gd, residual_filt_buf + 10, subframe_size);
++    *voicing = FFMAX(*voicing, long_term_filter(adsp, pitch_delay_int,
 +                                                residual, residual_filt_buf + 10,
 +                                                subframe_size));
 +
 +    /* shift residual for using in next subframe */
 +    memmove(residual, residual + subframe_size, RES_PREV_DATA_SIZE * sizeof(int16_t));
 +
 +    /* short-term filter tilt compensation */
++    tilt_comp_coeff = get_tilt_comp(adsp, lp_gn, lp_gd, residual_filt_buf + 10, subframe_size);
 +
 +    /* Apply second half of short-term postfilter: 1/A(z/FORMANT_PP_FACTOR_DEN) */
 +    ff_celp_lp_synthesis_filter(pos_filter_data + 10, lp_gd + 1,
 +                                residual_filt_buf + 10,
 +                                subframe_size, 10, 0, 0, 0x800);
 +    memcpy(pos_filter_data, pos_filter_data + subframe_size, 10 * sizeof(int16_t));
 +
 +    *ht_prev_data = apply_tilt_comp(speech, pos_filter_data + 10, tilt_comp_coeff,
 +                                    subframe_size, *ht_prev_data);
 +}
 +
 +/**
 + * \brief Adaptive gain control (4.2.4)
 + * \param gain_before gain of speech before applying postfilters
 + * \param gain_after  gain of speech after applying postfilters
 + * \param speech [in/out] signal buffer
 + * \param subframe_size length of subframe
 + * \param gain_prev (3.12) previous value of gain coefficient
 + *
 + * \return (3.12) last value of gain coefficient
 + */
 +int16_t ff_g729_adaptive_gain_control(int gain_before, int gain_after, int16_t *speech,
 +                                   int subframe_size, int16_t gain_prev)
 +{
 +    int gain; // (3.12)
 +    int n;
 +    int exp_before, exp_after;
 +
 +    if(!gain_after && gain_before)
 +        return 0;
 +
 +    if (gain_before) {
 +
 +        exp_before  = 14 - av_log2(gain_before);
 +        gain_before = bidir_sal(gain_before, exp_before);
 +
 +        exp_after  = 14 - av_log2(gain_after);
 +        gain_after = bidir_sal(gain_after, exp_after);
 +
 +        if (gain_before < gain_after) {
 +            gain = (gain_before << 15) / gain_after;
 +            gain = bidir_sal(gain, exp_after - exp_before - 1);
 +        } else {
 +            gain = ((gain_before - gain_after) << 14) / gain_after + 0x4000;
 +            gain = bidir_sal(gain, exp_after - exp_before);
 +        }
 +        gain = (gain * G729_AGC_FAC1 + 0x4000) >> 15; // gain * (1-0.9875)
 +    } else
 +        gain = 0;
 +
 +    for (n = 0; n < subframe_size; n++) {
 +        // gain_prev = gain + 0.9875 * gain_prev
 +        gain_prev = (G729_AGC_FACTOR * gain_prev + 0x4000) >> 15;
 +        gain_prev = av_clip_int16(gain + gain_prev);
 +        speech[n] = av_clip_int16((speech[n] * gain_prev + 0x2000) >> 14);
 +    }
 +    return gain_prev;
 +}
index 5239fc8,0000000..89e3e40
mode 100644,000000..100644
--- /dev/null
@@@ -1,116 -1,0 +1,116 @@@
- #include "dsputil.h"
 +/*
 + * G.729, G729 Annex D postfilter
 + * Copyright (c) 2008 Vladimir Voroshilov
 + *
 + * 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
 + * version 2.1 of the License, or (at your option) any later version.
 + *
 + * FFmpeg is distributed in the hope that it will be useful,
 + * but WITHOUT ANY WARRANTY; without even the implied warranty of
 + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 + * Lesser General Public License for more details.
 + *
 + * You should have received a copy of the GNU Lesser General Public
 + * License along with FFmpeg; if not, write to the Free Software
 + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 + */
 +#ifndef FFMPEG_G729POSTFILTER_H
 +#define FFMPEG_G729POSTFILTER_H
 +
 +#include <stdint.h>
- void ff_g729_postfilter(DSPContext *dsp, int16_t* ht_prev_data, int* voicing,
++#include "audiodsp.h"
 +
 +/**
 + * tilt compensation factor (G.729, k1>0)
 + * 0.2 in Q15
 + */
 +#define G729_TILT_FACTOR_PLUS       6554
 +
 +/**
 + * tilt compensation factor (G.729, k1<0)
 + * 0.9 in Q15
 + */
 +#define G729_TILT_FACTOR_MINUS     29491
 +
 +/* 4.2.2 */
 +#define FORMANT_PP_FACTOR_NUM  18022             //0.55 in Q15
 +#define FORMANT_PP_FACTOR_DEN  22938             //0.70 in Q15
 +
 +/**
 + * gain adjustment factor (G.729, 4.2.4)
 + * 0.9875 in Q15
 + */
 +#define G729_AGC_FACTOR            32358
 +#define G729_AGC_FAC1 (32768-G729_AGC_FACTOR)
 +
 +/**
 + * 1.0 / (1.0 + 0.5) in Q15
 + * where 0.5 is the minimum value of
 + * weight factor, controlling amount of long-term postfiltering
 + */
 +#define MIN_LT_FILT_FACTOR_A       21845
 +
 +/**
 + * Short interpolation filter length
 + */
 +#define SHORT_INT_FILT_LEN         2
 +
 +/**
 + * Long interpolation filter length
 + */
 +#define LONG_INT_FILT_LEN          8
 +
 +/**
 + * Number of analyzed fractional pitch delays in second stage of long-term
 + * postfilter
 + */
 +#define ANALYZED_FRAC_DELAYS       7
 +
 +/**
 + * Amount of past residual signal data stored in buffer
 + */
 +#define RES_PREV_DATA_SIZE (PITCH_DELAY_MAX + LONG_INT_FILT_LEN + 1)
 +
 +/**
 + * \brief Signal postfiltering (4.2)
 + * \param dsp initialized DSP context
 + * \param ht_prev_data [in/out] (Q12) pointer to variable receiving tilt
 + *                     compensation filter data from previous subframe
 + * \param voicing [in/out] (Q0) pointer to variable receiving voicing decision
 + * \param lp_filter_coeffs (Q12) LP filter coefficients
 + * \param pitch_delay_int integer part of the pitch delay
 + * \param residual [in/out] (Q0) residual signal buffer (used in long-term postfilter)
 + * \param res_filter_data [in/out] (Q0) speech data of previous subframe
 + * \param pos_filter_data [in/out] (Q0) previous speech data for short-term postfilter
 + * \param speech [in/out] (Q0) signal buffer
 + * \param subframe_size size of subframe
 + *
 + * Filtering has the following  stages:
 + *   Long-term postfilter (4.2.1)
 + *   Short-term postfilter (4.2.2).
 + *   Tilt-compensation (4.2.3)
 + */
++void ff_g729_postfilter(AudioDSPContext *adsp, int16_t* ht_prev_data, int* voicing,
 +                     const int16_t *lp_filter_coeffs, int pitch_delay_int,
 +                     int16_t* residual, int16_t* res_filter_data,
 +                     int16_t* pos_filter_data, int16_t *speech,
 +                     int subframe_size);
 +
 +/**
 + * \brief Adaptive gain control (4.2.4)
 + * \param gain_before (Q0) gain of speech before applying postfilters
 + * \param gain_after  (Q0) gain of speech after applying postfilters
 + * \param speech [in/out] (Q0) signal buffer
 + * \param subframe_size length of subframe
 + * \param gain_prev (Q12) previous value of gain coefficient
 + *
 + * \return (Q12) last value of gain coefficient
 + */
 +int16_t ff_g729_adaptive_gain_control(int gain_before, int gain_after, int16_t *speech,
 +                                   int subframe_size, int16_t gain_prev);
 +
 +#endif // FFMPEG_G729POSTFILTER_H
@@@ -24,8 -25,6 +25,7 @@@ ALTIVEC-OBJS-$(CONFIG_DSPUTIL)         
                                            ppc/fdct_altivec.o            \
                                            ppc/gmc_altivec.o             \
                                            ppc/idct_altivec.o            \
-                                           ppc/int_altivec.o             \
  
  FFT-OBJS-$(HAVE_GNU_AS)                += ppc/fft_altivec_s.o
 +FFT-OBJS-$(HAVE_VSX)                   += ppc/fft_vsx.o
  ALTIVEC-OBJS-$(CONFIG_FFT)             += $(FFT-OBJS-yes)
index 0000000,36506ce..c88c3d9
mode 000000,100644..100644
--- /dev/null
@@@ -1,0 -1,72 +1,72 @@@
 - * This file is part of Libav.
+ /*
+  * Copyright (c) 2007 Luca Barbato <lu_zero@gentoo.org>
+  *
 - * Libav is free software; you can redistribute it and/or
++ * This file is part of FFmpeg.
+  *
 - * Libav is distributed in the hope that it will be useful,
++ * 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
+  * version 2.1 of the License, or (at your option) any later version.
+  *
 - * License along with Libav; if not, write to the Free Software
++ * FFmpeg is distributed in the hope that it will be useful,
+  * but WITHOUT ANY WARRANTY; without even the implied warranty of
+  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+  * Lesser General Public License for more details.
+  *
+  * You should have received a copy of the GNU Lesser General Public
++ * License along with FFmpeg; if not, write to the Free Software
+  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+  */
+ /**
+  * @file
+  * miscellaneous audio operations
+  */
+ #include "config.h"
+ #if HAVE_ALTIVEC_H
+ #include <altivec.h>
+ #endif
+ #include "libavutil/attributes.h"
+ #include "libavutil/cpu.h"
+ #include "libavutil/ppc/cpu.h"
+ #include "libavutil/ppc/types_altivec.h"
+ #include "libavutil/ppc/util_altivec.h"
+ #include "libavcodec/audiodsp.h"
+ #if HAVE_ALTIVEC
+ static int32_t scalarproduct_int16_altivec(const int16_t *v1, const int16_t *v2,
+                                            int order)
+ {
+     int i;
+     LOAD_ZERO;
+     register vec_s16 vec1;
+     register vec_s32 res = vec_splat_s32(0), t;
+     int32_t ires;
+     for (i = 0; i < order; i += 8) {
+         vec1 = vec_unaligned_load(v1);
+         t    = vec_msum(vec1, vec_ld(0, v2), zero_s32v);
+         res  = vec_sums(t, res);
+         v1  += 8;
+         v2  += 8;
+     }
+     res = vec_splat(res, 3);
+     vec_ste(res, 0, &ires);
+     return ires;
+ }
+ #endif /* HAVE_ALTIVEC */
+ av_cold void ff_audiodsp_init_ppc(AudioDSPContext *c)
+ {
+ #if HAVE_ALTIVEC
+     if (!PPC_ALTIVEC(av_get_cpu_flags()))
+         return;
+     c->scalarproduct_int16 = scalarproduct_int16_altivec;
+ #endif /* HAVE_ALTIVEC */
+ }
Simple merge
  av_cold void ff_dsputil_init_ppc(DSPContext *c, AVCodecContext *avctx,
                                   unsigned high_bit_depth)
  {
 -    if (PPC_ALTIVEC(av_get_cpu_flags())) {
 +    int mm_flags = av_get_cpu_flags();
 +    if (PPC_ALTIVEC(mm_flags)) {
          ff_dsputil_init_altivec(c, avctx, high_bit_depth);
-         ff_int_init_altivec(c, avctx);
          c->gmc1 = ff_gmc1_altivec;
  
          if (!high_bit_depth) {
@@@ -1681,9 -1674,12 +1681,9 @@@ unsigned int ff_rescale_rms(unsigned in
  }
  
  /** inverse root mean square */
- int ff_irms(DSPContext *dsp, const int16_t *data)
 -int ff_irms(const int16_t *data)
++int ff_irms(AudioDSPContext *adsp, const int16_t *data)
  {
-     unsigned int sum = dsp->scalarproduct_int16(data, data, BLOCKSIZE);
 -    unsigned int i, sum = 0;
 -
 -    for (i=0; i < BLOCKSIZE; i++)
 -        sum += data[i] * data[i];
++    unsigned int sum = adsp->scalarproduct_int16(data, data, BLOCKSIZE);
  
      if (sum == 0)
          return 0; /* OOPS - division by zero */
@@@ -1700,8 -1697,8 +1700,8 @@@ void ff_subblock_synthesis(RA144Contex
  
      if (cba_idx) {
          cba_idx += BLOCKSIZE/2 - 1;
 -        ff_copy_and_dup(buffer_a, ractx->adapt_cb, cba_idx);
 -        m[0] = (ff_irms(buffer_a) * gval) >> 12;
 +        ff_copy_and_dup(ractx->buffer_a, ractx->adapt_cb, cba_idx);
-         m[0] = (ff_irms(&ractx->dsp, ractx->buffer_a) * gval) >> 12;
++        m[0] = (ff_irms(&ractx->adsp, ractx->buffer_a) * gval) >> 12;
      } else {
          m[0] = 0;
      }
@@@ -25,7 -25,6 +25,7 @@@
  #include <stdint.h>
  #include "lpc.h"
  #include "audio_frame_queue.h"
- #include "dsputil.h"
++#include "audiodsp.h"
  
  #define NBLOCKS         4       ///< number of subblocks within a block
  #define BLOCKSIZE       40      ///< subblock size in 16-bit words
@@@ -36,7 -35,6 +36,7 @@@
  
  typedef struct RA144Context {
      AVCodecContext *avctx;
-     DSPContext dsp;
++    AudioDSPContext adsp;
      LPCContext lpc_ctx;
      AudioFrameQueue afq;
      int last_frame;
@@@ -72,8 -68,8 +72,8 @@@ unsigned int ff_rms(const int *data)
  int ff_interp(RA144Context *ractx, int16_t *out, int a, int copyold,
                int energy);
  unsigned int ff_rescale_rms(unsigned int rms, unsigned int energy);
- int ff_irms(DSPContext *dsp, const int16_t *data/*align 16*/);
 -int ff_irms(const int16_t *data);
 -void ff_subblock_synthesis(RA144Context *ractx, const uint16_t *lpc_coefs,
++int ff_irms(AudioDSPContext *adsp, const int16_t *data/*align 16*/);
 +void ff_subblock_synthesis(RA144Context *ractx, const int16_t *lpc_coefs,
                             int cba_idx, int cb1_idx, int cb2_idx,
                             int gval, int gain);
  
@@@ -34,7 -34,6 +34,7 @@@ static av_cold int ra144_decode_init(AV
      RA144Context *ractx = avctx->priv_data;
  
      ractx->avctx = avctx;
-     ff_dsputil_init(&ractx->dsp, avctx);
++    ff_audiodsp_init(&ractx->adsp);
  
      ractx->lpc_coef[0] = ractx->lpc_tables[0];
      ractx->lpc_coef[1] = ractx->lpc_tables[1];
@@@ -61,7 -62,6 +61,7 @@@ static av_cold int ra144_encode_init(AV
      ractx->lpc_coef[0] = ractx->lpc_tables[0];
      ractx->lpc_coef[1] = ractx->lpc_tables[1];
      ractx->avctx = avctx;
-     ff_dsputil_init(&ractx->dsp, avctx);
++    ff_audiodsp_init(&ractx->adsp);
      ret = ff_lpc_init(&ractx->lpc_ctx, avctx->frame_size, LPC_ORDER,
                        FF_LPC_TYPE_LEVINSON);
      if (ret < 0)
@@@ -373,8 -373,8 +373,8 @@@ static void ra144_encode_subblock(RA144
           */
          memcpy(cba, work + LPC_ORDER, sizeof(cba));
  
 -        ff_copy_and_dup(cba_vect, ractx->adapt_cb, cba_idx + BLOCKSIZE / 2 - 1);
 -        m[0] = (ff_irms(cba_vect) * rms) >> 12;
 +        ff_copy_and_dup(ractx->buffer_a, ractx->adapt_cb, cba_idx + BLOCKSIZE / 2 - 1);
-         m[0] = (ff_irms(&ractx->dsp, ractx->buffer_a) * rms) >> 12;
++        m[0] = (ff_irms(&ractx->adsp, ractx->buffer_a) * rms) >> 12;
      }
      fixed_cb_search(work + LPC_ORDER, coefs, data, cba_idx, &cb1_idx, &cb2_idx);
      for (i = 0; i < BLOCKSIZE; i++) {
@@@ -28,9 -28,8 +28,9 @@@
  #include "libavutil/internal.h"
  #include "libavutil/samplefmt.h"
  #include "tak.h"
+ #include "audiodsp.h"
 +#include "thread.h"
  #include "avcodec.h"
- #include "dsputil.h"
  #include "internal.h"
  #include "unary.h"
  
@@@ -45,31 -44,27 +45,31 @@@ typedef struct MCDParam 
  } MCDParam;
  
  typedef struct TAKDecContext {
 -    AVCodecContext *avctx;                          // parent AVCodecContext
 +    AVCodecContext *avctx;                          ///< parent AVCodecContext
-     DSPContext      dsp;
+     AudioDSPContext adsp;
      TAKStreamInfo   ti;
 -    GetBitContext   gb;                             // bitstream reader initialized to start at the current frame
 +    GetBitContext   gb;                             ///< bitstream reader initialized to start at the current frame
  
      int             uval;
 -    int             nb_samples;                     // number of samples in the current frame
 +    int             nb_samples;                     ///< number of samples in the current frame
      uint8_t        *decode_buffer;
      unsigned int    decode_buffer_size;
 -    int32_t        *decoded[TAK_MAX_CHANNELS];      // decoded samples for each channel
 +    int32_t        *decoded[TAK_MAX_CHANNELS];      ///< decoded samples for each channel
  
      int8_t          lpc_mode[TAK_MAX_CHANNELS];
 -    int8_t          sample_shift[TAK_MAX_CHANNELS]; // shift applied to every sample in the channel
 +    int8_t          sample_shift[TAK_MAX_CHANNELS]; ///< shift applied to every sample in the channel
 +    int16_t         predictors[MAX_PREDICTORS];
 +    int             nb_subframes;                   ///< number of subframes in the current frame
 +    int16_t         subframe_len[MAX_SUBFRAMES];    ///< subframe length in samples
      int             subframe_scale;
  
 -    int8_t          dmode;                          // channel decorrelation type in the current frame
 +    int8_t          dmode;                          ///< channel decorrelation type in the current frame
  
 -    MCDParam        mcdparams[TAK_MAX_CHANNELS];    // multichannel decorrelation parameters
 +    MCDParam        mcdparams[TAK_MAX_CHANNELS];    ///< multichannel decorrelation parameters
  
 -    int16_t        *residues;
 -    unsigned int    residues_buf_size;
 +    int8_t          coding_mode[128];
 +    DECLARE_ALIGNED(16, int16_t, filter)[MAX_PREDICTORS];
 +    DECLARE_ALIGNED(16, int16_t, residues)[544];
  } TAKDecContext;
  
  static const int8_t mc_dmodes[] = { 1, 3, 4, 6, };
@@@ -171,10 -172,9 +171,10 @@@ static av_cold int tak_decode_init(AVCo
  {
      TAKDecContext *s = avctx->priv_data;
  
-     ff_dsputil_init(&s->dsp, avctx);
+     ff_audiodsp_init(&s->adsp);
  
      s->avctx = avctx;
 +    avctx->bits_per_raw_sample = avctx->bits_per_coded_sample;
  
      set_sample_rate_params(avctx);
  
@@@ -460,31 -475,21 +460,31 @@@ static int decode_subframe(TAKDecContex
      for (i = 0; i < filter_order; i++)
          s->residues[i] = *decoded++ >> dshift;
  
 -    for (i = 0; i < subframe_size - filter_order; i++) {
 -        int v = 1 << (filter_quant - 1);
 -
 -        v += s->adsp.scalarproduct_int16(&s->residues[i], filter,
 -                                         FFALIGN(filter_order, 16));
 +    y    = FF_ARRAY_ELEMS(s->residues) - filter_order;
 +    x    = subframe_size - filter_order;
 +    while (x > 0) {
 +        tmp = FFMIN(y, x);
 +
 +        for (i = 0; i < tmp; i++) {
 +            int v = 1 << (filter_quant - 1);
 +
 +            if (filter_order & -16)
-                 v += s->dsp.scalarproduct_int16(&s->residues[i], s->filter,
-                                                 filter_order & -16);
++                v += s->adsp.scalarproduct_int16(&s->residues[i], s->filter,
++                                                 filter_order & -16);
 +            for (j = filter_order & -16; j < filter_order; j += 4) {
 +                v += s->residues[i + j + 3] * s->filter[j + 3] +
 +                     s->residues[i + j + 2] * s->filter[j + 2] +
 +                     s->residues[i + j + 1] * s->filter[j + 1] +
 +                     s->residues[i + j    ] * s->filter[j    ];
 +            }
 +            v = (av_clip(v >> filter_quant, -8192, 8191) << dshift) - *decoded;
 +            *decoded++ = v;
 +            s->residues[filter_order + i] = v >> dshift;
 +        }
  
 -        v = (av_clip(v >> filter_quant, -8192, 8191) << dshift) - *decoded;
 -        *decoded++ = v;
 -        s->residues[filter_order + i] = v >> dshift;
 +        x -= tmp;
 +        if (x > 0)
 +            memcpy(s->residues, &s->residues[y], 2 * filter_order);
      }
  
      emms_c();
@@@ -624,40 -640,24 +624,40 @@@ static int decorrelate(TAKDecContext *s
              }
          }
  
 -        av_fast_malloc(&s->residues, &s->residues_buf_size,
 -                       FFALIGN(length + 16, 16) * sizeof(*s->residues));
 -        if (!s->residues)
 -            return AVERROR(ENOMEM);
 -        memset(s->residues, 0, s->residues_buf_size);
  
 -        for (i = 0; i < length; i++)
 -            s->residues[i] = p2[i] >> dshift;
 +        for (i = 0; i < filter_order; i++)
 +            s->residues[i] = *p2++ >> dshift;
  
          p1 += order_half;
-                     v += s->dsp.scalarproduct_int16(&s->residues[i], s->filter,
-                                                     filter_order);
 +        x = FF_ARRAY_ELEMS(s->residues) - filter_order;
 +        for (; length2 > 0; length2 -= tmp) {
 +            tmp = FFMIN(length2, x);
 +
 +            for (i = 0; i < tmp; i++)
 +                s->residues[filter_order + i] = *p2++ >> dshift;
 +
 +            for (i = 0; i < tmp; i++) {
 +                int v = 1 << 9;
 +
 +                if (filter_order == 16) {
++                    v += s->adsp.scalarproduct_int16(&s->residues[i], s->filter,
++                                                     filter_order);
 +                } else {
 +                    v += s->residues[i + 7] * s->filter[7] +
 +                         s->residues[i + 6] * s->filter[6] +
 +                         s->residues[i + 5] * s->filter[5] +
 +                         s->residues[i + 4] * s->filter[4] +
 +                         s->residues[i + 3] * s->filter[3] +
 +                         s->residues[i + 2] * s->filter[2] +
 +                         s->residues[i + 1] * s->filter[1] +
 +                         s->residues[i    ] * s->filter[0];
 +                }
  
 -        for (i = 0; i < length2; i++) {
 -            int v = 1 << 9;
 -
 -            v += s->adsp.scalarproduct_int16(&s->residues[i], filter,
 -                                             FFALIGN(filter_order, 16));
 +                v = (av_clip(v >> 10, -8192, 8191) << dshift) - *p1;
 +                *p1++ = v;
 +            }
  
 -            p1[i] = (av_clip(v >> 10, -8192, 8191) << dshift) - p1[i];
 +            memcpy(s->residues, &s->residues[tmp], 2 * filter_order);
          }
  
          emms_c();
@@@ -2,7 -2,7 +2,8 @@@ OBJS                                   
                                            x86/fmtconvert_init.o         \
  
  OBJS-$(CONFIG_AC3DSP)                  += x86/ac3dsp_init.o
+ OBJS-$(CONFIG_AUDIODSP)                += x86/audiodsp_init.o
 +OBJS-$(CONFIG_BLOCKDSP)                += x86/blockdsp_mmx.o
  OBJS-$(CONFIG_DCT)                     += x86/dct_init.o
  OBJS-$(CONFIG_DSPUTIL)                 += x86/dsputil_init.o
  OBJS-$(CONFIG_ENCODERS)                += x86/dsputilenc_mmx.o          \
@@@ -69,10 -63,8 +70,11 @@@ YASM-OBJS                              
                                            x86/fmtconvert.o              \
  
  YASM-OBJS-$(CONFIG_AC3DSP)             += x86/ac3dsp.o
+ YASM-OBJS-$(CONFIG_AUDIODSP)           += x86/audiodsp.o
 +YASM-OBJS-$(CONFIG_BLOCKDSP)           += x86/blockdsp.o
  YASM-OBJS-$(CONFIG_DCT)                += x86/dct32.o
 +YASM-OBJS-$(CONFIG_DIRAC_DECODER)      += x86/diracdsp_mmx.o x86/diracdsp_yasm.o\
 +                                          x86/dwt_yasm.o
  YASM-OBJS-$(CONFIG_DNXHD_ENCODER)      += x86/dnxhdenc.o
  YASM-OBJS-$(CONFIG_DSPUTIL)            += x86/dsputil.o
  YASM-OBJS-$(CONFIG_ENCODERS)           += x86/dsputilenc.o
index 0000000,f2e831d..83f9bb6
mode 000000,100644..100644
--- /dev/null
@@@ -1,0 -1,137 +1,133 @@@
 -;* This file is part of Libav.
+ ;******************************************************************************
+ ;* optimized audio functions
+ ;* Copyright (c) 2008 Loren Merritt
+ ;*
 -;* Libav is free software; you can redistribute it and/or
++;* This file is part of FFmpeg.
+ ;*
 -;* Libav is distributed in the hope that it will be useful,
++;* 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
+ ;* version 2.1 of the License, or (at your option) any later version.
+ ;*
 -;* License along with Libav; if not, write to the Free Software
++;* FFmpeg is distributed in the hope that it will be useful,
+ ;* but WITHOUT ANY WARRANTY; without even the implied warranty of
+ ;* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ ;* Lesser General Public License for more details.
+ ;*
+ ;* You should have received a copy of the GNU Lesser General Public
 -%if mmsize == 16
 -    movhlps m0, m2
 -    paddd   m2, m0
 -    pshuflw m0, m2, 0x4e
 -%else
 -    pshufw  m0, m2, 0x4e
 -%endif
 -    paddd   m2, m0
++;* License along with FFmpeg; if not, write to the Free Software
+ ;* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ ;******************************************************************************
+ %include "libavutil/x86/x86util.asm"
+ SECTION_TEXT
+ %macro SCALARPRODUCT 0
+ ; int ff_scalarproduct_int16(int16_t *v1, int16_t *v2, int order)
+ cglobal scalarproduct_int16, 3,3,3, v1, v2, order
+     shl orderq, 1
+     add v1q, orderq
+     add v2q, orderq
+     neg orderq
+     pxor    m2, m2
+ .loop:
+     movu    m0, [v1q + orderq]
+     movu    m1, [v1q + orderq + mmsize]
+     pmaddwd m0, [v2q + orderq]
+     pmaddwd m1, [v2q + orderq + mmsize]
+     paddd   m2, m0
+     paddd   m2, m1
+     add     orderq, mmsize*2
+     jl .loop
 -%assign %%i 1
++    HADDD   m2, m0
+     movd   eax, m2
++%if mmsize == 8
++    emms
++%endif
+     RET
+ %endmacro
+ INIT_MMX mmxext
+ SCALARPRODUCT
+ INIT_XMM sse2
+ SCALARPRODUCT
+ ;-----------------------------------------------------------------------------
+ ; void ff_vector_clip_int32(int32_t *dst, const int32_t *src, int32_t min,
+ ;                           int32_t max, unsigned int len)
+ ;-----------------------------------------------------------------------------
+ ; %1 = number of xmm registers used
+ ; %2 = number of inline load/process/store loops per asm loop
+ ; %3 = process 4*mmsize (%3=0) or 8*mmsize (%3=1) bytes per loop
+ ; %4 = CLIPD function takes min/max as float instead of int (CLIPD_SSE2)
+ ; %5 = suffix
+ %macro VECTOR_CLIP_INT32 4-5
+ cglobal vector_clip_int32%5, 5,5,%1, dst, src, min, max, len
+ %if %4
+     cvtsi2ss  m4, minm
+     cvtsi2ss  m5, maxm
+ %else
+     movd      m4, minm
+     movd      m5, maxm
+ %endif
+     SPLATD    m4
+     SPLATD    m5
+ .loop:
 -    mova      m0,  [srcq+mmsize*0*%%i]
 -    mova      m1,  [srcq+mmsize*1*%%i]
 -    mova      m2,  [srcq+mmsize*2*%%i]
 -    mova      m3,  [srcq+mmsize*3*%%i]
++%assign %%i 0
+ %rep %2
 -    mova      m7,  [srcq+mmsize*4*%%i]
 -    mova      m8,  [srcq+mmsize*5*%%i]
 -    mova      m9,  [srcq+mmsize*6*%%i]
 -    mova      m10, [srcq+mmsize*7*%%i]
++    mova      m0,  [srcq+mmsize*(0+%%i)]
++    mova      m1,  [srcq+mmsize*(1+%%i)]
++    mova      m2,  [srcq+mmsize*(2+%%i)]
++    mova      m3,  [srcq+mmsize*(3+%%i)]
+ %if %3
 -    mova  [dstq+mmsize*0*%%i], m0
 -    mova  [dstq+mmsize*1*%%i], m1
 -    mova  [dstq+mmsize*2*%%i], m2
 -    mova  [dstq+mmsize*3*%%i], m3
++    mova      m7,  [srcq+mmsize*(4+%%i)]
++    mova      m8,  [srcq+mmsize*(5+%%i)]
++    mova      m9,  [srcq+mmsize*(6+%%i)]
++    mova      m10, [srcq+mmsize*(7+%%i)]
+ %endif
+     CLIPD  m0,  m4, m5, m6
+     CLIPD  m1,  m4, m5, m6
+     CLIPD  m2,  m4, m5, m6
+     CLIPD  m3,  m4, m5, m6
+ %if %3
+     CLIPD  m7,  m4, m5, m6
+     CLIPD  m8,  m4, m5, m6
+     CLIPD  m9,  m4, m5, m6
+     CLIPD  m10, m4, m5, m6
+ %endif
 -    mova  [dstq+mmsize*4*%%i], m7
 -    mova  [dstq+mmsize*5*%%i], m8
 -    mova  [dstq+mmsize*6*%%i], m9
 -    mova  [dstq+mmsize*7*%%i], m10
++    mova  [dstq+mmsize*(0+%%i)], m0
++    mova  [dstq+mmsize*(1+%%i)], m1
++    mova  [dstq+mmsize*(2+%%i)], m2
++    mova  [dstq+mmsize*(3+%%i)], m3
+ %if %3
 -%assign %%i %%i+1
++    mova  [dstq+mmsize*(4+%%i)], m7
++    mova  [dstq+mmsize*(5+%%i)], m8
++    mova  [dstq+mmsize*(6+%%i)], m9
++    mova  [dstq+mmsize*(7+%%i)], m10
+ %endif
++%assign %%i %%i+4*(%3+1)
+ %endrep
+     add     srcq, mmsize*4*(%2+%3)
+     add     dstq, mmsize*4*(%2+%3)
+     sub     lend, mmsize*(%2+%3)
+     jg .loop
+     REP_RET
+ %endmacro
+ INIT_MMX mmx
+ %define CLIPD CLIPD_MMX
+ VECTOR_CLIP_INT32 0, 1, 0, 0
+ INIT_XMM sse2
+ VECTOR_CLIP_INT32 6, 1, 0, 0, _int
+ %define CLIPD CLIPD_SSE2
+ VECTOR_CLIP_INT32 6, 2, 0, 1
+ INIT_XMM sse4
+ %define CLIPD CLIPD_SSE41
+ %ifdef m8
+ VECTOR_CLIP_INT32 11, 1, 1, 0
+ %else
+ VECTOR_CLIP_INT32 6, 1, 0, 0
+ %endif
index 0000000,321056b..35f9f14
mode 000000,100644..100644
--- /dev/null
@@@ -1,0 -1,25 +1,25 @@@
 - * This file is part of Libav.
+ /*
 - * Libav is free software; you can redistribute it and/or
++ * This file is part of FFmpeg.
+  *
 - * Libav is distributed in the hope that it will be useful,
++ * 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
+  * version 2.1 of the License, or (at your option) any later version.
+  *
 - * License along with Libav; if not, write to the Free Software
++ * FFmpeg is distributed in the hope that it will be useful,
+  * but WITHOUT ANY WARRANTY; without even the implied warranty of
+  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+  * Lesser General Public License for more details.
+  *
+  * You should have received a copy of the GNU Lesser General Public
++ * License along with FFmpeg; if not, write to the Free Software
+  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+  */
+ #ifndef AVCODEC_X86_AUDIODSP_H
+ #define AVCODEC_X86_AUDIODSP_H
+ void ff_vector_clipf_sse(float *dst, const float *src,
+                          float min, float max, int len);
+ #endif /* AVCODEC_X86_AUDIODSP_H */
index 0000000,743f5a3..d586bf6
mode 000000,100644..100644
--- /dev/null
@@@ -1,0 -1,66 +1,66 @@@
 - * This file is part of Libav.
+ /*
 - * Libav is free software; you can redistribute it and/or
++ * This file is part of FFmpeg.
+  *
 - * Libav is distributed in the hope that it will be useful,
++ * 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
+  * version 2.1 of the License, or (at your option) any later version.
+  *
 - * License along with Libav; if not, write to the Free Software
++ * FFmpeg is distributed in the hope that it will be useful,
+  * but WITHOUT ANY WARRANTY; without even the implied warranty of
+  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+  * Lesser General Public License for more details.
+  *
+  * You should have received a copy of the GNU Lesser General Public
 -    if (INLINE_SSE(cpu_flags))
++ * License along with FFmpeg; if not, write to the Free Software
+  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+  */
+ #include <stdint.h>
+ #include "config.h"
+ #include "libavutil/attributes.h"
+ #include "libavutil/cpu.h"
+ #include "libavutil/x86/asm.h"
+ #include "libavutil/x86/cpu.h"
+ #include "libavcodec/audiodsp.h"
+ #include "audiodsp.h"
+ int32_t ff_scalarproduct_int16_mmxext(const int16_t *v1, const int16_t *v2,
+                                       int order);
+ int32_t ff_scalarproduct_int16_sse2(const int16_t *v1, const int16_t *v2,
+                                     int order);
+ void ff_vector_clip_int32_mmx(int32_t *dst, const int32_t *src,
+                               int32_t min, int32_t max, unsigned int len);
+ void ff_vector_clip_int32_sse2(int32_t *dst, const int32_t *src,
+                                int32_t min, int32_t max, unsigned int len);
+ void ff_vector_clip_int32_int_sse2(int32_t *dst, const int32_t *src,
+                                    int32_t min, int32_t max, unsigned int len);
+ void ff_vector_clip_int32_sse4(int32_t *dst, const int32_t *src,
+                                int32_t min, int32_t max, unsigned int len);
+ av_cold void ff_audiodsp_init_x86(AudioDSPContext *c)
+ {
+     int cpu_flags = av_get_cpu_flags();
+     if (EXTERNAL_MMX(cpu_flags))
+         c->vector_clip_int32 = ff_vector_clip_int32_mmx;
+     if (EXTERNAL_MMXEXT(cpu_flags))
+         c->scalarproduct_int16 = ff_scalarproduct_int16_mmxext;
++    if (EXTERNAL_SSE(cpu_flags))
+         c->vector_clipf = ff_vector_clipf_sse;
+     if (EXTERNAL_SSE2(cpu_flags)) {
+         c->scalarproduct_int16 = ff_scalarproduct_int16_sse2;
+         if (cpu_flags & AV_CPU_FLAG_ATOM)
+             c->vector_clip_int32 = ff_vector_clip_int32_int_sse2;
+         else
+             c->vector_clip_int32 = ff_vector_clip_int32_sse2;
+     }
+     if (EXTERNAL_SSE4(cpu_flags))
+         c->vector_clip_int32 = ff_vector_clip_int32_sse4;
+ }
  SECTION_RODATA
  pb_bswap32: db 3, 2, 1, 0, 7, 6, 5, 4, 11, 10, 9, 8, 15, 14, 13, 12
  
 +cextern pb_80
 +
  SECTION_TEXT
  
- %macro SCALARPRODUCT 0
- ; int ff_scalarproduct_int16(int16_t *v1, int16_t *v2, int order)
- cglobal scalarproduct_int16, 3,3,3, v1, v2, order
-     shl orderq, 1
-     add v1q, orderq
-     add v2q, orderq
-     neg orderq
-     pxor    m2, m2
- .loop:
-     movu    m0, [v1q + orderq]
-     movu    m1, [v1q + orderq + mmsize]
-     pmaddwd m0, [v2q + orderq]
-     pmaddwd m1, [v2q + orderq + mmsize]
-     paddd   m2, m0
-     paddd   m2, m1
-     add     orderq, mmsize*2
-     jl .loop
-     HADDD   m2, m0
-     movd   eax, m2
- %if mmsize == 8
-     emms
- %endif
-     RET
- %endmacro
- INIT_MMX mmxext
- SCALARPRODUCT
- INIT_XMM sse2
- SCALARPRODUCT
- ;-----------------------------------------------------------------------------
- ; void ff_vector_clip_int32(int32_t *dst, const int32_t *src, int32_t min,
- ;                           int32_t max, unsigned int len)
- ;-----------------------------------------------------------------------------
- ; %1 = number of xmm registers used
- ; %2 = number of inline load/process/store loops per asm loop
- ; %3 = process 4*mmsize (%3=0) or 8*mmsize (%3=1) bytes per loop
- ; %4 = CLIPD function takes min/max as float instead of int (CLIPD_SSE2)
- ; %5 = suffix
- %macro VECTOR_CLIP_INT32 4-5
- cglobal vector_clip_int32%5, 5,5,%1, dst, src, min, max, len
- %if %4
-     cvtsi2ss  m4, minm
-     cvtsi2ss  m5, maxm
- %else
-     movd      m4, minm
-     movd      m5, maxm
- %endif
-     SPLATD    m4
-     SPLATD    m5
- .loop:
- %assign %%i 0
- %rep %2
-     mova      m0,  [srcq+mmsize*(0+%%i)]
-     mova      m1,  [srcq+mmsize*(1+%%i)]
-     mova      m2,  [srcq+mmsize*(2+%%i)]
-     mova      m3,  [srcq+mmsize*(3+%%i)]
- %if %3
-     mova      m7,  [srcq+mmsize*(4+%%i)]
-     mova      m8,  [srcq+mmsize*(5+%%i)]
-     mova      m9,  [srcq+mmsize*(6+%%i)]
-     mova      m10, [srcq+mmsize*(7+%%i)]
- %endif
-     CLIPD  m0,  m4, m5, m6
-     CLIPD  m1,  m4, m5, m6
-     CLIPD  m2,  m4, m5, m6
-     CLIPD  m3,  m4, m5, m6
- %if %3
-     CLIPD  m7,  m4, m5, m6
-     CLIPD  m8,  m4, m5, m6
-     CLIPD  m9,  m4, m5, m6
-     CLIPD  m10, m4, m5, m6
- %endif
-     mova  [dstq+mmsize*(0+%%i)], m0
-     mova  [dstq+mmsize*(1+%%i)], m1
-     mova  [dstq+mmsize*(2+%%i)], m2
-     mova  [dstq+mmsize*(3+%%i)], m3
- %if %3
-     mova  [dstq+mmsize*(4+%%i)], m7
-     mova  [dstq+mmsize*(5+%%i)], m8
-     mova  [dstq+mmsize*(6+%%i)], m9
-     mova  [dstq+mmsize*(7+%%i)], m10
- %endif
- %assign %%i %%i+4*(%3+1)
- %endrep
-     add     srcq, mmsize*4*(%2+%3)
-     add     dstq, mmsize*4*(%2+%3)
-     sub     lend, mmsize*(%2+%3)
-     jg .loop
-     REP_RET
- %endmacro
- INIT_MMX mmx
- %define CLIPD CLIPD_MMX
- VECTOR_CLIP_INT32 0, 1, 0, 0
- INIT_XMM sse2
- VECTOR_CLIP_INT32 6, 1, 0, 0, _int
- %define CLIPD CLIPD_SSE2
- VECTOR_CLIP_INT32 6, 2, 0, 1
- INIT_XMM sse4
- %define CLIPD CLIPD_SSE41
- %ifdef m8
- VECTOR_CLIP_INT32 11, 1, 1, 0
- %else
- VECTOR_CLIP_INT32 6, 1, 0, 0
- %endif
  ; %1 = aligned/unaligned
  %macro BSWAP_LOOPS  1
      mov      r3, r2
@@@ -75,15 -56,8 +61,14 @@@ static av_cold void dsputil_init_mmx(DS
          }
      }
  
 +#if CONFIG_VIDEODSP && (ARCH_X86_32 || !HAVE_YASM)
      c->gmc = ff_gmc_mmx;
 +#endif
  #endif /* HAVE_MMX_INLINE */
-     c->vector_clip_int32 = ff_vector_clip_int32_mmx;
 +
 +#if HAVE_MMX_EXTERNAL
 +    c->put_signed_pixels_clamped = ff_put_signed_pixels_clamped_mmx;
 +#endif /* HAVE_MMX_EXTERNAL */
  }
  
  static av_cold void dsputil_init_mmxext(DSPContext *c, AVCodecContext *avctx,
          c->idct     = ff_idct_xvid_mmxext;
      }
  #endif /* HAVE_MMXEXT_INLINE */
- #if HAVE_MMXEXT_EXTERNAL
-     c->scalarproduct_int16          = ff_scalarproduct_int16_mmxext;
- #endif /* HAVE_MMXEXT_EXTERNAL */
  }
  
- #if HAVE_SSE_EXTERNAL
-     c->vector_clipf = ff_vector_clipf_sse;
- #endif
 +static av_cold void dsputil_init_sse(DSPContext *c, AVCodecContext *avctx,
 +                                     int cpu_flags, unsigned high_bit_depth)
 +{
 +#if HAVE_YASM
 +#if HAVE_INLINE_ASM && CONFIG_VIDEODSP
 +    c->gmc = ff_gmc_sse;
 +#endif
 +#endif /* HAVE_YASM */
 +}
 +
  static av_cold void dsputil_init_sse2(DSPContext *c, AVCodecContext *avctx,
                                        int cpu_flags, unsigned high_bit_depth)
  {
  #endif /* HAVE_SSE2_INLINE */
  
  #if HAVE_SSE2_EXTERNAL
-     c->scalarproduct_int16          = ff_scalarproduct_int16_sse2;
-     if (cpu_flags & AV_CPU_FLAG_ATOM) {
-         c->vector_clip_int32 = ff_vector_clip_int32_int_sse2;
-     } else {
-         c->vector_clip_int32 = ff_vector_clip_int32_sse2;
-     }
      c->bswap_buf = ff_bswap32_buf_sse2;
 +    c->put_signed_pixels_clamped = ff_put_signed_pixels_clamped_sse2;
  #endif /* HAVE_SSE2_EXTERNAL */
  }
  
   */
  
  #include "config.h"
 +#include "libavutil/avassert.h"
  #include "libavutil/cpu.h"
  #include "libavutil/x86/asm.h"
- #include "constants.h"
 +#include "libavcodec/pixels.h"
 +#include "libavcodec/videodsp.h"
  #include "dsputil_x86.h"
  #include "inline_asm.h"
  
@@@ -48,16 -46,4 +48,12 @@@ void ff_gmc_mmx(uint8_t *dst, uint8_t *
                  int dxx, int dxy, int dyx, int dyy,
                  int shift, int r, int width, int height);
  
- void ff_vector_clipf_sse(float *dst, const float *src,
-                          float min, float max, int len);
 +void ff_gmc_sse(uint8_t *dst, uint8_t *src,
 +                int stride, int h, int ox, int oy,
 +                int dxx, int dxy, int dyx, int dyy,
 +                int shift, int r, int width, int height);
 +
 +void ff_mmx_idct(int16_t *block);
 +void ff_mmxext_idct(int16_t *block);
 +
  #endif /* AVCODEC_X86_DSPUTIL_X86_H */