Update SILK code using the CELT range coder
[opus.git] / src_common / SKP_Silk_main.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 #ifndef SKP_SILK_MAIN_H\r
29 #define SKP_SILK_MAIN_H\r
30 \r
31 #include "SKP_Silk_SigProc_FIX.h"\r
32 #include "SKP_Silk_define.h"\r
33 #include "SKP_Silk_structs.h"\r
34 #include "SKP_Silk_tables.h"\r
35 #include "SKP_Silk_PLC.h"\r
36 #include "SKP_debug.h"\r
37 #include "entenc.h"\r
38 #include "entdec.h"\r
39 \r
40 #ifdef __cplusplus\r
41 extern "C"\r
42 {\r
43 #endif\r
44 \r
45 /* Encodes signs of excitation */\r
46 void SKP_Silk_encode_signs(\r
47     SKP_Silk_range_coder_state  *psRC,              /* I/O  Range coder state                           */\r
48     const SKP_int8              q[],                /* I    pulse signal                                */\r
49     const SKP_int               length,             /* I    length of input                             */\r
50     const SKP_int               sigtype,            /* I    Signal type                                 */\r
51     const SKP_int               QuantOffsetType,    /* I    Quantization offset type                    */\r
52     const SKP_int               RateLevelIndex      /* I    Rate Level Index                            */\r
53 );\r
54 \r
55 /* Decodes signs of excitation */\r
56 void SKP_Silk_decode_signs(\r
57     SKP_Silk_range_coder_state  *psRC,              /* I/O  Range coder state                           */\r
58     SKP_int                     q[],                /* I/O  pulse signal                                */\r
59     const SKP_int               length,             /* I    length of output                            */\r
60     const SKP_int               sigtype,            /* I    Signal type                                 */\r
61     const SKP_int               QuantOffsetType,    /* I    Quantization offset type                    */\r
62     const SKP_int               RateLevelIndex      /* I    Rate Level Index                            */\r
63 );\r
64 \r
65 /***************/\r
66 /* Shell coder */\r
67 /***************/\r
68 \r
69 /* Encode quantization indices of excitation */\r
70 void SKP_Silk_encode_pulses(\r
71     SKP_Silk_range_coder_state  *psRC,              /* I/O  Range coder state                           */\r
72     const SKP_int               sigtype,            /* I    Sigtype                                     */\r
73     const SKP_int               QuantOffsetType,    /* I    QuantOffsetType                             */\r
74     SKP_int8                    q[],                /* I    quantization indices                        */\r
75     const SKP_int               frame_length        /* I    Frame length                                */\r
76 );\r
77 \r
78 /* Shell encoder, operates on one shell code frame of 16 pulses */\r
79 void SKP_Silk_shell_encoder(\r
80     SKP_Silk_range_coder_state  *psRC,              /* I/O  compressor data structure                   */\r
81     const SKP_int               *pulses0            /* I    data: nonnegative pulse amplitudes          */\r
82 );\r
83 \r
84 /* Shell decoder, operates on one shell code frame of 16 pulses */\r
85 void SKP_Silk_shell_decoder(\r
86     SKP_int                     *pulses0,           /* O    data: nonnegative pulse amplitudes          */\r
87     SKP_Silk_range_coder_state  *psRC,              /* I/O  compressor data structure                   */\r
88     const SKP_int               pulses4             /* I    number of pulses per pulse-subframe         */\r
89 );\r
90 \r
91 /***************/\r
92 /* Range coder */\r
93 /***************/\r
94 /* Range encoder for one symbol */\r
95 void SKP_Silk_range_encoder(\r
96     SKP_Silk_range_coder_state  *psRC,              /* I/O  compressor data structure                   */\r
97     const SKP_int               data,               /* I    uncompressed data                           */\r
98     const SKP_uint16            prob[]              /* I    cumulative density functions                */\r
99 );\r
100     \r
101 /* Range encoder for one symbol, with uniform PDF*/\r
102 void SKP_Silk_range_encode_uniform(\r
103     SKP_Silk_range_coder_state      *psRC,              /* I/O  compressor data structure                   */\r
104     const SKP_int                   data,               /* I    uncompressed data                           */\r
105     const SKP_int                   N                   /* I    number of possible outcomes                 */\r
106 );\r
107 \r
108 /* Range encoder for multiple symbols */\r
109 void SKP_Silk_range_encoder_multi(\r
110     SKP_Silk_range_coder_state  *psRC,              /* I/O  compressor data structure                   */\r
111     const SKP_int               data[],             /* I    uncompressed data    [nSymbols]             */\r
112     const SKP_uint16 * const    prob[],             /* I    cumulative density functions                */\r
113     const SKP_int               nSymbols            /* I    number of data symbols                      */\r
114 );\r
115 \r
116 /* Range decoder for one symbol */\r
117 void SKP_Silk_range_decoder(\r
118     SKP_int                     data[],             /* O    uncompressed data                           */\r
119     SKP_Silk_range_coder_state  *psRC,              /* I/O  compressor data structure                   */\r
120     const SKP_uint16            prob[],             /* I    cumulative density function                 */\r
121     SKP_int                     probIx              /* I    initial (middle) entry of cdf               */\r
122 );\r
123 \r
124 /* Range decoder for one symbol, with uniform PDF*/\r
125 void SKP_Silk_range_decode_uniform(\r
126     SKP_int                         data[],             /* O    uncompressed data                           */\r
127     SKP_Silk_range_coder_state      *psRC,              /* I/O  compressor data structure                   */\r
128     const SKP_int                   N                   /* I    number of possible outcomes                 */\r
129 );\r
130 \r
131 /* Range decoder for multiple symbols */\r
132 void SKP_Silk_range_decoder_multi(\r
133     SKP_int                     data[],             /* O    uncompressed data                [nSymbols] */\r
134     SKP_Silk_range_coder_state  *psRC,              /* I/O  compressor data structure                   */\r
135     const SKP_uint16 * const    prob[],             /* I    cumulative density functions                */\r
136     const SKP_int               probStartIx[],      /* I    initial (middle) entries of cdfs [nSymbols] */\r
137     const SKP_int               nSymbols            /* I    number of data symbols                      */\r
138 );\r
139 \r
140 /* Initialize range coder structure for encoder */\r
141 void SKP_Silk_range_enc_init(\r
142     SKP_Silk_range_coder_state  *psRC               /* O    compressor data structure                   */\r
143 );\r
144 \r
145 /* Initialize range coder structure for decoder */\r
146 void SKP_Silk_range_dec_init(\r
147     SKP_Silk_range_coder_state  *psRC,              /* O    compressor data structure                   */\r
148     const SKP_uint8             buffer[],           /* I    buffer for compressed data [bufferLength]   */\r
149     const SKP_int32             bufferLength        /* I    buffer length (in bytes)                    */\r
150 );\r
151 \r
152 /* Determine length of bitstream */\r
153 SKP_int SKP_Silk_range_encoder_get_length(          /* O    returns number of BITS in stream            */\r
154     SKP_Silk_range_coder_state          *psRC,      /* I    compressed data structure                   */\r
155     SKP_int                             *nBytes     /* O    number of BYTES in stream                   */\r
156 );\r
157 \r
158 /* Determine length of bitstream */\r
159 SKP_int SKP_Silk_range_decoder_get_length(          /* O    returns number of BITS in stream            */\r
160     SKP_Silk_range_coder_state          *psRC,      /* I    compressed data structure                   */\r
161     SKP_int                             *nBytes     /* O    number of BYTES in stream                   */\r
162 );\r
163 \r
164 /* Check that any remaining bits in the last byte are set to 1 */\r
165 void SKP_Silk_range_coder_check_after_decoding(\r
166     SKP_Silk_range_coder_state  *psRC               /* I/O  compressed data structure                   */\r
167 );\r
168 \r
169 /* Gain scalar quantization with hysteresis, uniform on log scale */\r
170 void SKP_Silk_gains_quant(\r
171     SKP_int                         ind[ MAX_NB_SUBFR ],        /* O    gain indices                            */\r
172     SKP_int32                       gain_Q16[ MAX_NB_SUBFR ],   /* I/O  gains (quantized out)                   */\r
173     SKP_int                         *prev_ind,                  /* I/O  last index in previous frame            */\r
174     const SKP_int                   conditional,                /* I    first gain is delta coded if 1          */\r
175     const SKP_int                   nb_subfr                    /* I    number of subframes                     */\r
176 );\r
177 \r
178 /* Gains scalar dequantization, uniform on log scale */\r
179 void SKP_Silk_gains_dequant(\r
180     SKP_int32                       gain_Q16[ MAX_NB_SUBFR ],   /* O    quantized gains                         */\r
181     const SKP_int                   ind[ MAX_NB_SUBFR ],        /* I    gain indices                            */\r
182     SKP_int                         *prev_ind,                  /* I/O  last index in previous frame            */\r
183     const SKP_int                   conditional,                /* I    first gain is delta coded if 1          */\r
184     const SKP_int                   nb_subfr                    /* I    number of subframes                     */\r
185 );\r
186 \r
187 /* Convert NLSF parameters to stable AR prediction filter coefficients */\r
188 void SKP_Silk_NLSF2A_stable(\r
189     SKP_int16                   pAR_Q12[ MAX_LPC_ORDER ],   /* O    Stabilized AR coefs [LPC_order]     */ \r
190     const SKP_int               pNLSF[ MAX_LPC_ORDER ],     /* I    NLSF vector         [LPC_order]     */\r
191     const SKP_int               LPC_order                   /* I    LPC/LSF order                       */\r
192 );\r
193 \r
194 /* Interpolate two vectors */\r
195 void SKP_Silk_interpolate(\r
196     SKP_int                     xi[ MAX_LPC_ORDER ],    /* O    interpolated vector                     */\r
197     const SKP_int               x0[ MAX_LPC_ORDER ],    /* I    first vector                            */\r
198     const SKP_int               x1[ MAX_LPC_ORDER ],    /* I    second vector                           */\r
199     const SKP_int               ifact_Q2,               /* I    interp. factor, weight on 2nd vector    */\r
200     const SKP_int               d                       /* I    number of parameters                    */\r
201 );\r
202 \r
203 /***********************************/\r
204 /* Noise shaping quantization (NSQ)*/\r
205 /***********************************/\r
206 void SKP_Silk_NSQ(\r
207     SKP_Silk_encoder_state          *psEncC,                                    /* I/O  Encoder State                       */\r
208     SKP_Silk_encoder_control        *psEncCtrlC,                                /* I    Encoder Control                     */\r
209     SKP_Silk_nsq_state              *NSQ,                                       /* I/O  NSQ state                           */\r
210     const SKP_int16                 x[],                                        /* I    prefiltered input signal            */\r
211     SKP_int8                        q[],                                        /* O    quantized qulse signal              */\r
212     const SKP_int                   LSFInterpFactor_Q2,                         /* I    LSF interpolation factor in Q2      */\r
213     const SKP_int16                 PredCoef_Q12[ 2 * MAX_LPC_ORDER ],          /* I    Short term prediction coefficients  */\r
214     const SKP_int16                 LTPCoef_Q14[ LTP_ORDER * MAX_NB_SUBFR ],        /* I    Long term prediction coefficients   */\r
215     const SKP_int16                 AR2_Q13[ MAX_NB_SUBFR * MAX_SHAPE_LPC_ORDER ],  /* I                                    */\r
216     const SKP_int                   HarmShapeGain_Q14[ MAX_NB_SUBFR ],              /* I                                    */\r
217     const SKP_int                   Tilt_Q14[ MAX_NB_SUBFR ],                       /* I    Spectral tilt                   */\r
218     const SKP_int32                 LF_shp_Q14[ MAX_NB_SUBFR ],                     /* I                                    */\r
219     const SKP_int32                 Gains_Q16[ MAX_NB_SUBFR ],                      /* I                                    */\r
220     const SKP_int                   Lambda_Q10,                                 /* I                                        */\r
221     const SKP_int                   LTP_scale_Q14                               /* I    LTP state scaling                   */\r
222 );\r
223 \r
224 /* Noise shaping using delayed decision */\r
225 void SKP_Silk_NSQ_del_dec(\r
226     SKP_Silk_encoder_state          *psEncC,                                    /* I/O  Encoder State                       */\r
227     SKP_Silk_encoder_control        *psEncCtrlC,                                /* I    Encoder Control                     */\r
228     SKP_Silk_nsq_state              *NSQ,                                       /* I/O  NSQ state                           */\r
229     const SKP_int16                 x[],                                        /* I    Prefiltered input signal            */\r
230     SKP_int8                        q[],                                        /* O    Quantized pulse signal              */\r
231     const SKP_int                   LSFInterpFactor_Q2,                         /* I    LSF interpolation factor in Q2      */\r
232     const SKP_int16                 PredCoef_Q12[ 2 * MAX_LPC_ORDER ],          /* I    Prediction coefs                    */\r
233     const SKP_int16                 LTPCoef_Q14[ LTP_ORDER * MAX_NB_SUBFR ],        /* I    LT prediction coefs                 */\r
234     const SKP_int16                 AR2_Q13[ MAX_NB_SUBFR * MAX_SHAPE_LPC_ORDER ],  /* I                                        */\r
235     const SKP_int                   HarmShapeGain_Q14[ MAX_NB_SUBFR ],              /* I                                        */\r
236     const SKP_int                   Tilt_Q14[ MAX_NB_SUBFR ],                       /* I    Spectral tilt                       */\r
237     const SKP_int32                 LF_shp_Q14[ MAX_NB_SUBFR ],                     /* I                                        */\r
238     const SKP_int32                 Gains_Q16[ MAX_NB_SUBFR ],                      /* I                                        */\r
239     const SKP_int                   Lambda_Q10,                                 /* I                                        */\r
240     const SKP_int                   LTP_scale_Q14                               /* I    LTP state scaling                   */\r
241 );\r
242 \r
243 /************/\r
244 /* Silk VAD */\r
245 /************/\r
246 /* Initialize the Silk VAD */\r
247 SKP_int SKP_Silk_VAD_Init(                          /* O    Return value, 0 if success                  */ \r
248     SKP_Silk_VAD_state          *psSilk_VAD         /* I/O  Pointer to Silk VAD state                   */ \r
249 ); \r
250 \r
251 /* Silk VAD noise level estimation */\r
252 void SKP_Silk_VAD_GetNoiseLevels(\r
253     const SKP_int32             pX[ VAD_N_BANDS ],  /* I    subband energies                            */\r
254     SKP_Silk_VAD_state          *psSilk_VAD         /* I/O  Pointer to Silk VAD state                   */ \r
255 );\r
256 \r
257 /* Get speech activity level in Q8 */\r
258 SKP_int SKP_Silk_VAD_GetSA_Q8(                                  /* O    Return value, 0 if success      */\r
259     SKP_Silk_VAD_state          *psSilk_VAD,                    /* I/O  Silk VAD state                  */\r
260     SKP_int                     *pSA_Q8,                        /* O    Speech activity level in Q8     */\r
261     SKP_int                     pQuality_Q15[ VAD_N_BANDS ],    /* O    Smoothed SNR for each band      */\r
262     SKP_int                     *pTilt_Q15,                     /* O    current frame's frequency tilt  */\r
263     const SKP_int16             pIn[],                          /* I    PCM input       [framelength]   */\r
264     const SKP_int               framelength,                    /* I    Input frame length              */\r
265     const SKP_int               fs_kHz                          /* I    Input frame sample frequency    */\r
266 );\r
267 \r
268 /* Detect signal in 8 - 12 khz range */\r
269 void SKP_Silk_detect_SWB_input(\r
270     SKP_Silk_detect_SWB_state   *psSWBdetect,       /* I/O  Encoder state                               */\r
271     const SKP_int16             samplesIn[],        /* I    Input to encoder                            */\r
272     SKP_int                     nSamplesIn          /* I    Length of input                             */\r
273 );\r
274 \r
275 #if SWITCH_TRANSITION_FILTERING\r
276 /* Low-pass filter with variable cutoff frequency based on  */\r
277 /* piece-wise linear interpolation between elliptic filters */\r
278 /* Start by setting transition_frame_no = 1;                */\r
279 void SKP_Silk_LP_variable_cutoff(\r
280     SKP_Silk_LP_state           *psLP,              /* I/O  LP filter state                             */\r
281     SKP_int16                   *out,               /* O    Low-pass filtered output signal             */\r
282     const SKP_int16             *in,                /* I    Input signal                                */\r
283     const SKP_int               frame_length        /* I    Frame length                                */\r
284 );\r
285 #endif\r
286 \r
287 /****************************************************/\r
288 /* Decoder Functions                                */\r
289 /****************************************************/\r
290 SKP_int SKP_Silk_create_decoder(\r
291     SKP_Silk_decoder_state      **ppsDec            /* I/O  Decoder state pointer pointer               */\r
292 );\r
293 \r
294 SKP_int SKP_Silk_free_decoder(\r
295     SKP_Silk_decoder_state      *psDec              /* I/O  Decoder state pointer                       */\r
296 );\r
297 \r
298 SKP_int SKP_Silk_init_decoder(\r
299     SKP_Silk_decoder_state      *psDec              /* I/O  Decoder state pointer                       */\r
300 );\r
301 \r
302 /* Set decoder sampling rate */\r
303 void SKP_Silk_decoder_set_fs(\r
304     SKP_Silk_decoder_state          *psDec,             /* I/O  Decoder state pointer                       */\r
305     SKP_int                         fs_kHz,             /* I    Sampling frequency (kHz)                    */\r
306     SKP_int                         nb_subfr            /* I    Number of subframes                         */\r
307 );\r
308 \r
309 /****************/\r
310 /* Decode frame */\r
311 /****************/\r
312 SKP_int SKP_Silk_decode_frame(\r
313     SKP_Silk_decoder_state      *psDec,             /* I/O  Pointer to Silk decoder state               */\r
314     SKP_int16                   pOut[],             /* O    Pointer to output speech frame              */\r
315     SKP_int16                   *pN,                /* O    Pointer to size of output frame             */\r
316     const SKP_uint8             pCode[],            /* I    Pointer to payload                          */\r
317     const SKP_int               nBytes,             /* I    Payload length                              */\r
318     SKP_int                     action,             /* I    Action from Jitter Buffer                   */\r
319     SKP_int                     *decBytes           /* O    Used bytes to decode this frame             */\r
320 );\r
321 \r
322 /* Decode indices from payload v4 Bitstream */\r
323 void SKP_Silk_decode_indices_v4(\r
324     SKP_Silk_decoder_state      *psDec              /* I/O  State                                       */\r
325 );\r
326 \r
327 /* Decode parameters from payload v4 Bitstream */\r
328 void SKP_Silk_decode_parameters_v4(\r
329     SKP_Silk_decoder_state      *psDec,                                 /* I/O  State                                    */\r
330     SKP_Silk_decoder_control    *psDecCtrl,                             /* I/O  Decoder control                          */\r
331     SKP_int                     q[ MAX_FRAME_LENGTH ],                  /* O    Excitation signal                        */\r
332     const SKP_int               fullDecoding                            /* I    Flag to tell if only arithmetic decoding */\r
333 );\r
334 \r
335 /* Core decoder. Performs inverse NSQ operation LTP + LPC */\r
336 void SKP_Silk_decode_core(\r
337     SKP_Silk_decoder_state      *psDec,                             /* I/O  Decoder state               */\r
338     SKP_Silk_decoder_control    *psDecCtrl,                         /* I    Decoder control             */\r
339     SKP_int16                   xq[],                               /* O    Decoded speech              */\r
340     const SKP_int               q[ MAX_FRAME_LENGTH ]               /* I    Pulse signal                */\r
341 );\r
342 \r
343 /* NLSF vector decoder */\r
344 void SKP_Silk_NLSF_MSVQ_decode(\r
345     SKP_int                         *pNLSF_Q15,     /* O    Pointer to decoded output [LPC_ORDER x 1]   */\r
346     const SKP_Silk_NLSF_CB_struct   *psNLSF_CB,     /* I    Pointer to NLSF codebook struct             */\r
347     const SKP_int                   *NLSFIndices,   /* I    Pointer to NLSF indices [nStages x 1]       */\r
348     const SKP_int                   LPC_order       /* I    LPC order                                   */\r
349 );\r
350 \r
351 /**********************/\r
352 /* Arithmetic coding */\r
353 /*********************/\r
354 \r
355 /* Decode quantization indices of excitation (Shell coding) */\r
356 void SKP_Silk_decode_pulses(\r
357     SKP_Silk_range_coder_state  *psRC,              /* I/O  Range coder state                           */\r
358     SKP_Silk_decoder_control    *psDecCtrl,         /* I/O  Decoder control                             */\r
359     SKP_int                     q[],                /* O    Excitation signal                           */\r
360     const SKP_int               frame_length        /* I    Frame length (preliminary)                  */\r
361 );\r
362 \r
363 /******************/\r
364 /* CNG */\r
365 /******************/\r
366 \r
367 /* Reset CNG */\r
368 void SKP_Silk_CNG_Reset(\r
369     SKP_Silk_decoder_state      *psDec              /* I/O  Decoder state                               */\r
370 );\r
371 \r
372 /* Updates CNG estimate, and applies the CNG when packet was lost   */\r
373 void SKP_Silk_CNG(\r
374     SKP_Silk_decoder_state      *psDec,             /* I/O  Decoder state                               */\r
375     SKP_Silk_decoder_control    *psDecCtrl,         /* I/O  Decoder control                             */\r
376     SKP_int16                   signal[],           /* I/O  Signal                                      */\r
377     SKP_int                     length              /* I    Length of residual                          */\r
378 );\r
379 \r
380 /* Encoding of various parameters */\r
381 void SKP_Silk_encode_parameters_v4(\r
382     SKP_Silk_encoder_state      *psEncC,            /* I/O  Encoder state                               */\r
383     SKP_Silk_encoder_control    *psEncCtrlC,        /* I/O  Encoder control                             */\r
384     SKP_Silk_range_coder_state  *psRC               /* I/O  Range encoder state                         */\r
385 );\r
386 \r
387 /* Extract lowest layer encoding */\r
388 void SKP_Silk_get_low_layer_internal(\r
389     const SKP_uint8             *indata,            /* I:   Encoded input vector                        */\r
390     const SKP_int16             nBytesIn,           /* I:   Number of input Bytes                       */\r
391     SKP_uint8                   *Layer0data,        /* O:   Layer0 payload                              */\r
392     SKP_int16                   *nLayer0Bytes       /* O:   Number of FEC Bytes                         */\r
393 );\r
394 \r
395 /* Resets LBRR buffer, used if packet size changes */\r
396 void SKP_Silk_LBRR_reset( \r
397     SKP_Silk_encoder_state      *psEncC             /* I/O  Pointer to Silk encoder state               */\r
398 );\r
399 \r
400 /* Predict number of bytes used to encode q */\r
401 SKP_int SKP_Silk_pulses_to_bytes( /* O  Return value, predicted number of bytes used to encode q */ \r
402     SKP_Silk_encoder_state      *psEncC,            /* I/O  Encoder State*/\r
403     SKP_int8                    q[]                 /* I     Pulse signal */\r
404 );\r
405 \r
406 #ifdef __cplusplus\r
407 }\r
408 #endif\r
409 \r
410 #endif\r