Revision 2398930f
libavcodec/acelp_filters.h  

79  79 
extern const int16_t ff_acelp_interp_filter[61]; 
80  80  
81  81 
/** 
82 
* \brief Generic interpolation routine


83 
* \param out [out] buffer for interpolated data


84 
* \param in input data


85 
* \param filter_coeffs interpolation filter coefficients (0.15)


86 
* \param precision filter is able to interpolate with 1/precision precision of pitch delay


87 
* \param pitch_delay_frac pitch delay, fractional part [0..precision1]


88 
* \param filter_length filter length


89 
* \param length length of speech data to process


82 
* Generic interpolation routine.


83 
* @param out [out] buffer for interpolated data


84 
* @param in input data


85 
* @param filter_coeffs interpolation filter coefficients (0.15)


86 
* @param precision filter is able to interpolate with 1/precision precision of pitch delay


87 
* @param pitch_delay_frac pitch delay, fractional part [0..precision1]


88 
* @param filter_length filter length


89 
* @param length length of speech data to process


90  90 
* 
91  91 
* filter_coeffs contains coefficients of the positive half of the symmetric 
92  92 
* interpolation filter. filter_coeffs[0] should the central (unpaired) coefficient. 
...  ...  
103  103 
int length); 
104  104  
105  105 
/** 
106 
* \brief Circularly convolve fixed vector with a phase dispersion impulse


106 
* Circularly convolve fixed vector with a phase dispersion impulse 

107  107 
* response filter (D.6.2 of G.729 and 6.1.5 of AMR). 
108 
* \param fc_out vector with filter applied


109 
* \param fc_in source vector


110 
* \param filter phase filter coefficients


108 
* @param fc_out vector with filter applied


109 
* @param fc_in source vector


110 
* @param filter phase filter coefficients


111  111 
* 
112  112 
* fc_out[n] = sum(i,0,len1){ fc_in[i] * filter[(len + n  i)%len] } 
113  113 
* 
...  ...  
120  120 
int subframe_size); 
121  121  
122  122 
/** 
123 
* \brief LP synthesis filter


124 
* \param out [out] pointer to output buffer


125 
* \param filter_coeffs filter coefficients (0x8000 <= (3.12) < 0x8000)


126 
* \param in input signal


127 
* \param buffer_length amount of data to process


128 
* \param filter_length filter length (10 for 10th order LP filter)


129 
* \param stop_on_overflow 1  return immediately if overflow occurs


123 
* LP synthesis filter.


124 
* @param out [out] pointer to output buffer


125 
* @param filter_coeffs filter coefficients (0x8000 <= (3.12) < 0x8000)


126 
* @param in input signal


127 
* @param buffer_length amount of data to process


128 
* @param filter_length filter length (10 for 10th order LP filter)


129 
* @param stop_on_overflow 1  return immediately if overflow occurs


130  130 
* 0  ignore overflows 
131 
* \param rounder the amount to add for rounding (usually 0x800 or 0xfff)


131 
* @param rounder the amount to add for rounding (usually 0x800 or 0xfff)


132  132 
* 
133 
* \return 1 if overflow occurred, 0  otherwise


133 
* @return 1 if overflow occurred, 0  otherwise


134  134 
* 
135 
* \note Output buffer must contain 10 samples of past


135 
* @note Output buffer must contain 10 samples of past


136  136 
* speech data before pointer. 
137  137 
* 
138  138 
* Routine applies 1/A(z) filter to given speech data. 
...  ...  
147  147 
int rounder); 
148  148  
149  149 
/** 
150 
* \brief Calculates coefficients of weighted A(z/weight) filter.


151 
* \param out [out] weighted A(z/weight) result


150 
* Calculates coefficients of weighted A(z/weight) filter. 

151 
* @param out [out] weighted A(z/weight) result


152  152 
* filter (0x8000 <= (3.12) < 0x8000) 
153 
* \param in source filter (0x8000 <= (3.12) < 0x8000)


154 
* \param weight_pow array containing weight^i (0x8000 <= (0.15) < 0x8000)


155 
* \param filter_length filter length (11 for 10th order LP filter)


153 
* @param in source filter (0x8000 <= (3.12) < 0x8000)


154 
* @param weight_pow array containing weight^i (0x8000 <= (0.15) < 0x8000)


155 
* @param filter_length filter length (11 for 10th order LP filter)


156  156 
* 
157  157 
* out[i]=weight_pow[i]*in[i] , i=0..9 
158  158 
*/ 
...  ...  
163  163 
int filter_length); 
164  164  
165  165 
/** 
166 
* \brief highpass filtering and upscaling (4.2.5 of G.729)


167 
* \param out [out] output buffer for filtered speech data


168 
* \param hpf_f [in/out] past filtered data from previous (2 items long)


166 
* highpass filtering and upscaling (4.2.5 of G.729).


167 
* @param out [out] output buffer for filtered speech data


168 
* @param hpf_f [in/out] past filtered data from previous (2 items long)


169  169 
* frames (0x20000000 <= (14.13) < 0x20000000) 
170 
* \param in speech data to process


171 
* \param length input data size


170 
* @param in speech data to process


171 
* @param length input data size


172  172 
* 
173  173 
* out[i] = 0.93980581 * in[i]  1.8795834 * in[i1] + 0.93980581 * in[i2] + 
174  174 
* 1.9330735 * out[i1]  0.93589199 * out[i2] 
175  175 
* 
176  176 
* The filter has a cutoff frequency of 100Hz 
177  177 
* 
178 
* \note Two items before the top of the out buffer must contain two items from the


178 
* @note Two items before the top of the out buffer must contain two items from the


179  179 
* tail of the previous subframe. 
180  180 
* 
181 
* \remark It is safe to pass the same array in in and out parameters.


181 
* @remark It is safe to pass the same array in in and out parameters.


182  182 
* 
183 
* \remark AMR uses mostly the same filter (cutoff frequency 60Hz, same formula,


183 
* @remark AMR uses mostly the same filter (cutoff frequency 60Hz, same formula,


184  184 
* but constants differs in 5th sign after comma). Fortunately in 
185  185 
* fixedpoint all coefficients are the same as in G.729. Thus this 
186  186 
* routine can be used for the fixedpoint AMR decoder, too. 
Also available in: Unified diff