Initial Skype commit taken from FreeSwitch, which got it from the IETF draft.
[opus.git] / src / SKP_Silk_decode_parameters.c
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 #include "SKP_Silk_main.h"\r
29 \r
30 /* Decode parameters from payload */\r
31 void SKP_Silk_decode_parameters(\r
32     SKP_Silk_decoder_state      *psDec,             /* I/O  State                                       */\r
33     SKP_Silk_decoder_control    *psDecCtrl,         /* I/O  Decoder control                             */\r
34     SKP_int                     q[],                /* O    Excitation signal                           */\r
35     const SKP_int               fullDecoding        /* I    Flag to tell if only arithmetic decoding    */\r
36 )\r
37 {\r
38     SKP_int   i, k, Ix, fs_kHz_dec, nBytesUsed;\r
39     SKP_int   Ixs[ NB_SUBFR ];\r
40     SKP_int   GainsIndices[ NB_SUBFR ];\r
41     SKP_int   NLSFIndices[ NLSF_MSVQ_MAX_CB_STAGES ];\r
42     SKP_int   pNLSF_Q15[ MAX_LPC_ORDER ], pNLSF0_Q15[ MAX_LPC_ORDER ];\r
43     const SKP_int16 *cbk_ptr_Q14;\r
44     const SKP_Silk_NLSF_CB_struct *psNLSF_CB = NULL;\r
45     SKP_Silk_range_coder_state  *psRC = &psDec->sRC;\r
46 \r
47     /************************/\r
48     /* Decode sampling rate */\r
49     /************************/\r
50     /* only done for first frame of packet */\r
51     if( psDec->nFramesDecoded == 0 ) {\r
52         SKP_Silk_range_decoder( &Ix, psRC, SKP_Silk_SamplingRates_CDF, SKP_Silk_SamplingRates_offset );\r
53 \r
54         /* check that sampling rate is supported */\r
55         if( Ix < 0 || Ix > 3 ) {\r
56             psRC->error = RANGE_CODER_ILLEGAL_SAMPLING_RATE;\r
57             return;\r
58         }\r
59         fs_kHz_dec = SKP_Silk_SamplingRates_table[ Ix ];\r
60         SKP_Silk_decoder_set_fs( psDec, fs_kHz_dec );\r
61     }\r
62 \r
63     /*******************************************/\r
64     /* Decode signal type and quantizer offset */\r
65     /*******************************************/\r
66     if( psDec->nFramesDecoded == 0 ) {\r
67         /* first frame in packet: independent coding */\r
68         SKP_Silk_range_decoder( &Ix, psRC, SKP_Silk_type_offset_CDF, SKP_Silk_type_offset_CDF_offset );\r
69     } else {\r
70         /* condidtional coding */\r
71         SKP_Silk_range_decoder( &Ix, psRC, SKP_Silk_type_offset_joint_CDF[ psDec->typeOffsetPrev ], \r
72                 SKP_Silk_type_offset_CDF_offset );\r
73     }\r
74     psDecCtrl->sigtype         = SKP_RSHIFT( Ix, 1 );\r
75     psDecCtrl->QuantOffsetType = Ix & 1;\r
76     psDec->typeOffsetPrev      = Ix;\r
77 \r
78     /****************/\r
79     /* Decode gains */\r
80     /****************/\r
81     /* first subframe */    \r
82     if( psDec->nFramesDecoded == 0 ) {\r
83         /* first frame in packet: independent coding */\r
84         SKP_Silk_range_decoder( &GainsIndices[ 0 ], psRC, SKP_Silk_gain_CDF[ psDecCtrl->sigtype ], SKP_Silk_gain_CDF_offset );\r
85     } else {\r
86         /* condidtional coding */\r
87         SKP_Silk_range_decoder( &GainsIndices[ 0 ], psRC, SKP_Silk_delta_gain_CDF, SKP_Silk_delta_gain_CDF_offset );\r
88     }\r
89 \r
90     /* remaining subframes */\r
91     for( i = 1; i < NB_SUBFR; i++ ) {\r
92         SKP_Silk_range_decoder( &GainsIndices[ i ], psRC, SKP_Silk_delta_gain_CDF, SKP_Silk_delta_gain_CDF_offset );\r
93     }\r
94     \r
95     /* Dequant Gains */\r
96     SKP_Silk_gains_dequant( psDecCtrl->Gains_Q16, GainsIndices, &psDec->LastGainIndex, psDec->nFramesDecoded );\r
97     /****************/\r
98     /* Decode NLSFs */\r
99     /****************/\r
100     /* Set pointer to NLSF VQ CB for the current signal type */\r
101     psNLSF_CB = psDec->psNLSF_CB[ psDecCtrl->sigtype ];\r
102 \r
103     /* Arithmetically decode NLSF path */\r
104     SKP_Silk_range_decoder_multi( NLSFIndices, psRC, psNLSF_CB->StartPtr, psNLSF_CB->MiddleIx, psNLSF_CB->nStages );\r
105 \r
106     /* From the NLSF path, decode an NLSF vector */\r
107     SKP_Silk_NLSF_MSVQ_decode( pNLSF_Q15, psNLSF_CB, NLSFIndices, psDec->LPC_order );\r
108 \r
109     /************************************/\r
110     /* Decode NLSF interpolation factor */\r
111     /************************************/\r
112     SKP_Silk_range_decoder( &psDecCtrl->NLSFInterpCoef_Q2, psRC, SKP_Silk_NLSF_interpolation_factor_CDF, \r
113         SKP_Silk_NLSF_interpolation_factor_offset );\r
114     \r
115     /* If just reset, e.g., because internal Fs changed, do not allow interpolation */\r
116     /* improves the case of packet loss in the first frame after a switch           */\r
117     if( psDec->first_frame_after_reset == 1 ) {\r
118         psDecCtrl->NLSFInterpCoef_Q2 = 4;\r
119     }\r
120 \r
121     if( fullDecoding ) {\r
122         /* Convert NLSF parameters to AR prediction filter coefficients */\r
123         SKP_Silk_NLSF2A_stable( psDecCtrl->PredCoef_Q12[ 1 ], pNLSF_Q15, psDec->LPC_order );\r
124 \r
125         if( psDecCtrl->NLSFInterpCoef_Q2 < 4 ) {\r
126             /* Calculation of the interpolated NLSF0 vector from the interpolation factor, */ \r
127             /* the previous NLSF1, and the current NLSF1                                   */\r
128             for( i = 0; i < psDec->LPC_order; i++ ) {\r
129                 pNLSF0_Q15[ i ] = psDec->prevNLSF_Q15[ i ] + SKP_RSHIFT( SKP_MUL( psDecCtrl->NLSFInterpCoef_Q2, \r
130                     ( pNLSF_Q15[ i ] - psDec->prevNLSF_Q15[ i ] ) ), 2 );\r
131             }\r
132 \r
133             /* Convert NLSF parameters to AR prediction filter coefficients */\r
134             SKP_Silk_NLSF2A_stable( psDecCtrl->PredCoef_Q12[ 0 ], pNLSF0_Q15, psDec->LPC_order );\r
135         } else {\r
136             /* Copy LPC coefficients for first half from second half */\r
137             SKP_memcpy( psDecCtrl->PredCoef_Q12[ 0 ], psDecCtrl->PredCoef_Q12[ 1 ], \r
138                 psDec->LPC_order * sizeof( SKP_int16 ) );\r
139         }\r
140     }\r
141 \r
142     SKP_memcpy( psDec->prevNLSF_Q15, pNLSF_Q15, psDec->LPC_order * sizeof( SKP_int ) );\r
143 \r
144     /* After a packet loss do BWE of LPC coefs */\r
145     if( psDec->lossCnt ) {\r
146         SKP_Silk_bwexpander( psDecCtrl->PredCoef_Q12[ 0 ], psDec->LPC_order, BWE_AFTER_LOSS_Q16 );\r
147         SKP_Silk_bwexpander( psDecCtrl->PredCoef_Q12[ 1 ], psDec->LPC_order, BWE_AFTER_LOSS_Q16 );\r
148     }\r
149 \r
150     if( psDecCtrl->sigtype == SIG_TYPE_VOICED ) {\r
151         /*********************/\r
152         /* Decode pitch lags */\r
153         /*********************/\r
154         /* Get lag index */\r
155         if( psDec->fs_kHz == 8 ) {\r
156             SKP_Silk_range_decoder( &Ixs[ 0 ], psRC, SKP_Silk_pitch_lag_NB_CDF,  SKP_Silk_pitch_lag_NB_CDF_offset );\r
157         } else if( psDec->fs_kHz == 12 ) {\r
158             SKP_Silk_range_decoder( &Ixs[ 0 ], psRC, SKP_Silk_pitch_lag_MB_CDF,  SKP_Silk_pitch_lag_MB_CDF_offset );\r
159         } else if( psDec->fs_kHz == 16 ) {\r
160             SKP_Silk_range_decoder( &Ixs[ 0 ], psRC, SKP_Silk_pitch_lag_WB_CDF,  SKP_Silk_pitch_lag_WB_CDF_offset );\r
161         } else {\r
162             SKP_Silk_range_decoder( &Ixs[ 0 ], psRC, SKP_Silk_pitch_lag_SWB_CDF, SKP_Silk_pitch_lag_SWB_CDF_offset );\r
163         }\r
164         \r
165         /* Get countour index */\r
166         if( psDec->fs_kHz == 8 ) {\r
167             /* Less codevectors used in 8 khz mode */\r
168             SKP_Silk_range_decoder( &Ixs[ 1 ], psRC, SKP_Silk_pitch_contour_NB_CDF, SKP_Silk_pitch_contour_NB_CDF_offset );\r
169         } else {\r
170             /* Joint for 12, 16, and 24 khz */\r
171             SKP_Silk_range_decoder( &Ixs[ 1 ], psRC, SKP_Silk_pitch_contour_CDF, SKP_Silk_pitch_contour_CDF_offset );\r
172         }\r
173         \r
174         /* Decode pitch values */\r
175         SKP_Silk_decode_pitch( Ixs[ 0 ], Ixs[ 1 ], psDecCtrl->pitchL, psDec->fs_kHz );\r
176 \r
177         /********************/\r
178         /* Decode LTP gains */\r
179         /********************/\r
180         /* Decode PERIndex value */\r
181         SKP_Silk_range_decoder( &psDecCtrl->PERIndex, psRC, SKP_Silk_LTP_per_index_CDF, \r
182                 SKP_Silk_LTP_per_index_CDF_offset );\r
183 \r
184         /* Decode Codebook Index */\r
185         cbk_ptr_Q14 = SKP_Silk_LTP_vq_ptrs_Q14[ psDecCtrl->PERIndex ]; // set pointer to start of codebook\r
186         \r
187         for( k = 0; k < NB_SUBFR; k++ ) {\r
188             SKP_Silk_range_decoder( &Ix, psRC, SKP_Silk_LTP_gain_CDF_ptrs[ psDecCtrl->PERIndex ], \r
189                 SKP_Silk_LTP_gain_CDF_offsets[ psDecCtrl->PERIndex ] );\r
190 \r
191             for( i = 0; i < LTP_ORDER; i++ ) {\r
192                 psDecCtrl->LTPCoef_Q14[ SKP_SMULBB( k, LTP_ORDER ) + i ] = cbk_ptr_Q14[ SKP_SMULBB( Ix, LTP_ORDER ) + i ];\r
193             }\r
194         }\r
195 \r
196         /**********************/\r
197         /* Decode LTP scaling */\r
198         /**********************/\r
199         SKP_Silk_range_decoder( &Ix, psRC, SKP_Silk_LTPscale_CDF, SKP_Silk_LTPscale_offset );\r
200         psDecCtrl->LTP_scale_Q14 = SKP_Silk_LTPScales_table_Q14[ Ix ];\r
201     } else {\r
202         SKP_memset( psDecCtrl->pitchL,      0, NB_SUBFR * sizeof( SKP_int ) );\r
203         SKP_memset( psDecCtrl->LTPCoef_Q14, 0, NB_SUBFR * LTP_ORDER * sizeof( SKP_int16 ) );\r
204         psDecCtrl->PERIndex      = 0;\r
205         psDecCtrl->LTP_scale_Q14 = 0;\r
206     }\r
207 \r
208     /***************/\r
209     /* Decode seed */\r
210     /***************/\r
211     SKP_Silk_range_decoder( &Ix, psRC, SKP_Silk_Seed_CDF, SKP_Silk_Seed_offset );\r
212     psDecCtrl->Seed = ( SKP_int32 )Ix;\r
213     /*********************************************/\r
214     /* Decode quantization indices of excitation */\r
215     /*********************************************/\r
216     SKP_Silk_decode_pulses( psRC, psDecCtrl, q, psDec->frame_length );\r
217 \r
218     /*********************************************/\r
219     /* Decode VAD flag                           */\r
220     /*********************************************/\r
221     SKP_Silk_range_decoder( &psDec->vadFlag, psRC, SKP_Silk_vadflag_CDF, SKP_Silk_vadflag_offset );\r
222 \r
223     /**************************************/\r
224     /* Decode Frame termination indicator */\r
225     /**************************************/\r
226     SKP_Silk_range_decoder( &psDec->FrameTermination, psRC, SKP_Silk_FrameTermination_CDF, SKP_Silk_FrameTermination_offset );\r
227 \r
228     /****************************************/\r
229     /* get number of bytes used so far      */\r
230     /****************************************/\r
231     SKP_Silk_range_coder_get_length( psRC, &nBytesUsed );\r
232     psDec->nBytesLeft = psRC->bufferLength - nBytesUsed;\r
233     if( psDec->nBytesLeft < 0 ) {\r
234         psRC->error = RANGE_CODER_READ_BEYOND_BUFFER;\r
235     }\r
236 \r
237     /****************************************/\r
238     /* check remaining bits in last byte    */\r
239     /****************************************/\r
240     if( psDec->nBytesLeft == 0 ) {\r
241         SKP_Silk_range_coder_check_after_decoding( psRC );\r
242     }\r
243 }\r