Clean up: alignment of comments
[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, 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_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 #if defined(OPUS_X86_MAY_HAVE_SSE4_1)
42 #include "x86/main_sse.h"
43 #endif
44
45 /* Convert Left/Right stereo signal to adaptive Mid/Side representation */
46 void silk_stereo_LR_to_MS(
47     stereo_enc_state            *state,                         /* I/O  State                                       */
48     opus_int16                  x1[],                           /* I/O  Left input signal, becomes mid signal       */
49     opus_int16                  x2[],                           /* I/O  Right input signal, becomes side signal     */
50     opus_int8                   ix[ 2 ][ 3 ],                   /* O    Quantization indices                        */
51     opus_int8                   *mid_only_flag,                 /* O    Flag: only mid signal coded                 */
52     opus_int32                  mid_side_rates_bps[],           /* O    Bitrates for mid and side signals           */
53     opus_int32                  total_rate_bps,                 /* I    Total bitrate                               */
54     opus_int                    prev_speech_act_Q8,             /* I    Speech activity level in previous frame     */
55     opus_int                    toMono,                         /* I    Last frame before a stereo->mono transition */
56     opus_int                    fs_kHz,                         /* I    Sample rate (kHz)                           */
57     opus_int                    frame_length                    /* I    Number of samples                           */
58 );
59
60 /* Convert adaptive Mid/Side representation to Left/Right stereo signal */
61 void silk_stereo_MS_to_LR(
62     stereo_dec_state            *state,                         /* I/O  State                                       */
63     opus_int16                  x1[],                           /* I/O  Left input signal, becomes mid signal       */
64     opus_int16                  x2[],                           /* I/O  Right input signal, becomes side signal     */
65     const opus_int32            pred_Q13[],                     /* I    Predictors                                  */
66     opus_int                    fs_kHz,                         /* I    Samples rate (kHz)                          */
67     opus_int                    frame_length                    /* I    Number of samples                           */
68 );
69
70 /* Find least-squares prediction gain for one signal based on another and quantize it */
71 opus_int32 silk_stereo_find_predictor(                          /* O    Returns predictor in Q13                    */
72     opus_int32                  *ratio_Q14,                     /* O    Ratio of residual and mid energies          */
73     const opus_int16            x[],                            /* I    Basis signal                                */
74     const opus_int16            y[],                            /* I    Target signal                               */
75     opus_int32                  mid_res_amp_Q0[],               /* I/O  Smoothed mid, residual norms                */
76     opus_int                    length,                         /* I    Number of samples                           */
77     opus_int                    smooth_coef_Q16                 /* I    Smoothing coefficient                       */
78 );
79
80 /* Quantize mid/side predictors */
81 void silk_stereo_quant_pred(
82     opus_int32                  pred_Q13[],                     /* I/O  Predictors (out: quantized)                 */
83     opus_int8                   ix[ 2 ][ 3 ]                    /* O    Quantization indices                        */
84 );
85
86 /* Entropy code the mid/side quantization indices */
87 void silk_stereo_encode_pred(
88     ec_enc                      *psRangeEnc,                    /* I/O  Compressor data structure                   */
89     opus_int8                   ix[ 2 ][ 3 ]                    /* I    Quantization indices                        */
90 );
91
92 /* Entropy code the mid-only flag */
93 void silk_stereo_encode_mid_only(
94     ec_enc                      *psRangeEnc,                    /* I/O  Compressor data structure                   */
95     opus_int8                   mid_only_flag
96 );
97
98 /* Decode mid/side predictors */
99 void silk_stereo_decode_pred(
100     ec_dec                      *psRangeDec,                    /* I/O  Compressor data structure                   */
101     opus_int32                  pred_Q13[]                      /* O    Predictors                                  */
102 );
103
104 /* Decode mid-only flag */
105 void silk_stereo_decode_mid_only(
106     ec_dec                      *psRangeDec,                    /* I/O  Compressor data structure                   */
107     opus_int                    *decode_only_mid                /* O    Flag that only mid channel has been coded   */
108 );
109
110 /* Encodes signs of excitation */
111 void silk_encode_signs(
112     ec_enc                      *psRangeEnc,                        /* I/O  Compressor data structure               */
113     const opus_int8             pulses[],                           /* I    pulse signal                            */
114     opus_int                    length,                             /* I    length of input                         */
115     const opus_int              signalType,                         /* I    Signal type                             */
116     const opus_int              quantOffsetType,                    /* I    Quantization offset type                */
117     const opus_int              sum_pulses[ MAX_NB_SHELL_BLOCKS ]   /* I    Sum of absolute pulses per block        */
118 );
119
120 /* Decodes signs of excitation */
121 void silk_decode_signs(
122     ec_dec                      *psRangeDec,                        /* I/O  Compressor data structure               */
123     opus_int16                  pulses[],                           /* I/O  pulse signal                            */
124     opus_int                    length,                             /* I    length of input                         */
125     const opus_int              signalType,                         /* I    Signal type                             */
126     const opus_int              quantOffsetType,                    /* I    Quantization offset type                */
127     const opus_int              sum_pulses[ MAX_NB_SHELL_BLOCKS ]   /* I    Sum of absolute pulses per block        */
128 );
129
130 /* Check encoder control struct */
131 opus_int check_control_input(
132     silk_EncControlStruct        *encControl                    /* I    Control structure                           */
133 );
134
135 /* Control internal sampling rate */
136 opus_int silk_control_audio_bandwidth(
137     silk_encoder_state          *psEncC,                        /* I/O  Pointer to Silk encoder state               */
138     silk_EncControlStruct       *encControl                     /* I    Control structure                           */
139 );
140
141 /* Control SNR of redidual quantizer */
142 opus_int silk_control_SNR(
143     silk_encoder_state          *psEncC,                        /* I/O  Pointer to Silk encoder state               */
144     opus_int32                  TargetRate_bps                  /* I    Target max bitrate (bps)                    */
145 );
146
147 /***************/
148 /* Shell coder */
149 /***************/
150
151 /* Encode quantization indices of excitation */
152 void silk_encode_pulses(
153     ec_enc                      *psRangeEnc,                    /* I/O  compressor data structure                   */
154     const opus_int              signalType,                     /* I    Signal type                                 */
155     const opus_int              quantOffsetType,                /* I    quantOffsetType                             */
156     opus_int8                   pulses[],                       /* I    quantization indices                        */
157     const opus_int              frame_length                    /* I    Frame length                                */
158 );
159
160 /* Shell encoder, operates on one shell code frame of 16 pulses */
161 void silk_shell_encoder(
162     ec_enc                      *psRangeEnc,                    /* I/O  compressor data structure                   */
163     const opus_int              *pulses0                        /* I    data: nonnegative pulse amplitudes          */
164 );
165
166 /* Shell decoder, operates on one shell code frame of 16 pulses */
167 void silk_shell_decoder(
168     opus_int16                  *pulses0,                       /* O    data: nonnegative pulse amplitudes          */
169     ec_dec                      *psRangeDec,                    /* I/O  Compressor data structure                   */
170     const opus_int              pulses4                         /* I    number of pulses per pulse-subframe         */
171 );
172
173 /* Gain scalar quantization with hysteresis, uniform on log scale */
174 void silk_gains_quant(
175     opus_int8                   ind[ MAX_NB_SUBFR ],            /* O    gain indices                                */
176     opus_int32                  gain_Q16[ MAX_NB_SUBFR ],       /* I/O  gains (quantized out)                       */
177     opus_int8                   *prev_ind,                      /* I/O  last index in previous frame                */
178     const opus_int              conditional,                    /* I    first gain is delta coded if 1              */
179     const opus_int              nb_subfr                        /* I    number of subframes                         */
180 );
181
182 /* Gains scalar dequantization, uniform on log scale */
183 void silk_gains_dequant(
184     opus_int32                  gain_Q16[ MAX_NB_SUBFR ],       /* O    quantized gains                             */
185     const opus_int8             ind[ MAX_NB_SUBFR ],            /* I    gain indices                                */
186     opus_int8                   *prev_ind,                      /* I/O  last index in previous frame                */
187     const opus_int              conditional,                    /* I    first gain is delta coded if 1              */
188     const opus_int              nb_subfr                        /* I    number of subframes                          */
189 );
190
191 /* Compute unique identifier of gain indices vector */
192 opus_int32 silk_gains_ID(                                       /* O    returns unique identifier of gains          */
193     const opus_int8             ind[ MAX_NB_SUBFR ],            /* I    gain indices                                */
194     const opus_int              nb_subfr                        /* I    number of subframes                         */
195 );
196
197 /* Interpolate two vectors */
198 void silk_interpolate(
199     opus_int16                  xi[ MAX_LPC_ORDER ],            /* O    interpolated vector                         */
200     const opus_int16            x0[ MAX_LPC_ORDER ],            /* I    first vector                                */
201     const opus_int16            x1[ MAX_LPC_ORDER ],            /* I    second vector                               */
202     const opus_int              ifact_Q2,                       /* I    interp. factor, weight on 2nd vector        */
203     const opus_int              d                               /* I    number of parameters                        */
204 );
205
206 /* LTP tap quantizer */
207 void silk_quant_LTP_gains(
208     opus_int16                  B_Q14[ MAX_NB_SUBFR * LTP_ORDER ],          /* O    Quantized LTP gains             */
209     opus_int8                   cbk_index[ MAX_NB_SUBFR ],                  /* O    Codebook Index                  */
210     opus_int8                   *periodicity_index,                         /* O    Periodicity Index               */
211     opus_int                    *pred_gain_dB_Q7,                           /* O    LTP prediction gain             */
212     const opus_int32            XX_Q17[ MAX_NB_SUBFR*LTP_ORDER*LTP_ORDER ], /* I    Correlation matrix in Q18       */
213     const opus_int32            xX_Q17[ MAX_NB_SUBFR*LTP_ORDER*LTP_ORDER ], /* I    Correlation vector in Q18       */
214     const opus_int              subfr_len,                                  /* I    Number of samples per subframe  */
215     const opus_int              nb_subfr,                                   /* I    Number of subframes             */
216     int                         arch                                        /* I    Run-time architecture           */
217 );
218
219 /* Entropy constrained matrix-weighted VQ, for a single input data vector */
220 void silk_VQ_WMat_EC_c(
221     opus_int8                   *ind,                           /* O    index of best codebook vector               */
222     opus_int32                  *res_nrg_Q15,                   /* O    best residual energy                        */
223     opus_int32                  *rate_dist_Q8,                  /* O    best total bitrate                          */
224     const opus_int32            *XX_Q17,                        /* I    correlation matrix                          */
225     const opus_int32            *xX_Q17,                        /* I    correlation vector                          */
226     const opus_int8             *cb_Q7,                         /* I    codebook                                    */
227     const opus_uint8            *cl_Q5,                         /* I    code length for each codebook vector        */
228     const opus_int              subfr_len,                      /* I    number of samples per subframe              */
229     const opus_int              L                               /* I    number of vectors in codebook               */
230 );
231
232 #if !defined(OVERRIDE_silk_VQ_WMat_EC)
233 #define silk_VQ_WMat_EC(ind, rate_dist_Q15, gain_Q8, XX_Q17, xX_Q17, cb_Q7, cl_Q5, subfr_len, L, arch) \
234     ((void)(arch),silk_VQ_WMat_EC_c(ind, rate_dist_Q15, gain_Q8, XX_Q17, xX_Q17, cb_Q7, cl_Q5, subfr_len, L))
235 #endif
236
237 /************************************/
238 /* Noise shaping quantization (NSQ) */
239 /************************************/
240
241 void silk_NSQ_c(
242     const silk_encoder_state    *psEncC,                                    /* I/O  Encoder State                   */
243     silk_nsq_state              *NSQ,                                       /* I/O  NSQ state                       */
244     SideInfoIndices             *psIndices,                                 /* I/O  Quantization Indices            */
245     const opus_int16            x16[],                                      /* I    Input                           */
246     opus_int8                   pulses[],                                   /* O    Quantized pulse signal          */
247     const opus_int16            PredCoef_Q12[ 2 * MAX_LPC_ORDER ],          /* I    Short term prediction coefs     */
248     const opus_int16            LTPCoef_Q14[ LTP_ORDER * MAX_NB_SUBFR ],    /* I    Long term prediction coefs      */
249     const opus_int16            AR_Q13[ MAX_NB_SUBFR * MAX_SHAPE_LPC_ORDER ], /* I  Noise shaping coefs             */
250     const opus_int              HarmShapeGain_Q14[ MAX_NB_SUBFR ],          /* I    Long term shaping coefs         */
251     const opus_int              Tilt_Q14[ MAX_NB_SUBFR ],                   /* I    Spectral tilt                   */
252     const opus_int32            LF_shp_Q14[ MAX_NB_SUBFR ],                 /* I    Low frequency shaping coefs     */
253     const opus_int32            Gains_Q16[ MAX_NB_SUBFR ],                  /* I    Quantization step sizes         */
254     const opus_int              pitchL[ MAX_NB_SUBFR ],                     /* I    Pitch lags                      */
255     const opus_int              Lambda_Q10,                                 /* I    Rate/distortion tradeoff        */
256     const opus_int              LTP_scale_Q14                               /* I    LTP state scaling               */
257 );
258
259 #if !defined(OVERRIDE_silk_NSQ)
260 #define silk_NSQ(psEncC, NSQ, psIndices, x16, pulses, PredCoef_Q12, LTPCoef_Q14, AR_Q13, \
261                    HarmShapeGain_Q14, Tilt_Q14, LF_shp_Q14, Gains_Q16, pitchL, Lambda_Q10, LTP_scale_Q14, arch) \
262     ((void)(arch),silk_NSQ_c(psEncC, NSQ, psIndices, x16, pulses, PredCoef_Q12, LTPCoef_Q14, AR_Q13, \
263                    HarmShapeGain_Q14, Tilt_Q14, LF_shp_Q14, Gains_Q16, pitchL, Lambda_Q10, LTP_scale_Q14))
264 #endif
265
266 /* Noise shaping using delayed decision */
267 void silk_NSQ_del_dec_c(
268     const silk_encoder_state    *psEncC,                                    /* I/O  Encoder State                   */
269     silk_nsq_state              *NSQ,                                       /* I/O  NSQ state                       */
270     SideInfoIndices             *psIndices,                                 /* I/O  Quantization Indices            */
271     const opus_int16            x16[],                                      /* I    Input                           */
272     opus_int8                   pulses[],                                   /* O    Quantized pulse signal          */
273     const opus_int16            PredCoef_Q12[ 2 * MAX_LPC_ORDER ],          /* I    Short term prediction coefs     */
274     const opus_int16            LTPCoef_Q14[ LTP_ORDER * MAX_NB_SUBFR ],    /* I    Long term prediction coefs      */
275     const opus_int16            AR_Q13[ MAX_NB_SUBFR * MAX_SHAPE_LPC_ORDER ], /* I  Noise shaping coefs             */
276     const opus_int              HarmShapeGain_Q14[ MAX_NB_SUBFR ],          /* I    Long term shaping coefs         */
277     const opus_int              Tilt_Q14[ MAX_NB_SUBFR ],                   /* I    Spectral tilt                   */
278     const opus_int32            LF_shp_Q14[ MAX_NB_SUBFR ],                 /* I    Low frequency shaping coefs     */
279     const opus_int32            Gains_Q16[ MAX_NB_SUBFR ],                  /* I    Quantization step sizes         */
280     const opus_int              pitchL[ MAX_NB_SUBFR ],                     /* I    Pitch lags                      */
281     const opus_int              Lambda_Q10,                                 /* I    Rate/distortion tradeoff        */
282     const opus_int              LTP_scale_Q14                               /* I    LTP state scaling               */
283 );
284
285 #if !defined(OVERRIDE_silk_NSQ_del_dec)
286 #define silk_NSQ_del_dec(psEncC, NSQ, psIndices, x16, pulses, PredCoef_Q12, LTPCoef_Q14, AR_Q13, \
287                            HarmShapeGain_Q14, Tilt_Q14, LF_shp_Q14, Gains_Q16, pitchL, Lambda_Q10, LTP_scale_Q14, arch) \
288     ((void)(arch),silk_NSQ_del_dec_c(psEncC, NSQ, psIndices, x16, pulses, PredCoef_Q12, LTPCoef_Q14, AR_Q13, \
289                            HarmShapeGain_Q14, Tilt_Q14, LF_shp_Q14, Gains_Q16, pitchL, Lambda_Q10, LTP_scale_Q14))
290 #endif
291
292 /************/
293 /* Silk VAD */
294 /************/
295 /* Initialize the Silk VAD */
296 opus_int silk_VAD_Init(                                         /* O    Return value, 0 if success                  */
297     silk_VAD_state              *psSilk_VAD                     /* I/O  Pointer to Silk VAD state                   */
298 );
299
300 /* Get speech activity level in Q8 */
301 opus_int silk_VAD_GetSA_Q8_c(                                   /* O    Return value, 0 if success                  */
302     silk_encoder_state          *psEncC,                        /* I/O  Encoder state                               */
303     const opus_int16            pIn[]                           /* I    PCM input                                   */
304 );
305
306 #if !defined(OVERRIDE_silk_VAD_GetSA_Q8)
307 #define silk_VAD_GetSA_Q8(psEnC, pIn, arch) ((void)(arch),silk_VAD_GetSA_Q8_c(psEnC, pIn))
308 #endif
309
310 /* Low-pass filter with variable cutoff frequency based on  */
311 /* piece-wise linear interpolation between elliptic filters */
312 /* Start by setting transition_frame_no = 1;                */
313 void silk_LP_variable_cutoff(
314     silk_LP_state               *psLP,                          /* I/O  LP filter state                             */
315     opus_int16                  *frame,                         /* I/O  Low-pass filtered output signal             */
316     const opus_int              frame_length                    /* I    Frame length                                */
317 );
318
319 /******************/
320 /* NLSF Quantizer */
321 /******************/
322 /* Limit, stabilize, convert and quantize NLSFs */
323 void silk_process_NLSFs(
324     silk_encoder_state          *psEncC,                            /* I/O  Encoder state                               */
325     opus_int16                  PredCoef_Q12[ 2 ][ MAX_LPC_ORDER ], /* O    Prediction coefficients                     */
326     opus_int16                  pNLSF_Q15[         MAX_LPC_ORDER ], /* I/O  Normalized LSFs (quant out) (0 - (2^15-1))  */
327     const opus_int16            prev_NLSFq_Q15[    MAX_LPC_ORDER ]  /* I    Previous Normalized LSFs (0 - (2^15-1))     */
328 );
329
330 opus_int32 silk_NLSF_encode(                                    /* O    Returns RD value in Q25                     */
331           opus_int8             *NLSFIndices,                   /* I    Codebook path vector [ LPC_ORDER + 1 ]      */
332           opus_int16            *pNLSF_Q15,                     /* I/O  Quantized NLSF vector [ LPC_ORDER ]         */
333     const silk_NLSF_CB_struct   *psNLSF_CB,                     /* I    Codebook object                             */
334     const opus_int16            *pW_QW,                         /* I    NLSF weight vector [ LPC_ORDER ]            */
335     const opus_int              NLSF_mu_Q20,                    /* I    Rate weight for the RD optimization         */
336     const opus_int              nSurvivors,                     /* I    Max survivors after first stage             */
337     const opus_int              signalType                      /* I    Signal type: 0/1/2                          */
338 );
339
340 /* Compute quantization errors for an LPC_order element input vector for a VQ codebook */
341 void silk_NLSF_VQ(
342     opus_int32                  err_Q26[],                      /* O    Quantization errors [K]                     */
343     const opus_int16            in_Q15[],                       /* I    Input vectors to be quantized [LPC_order]   */
344     const opus_uint8            pCB_Q8[],                       /* I    Codebook vectors [K*LPC_order]              */
345     const opus_int16            pWght_Q9[],                     /* I    Codebook weights [K*LPC_order]              */
346     const opus_int              K,                              /* I    Number of codebook vectors                  */
347     const opus_int              LPC_order                       /* I    Number of LPCs                              */
348 );
349
350 /* Delayed-decision quantizer for NLSF residuals */
351 opus_int32 silk_NLSF_del_dec_quant(                             /* O    Returns RD value in Q25                     */
352     opus_int8                   indices[],                      /* O    Quantization indices [ order ]              */
353     const opus_int16            x_Q10[],                        /* I    Input [ order ]                             */
354     const opus_int16            w_Q5[],                         /* I    Weights [ order ]                           */
355     const opus_uint8            pred_coef_Q8[],                 /* I    Backward predictor coefs [ order ]          */
356     const opus_int16            ec_ix[],                        /* I    Indices to entropy coding tables [ order ]  */
357     const opus_uint8            ec_rates_Q5[],                  /* I    Rates []                                    */
358     const opus_int              quant_step_size_Q16,            /* I    Quantization step size                      */
359     const opus_int16            inv_quant_step_size_Q6,         /* I    Inverse quantization step size              */
360     const opus_int32            mu_Q20,                         /* I    R/D tradeoff                                */
361     const opus_int16            order                           /* I    Number of input values                      */
362 );
363
364 /* Unpack predictor values and indices for entropy coding tables */
365 void silk_NLSF_unpack(
366           opus_int16            ec_ix[],                        /* O    Indices to entropy tables [ LPC_ORDER ]     */
367           opus_uint8            pred_Q8[],                      /* O    LSF predictor [ LPC_ORDER ]                 */
368     const silk_NLSF_CB_struct   *psNLSF_CB,                     /* I    Codebook object                             */
369     const opus_int              CB1_index                       /* I    Index of vector in first LSF codebook       */
370 );
371
372 /***********************/
373 /* NLSF vector decoder */
374 /***********************/
375 void silk_NLSF_decode(
376           opus_int16            *pNLSF_Q15,                     /* O    Quantized NLSF vector [ LPC_ORDER ]         */
377           opus_int8             *NLSFIndices,                   /* I    Codebook path vector [ LPC_ORDER + 1 ]      */
378     const silk_NLSF_CB_struct   *psNLSF_CB                      /* I    Codebook object                             */
379 );
380
381 /****************************************************/
382 /* Decoder Functions                                */
383 /****************************************************/
384 opus_int silk_init_decoder(
385     silk_decoder_state          *psDec                          /* I/O  Decoder state pointer                       */
386 );
387
388 /* Set decoder sampling rate */
389 opus_int silk_decoder_set_fs(
390     silk_decoder_state          *psDec,                         /* I/O  Decoder state pointer                       */
391     opus_int                    fs_kHz,                         /* I    Sampling frequency (kHz)                    */
392     opus_int32                  fs_API_Hz                       /* I    API Sampling frequency (Hz)                 */
393 );
394
395 /****************/
396 /* Decode frame */
397 /****************/
398 opus_int silk_decode_frame(
399     silk_decoder_state          *psDec,                         /* I/O  Pointer to Silk decoder state               */
400     ec_dec                      *psRangeDec,                    /* I/O  Compressor data structure                   */
401     opus_int16                  pOut[],                         /* O    Pointer to output speech frame              */
402     opus_int32                  *pN,                            /* O    Pointer to size of output frame             */
403     opus_int                    lostFlag,                       /* I    0: no loss, 1 loss, 2 decode fec            */
404     opus_int                    condCoding,                     /* I    The type of conditional coding to use       */
405     int                         arch                            /* I    Run-time architecture                       */
406 );
407
408 /* Decode indices from bitstream */
409 void silk_decode_indices(
410     silk_decoder_state          *psDec,                         /* I/O  State                                       */
411     ec_dec                      *psRangeDec,                    /* I/O  Compressor data structure                   */
412     opus_int                    FrameIndex,                     /* I    Frame number                                */
413     opus_int                    decode_LBRR,                    /* I    Flag indicating LBRR data is being decoded  */
414     opus_int                    condCoding                      /* I    The type of conditional coding to use       */
415 );
416
417 /* Decode parameters from payload */
418 void silk_decode_parameters(
419     silk_decoder_state          *psDec,                         /* I/O  State                                       */
420     silk_decoder_control        *psDecCtrl,                     /* I/O  Decoder control                             */
421     opus_int                    condCoding                      /* I    The type of conditional coding to use       */
422 );
423
424 /* Core decoder. Performs inverse NSQ operation LTP + LPC */
425 void silk_decode_core(
426     silk_decoder_state          *psDec,                         /* I/O  Decoder state                               */
427     silk_decoder_control        *psDecCtrl,                     /* I    Decoder control                             */
428     opus_int16                  xq[],                           /* O    Decoded speech                              */
429     const opus_int16            pulses[ MAX_FRAME_LENGTH ],     /* I    Pulse signal                                */
430     int                         arch                            /* I    Run-time architecture                       */
431 );
432
433 /* Decode quantization indices of excitation (Shell coding) */
434 void silk_decode_pulses(
435     ec_dec                      *psRangeDec,                    /* I/O  Compressor data structure                   */
436     opus_int16                  pulses[],                       /* O    Excitation signal                           */
437     const opus_int              signalType,                     /* I    Sigtype                                     */
438     const opus_int              quantOffsetType,                /* I    quantOffsetType                             */
439     const opus_int              frame_length                    /* I    Frame length                                */
440 );
441
442 /******************/
443 /* CNG */
444 /******************/
445
446 /* Reset CNG */
447 void silk_CNG_Reset(
448     silk_decoder_state          *psDec                          /* I/O  Decoder state                               */
449 );
450
451 /* Updates CNG estimate, and applies the CNG when packet was lost */
452 void silk_CNG(
453     silk_decoder_state          *psDec,                         /* I/O  Decoder state                               */
454     silk_decoder_control        *psDecCtrl,                     /* I/O  Decoder control                             */
455     opus_int16                  frame[],                        /* I/O  Signal                                      */
456     opus_int                    length                          /* I    Length of residual                          */
457 );
458
459 /* Encoding of various parameters */
460 void silk_encode_indices(
461     silk_encoder_state          *psEncC,                        /* I/O  Encoder state                               */
462     ec_enc                      *psRangeEnc,                    /* I/O  Compressor data structure                   */
463     opus_int                    FrameIndex,                     /* I    Frame number                                */
464     opus_int                    encode_LBRR,                    /* I    Flag indicating LBRR data is being encoded  */
465     opus_int                    condCoding                      /* I    The type of conditional coding to use       */
466 );
467
468 #endif