Move shared tables to aactab.c and add declarations to aactab.h. Also sync with

[ffmpeg] / libavcodec / acelp_filters.c

diff --git a/libavcodec/acelp_filters.c b/libavcodec/acelp_filters.c
index b98c6f741eec1765413c287abf0d82db99ebdbf6..8b4ed443fb7af8e43d297d7a6cf61d77ee558805 100644 (file)
--- a/libavcodec/acelp_filters.c
+++ b/libavcodec/acelp_filters.c
@@ -27,6 +27,60 @@
 #define FRAC_BITS 13
 #include "mathops.h"
 
+const int16_t ff_acelp_interp_filter[61] =
+{ /* (0.15) */
+  29443, 28346, 25207, 20449, 14701,  8693,
+   3143, -1352, -4402, -5865, -5850, -4673,
+  -2783,  -672,  1211,  2536,  3130,  2991,
+   2259,  1170,     0, -1001, -1652, -1868,
+  -1666, -1147,  -464,   218,   756,  1060,
+   1099,   904,   550,   135,  -245,  -514,
+   -634,  -602,  -451,  -231,     0,   191,
+    308,   340,   296,   198,    78,   -36,
+   -120,  -163,  -165,  -132,   -79,   -19,
+     34,    73,    91,    89,    70,    38,
+      0,
+};
+
+void ff_acelp_interpolate(
+        int16_t* out,
+        const int16_t* in,
+        const int16_t* filter_coeffs,
+        int precision,
+        int pitch_delay_frac,
+        int filter_length,
+        int length)
+{
+    int n, i;
+
+    assert(pitch_delay_frac >= 0 && pitch_delay_frac < precision);
+
+    for(n=0; n<length; n++)
+    {
+        int idx = 0;
+        int v = 0x4000;
+
+        for(i=0; i<filter_length;)
+        {
+
+            /* The reference G.729 and AMR fixed point code performs clipping after
+               each of the two following accumulations.
+               Since clipping affects only the synthetic OVERFLOW test without
+               causing an int type overflow, it was moved outside the loop. */
+
+            /*  R(x):=ac_v[-k+x]
+                v += R(n-i)*ff_acelp_interp_filter(t+6i)
+                v += R(n+i+1)*ff_acelp_interp_filter(6-t+6i) */
+
+            v += in[n + i] * filter_coeffs[idx + pitch_delay_frac];
+            idx += precision;
+            i++;
+            v += in[n - i] * filter_coeffs[idx - pitch_delay_frac];
+        }
+        out[n] = av_clip_int16(v >> 15);
+    }
+}
+
 void ff_acelp_convolve_circ(
         int16_t* fc_out,
         const int16_t* fc_in,
@@ -37,13 +91,12 @@ void ff_acelp_convolve_circ(
 
     memset(fc_out, 0, subframe_size * sizeof(int16_t));
 
-    /* Since there are few pulses over entire subframe (i.e. almost all
-       fc_in[i] are zero, in case of G.729D the buffer contains two non-zero
-       samples before the call to ff_acelp_enhance_harmonics, and (due to
-       pitch_delay bounded to [20; 143]) a maximum four non-zero samples
-       for a total of 40 after the call to it), it is faster to swap two loops
-       and process non-zero samples only. This will reduce the number of
-       multiplications from 40*40 to 4*40 for G.729D */
+    /* Since there are few pulses over an entire subframe (i.e. almost
+       all fc_in[i] are zero) it is faster to swap two loops and process
+       non-zero samples only. In the case of G.729D the buffer contains
+       two non-zero samples before the call to ff_acelp_enhance_harmonics
+       and, due to pitch_delay being bounded by [20; 143], a maximum
+       of four non-zero samples for a total of 40 after the call. */
     for(i=0; i<subframe_size; i++)
     {
         if(fc_in[i])
@@ -63,13 +116,18 @@ int ff_acelp_lp_synthesis_filter(
         const int16_t* in,
         int buffer_length,
         int filter_length,
-        int stop_on_overflow)
+        int stop_on_overflow,
+        int rounder)
 {
     int i,n;
 
+    // These two lines are to avoid a -1 subtraction in the main loop
+    filter_length++;
+    filter_coeffs--;
+
     for(n=0; n<buffer_length; n++)
     {
-        int sum = 0x800;
+        int sum = rounder;
         for(i=1; i<filter_length; i++)
             sum -= filter_coeffs[i] * out[n-i];