The Tor Browser / file comparison

comparison: media/libopus/silk/float/main_FLP.h

media/libopus/silk/float/main_FLP.h

branch
TOR_BUG_9701
changeset 15
b8a032363ba2
equal deleted inserted replaced
-1:000000000000 0:de68aef9fed1
1 /***********************************************************************
2 Copyright (c) 2006-2011, Skype Limited. All rights reserved.
3 Redistribution and use in source and binary forms, with or without
4 modification, are permitted provided that the following conditions
5 are met:
6 - Redistributions of source code must retain the above copyright notice,
7 this list of conditions and the following disclaimer.
8 - Redistributions in binary form must reproduce the above copyright
9 notice, this list of conditions and the following disclaimer in the
10 documentation and/or other materials provided with the distribution.
11 - Neither the name of Internet Society, IETF or IETF Trust, nor the
12 names of specific contributors, may be used to endorse or promote
13 products derived from this software without specific prior written
14 permission.
15 THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
16 AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
17 IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
18 ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
19 LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
20 CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
21 SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
22 INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
23 CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
24 ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
25 POSSIBILITY OF SUCH DAMAGE.
26 ***********************************************************************/
27
28 #ifndef SILK_MAIN_FLP_H
29 #define SILK_MAIN_FLP_H
30
31 #include "SigProc_FLP.h"
32 #include "SigProc_FIX.h"
33 #include "structs_FLP.h"
34 #include "main.h"
35 #include "define.h"
36 #include "debug.h"
37 #include "entenc.h"
38
39 #ifdef __cplusplus
40 extern "C"
41 {
42 #endif
43
44 #define silk_encoder_state_Fxx silk_encoder_state_FLP
45 #define silk_encode_do_VAD_Fxx silk_encode_do_VAD_FLP
46 #define silk_encode_frame_Fxx silk_encode_frame_FLP
47
48 /*********************/
49 /* Encoder Functions */
50 /*********************/
51
52 /* High-pass filter with cutoff frequency adaptation based on pitch lag statistics */
53 void silk_HP_variable_cutoff(
54 silk_encoder_state_Fxx state_Fxx[] /* I/O Encoder states */
55 );
56
57 /* Encoder main function */
58 void silk_encode_do_VAD_FLP(
59 silk_encoder_state_FLP *psEnc /* I/O Encoder state FLP */
60 );
61
62 /* Encoder main function */
63 opus_int silk_encode_frame_FLP(
64 silk_encoder_state_FLP *psEnc, /* I/O Encoder state FLP */
65 opus_int32 *pnBytesOut, /* O Number of payload bytes; */
66 ec_enc *psRangeEnc, /* I/O compressor data structure */
67 opus_int condCoding, /* I The type of conditional coding to use */
68 opus_int maxBits, /* I If > 0: maximum number of output bits */
69 opus_int useCBR /* I Flag to force constant-bitrate operation */
70 );
71
72 /* Initializes the Silk encoder state */
73 opus_int silk_init_encoder(
74 silk_encoder_state_FLP *psEnc, /* I/O Encoder state FLP */
75 int arch /* I Run-tim architecture */
76 );
77
78 /* Control the Silk encoder */
79 opus_int silk_control_encoder(
80 silk_encoder_state_FLP *psEnc, /* I/O Pointer to Silk encoder state FLP */
81 silk_EncControlStruct *encControl, /* I Control structure */
82 const opus_int32 TargetRate_bps, /* I Target max bitrate (bps) */
83 const opus_int allow_bw_switch, /* I Flag to allow switching audio bandwidth */
84 const opus_int channelNb, /* I Channel number */
85 const opus_int force_fs_kHz
86 );
87
88 /****************/
89 /* Prefiltering */
90 /****************/
91 void silk_prefilter_FLP(
92 silk_encoder_state_FLP *psEnc, /* I/O Encoder state FLP */
93 const silk_encoder_control_FLP *psEncCtrl, /* I Encoder control FLP */
94 silk_float xw[], /* O Weighted signal */
95 const silk_float x[] /* I Speech signal */
96 );
97
98 /**************************/
99 /* Noise shaping analysis */
100 /**************************/
101 /* Compute noise shaping coefficients and initial gain values */
102 void silk_noise_shape_analysis_FLP(
103 silk_encoder_state_FLP *psEnc, /* I/O Encoder state FLP */
104 silk_encoder_control_FLP *psEncCtrl, /* I/O Encoder control FLP */
105 const silk_float *pitch_res, /* I LPC residual from pitch analysis */
106 const silk_float *x /* I Input signal [frame_length + la_shape] */
107 );
108
109 /* Autocorrelations for a warped frequency axis */
110 void silk_warped_autocorrelation_FLP(
111 silk_float *corr, /* O Result [order + 1] */
112 const silk_float *input, /* I Input data to correlate */
113 const silk_float warping, /* I Warping coefficient */
114 const opus_int length, /* I Length of input */
115 const opus_int order /* I Correlation order (even) */
116 );
117
118 /* Calculation of LTP state scaling */
119 void silk_LTP_scale_ctrl_FLP(
120 silk_encoder_state_FLP *psEnc, /* I/O Encoder state FLP */
121 silk_encoder_control_FLP *psEncCtrl, /* I/O Encoder control FLP */
122 opus_int condCoding /* I The type of conditional coding to use */
123 );
124
125 /**********************************************/
126 /* Prediction Analysis */
127 /**********************************************/
128 /* Find pitch lags */
129 void silk_find_pitch_lags_FLP(
130 silk_encoder_state_FLP *psEnc, /* I/O Encoder state FLP */
131 silk_encoder_control_FLP *psEncCtrl, /* I/O Encoder control FLP */
132 silk_float res[], /* O Residual */
133 const silk_float x[], /* I Speech signal */
134 int arch /* I Run-time architecture */
135 );
136
137 /* Find LPC and LTP coefficients */
138 void silk_find_pred_coefs_FLP(
139 silk_encoder_state_FLP *psEnc, /* I/O Encoder state FLP */
140 silk_encoder_control_FLP *psEncCtrl, /* I/O Encoder control FLP */
141 const silk_float res_pitch[], /* I Residual from pitch analysis */
142 const silk_float x[], /* I Speech signal */
143 opus_int condCoding /* I The type of conditional coding to use */
144 );
145
146 /* LPC analysis */
147 void silk_find_LPC_FLP(
148 silk_encoder_state *psEncC, /* I/O Encoder state */
149 opus_int16 NLSF_Q15[], /* O NLSFs */
150 const silk_float x[], /* I Input signal */
151 const silk_float minInvGain /* I Prediction gain from LTP (dB) */
152 );
153
154 /* LTP analysis */
155 void silk_find_LTP_FLP(
156 silk_float b[ MAX_NB_SUBFR * LTP_ORDER ], /* O LTP coefs */
157 silk_float WLTP[ MAX_NB_SUBFR * LTP_ORDER * LTP_ORDER ], /* O Weight for LTP quantization */
158 silk_float *LTPredCodGain, /* O LTP coding gain */
159 const silk_float r_lpc[], /* I LPC residual */
160 const opus_int lag[ MAX_NB_SUBFR ], /* I LTP lags */
161 const silk_float Wght[ MAX_NB_SUBFR ], /* I Weights */
162 const opus_int subfr_length, /* I Subframe length */
163 const opus_int nb_subfr, /* I number of subframes */
164 const opus_int mem_offset /* I Number of samples in LTP memory */
165 );
166
167 void silk_LTP_analysis_filter_FLP(
168 silk_float *LTP_res, /* O LTP res MAX_NB_SUBFR*(pre_lgth+subfr_lngth) */
169 const silk_float *x, /* I Input signal, with preceding samples */
170 const silk_float B[ LTP_ORDER * MAX_NB_SUBFR ], /* I LTP coefficients for each subframe */
171 const opus_int pitchL[ MAX_NB_SUBFR ], /* I Pitch lags */
172 const silk_float invGains[ MAX_NB_SUBFR ], /* I Inverse quantization gains */
173 const opus_int subfr_length, /* I Length of each subframe */
174 const opus_int nb_subfr, /* I number of subframes */
175 const opus_int pre_length /* I Preceding samples for each subframe */
176 );
177
178 /* Calculates residual energies of input subframes where all subframes have LPC_order */
179 /* of preceding samples */
180 void silk_residual_energy_FLP(
181 silk_float nrgs[ MAX_NB_SUBFR ], /* O Residual energy per subframe */
182 const silk_float x[], /* I Input signal */
183 silk_float a[ 2 ][ MAX_LPC_ORDER ], /* I AR coefs for each frame half */
184 const silk_float gains[], /* I Quantization gains */
185 const opus_int subfr_length, /* I Subframe length */
186 const opus_int nb_subfr, /* I number of subframes */
187 const opus_int LPC_order /* I LPC order */
188 );
189
190 /* 16th order LPC analysis filter */
191 void silk_LPC_analysis_filter_FLP(
192 silk_float r_LPC[], /* O LPC residual signal */
193 const silk_float PredCoef[], /* I LPC coefficients */
194 const silk_float s[], /* I Input signal */
195 const opus_int length, /* I Length of input signal */
196 const opus_int Order /* I LPC order */
197 );
198
199 /* LTP tap quantizer */
200 void silk_quant_LTP_gains_FLP(
201 silk_float B[ MAX_NB_SUBFR * LTP_ORDER ], /* I/O (Un-)quantized LTP gains */
202 opus_int8 cbk_index[ MAX_NB_SUBFR ], /* O Codebook index */
203 opus_int8 *periodicity_index, /* O Periodicity index */
204 opus_int32 *sum_log_gain_Q7, /* I/O Cumulative max prediction gain */
205 const silk_float W[ MAX_NB_SUBFR * LTP_ORDER * LTP_ORDER ], /* I Error weights */
206 const opus_int mu_Q10, /* I Mu value (R/D tradeoff) */
207 const opus_int lowComplexity, /* I Flag for low complexity */
208 const opus_int nb_subfr /* I number of subframes */
209 );
210
211 /* Residual energy: nrg = wxx - 2 * wXx * c + c' * wXX * c */
212 silk_float silk_residual_energy_covar_FLP( /* O Weighted residual energy */
213 const silk_float *c, /* I Filter coefficients */
214 silk_float *wXX, /* I/O Weighted correlation matrix, reg. out */
215 const silk_float *wXx, /* I Weighted correlation vector */
216 const silk_float wxx, /* I Weighted correlation value */
217 const opus_int D /* I Dimension */
218 );
219
220 /* Processing of gains */
221 void silk_process_gains_FLP(
222 silk_encoder_state_FLP *psEnc, /* I/O Encoder state FLP */
223 silk_encoder_control_FLP *psEncCtrl, /* I/O Encoder control FLP */
224 opus_int condCoding /* I The type of conditional coding to use */
225 );
226
227 /******************/
228 /* Linear Algebra */
229 /******************/
230 /* Calculates correlation matrix X'*X */
231 void silk_corrMatrix_FLP(
232 const silk_float *x, /* I x vector [ L+order-1 ] used to create X */
233 const opus_int L, /* I Length of vectors */
234 const opus_int Order, /* I Max lag for correlation */
235 silk_float *XX /* O X'*X correlation matrix [order x order] */
236 );
237
238 /* Calculates correlation vector X'*t */
239 void silk_corrVector_FLP(
240 const silk_float *x, /* I x vector [L+order-1] used to create X */
241 const silk_float *t, /* I Target vector [L] */
242 const opus_int L, /* I Length of vecors */
243 const opus_int Order, /* I Max lag for correlation */
244 silk_float *Xt /* O X'*t correlation vector [order] */
245 );
246
247 /* Add noise to matrix diagonal */
248 void silk_regularize_correlations_FLP(
249 silk_float *XX, /* I/O Correlation matrices */
250 silk_float *xx, /* I/O Correlation values */
251 const silk_float noise, /* I Noise energy to add */
252 const opus_int D /* I Dimension of XX */
253 );
254
255 /* Function to solve linear equation Ax = b, where A is an MxM symmetric matrix */
256 void silk_solve_LDL_FLP(
257 silk_float *A, /* I/O Symmetric square matrix, out: reg. */
258 const opus_int M, /* I Size of matrix */
259 const silk_float *b, /* I Pointer to b vector */
260 silk_float *x /* O Pointer to x solution vector */
261 );
262
263 /* Apply sine window to signal vector. */
264 /* Window types: */
265 /* 1 -> sine window from 0 to pi/2 */
266 /* 2 -> sine window from pi/2 to pi */
267 void silk_apply_sine_window_FLP(
268 silk_float px_win[], /* O Pointer to windowed signal */
269 const silk_float px[], /* I Pointer to input signal */
270 const opus_int win_type, /* I Selects a window type */
271 const opus_int length /* I Window length, multiple of 4 */
272 );
273
274 /* Wrapper functions. Call flp / fix code */
275
276 /* Convert AR filter coefficients to NLSF parameters */
277 void silk_A2NLSF_FLP(
278 opus_int16 *NLSF_Q15, /* O NLSF vector [ LPC_order ] */
279 const silk_float *pAR, /* I LPC coefficients [ LPC_order ] */
280 const opus_int LPC_order /* I LPC order */
281 );
282
283 /* Convert NLSF parameters to AR prediction filter coefficients */
284 void silk_NLSF2A_FLP(
285 silk_float *pAR, /* O LPC coefficients [ LPC_order ] */
286 const opus_int16 *NLSF_Q15, /* I NLSF vector [ LPC_order ] */
287 const opus_int LPC_order /* I LPC order */
288 );
289
290 /* Limit, stabilize, and quantize NLSFs */
291 void silk_process_NLSFs_FLP(
292 silk_encoder_state *psEncC, /* I/O Encoder state */
293 silk_float PredCoef[ 2 ][ MAX_LPC_ORDER ], /* O Prediction coefficients */
294 opus_int16 NLSF_Q15[ MAX_LPC_ORDER ], /* I/O Normalized LSFs (quant out) (0 - (2^15-1)) */
295 const opus_int16 prev_NLSF_Q15[ MAX_LPC_ORDER ] /* I Previous Normalized LSFs (0 - (2^15-1)) */
296 );
297
298 /* Floating-point Silk NSQ wrapper */
299 void silk_NSQ_wrapper_FLP(
300 silk_encoder_state_FLP *psEnc, /* I/O Encoder state FLP */
301 silk_encoder_control_FLP *psEncCtrl, /* I/O Encoder control FLP */
302 SideInfoIndices *psIndices, /* I/O Quantization indices */
303 silk_nsq_state *psNSQ, /* I/O Noise Shaping Quantzation state */
304 opus_int8 pulses[], /* O Quantized pulse signal */
305 const silk_float x[] /* I Prefiltered input signal */
306 );
307
308 #ifdef __cplusplus
309 }
310 #endif
311
312 #endif

Mercurial Repository: The Tor Browser

Europalab SCM Repository Server

mercurial