LCOV - code coverage report
Current view: top level - src/libavcodec - acelp_filters.c (source / functions) Hit Total Coverage
Test: coverage.info Lines: 29 51 56.9 %
Date: 2017-09-22 00:04:37 Functions: 4 6 66.7 %

          Line data    Source code
       1             : /*
       2             :  * various filters for ACELP-based codecs
       3             :  *
       4             :  * Copyright (c) 2008 Vladimir Voroshilov
       5             :  *
       6             :  * This file is part of FFmpeg.
       7             :  *
       8             :  * FFmpeg is free software; you can redistribute it and/or
       9             :  * modify it under the terms of the GNU Lesser General Public
      10             :  * License as published by the Free Software Foundation; either
      11             :  * version 2.1 of the License, or (at your option) any later version.
      12             :  *
      13             :  * FFmpeg is distributed in the hope that it will be useful,
      14             :  * but WITHOUT ANY WARRANTY; without even the implied warranty of
      15             :  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
      16             :  * Lesser General Public License for more details.
      17             :  *
      18             :  * You should have received a copy of the GNU Lesser General Public
      19             :  * License along with FFmpeg; if not, write to the Free Software
      20             :  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
      21             :  */
      22             : 
      23             : #include <inttypes.h>
      24             : 
      25             : #include "libavutil/avassert.h"
      26             : #include "libavutil/common.h"
      27             : #include "avcodec.h"
      28             : #include "acelp_filters.h"
      29             : 
      30             : const int16_t ff_acelp_interp_filter[61] = { /* (0.15) */
      31             :   29443, 28346, 25207, 20449, 14701,  8693,
      32             :    3143, -1352, -4402, -5865, -5850, -4673,
      33             :   -2783,  -672,  1211,  2536,  3130,  2991,
      34             :    2259,  1170,     0, -1001, -1652, -1868,
      35             :   -1666, -1147,  -464,   218,   756,  1060,
      36             :    1099,   904,   550,   135,  -245,  -514,
      37             :    -634,  -602,  -451,  -231,     0,   191,
      38             :     308,   340,   296,   198,    78,   -36,
      39             :    -120,  -163,  -165,  -132,   -79,   -19,
      40             :      34,    73,    91,    89,    70,    38,
      41             :       0,
      42             : };
      43             : 
      44           0 : void ff_acelp_interpolate(int16_t* out, const int16_t* in,
      45             :                           const int16_t* filter_coeffs, int precision,
      46             :                           int frac_pos, int filter_length, int length)
      47             : {
      48             :     int n, i;
      49             : 
      50             :     av_assert1(frac_pos >= 0 && frac_pos < precision);
      51             : 
      52           0 :     for (n = 0; n < length; n++) {
      53           0 :         int idx = 0;
      54           0 :         int v = 0x4000;
      55             : 
      56           0 :         for (i = 0; i < filter_length;) {
      57             : 
      58             :             /* The reference G.729 and AMR fixed point code performs clipping after
      59             :                each of the two following accumulations.
      60             :                Since clipping affects only the synthetic OVERFLOW test without
      61             :                causing an int type overflow, it was moved outside the loop. */
      62             : 
      63             :             /*  R(x):=ac_v[-k+x]
      64             :                 v += R(n-i)*ff_acelp_interp_filter(t+6i)
      65             :                 v += R(n+i+1)*ff_acelp_interp_filter(6-t+6i) */
      66             : 
      67           0 :             v += in[n + i] * filter_coeffs[idx + frac_pos];
      68           0 :             idx += precision;
      69           0 :             i++;
      70           0 :             v += in[n - i] * filter_coeffs[idx - frac_pos];
      71             :         }
      72           0 :         if (av_clip_int16(v >> 15) != (v >> 15))
      73           0 :             av_log(NULL, AV_LOG_WARNING, "overflow that would need clipping in ff_acelp_interpolate()\n");
      74           0 :         out[n] = v >> 15;
      75             :     }
      76           0 : }
      77             : 
      78       81084 : void ff_acelp_interpolatef(float *out, const float *in,
      79             :                            const float *filter_coeffs, int precision,
      80             :                            int frac_pos, int filter_length, int length)
      81             : {
      82             :     int n, i;
      83             : 
      84     3759732 :     for (n = 0; n < length; n++) {
      85     3678648 :         int idx = 0;
      86     3678648 :         float v = 0;
      87             : 
      88    54342576 :         for (i = 0; i < filter_length;) {
      89    46985280 :             v += in[n + i] * filter_coeffs[idx + frac_pos];
      90    46985280 :             idx += precision;
      91    46985280 :             i++;
      92    46985280 :             v += in[n - i] * filter_coeffs[idx - frac_pos];
      93             :         }
      94     3678648 :         out[n] = v;
      95             :     }
      96       81084 : }
      97             : 
      98             : 
      99           0 : void ff_acelp_high_pass_filter(int16_t* out, int hpf_f[2],
     100             :                                const int16_t* in, int length)
     101             : {
     102             :     int i;
     103             :     int tmp;
     104             : 
     105           0 :     for (i = 0; i < length; i++) {
     106           0 :         tmp  = (hpf_f[0]* 15836LL) >> 13;
     107           0 :         tmp += (hpf_f[1]* -7667LL) >> 13;
     108           0 :         tmp += 7699 * (in[i] - 2*in[i-1] + in[i-2]);
     109             : 
     110             :         /* With "+0x800" rounding, clipping is needed
     111             :            for ALGTHM and SPEECH tests. */
     112           0 :         out[i] = av_clip_int16((tmp + 0x800) >> 12);
     113             : 
     114           0 :         hpf_f[1] = hpf_f[0];
     115           0 :         hpf_f[0] = tmp;
     116             :     }
     117           0 : }
     118             : 
     119       61600 : void ff_acelp_apply_order_2_transfer_function(float *out, const float *in,
     120             :                                               const float zero_coeffs[2],
     121             :                                               const float pole_coeffs[2],
     122             :                                               float gain, float mem[2], int n)
     123             : {
     124             :     int i;
     125             :     float tmp;
     126             : 
     127     4701344 :     for (i = 0; i < n; i++) {
     128     4639744 :         tmp = gain * in[i] - pole_coeffs[0] * mem[0] - pole_coeffs[1] * mem[1];
     129     4639744 :         out[i] =       tmp + zero_coeffs[0] * mem[0] + zero_coeffs[1] * mem[1];
     130             : 
     131     4639744 :         mem[1] = mem[0];
     132     4639744 :         mem[0] = tmp;
     133             :     }
     134       61600 : }
     135             : 
     136       20041 : void ff_tilt_compensation(float *mem, float tilt, float *samples, int size)
     137             : {
     138       20041 :     float new_tilt_mem = samples[size - 1];
     139             :     int i;
     140             : 
     141      756992 :     for (i = size - 1; i > 0; i--)
     142      736951 :         samples[i] -= tilt * samples[i - 1];
     143             : 
     144       20041 :     samples[0] -= tilt * *mem;
     145       20041 :     *mem = new_tilt_mem;
     146       20041 : }
     147             : 
     148          38 : void ff_acelp_filter_init(ACELPFContext *c)
     149             : {
     150          38 :     c->acelp_interpolatef                      = ff_acelp_interpolatef;
     151          38 :     c->acelp_apply_order_2_transfer_function   = ff_acelp_apply_order_2_transfer_function;
     152             : 
     153             :     if(HAVE_MIPSFPU)
     154             :         ff_acelp_filter_init_mips(c);
     155          38 : }

Generated by: LCOV version 1.13