Optimization of the CBR loop
[opus.git] / silk / main.h
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, (subject to the limitations in the disclaimer below)
5 are permitted provided that the following conditions 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 Skype Limited, nor the names of specific
12 contributors, may be used to endorse or promote products derived from
13 this software without specific prior written permission.
14 NO EXPRESS OR IMPLIED LICENSES TO ANY PARTY'S PATENT RIGHTS ARE GRANTED
15 BY THIS LICENSE. THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
16 CONTRIBUTORS ''AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING,
17 BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
18 FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
19 COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
20 INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
21 NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
22 USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
23 ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
24 (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
25 OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
26 ***********************************************************************/
27
28 #ifndef SILK_MAIN_H
29 #define SILK_MAIN_H
30
31 #include "SigProc_FIX.h"
32 #include "define.h"
33 #include "structs.h"
34 #include "tables.h"
35 #include "PLC.h"
36 #include "control.h"
37 #include "debug.h"
38 #include "entenc.h"
39 #include "entdec.h"
40
41 /* Uncomment the next line to store intermadiate data to files */
42 /*#define SAVE_ALL_INTERNAL_DATA      1*/
43 /* Uncomment the next line to force a fixed internal sampling rate (independent of what bitrate is used */
44 /*#define FORCE_INTERNAL_FS_KHZ       16*/
45
46 /* Simple way to make [8000, 12000, 16000, 24000, 48000] to [0,1,2,3,4] */
47 #define rateID(R) ( ( ( ((R)>>12) - ((R)>16000) ) >> ((R)>24000) ) - 1 )
48
49 /* Convert Left/Right stereo signal to adaptive Mid/Side representation */
50 void silk_stereo_LR_to_MS(
51     stereo_enc_state    *state,                         /* I/O  State                                       */
52     opus_int16           x1[],                           /* I/O  Left input signal, becomes mid signal       */
53     opus_int16           x2[],                           /* I/O  Right input signal, becomes side signal     */
54     opus_int8            ix[ 2 ][ 3 ],                   /* O    Quantization indices                        */
55     opus_int8            *mid_only_flag,                 /* O    Flag: only mid signal coded                 */
56     opus_int32           mid_side_rates_bps[],           /* O    Bitrates for mid and side signals           */
57     opus_int32           total_rate_bps,                 /* I    Total bitrate                               */
58     opus_int             prev_speech_act_Q8,             /* I    Speech activity level in previous frame     */
59     opus_int             toMono,                         /* I    Last frame before a stereo->mono transition */
60     opus_int             fs_kHz,                         /* I    Sample rate (kHz)                           */
61     opus_int             frame_length                    /* I    Number of samples                           */
62 );
63
64 /* Convert adaptive Mid/Side representation to Left/Right stereo signal */
65 void silk_stereo_MS_to_LR(
66     stereo_dec_state    *state,                         /* I/O  State                                       */
67     opus_int16           x1[],                           /* I/O  Left input signal, becomes mid signal       */
68     opus_int16           x2[],                           /* I/O  Right input signal, becomes side signal     */
69     const opus_int32     pred_Q13[],                     /* I    Predictors                                  */
70     opus_int             fs_kHz,                         /* I    Samples rate (kHz)                          */
71     opus_int             frame_length                    /* I    Number of samples                           */
72 );
73
74 /* Find least-squares prediction gain for one signal based on another and quantize it */
75 opus_int32 silk_stereo_find_predictor(                   /* O    Returns predictor in Q13                    */
76     opus_int32           *ratio_Q14,                     /* O    Ratio of residual and mid energies          */
77     const opus_int16     x[],                            /* I    Basis signal                                */
78     const opus_int16     y[],                            /* I    Target signal                               */
79     opus_int32           mid_res_amp_Q0[],               /* I/O  Smoothed mid, residual norms                */
80     opus_int             length,                         /* I    Number of samples                           */
81     opus_int             smooth_coef_Q16                 /* I    Smoothing coefficient                       */
82 );
83
84 /* Quantize mid/side predictors */
85 void silk_stereo_quant_pred(
86     opus_int32           pred_Q13[],                     /* I/O  Predictors (out: quantized)                 */
87     opus_int8            ix[ 2 ][ 3 ]                    /* O    Quantization indices                        */
88 );
89
90 /* Entropy code the mid/side quantization indices */
91 void silk_stereo_encode_pred(
92     ec_enc              *psRangeEnc,                    /* I/O  Compressor data structure                   */
93     opus_int8            ix[ 2 ][ 3 ]                    /* I    Quantization indices                        */
94 );
95
96 /* Entropy code the mid-only flag */
97 void silk_stereo_encode_mid_only(
98     ec_enc              *psRangeEnc,                    /* I/O  Compressor data structure                   */
99     opus_int8            mid_only_flag
100 );
101
102 /* Decode mid/side predictors */
103 void silk_stereo_decode_pred(
104     ec_dec              *psRangeDec,                    /* I/O  Compressor data structure                   */
105     opus_int32           pred_Q13[]                      /* O    Predictors                                  */
106 );
107
108 /* Decode mid-only flag */
109 void silk_stereo_decode_mid_only(
110     ec_dec              *psRangeDec,                    /* I/O  Compressor data structure                   */
111     opus_int             *decode_only_mid                /* O    Flag that only mid channel has been coded   */
112 );
113
114 /* Encodes signs of excitation */
115 void silk_encode_signs(
116     ec_enc                      *psRangeEnc,                        /* I/O  Compressor data structure                   */
117     const opus_int8              pulses[],                           /* I    pulse signal                                */
118     opus_int                     length,                             /* I    length of input                             */
119     const opus_int               signalType,                         /* I    Signal type                                 */
120     const opus_int               quantOffsetType,                    /* I    Quantization offset type                    */
121     const opus_int               sum_pulses[ MAX_NB_SHELL_BLOCKS ]   /* I    Sum of absolute pulses per block            */
122 );
123
124 /* Decodes signs of excitation */
125 void silk_decode_signs(
126     ec_dec                      *psRangeDec,                        /* I/O  Compressor data structure                   */
127     opus_int                     pulses[],                           /* I/O  pulse signal                                */
128     opus_int                     length,                             /* I    length of input                             */
129     const opus_int               signalType,                         /* I    Signal type                                 */
130     const opus_int               quantOffsetType,                    /* I    Quantization offset type                    */
131     const opus_int               sum_pulses[ MAX_NB_SHELL_BLOCKS ]   /* I    Sum of absolute pulses per block            */
132 );
133
134 /* Check encoder control struct */
135 opus_int check_control_input(
136     silk_EncControlStruct        *encControl     /* I:   Control structure                               */
137 );
138
139 /* Control internal sampling rate */
140 opus_int silk_control_audio_bandwidth(
141     silk_encoder_state          *psEncC,            /* I/O  Pointer to Silk encoder state               */
142     silk_EncControlStruct       *encControl         /* I:   Control structure                       */
143 );
144
145 /* Control SNR of redidual quantizer */
146 opus_int silk_control_SNR(
147     silk_encoder_state          *psEncC,            /* I/O  Pointer to Silk encoder state               */
148     opus_int32                   TargetRate_bps      /* I    Target max bitrate (bps)                    */
149 );
150
151 /***************/
152 /* Shell coder */
153 /***************/
154
155 /* Encode quantization indices of excitation */
156 void silk_encode_pulses(
157     ec_enc                      *psRangeEnc,        /* I/O  compressor data structure                   */
158     const opus_int               signalType,         /* I    Signal type                                 */
159     const opus_int               quantOffsetType,    /* I    quantOffsetType                             */
160     opus_int8                    pulses[],           /* I    quantization indices                        */
161     const opus_int               frame_length        /* I    Frame length                                */
162 );
163
164 /* Shell encoder, operates on one shell code frame of 16 pulses */
165 void silk_shell_encoder(
166     ec_enc                      *psRangeEnc,        /* I/O  compressor data structure                   */
167     const opus_int               *pulses0            /* I    data: nonnegative pulse amplitudes          */
168 );
169
170 /* Shell decoder, operates on one shell code frame of 16 pulses */
171 void silk_shell_decoder(
172     opus_int                     *pulses0,           /* O    data: nonnegative pulse amplitudes          */
173     ec_dec                      *psRangeDec,        /* I/O  Compressor data structure                   */
174     const opus_int               pulses4             /* I    number of pulses per pulse-subframe         */
175 );
176
177 /* Gain scalar quantization with hysteresis, uniform on log scale */
178 void silk_gains_quant(
179     opus_int8                        ind[ MAX_NB_SUBFR ],        /* O    gain indices                            */
180     opus_int32                       gain_Q16[ MAX_NB_SUBFR ],   /* I/O  gains (quantized out)                   */
181     opus_int8                        *prev_ind,                  /* I/O  last index in previous frame            */
182     const opus_int                   conditional,                /* I    first gain is delta coded if 1          */
183     const opus_int                   nb_subfr                    /* I    number of subframes                     */
184 );
185
186 /* Gains scalar dequantization, uniform on log scale */
187 void silk_gains_dequant(
188     opus_int32                       gain_Q16[ MAX_NB_SUBFR ],   /* O    quantized gains                         */
189     const opus_int8                  ind[ MAX_NB_SUBFR ],        /* I    gain indices                            */
190     opus_int8                        *prev_ind,                  /* I/O  last index in previous frame            */
191     const opus_int                   conditional,                /* I    first gain is delta coded if 1          */
192     const opus_int                   nb_subfr                    /* I    number of subframes                     */
193 );
194
195 /* Compute unique identifier of gain indices vector */
196 opus_int32 silk_gains_ID(                                        /* O    returns unique identifier of gains      */
197     const opus_int8                  ind[ MAX_NB_SUBFR ],        /* I    gain indices                            */
198     const opus_int                   nb_subfr                    /* I    number of subframes                     */
199 );
200
201 /* Interpolate two vectors */
202 void silk_interpolate(
203     opus_int16                       xi[ MAX_LPC_ORDER ],    /* O    interpolated vector                     */
204     const opus_int16                 x0[ MAX_LPC_ORDER ],    /* I    first vector                            */
205     const opus_int16                 x1[ MAX_LPC_ORDER ],    /* I    second vector                           */
206     const opus_int                   ifact_Q2,               /* I    interp. factor, weight on 2nd vector    */
207     const opus_int                   d                       /* I    number of parameters                    */
208 );
209
210 /* LTP tap quantizer */
211 void silk_quant_LTP_gains(
212     opus_int16           B_Q14[ MAX_NB_SUBFR * LTP_ORDER ],              /* I/O  (un)quantized LTP gains     */
213     opus_int8            cbk_index[ MAX_NB_SUBFR ],                      /* O    Codebook Index              */
214     opus_int8            *periodicity_index,                             /* O    Periodicity Index           */
215     const opus_int32     W_Q18[ MAX_NB_SUBFR*LTP_ORDER*LTP_ORDER ],      /* I    Error Weights in Q18        */
216     opus_int             mu_Q9,                                          /* I    Mu value (R/D tradeoff)     */
217     opus_int             lowComplexity,                                  /* I    Flag for low complexity     */
218     const opus_int       nb_subfr                                        /* I    number of subframes         */
219 );
220
221 /* Entropy constrained matrix-weighted VQ, for a single input data vector */
222 void silk_VQ_WMat_EC(
223     opus_int8                        *ind,               /* O    index of best codebook vector               */
224     opus_int32                       *rate_dist_Q14,     /* O    best weighted quantization error + mu * rate*/
225     const opus_int16                 *in_Q14,            /* I    input vector to be quantized                */
226     const opus_int32                 *W_Q18,             /* I    weighting matrix                            */
227     const opus_int8                  *cb_Q7,             /* I    codebook                                    */
228     const opus_uint8                 *cl_Q5,             /* I    code length for each codebook vector        */
229     const opus_int                   mu_Q9,              /* I    tradeoff between weighted error and rate    */
230     opus_int                         L                   /* I    number of vectors in codebook               */
231 );
232
233 /***********************************/
234 /* Noise shaping quantization (NSQ)*/
235 /***********************************/
236 void silk_NSQ(
237     const silk_encoder_state        *psEncC,                                    /* I/O  Encoder State                       */
238     silk_nsq_state                  *NSQ,                                       /* I/O  NSQ state                           */
239     SideInfoIndices                 *psIndices,                                 /* I/O  Quantization Indices                */
240     const opus_int16                 x[],                                        /* I    prefiltered input signal            */
241     opus_int8                        pulses[],                                   /* O    quantized qulse signal              */
242     const opus_int16                 PredCoef_Q12[ 2 * MAX_LPC_ORDER ],          /* I    Short term prediction coefficients  */
243     const opus_int16                 LTPCoef_Q14[ LTP_ORDER * MAX_NB_SUBFR ],    /* I    Long term prediction coefficients   */
244     const opus_int16                 AR2_Q13[ MAX_NB_SUBFR * MAX_SHAPE_LPC_ORDER ], /* I                                     */
245     const opus_int                   HarmShapeGain_Q14[ MAX_NB_SUBFR ],          /* I                                        */
246     const opus_int                   Tilt_Q14[ MAX_NB_SUBFR ],                   /* I    Spectral tilt                       */
247     const opus_int32                 LF_shp_Q14[ MAX_NB_SUBFR ],                 /* I                                        */
248     const opus_int32                 Gains_Q16[ MAX_NB_SUBFR ],                  /* I                                        */
249     const opus_int                   pitchL[ MAX_NB_SUBFR ],                     /* I                                        */
250     const opus_int                   Lambda_Q10,                                 /* I                                        */
251     const opus_int                   LTP_scale_Q14                               /* I    LTP state scaling                   */
252 );
253
254 /* Noise shaping using delayed decision */
255 void silk_NSQ_del_dec(
256     const silk_encoder_state        *psEncC,                                    /* I/O  Encoder State                       */
257     silk_nsq_state                  *NSQ,                                       /* I/O  NSQ state                           */
258     SideInfoIndices                 *psIndices,                                 /* I/O  Quantization Indices                */
259     const opus_int16                 x[],                                        /* I    Prefiltered input signal            */
260     opus_int8                        pulses[],                                   /* O    Quantized pulse signal              */
261     const opus_int16                 PredCoef_Q12[ 2 * MAX_LPC_ORDER ],          /* I    Prediction coefs                    */
262     const opus_int16                 LTPCoef_Q14[ LTP_ORDER * MAX_NB_SUBFR ],    /* I    LT prediction coefs                 */
263     const opus_int16                 AR2_Q13[ MAX_NB_SUBFR * MAX_SHAPE_LPC_ORDER ], /* I                                     */
264     const opus_int                   HarmShapeGain_Q14[ MAX_NB_SUBFR ],          /* I                                        */
265     const opus_int                   Tilt_Q14[ MAX_NB_SUBFR ],                   /* I    Spectral tilt                       */
266     const opus_int32                 LF_shp_Q14[ MAX_NB_SUBFR ],                 /* I                                        */
267     const opus_int32                 Gains_Q16[ MAX_NB_SUBFR ],                  /* I                                        */
268     const opus_int                   pitchL[ MAX_NB_SUBFR ],                     /* I                                        */
269     const opus_int                   Lambda_Q10,                                 /* I                                        */
270     const opus_int                   LTP_scale_Q14                               /* I    LTP state scaling                   */
271 );
272
273 /************/
274 /* Silk VAD */
275 /************/
276 /* Initialize the Silk VAD */
277 opus_int silk_VAD_Init(                              /* O    Return value, 0 if success                  */
278     silk_VAD_state              *psSilk_VAD         /* I/O  Pointer to Silk VAD state                   */
279 );
280
281 /* Get speech activity level in Q8 */
282 opus_int silk_VAD_GetSA_Q8(                          /* O    Return value, 0 if success                  */
283     silk_encoder_state          *psEncC,            /* I/O  Encoder state                               */
284     const opus_int16             pIn[]               /* I    PCM input                                   */
285 );
286
287 /* Low-pass filter with variable cutoff frequency based on  */
288 /* piece-wise linear interpolation between elliptic filters */
289 /* Start by setting transition_frame_no = 1;                */
290 void silk_LP_variable_cutoff(
291     silk_LP_state               *psLP,              /* I/O  LP filter state                             */
292     opus_int16                   *signal,            /* I/O  Low-pass filtered output signal             */
293     const opus_int               frame_length        /* I    Frame length                                */
294 );
295
296 /******************/
297 /* NLSF Quantizer */
298 /******************/
299 /* Limit, stabilize, convert and quantize NLSFs */
300 void silk_process_NLSFs(
301     silk_encoder_state              *psEncC,                                /* I/O  Encoder state                               */
302     opus_int16                       PredCoef_Q12[ 2 ][ MAX_LPC_ORDER ],     /* O    Prediction coefficients                     */
303     opus_int16                       pNLSF_Q15[         MAX_LPC_ORDER ],     /* I/O  Normalized LSFs (quant out) (0 - (2^15-1))  */
304     const opus_int16                 prev_NLSFq_Q15[    MAX_LPC_ORDER ]      /* I    Previous Normalized LSFs (0 - (2^15-1))     */
305 );
306
307 opus_int32 silk_NLSF_encode(                                 /* O    Returns RD value in Q25                 */
308           opus_int8                  *NLSFIndices,           /* I    Codebook path vector [ LPC_ORDER + 1 ]  */
309           opus_int16                 *pNLSF_Q15,             /* I/O  Quantized NLSF vector [ LPC_ORDER ]     */
310     const silk_NLSF_CB_struct       *psNLSF_CB,             /* I    Codebook object                         */
311     const opus_int16                 *pW_QW,                 /* I    NLSF weight vector [ LPC_ORDER ]        */
312     const opus_int                   NLSF_mu_Q20,            /* I    Rate weight for the RD optimization     */
313     const opus_int                   nSurvivors,             /* I    Max survivors after first stage         */
314     const opus_int                   signalType              /* I    Signal type: 0/1/2                      */
315 );
316
317 /* Compute quantization errors for an LPC_order element input vector for a VQ codebook */
318 void silk_NLSF_VQ(
319     opus_int32                   err_Q26[],              /* O    Quantization errors [K]                     */
320     const opus_int16             in_Q15[],               /* I    Input vectors to be quantized [LPC_order]   */
321     const opus_uint8             pCB_Q8[],               /* I    Codebook vectors [K*LPC_order]              */
322     const opus_int               K,                      /* I    Number of codebook vectors                  */
323     const opus_int               LPC_order               /* I    Number of LPCs                              */
324 );
325
326 /* Delayed-decision quantizer for NLSF residuals */
327 opus_int32 silk_NLSF_del_dec_quant(                      /* O    Returns RD value in Q25                     */
328     opus_int8                    indices[],              /* O    Quantization indices [ order ]              */
329     const opus_int16             x_Q10[],                /* I    Input [ order ]                             */
330     const opus_int16             w_Q5[],                 /* I    Weights [ order ]                           */
331     const opus_uint8             pred_coef_Q8[],         /* I    Backward predictor coefs [ order ]          */
332     const opus_int16             ec_ix[],                /* I    Indices to entropy coding tables [ order ]  */
333     const opus_uint8             ec_rates_Q5[],          /* I    Rates []                                    */
334     const opus_int               quant_step_size_Q16,    /* I    Quantization step size                      */
335     const opus_int16             inv_quant_step_size_Q6, /* I    Inverse quantization step size              */
336     const opus_int32             mu_Q20,                 /* I    R/D tradeoff                                */
337     const opus_int16             order                   /* I    Number of input values                      */
338 );
339
340 /* Unpack predictor values and indices for entropy coding tables */
341 void silk_NLSF_unpack(
342           opus_int16                 ec_ix[],                /* O    Indices to entropy tales [ LPC_ORDER ]  */
343           opus_uint8                 pred_Q8[],              /* O    LSF predictor [ LPC_ORDER ]             */
344     const silk_NLSF_CB_struct       *psNLSF_CB,             /* I    Codebook object                         */
345     const opus_int                   CB1_index               /* I    Index of vector in first LSF codebook   */
346 );
347
348 /***********************/
349 /* NLSF vector decoder */
350 /***********************/
351 void silk_NLSF_decode(
352           opus_int16                 *pNLSF_Q15,             /* O    Quantized NLSF vector [ LPC_ORDER ]     */
353           opus_int8                  *NLSFIndices,           /* I    Codebook path vector [ LPC_ORDER + 1 ]  */
354     const silk_NLSF_CB_struct       *psNLSF_CB              /* I    Codebook object                         */
355 );
356
357 /****************************************************/
358 /* Decoder Functions                                */
359 /****************************************************/
360 opus_int silk_create_decoder(
361     silk_decoder_state              **ppsDec            /* I/O  Decoder state pointer pointer               */
362 );
363
364 opus_int silk_free_decoder(
365     silk_decoder_state              *psDec              /* I/O  Decoder state pointer                       */
366 );
367
368 opus_int silk_init_decoder(
369     silk_decoder_state              *psDec              /* I/O  Decoder state pointer                       */
370 );
371
372 /* Set decoder sampling rate */
373 opus_int silk_decoder_set_fs(
374     silk_decoder_state              *psDec,             /* I/O  Decoder state pointer                       */
375     opus_int                         fs_kHz,             /* I    Sampling frequency (kHz)                    */
376     opus_int                         fs_API_Hz           /* I    API Sampling frequency (Hz)                 */
377 );
378
379 /****************/
380 /* Decode frame */
381 /****************/
382 opus_int silk_decode_frame(
383     silk_decoder_state          *psDec,             /* I/O  Pointer to Silk decoder state               */
384     ec_dec                      *psRangeDec,        /* I/O  Compressor data structure                   */
385     opus_int16                   pOut[],             /* O    Pointer to output speech frame              */
386     opus_int32                   *pN,                /* O    Pointer to size of output frame             */
387     opus_int                     lostFlag,           /* I    0: no loss, 1 loss, 2 decode fec            */
388     opus_int                     condCoding          /* I    The type of conditional coding to use       */
389 );
390
391 /* Decode LBRR side info and excitation */
392 void silk_LBRR_extract(
393     silk_decoder_state          *psDec,             /* I/O  State                                       */
394     ec_dec                      *psRangeDec         /* I/O  Compressor data structure                   */
395 );
396
397 /* Decode indices from payload v4 Bitstream */
398 void silk_decode_indices(
399     silk_decoder_state          *psDec,             /* I/O  State                                       */
400     ec_dec                      *psRangeDec,        /* I/O  Compressor data structure                   */
401     opus_int                     FrameIndex,         /* I    Frame number                                */
402     opus_int                     decode_LBRR,        /* I    Flag indicating LBRR data is being decoded  */
403     opus_int                     condCoding          /* I    The type of conditional coding to use       */
404 );
405
406 /* Decode parameters from payload */
407 void silk_decode_parameters(
408     silk_decoder_state      *psDec,                             /* I/O  State                                    */
409     silk_decoder_control    *psDecCtrl,                         /* I/O  Decoder control                          */
410     opus_int                 condCoding                         /* I    The type of conditional coding to use    */
411 );
412
413 /* Core decoder. Performs inverse NSQ operation LTP + LPC */
414 void silk_decode_core(
415     silk_decoder_state          *psDec,                             /* I/O  Decoder state               */
416     silk_decoder_control        *psDecCtrl,                         /* I    Decoder control             */
417     opus_int16                   xq[],                               /* O    Decoded speech              */
418     const opus_int               pulses[ MAX_FRAME_LENGTH ]          /* I    Pulse signal                */
419 );
420
421 /* Decode quantization indices of excitation (Shell coding) */
422 void silk_decode_pulses(
423     ec_dec                          *psRangeDec,        /* I/O  Compressor data structure                   */
424     opus_int                         pulses[],           /* O    Excitation signal                           */
425     const opus_int                   signalType,         /* I    Sigtype                                     */
426     const opus_int                   quantOffsetType,    /* I    quantOffsetType                             */
427     const opus_int                   frame_length        /* I    Frame length                                */
428 );
429
430 /******************/
431 /* CNG */
432 /******************/
433
434 /* Reset CNG */
435 void silk_CNG_Reset(
436     silk_decoder_state          *psDec              /* I/O  Decoder state                               */
437 );
438
439 /* Updates CNG estimate, and applies the CNG when packet was lost */
440 void silk_CNG(
441     silk_decoder_state          *psDec,             /* I/O  Decoder state                               */
442     silk_decoder_control        *psDecCtrl,         /* I/O  Decoder control                             */
443     opus_int16                   signal[],           /* I/O  Signal                                      */
444     opus_int                     length              /* I    Length of residual                          */
445 );
446
447 /* Encoding of various parameters */
448 void silk_encode_indices(
449     silk_encoder_state          *psEncC,            /* I/O  Encoder state                               */
450     ec_enc                      *psRangeEnc,        /* I/O  Compressor data structure                   */
451     opus_int                     FrameIndex,         /* I    Frame number                                */
452     opus_int                     encode_LBRR,        /* I    Flag indicating LBRR data is being encoded  */
453     opus_int                     condCoding          /* I    The type of conditional coding to use       */
454 );
455
456 #endif