cosmetics: rename some functions from *get_* to *decode_*

[ffmpeg] / libavcodec / acelp_filters.c

diff --git a/libavcodec/acelp_filters.c b/libavcodec/acelp_filters.c
index 2aedbddab36ffa7a30534e95075ba1f08aa51c80..b5a666006662bc1cc44545d82eb7bf2550450be9 100644 (file)
--- a/libavcodec/acelp_filters.c
+++ b/libavcodec/acelp_filters.c
@@ -24,8 +24,6 @@
 
 #include "avcodec.h"
 #include "acelp_filters.h"
-#define FRAC_BITS 13
-#include "mathops.h"
 
 const int16_t ff_acelp_interp_filter[61] =
 { /* (0.15) */
@@ -47,7 +45,7 @@ void ff_acelp_interpolate(
         const int16_t* in,
         const int16_t* filter_coeffs,
         int precision,
-        int pitch_delay_frac,
+        int frac_pos,
         int filter_length,
         int length)
 {
@@ -72,10 +70,10 @@ void ff_acelp_interpolate(
                 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];
+            v += in[n + i] * filter_coeffs[idx + frac_pos];
             idx += precision;
             i++;
-            v += in[n - i] * filter_coeffs[idx - pitch_delay_frac];
+            v += in[n - i] * filter_coeffs[idx - frac_pos];
         }
         out[n] = av_clip_int16(v >> 15);
     }
@@ -85,27 +83,23 @@ void ff_acelp_convolve_circ(
         int16_t* fc_out,
         const int16_t* fc_in,
         const int16_t* filter,
-        int subframe_size)
+        int len)
 {
     int i, k;
 
-    memset(fc_out, 0, subframe_size * sizeof(int16_t));
+    memset(fc_out, 0, len * sizeof(int16_t));
 
     /* 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++)
+       all fc_in[i] are zero) it is faster to loop over fc_in first. */
+    for(i=0; i<len; i++)
     {
         if(fc_in[i])
         {
             for(k=0; k<i; k++)
-                fc_out[k] += (fc_in[i] * filter[subframe_size + k - i]) >> 15;
+                fc_out[k] += (fc_in[i] * filter[len + k - i]) >> 15;
 
-            for(k=i; k<subframe_size; k++)
-                fc_out[k] += (fc_in[i] * filter[k - i]) >> 15;
+            for(k=i; k<len; k++)
+                fc_out[k] += (fc_in[i] * filter[      k - i]) >> 15;
         }
     }
 }
@@ -116,19 +110,23 @@ 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];
 
         sum = (sum >> 12) + in[n];
 
-        /* Check for overflow */
         if(sum + 0x8000 > 0xFFFFU)
         {
             if(stop_on_overflow)
@@ -141,17 +139,6 @@ int ff_acelp_lp_synthesis_filter(
     return 0;
 }
 
-void ff_acelp_weighted_filter(
-        int16_t *out,
-        const int16_t* in,
-        const int16_t *weight_pow,
-        int filter_length)
-{
-    int n;
-    for(n=0; n<filter_length; n++)
-        out[n] = (in[n] * weight_pow[n] + 0x4000) >> 15; /* (3.12) = (0.15) * (3.12) with rounding */
-}
-
 void ff_acelp_high_pass_filter(
         int16_t* out,
         int hpf_f[2],
@@ -163,13 +150,10 @@ void ff_acelp_high_pass_filter(
 
     for(i=0; i<length; i++)
     {
-        tmp =  MULL(hpf_f[0], 15836);                     /* (14.13) = (13.13) * (1.13) */
-        tmp += MULL(hpf_f[1], -7667);                     /* (13.13) = (13.13) * (0.13) */
+        tmp =  (hpf_f[0]* 15836LL)>>13;                   /* (14.13) = (13.13) * (1.13) */
+        tmp += (hpf_f[1]* -7667LL)>>13;                   /* (13.13) = (13.13) * (0.13) */
         tmp += 7699 * (in[i] - 2*in[i-1] + in[i-2]); /* (14.13) =  (0.13) * (14.0) */
 
-        /* Multiplication by 2 with rounding can cause short type
-           overflow, thus clipping is required. */
-
         out[i] = av_clip_int16((tmp + 0x800) >> 12);      /* (15.0) = 2 * (13.13) = (14.13) */
 
         hpf_f[1] = hpf_f[0];