X-Git-Url: https://git.sesse.net/?a=blobdiff_plain;f=libavcodec%2Facelp_filters.c;h=16e2da1cc19f3614faa98152db5bdae6185f6fde;hb=d2205d6543881f2e6fa18c8a354bbcf91a1235f7;hp=6e5b1f46d7903cdade031711a30ab9f2d15772ef;hpb=fe4a5b185fdb5a96c1c66018e113b5144b01f6f3;p=ffmpeg diff --git a/libavcodec/acelp_filters.c b/libavcodec/acelp_filters.c index 6e5b1f46d79..16e2da1cc19 100644 --- a/libavcodec/acelp_filters.c +++ b/libavcodec/acelp_filters.c @@ -3,20 +3,20 @@ * * Copyright (c) 2008 Vladimir Voroshilov * - * This file is part of FFmpeg. + * This file is part of Libav. * - * FFmpeg is free software; you can redistribute it and/or + * Libav 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, + * Libav 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 + * License along with Libav; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA */ @@ -24,11 +24,8 @@ #include "avcodec.h" #include "acelp_filters.h" -#define FRAC_BITS 13 -#include "mathops.h" -const int16_t ff_acelp_interp_filter[61] = -{ /* (0.15) */ +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, @@ -42,26 +39,19 @@ const int16_t ff_acelp_interp_filter[61] = 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) +void ff_acelp_interpolate(int16_t* out, const int16_t* in, + const int16_t* filter_coeffs, int precision, + int frac_pos, int filter_length, int length) { int n, i; - assert(pitch_delay_frac >= 0 && pitch_delay_frac < precision); + assert(frac_pos >= 0 && frac_pos < precision); - for(n=0; n> 15); + if (av_clip_int16(v >> 15) != (v >> 15)) + av_log(NULL, AV_LOG_WARNING, "overflow that would need cliping in ff_acelp_interpolate()\n"); + out[n] = v >> 15; } } -void ff_acelp_convolve_circ( - int16_t* fc_out, - const int16_t* fc_in, - const int16_t* filter, - int subframe_size) +void ff_acelp_interpolatef(float *out, const float *in, + const float *filter_coeffs, int precision, + int frac_pos, int filter_length, int length) { - int i, k; - - memset(fc_out, 0, subframe_size * 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> 15; - - for(k=i; k> 15; - } - } -} + int n, i; -int ff_acelp_lp_synthesis_filter( - int16_t *out, - const int16_t* filter_coeffs, - const int16_t* in, - int buffer_length, - int filter_length, - int stop_on_overflow, - int rounder) -{ - int i,n; - - // These two lines are two avoid a -1 subtraction in the main loop - filter_length++; - filter_coeffs--; - - for(n=0; n> 12) + in[n]; - - /* Check for overflow */ - if(sum + 0x8000 > 0xFFFFU) - { - if(stop_on_overflow) - return 1; - sum = (sum >> 31) ^ 32767; + for (n = 0; n < length; n++) { + int idx = 0; + float v = 0; + + for (i = 0; i < filter_length;) { + v += in[n + i] * filter_coeffs[idx + frac_pos]; + idx += precision; + i++; + v += in[n - i] * filter_coeffs[idx - frac_pos]; } - out[n] = sum; + out[n] = v; } - - 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> 15; /* (3.12) = (0.15) * (3.12) with rounding */ -} -void ff_acelp_high_pass_filter( - int16_t* out, - int hpf_f[2], - const int16_t* in, - int length) +void ff_acelp_high_pass_filter(int16_t* out, int hpf_f[2], + const int16_t* in, int length) { int i; int tmp; - for(i=0; i> 13; + tmp += (hpf_f[1]* -7667LL) >> 13; + tmp += 7699 * (in[i] - 2*in[i-1] + in[i-2]); - out[i] = av_clip_int16((tmp + 0x800) >> 12); /* (15.0) = 2 * (13.13) = (14.13) */ + /* With "+0x800" rounding, clipping is needed + for ALGTHM and SPEECH tests. */ + out[i] = av_clip_int16((tmp + 0x800) >> 12); hpf_f[1] = hpf_f[0]; hpf_f[0] = tmp; } } + +void ff_acelp_apply_order_2_transfer_function(float *out, const float *in, + const float zero_coeffs[2], + const float pole_coeffs[2], + float gain, float mem[2], int n) +{ + int i; + float tmp; + + for (i = 0; i < n; i++) { + tmp = gain * in[i] - pole_coeffs[0] * mem[0] - pole_coeffs[1] * mem[1]; + out[i] = tmp + zero_coeffs[0] * mem[0] + zero_coeffs[1] * mem[1]; + + mem[1] = mem[0]; + mem[0] = tmp; + } +} + +void ff_tilt_compensation(float *mem, float tilt, float *samples, int size) +{ + float new_tilt_mem = samples[size - 1]; + int i; + + for (i = size - 1; i > 0; i--) + samples[i] -= tilt * samples[i - 1]; + + samples[0] -= tilt * *mem; + *mem = new_tilt_mem; +}