SILK update
[opus.git] / src_SigProc_FLP / SKP_Silk_SigProc_FLP.h
1 /***********************************************************************\r
2 Copyright (c) 2006-2010, Skype Limited. All rights reserved. \r
3 Redistribution and use in source and binary forms, with or without \r
4 modification, (subject to the limitations in the disclaimer below) \r
5 are permitted provided that the following conditions are met:\r
6 - Redistributions of source code must retain the above copyright notice,\r
7 this list of conditions and the following disclaimer.\r
8 - Redistributions in binary form must reproduce the above copyright \r
9 notice, this list of conditions and the following disclaimer in the \r
10 documentation and/or other materials provided with the distribution.\r
11 - Neither the name of Skype Limited, nor the names of specific \r
12 contributors, may be used to endorse or promote products derived from \r
13 this software without specific prior written permission.\r
14 NO EXPRESS OR IMPLIED LICENSES TO ANY PARTY'S PATENT RIGHTS ARE GRANTED \r
15 BY THIS LICENSE. THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND \r
16 CONTRIBUTORS ''AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING,\r
17 BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND \r
18 FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE \r
19 COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, \r
20 INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT\r
21 NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF \r
22 USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON \r
23 ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT \r
24 (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE \r
25 OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\r
26 ***********************************************************************/\r
27 \r
28 \r
29 #ifndef _SKP_SILK_SIGPROC_FLP_H_\r
30 #define _SKP_SILK_SIGPROC_FLP_H_\r
31 \r
32 #include "SKP_Silk_SigProc_FIX.h"\r
33 #include <math.h>\r
34 \r
35 #ifdef  __cplusplus\r
36 extern "C"\r
37 {\r
38 #endif\r
39 \r
40 /********************************************************************/\r
41 /*                    SIGNAL PROCESSING FUNCTIONS                   */\r
42 /********************************************************************/\r
43 \r
44 /* first-order allpass filter */\r
45 void SKP_Silk_allpass_int_FLP(\r
46     const SKP_float *in,                /* I:   input signal [len]              */\r
47     SKP_float       *S,                 /* I/O: state [1]                       */\r
48     SKP_float       A,                  /* I:   coefficient     (0 <= A < 1)        */\r
49     SKP_float       *out,               /* O:   output signal [len]             */\r
50     const SKP_int32 len                 /* I:   number of samples               */\r
51 );\r
52 \r
53 /* downsample by a factor 2, coarser */\r
54 void SKP_Silk_decimate2_coarse_FLP(\r
55     const SKP_float     *in,                 /* I:  signal [2*len]            */\r
56     SKP_float       *S,                  /* I/O: state vector [2]         */\r
57     SKP_float       *out,                /* O:  decimated signal [len]    */\r
58     SKP_float       *scratch,            /* I:  scratch memory [3*len]    */\r
59     const SKP_int32 len                  /* I:  number of OUTPUT samples  */\r
60 );\r
61 \r
62 /* downsample by a factor 2, coarsest */\r
63 void SKP_Silk_decimate2_coarsest_FLP(\r
64     const SKP_float     *in,                 /* I:  signal [2*len]            */\r
65     SKP_float       *S,                  /* I/O: state vector [2]         */\r
66     SKP_float       *out,                /* O:  decimated signal [len]    */\r
67     SKP_float       *scratch,            /* I:  scratch memory [3*len]    */\r
68     const SKP_int32 len                  /* I:  number of OUTPUT samples  */\r
69 );\r
70 \r
71 /* Chirp (bw expand) LP AR filter */\r
72 void SKP_Silk_bwexpander_FLP( \r
73     SKP_float *ar,                     /* io   AR filter to be expanded (without leading 1)    */\r
74     const SKP_int d,                   /* i     length of ar                                       */\r
75     const SKP_float chirp              /* i     chirp factor (typically in range (0..1) )          */\r
76 );\r
77 \r
78 /* compute inverse of LPC prediction gain, and                                                  */\r
79 /* test if LPC coefficients are stable (all poles within unit circle)   */\r
80 /* this code is based on SKP_Silk_FLP_a2k()                                                             */\r
81 SKP_int SKP_Silk_LPC_inverse_pred_gain_FLP( /* O:   returns 1 if unstable, otherwise 0    */\r
82     SKP_float            *invGain,      /* O:   inverse prediction gain, energy domain    */\r
83     const SKP_float      *A,            /* I:   prediction coefficients [order]           */\r
84     SKP_int32            order          /* I:   prediction order                          */\r
85 );\r
86 \r
87 SKP_float SKP_Silk_schur_FLP(           /* O    returns residual energy                     */\r
88     SKP_float       refl_coef[],        /* O    reflection coefficients (length order)      */\r
89     const SKP_float auto_corr[],        /* I    autocorrelation sequence (length order+1)   */\r
90     SKP_int         order               /* I    order                                       */\r
91 );\r
92 \r
93 void SKP_Silk_k2a_FLP(\r
94     SKP_float           *A,             /* O:   prediction coefficients [order]           */\r
95     const SKP_float     *rc,            /* I:   reflection coefficients [order]           */\r
96     SKP_int32           order           /* I:   prediction order                          */\r
97 );\r
98 \r
99 /* Solve the normal equations using the Levinson-Durbin recursion */\r
100 SKP_float SKP_Silk_levinsondurbin_FLP(  /* O    prediction error energy                                         */\r
101         SKP_float               A[],                            /* O    prediction coefficients [order]                         */\r
102         const SKP_float corr[],                         /* I    input auto-correlations [order + 1]                     */\r
103         const SKP_int   order                           /* I    prediction order                                                        */\r
104 );\r
105 \r
106 /* compute autocorrelation */\r
107 void SKP_Silk_autocorrelation_FLP( \r
108     SKP_float *results,                 /* o    result (length correlationCount)            */\r
109     const SKP_float *inputData,         /* i    input data to correlate                     */\r
110     SKP_int inputDataSize,              /* i    length of input                             */\r
111     SKP_int correlationCount            /* i    number of correlation taps to compute       */\r
112 );\r
113 \r
114 /* Pitch estimator */\r
115 #define SigProc_PE_MIN_COMPLEX        0\r
116 #define SigProc_PE_MID_COMPLEX        1\r
117 #define SigProc_PE_MAX_COMPLEX        2\r
118 \r
119 SKP_int SKP_Silk_pitch_analysis_core_FLP( /* O voicing estimate: 0 voiced, 1 unvoiced                       */\r
120     const SKP_float *signal,            /* I signal of length PE_FRAME_LENGTH_MS*Fs_kHz              */\r
121     SKP_int         *pitch_out,         /* O 4 pitch lag values                                             */\r
122     SKP_int         *lagIndex,          /* O lag Index                                                      */\r
123     SKP_int         *contourIndex,      /* O pitch contour Index                                            */\r
124     SKP_float       *LTPCorr,           /* I/O normalized correlation; input: value from previous frame     */\r
125     SKP_int         prevLag,            /* I last lag of previous frame; set to zero is unvoiced            */\r
126     const SKP_float search_thres1,      /* I first stage threshold for lag candidates 0 - 1                 */\r
127     const SKP_float search_thres2,      /* I final threshold for lag candidates 0 - 1                       */\r
128     const SKP_int   Fs_kHz,             /* I sample frequency (kHz)                                         */\r
129     const SKP_int   complexity,         /* I Complexity setting, 0-2, where 2 is highest                    */\r
130     const SKP_int   nb_subfr            /* I    number of 5 ms subframes                                    */\r
131 );\r
132 \r
133 #define PI               (3.1415926536f)\r
134 \r
135 void SKP_Silk_insertion_sort_decreasing_FLP(\r
136     SKP_float            *a,          /* I/O:  Unsorted / Sorted vector                */\r
137     SKP_int              *index,      /* O:    Index vector for the sorted elements    */\r
138     const SKP_int        L,           /* I:    Vector length                           */\r
139     const SKP_int        K            /* I:    Number of correctly sorted positions    */\r
140 );\r
141 \r
142 void SKP_Silk_insertion_sort_increasing_FLP(\r
143     SKP_float            *a,          /* I/O:  Unsorted / Sorted vector                */\r
144     SKP_int              *index,      /* O:    Index vector for the sorted elements    */\r
145     const SKP_int        L,           /* I:    Vector length                           */\r
146     const SKP_int        K            /* I:    Number of correctly sorted positions    */\r
147 );\r
148 \r
149 /* Laroia low complexity NLSF weights */\r
150 void SKP_Silk_NLSF_VQ_weights_laroia_FLP(       \r
151     SKP_float            *pXW,           /* 0: Pointer to input vector weights                [D x 1]    */\r
152     const SKP_float      *pX,            /* I: Pointer to input vector                        [D x 1]    */ \r
153     const SKP_int        D               /* I: Input vector dimension                                    */\r
154 );\r
155 \r
156 /* Compute reflection coefficients from input signal */\r
157 SKP_float SKP_Silk_burg_modified_FLP(       /* O    returns residual energy                                         */\r
158     SKP_float           A[],                /* O    prediction coefficients (length order)                          */\r
159     const SKP_float     x[],                /* I    input signal, length: nb_subfr*(D+L_sub)                        */\r
160     const SKP_int       subfr_length,       /* I    input signal subframe length (including D preceeding samples)   */\r
161     const SKP_int       nb_subfr,           /* I    number of subframes stacked in x                                */\r
162     const SKP_float     WhiteNoiseFrac,     /* I    fraction added to zero-lag autocorrelation                      */\r
163     const SKP_int       D                   /* I    order                                                           */\r
164 );\r
165 \r
166 /* multiply a vector by a constant */\r
167 void SKP_Silk_scale_vector_FLP( \r
168     SKP_float           *data1,\r
169     SKP_float           gain, \r
170     SKP_int             dataSize\r
171 );\r
172 \r
173 /* copy and multiply a vector by a constant */\r
174 void SKP_Silk_scale_copy_vector_FLP( \r
175     SKP_float           *data_out, \r
176     const SKP_float     *data_in, \r
177     SKP_float           gain, \r
178     SKP_int             dataSize\r
179 );\r
180 \r
181 /* inner product of two SKP_float arrays, with result as double */\r
182 double SKP_Silk_inner_product_FLP( \r
183     const SKP_float     *data1, \r
184     const SKP_float     *data2, \r
185     SKP_int             dataSize\r
186 );\r
187 \r
188 /* sum of squares of a SKP_float array, with result as double */\r
189 double SKP_Silk_energy_FLP( \r
190     const SKP_float     *data, \r
191     SKP_int             dataSize\r
192 );\r
193 \r
194 /********************************************************************/\r
195 /*                                MACROS                                */\r
196 /********************************************************************/\r
197 \r
198 #define SKP_min_float(a, b)                     (((a) < (b)) ? (a) :  (b)) \r
199 #define SKP_max_float(a, b)                     (((a) > (b)) ? (a) :  (b)) \r
200 #define SKP_abs_float(a)                        ((SKP_float)fabs(a))\r
201 \r
202 #define SKP_LIMIT_float( a, limit1, limit2)     ((limit1) > (limit2) ? ((a) > (limit1) ? (limit1) : ((a) < (limit2) ? (limit2) : (a))) \\r
203                                                                                                                              : ((a) > (limit2) ? (limit2) : ((a) < (limit1) ? (limit1) : (a))))\r
204 \r
205 /* sigmoid function */\r
206 SKP_INLINE SKP_float SKP_sigmoid(SKP_float x)\r
207 {\r
208     return (SKP_float)(1.0 / (1.0 + exp(-x)));\r
209 }\r
210 \r
211 /* floating-point to integer conversion (rounding) */\r
212 SKP_INLINE void SKP_float2short_array(\r
213     SKP_int16       *out, \r
214     const SKP_float *in, \r
215     SKP_int32       length\r
216\r
217 {\r
218     SKP_int32 k;\r
219     for (k = length-1; k >= 0; k--) {\r
220         double x = in[k];\r
221         out[k] = (SKP_int16)SKP_SAT16( ( x > 0 ) ? x + 0.5 : x - 0.5 );\r
222     }\r
223 }\r
224 \r
225 /* floating-point to integer conversion (rounding) */\r
226 SKP_INLINE SKP_int32 SKP_float2int(double x) \r
227 {\r
228     return (SKP_int32)( ( x > 0 ) ? x + 0.5 : x - 0.5 );\r
229 }\r
230 \r
231 /* integer to floating-point conversion */\r
232 SKP_INLINE void SKP_short2float_array(\r
233     SKP_float       *out, \r
234     const SKP_int16 *in, \r
235     SKP_int32       length\r
236\r
237 {\r
238     SKP_int32 k;\r
239     for (k = length-1; k >= 0; k--) {\r
240         out[k] = (SKP_float)in[k];\r
241     }\r
242 }\r
243 \r
244 #define SKP_round(x)            (SKP_float)((x)>=0 ? (SKP_int64)((x)+0.5) : (SKP_int64)((x)-0.5))\r
245 \r
246 #ifdef  __cplusplus\r
247 }\r
248 #endif\r
249 \r
250 #endif\r