Including config.h (fixes the fixed-point)
[opus.git] / silk / SKP_Silk_encode_indices.c
1 /***********************************************************************\r
2 Copyright (c) 2006-2011, 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 /* Encode side-information parameters to payload */\r
31 void SKP_Silk_encode_indices(\r
32     SKP_Silk_encoder_state      *psEncC,            /* I/O  Encoder state                               */\r
33     ec_enc                      *psRangeEnc,        /* I/O  Compressor data structure                   */\r
34     SKP_int                     FrameIndex,         /* I    Frame number                                */\r
35     SKP_int                     encode_LBRR         /* I    Flag indicating LBRR data is being encoded  */\r
36 )\r
37 {\r
38     SKP_int   i, k, condCoding, typeOffset;\r
39     SKP_int   encode_absolute_lagIndex, delta_lagIndex;\r
40     SKP_int16 ec_ix[ MAX_LPC_ORDER ];\r
41     SKP_uint8 pred_Q8[ MAX_LPC_ORDER ];\r
42     const SideInfoIndices *psIndices;\r
43 #if SAVE_ALL_INTERNAL_DATA\r
44     SKP_int nBytes_lagIndex, nBytes_contourIndex, nBytes_LTP;\r
45     SKP_int nBytes_after, nBytes_before;\r
46 #endif\r
47 \r
48     /* Use conditional coding if previous frame available */\r
49     if( FrameIndex > 0 && ( encode_LBRR == 0 || psEncC->LBRR_flags[ FrameIndex - 1 ] == 1 ) ) {\r
50         condCoding = 1;\r
51     } else {\r
52         condCoding = 0;\r
53     }\r
54 \r
55     if( encode_LBRR ) {\r
56          psIndices = &psEncC->indices_LBRR[ FrameIndex ];\r
57     } else {\r
58          psIndices = &psEncC->indices;\r
59     }\r
60 \r
61     /*******************************************/\r
62     /* Encode signal type and quantizer offset */\r
63     /*******************************************/\r
64     typeOffset = 2 * psIndices->signalType + psIndices->quantOffsetType;\r
65     SKP_assert( typeOffset >= 0 && typeOffset < 6 );\r
66     SKP_assert( encode_LBRR == 0 || typeOffset >= 2 );\r
67     if( encode_LBRR || typeOffset >= 2 ) {\r
68         ec_enc_icdf( psRangeEnc, typeOffset - 2, SKP_Silk_type_offset_VAD_iCDF, 8 );\r
69     } else {\r
70         ec_enc_icdf( psRangeEnc, typeOffset, SKP_Silk_type_offset_no_VAD_iCDF, 8 );\r
71     }\r
72 \r
73     /****************/\r
74     /* Encode gains */\r
75     /****************/\r
76 #ifdef SAVE_ALL_INTERNAL_DATA\r
77     nBytes_before = SKP_RSHIFT( ec_tell( psRangeEnc ) + 7, 3 );\r
78 #endif\r
79     /* first subframe */\r
80     if( condCoding ) {\r
81         /* conditional coding */\r
82         SKP_assert( psIndices->GainsIndices[ 0 ] >= 0 && psIndices->GainsIndices[ 0 ] < MAX_DELTA_GAIN_QUANT - MIN_DELTA_GAIN_QUANT + 1 );\r
83         ec_enc_icdf( psRangeEnc, psIndices->GainsIndices[ 0 ], SKP_Silk_delta_gain_iCDF, 8 );\r
84     } else {\r
85         /* independent coding, in two stages: MSB bits followed by 3 LSBs */\r
86         SKP_assert( psIndices->GainsIndices[ 0 ] >= 0 && psIndices->GainsIndices[ 0 ] < N_LEVELS_QGAIN );\r
87         ec_enc_icdf( psRangeEnc, SKP_RSHIFT( psIndices->GainsIndices[ 0 ], 3 ), SKP_Silk_gain_iCDF[ psIndices->signalType ], 8 );\r
88         ec_enc_icdf( psRangeEnc, psIndices->GainsIndices[ 0 ] & 7, SKP_Silk_uniform8_iCDF, 8 );\r
89     }\r
90 \r
91     /* remaining subframes */\r
92     for( i = 1; i < psEncC->nb_subfr; i++ ) {\r
93         SKP_assert( psIndices->GainsIndices[ i ] >= 0 && psIndices->GainsIndices[ i ] < MAX_DELTA_GAIN_QUANT - MIN_DELTA_GAIN_QUANT + 1 );\r
94         ec_enc_icdf( psRangeEnc, psIndices->GainsIndices[ i ], SKP_Silk_delta_gain_iCDF, 8 );\r
95     }\r
96 \r
97 #ifdef SAVE_ALL_INTERNAL_DATA\r
98     nBytes_after = SKP_RSHIFT( ec_tell( psRangeEnc ) + 7, 3 );\r
99     nBytes_after -= nBytes_before; // bytes just added\r
100     DEBUG_STORE_DATA( nBytes_gains.dat, &nBytes_after, sizeof( SKP_int ) );\r
101 #endif\r
102 \r
103     /****************/\r
104     /* Encode NLSFs */\r
105     /****************/\r
106 #ifdef SAVE_ALL_INTERNAL_DATA\r
107     nBytes_before = SKP_RSHIFT( ec_tell( psRangeEnc ) + 7, 3 );\r
108 #endif\r
109     ec_enc_icdf( psRangeEnc, psIndices->NLSFIndices[ 0 ], &psEncC->psNLSF_CB->CB1_iCDF[ ( psIndices->signalType >> 1 ) * psEncC->psNLSF_CB->nVectors ], 8 );\r
110     SKP_Silk_NLSF_unpack( ec_ix, pred_Q8, psEncC->psNLSF_CB, psIndices->NLSFIndices[ 0 ] );\r
111     SKP_assert( psEncC->psNLSF_CB->order == psEncC->predictLPCOrder );\r
112     for( i = 0; i < psEncC->psNLSF_CB->order; i++ ) {\r
113         if( psIndices->NLSFIndices[ i+1 ] >= NLSF_QUANT_MAX_AMPLITUDE ) {\r
114             ec_enc_icdf( psRangeEnc, 2 * NLSF_QUANT_MAX_AMPLITUDE, &psEncC->psNLSF_CB->ec_iCDF[ ec_ix[ i ] ], 8 );\r
115             ec_enc_icdf( psRangeEnc, psIndices->NLSFIndices[ i+1 ] - NLSF_QUANT_MAX_AMPLITUDE, SKP_Silk_NLSF_EXT_iCDF, 8 );\r
116         } else if( psIndices->NLSFIndices[ i+1 ] <= -NLSF_QUANT_MAX_AMPLITUDE ) {\r
117             ec_enc_icdf( psRangeEnc, 0, &psEncC->psNLSF_CB->ec_iCDF[ ec_ix[ i ] ], 8 );\r
118             ec_enc_icdf( psRangeEnc, -psIndices->NLSFIndices[ i+1 ] - NLSF_QUANT_MAX_AMPLITUDE, SKP_Silk_NLSF_EXT_iCDF, 8 );\r
119         } else {\r
120             ec_enc_icdf( psRangeEnc, psIndices->NLSFIndices[ i+1 ] + NLSF_QUANT_MAX_AMPLITUDE, &psEncC->psNLSF_CB->ec_iCDF[ ec_ix[ i ] ], 8 );\r
121         }\r
122     }\r
123 \r
124     /* Encode NLSF interpolation factor */\r
125     if( psEncC->nb_subfr == MAX_NB_SUBFR ) {\r
126         SKP_assert( psEncC->useInterpolatedNLSFs == 1 || psIndices->NLSFInterpCoef_Q2 == ( 1 << 2 ) );\r
127         SKP_assert( psIndices->NLSFInterpCoef_Q2 >= 0 && psIndices->NLSFInterpCoef_Q2 < 5 );\r
128         ec_enc_icdf( psRangeEnc, psIndices->NLSFInterpCoef_Q2, SKP_Silk_NLSF_interpolation_factor_iCDF, 8 );\r
129     }\r
130 \r
131 #ifdef SAVE_ALL_INTERNAL_DATA\r
132     DEBUG_STORE_DATA( lsf_interpol.dat, &psIndices->NLSFInterpCoef_Q2, sizeof(int) );\r
133     nBytes_after = SKP_RSHIFT( ec_tell( psRangeEnc ) + 7, 3 );\r
134     nBytes_after -= nBytes_before; // bytes just added\r
135     DEBUG_STORE_DATA( nBytes_LSF.dat, &nBytes_after, sizeof( SKP_int ) );\r
136 #endif\r
137 \r
138     if( psIndices->signalType == TYPE_VOICED ) \r
139     {\r
140         /*********************/\r
141         /* Encode pitch lags */\r
142         /*********************/\r
143 #ifdef SAVE_ALL_INTERNAL_DATA\r
144         nBytes_before = SKP_RSHIFT( ec_tell( psRangeEnc ) + 7, 3 );\r
145 #endif\r
146         /* lag index */\r
147         encode_absolute_lagIndex = 1;\r
148         if( condCoding && psEncC->ec_prevSignalType == TYPE_VOICED ) {\r
149             /* Delta Encoding */\r
150             delta_lagIndex = psIndices->lagIndex - psEncC->ec_prevLagIndex;\r
151             if( delta_lagIndex < -8 || delta_lagIndex > 11 ) {\r
152                 delta_lagIndex = 0;\r
153             } else {\r
154                 delta_lagIndex = delta_lagIndex + 9;\r
155                 encode_absolute_lagIndex = 0; /* Only use delta */\r
156             }\r
157             SKP_assert( delta_lagIndex >= 0 && delta_lagIndex < 21 );\r
158             ec_enc_icdf( psRangeEnc, delta_lagIndex, SKP_Silk_pitch_delta_iCDF, 8 );\r
159         }\r
160         if( encode_absolute_lagIndex ) {\r
161             /* Absolute encoding */\r
162             SKP_int32 pitch_high_bits, pitch_low_bits;\r
163             pitch_high_bits = SKP_DIV32_16( psIndices->lagIndex, SKP_RSHIFT( psEncC->fs_kHz, 1 ) );\r
164             pitch_low_bits = psIndices->lagIndex - SKP_SMULBB( pitch_high_bits, SKP_RSHIFT( psEncC->fs_kHz, 1 ) );\r
165             SKP_assert( pitch_low_bits < psEncC->fs_kHz / 2 );\r
166             SKP_assert( pitch_high_bits < 32 );\r
167             ec_enc_icdf( psRangeEnc, pitch_high_bits, SKP_Silk_pitch_lag_iCDF, 8 );\r
168             ec_enc_icdf( psRangeEnc, pitch_low_bits, psEncC->pitch_lag_low_bits_iCDF, 8 );\r
169         }\r
170         psEncC->ec_prevLagIndex = psIndices->lagIndex;\r
171 \r
172 #ifdef SAVE_ALL_INTERNAL_DATA\r
173         nBytes_after = SKP_RSHIFT( ec_tell( psRangeEnc ) + 7, 3 );\r
174         nBytes_lagIndex = nBytes_after - nBytes_before; // bytes just added\r
175 #endif\r
176 \r
177 #ifdef SAVE_ALL_INTERNAL_DATA\r
178         nBytes_before = SKP_RSHIFT( ec_tell( psRangeEnc ) + 7, 3 );\r
179 #endif\r
180         /* Countour index */\r
181         SKP_assert(   psIndices->contourIndex  >= 0 );\r
182         SKP_assert( ( psIndices->contourIndex < 34 && psEncC->fs_kHz  > 8 && psEncC->nb_subfr == 4 ) ||\r
183                     ( psIndices->contourIndex < 11 && psEncC->fs_kHz == 8 && psEncC->nb_subfr == 4 ) ||\r
184                     ( psIndices->contourIndex < 12 && psEncC->fs_kHz  > 8 && psEncC->nb_subfr == 2 ) ||\r
185                     ( psIndices->contourIndex <  3 && psEncC->fs_kHz == 8 && psEncC->nb_subfr == 2 ) );\r
186         ec_enc_icdf( psRangeEnc, psIndices->contourIndex, psEncC->pitch_contour_iCDF, 8 );\r
187 #ifdef SAVE_ALL_INTERNAL_DATA\r
188         nBytes_after = SKP_RSHIFT( ec_tell( psRangeEnc ) + 7, 3 );\r
189         nBytes_contourIndex = nBytes_after - nBytes_before; // bytes just added\r
190 #endif\r
191 \r
192         /********************/\r
193         /* Encode LTP gains */\r
194         /********************/\r
195 #ifdef SAVE_ALL_INTERNAL_DATA\r
196         nBytes_before = SKP_RSHIFT( ec_tell( psRangeEnc ) + 7, 3 );\r
197 #endif\r
198 \r
199         /* PERIndex value */\r
200         SKP_assert( psIndices->PERIndex >= 0 && psIndices->PERIndex < 3 );\r
201         ec_enc_icdf( psRangeEnc, psIndices->PERIndex, SKP_Silk_LTP_per_index_iCDF, 8 );\r
202 \r
203         /* Codebook Indices */\r
204         for( k = 0; k < psEncC->nb_subfr; k++ ) {\r
205             SKP_assert( psIndices->LTPIndex[ k ] >= 0 && psIndices->LTPIndex[ k ] < ( 8 << psIndices->PERIndex ) );\r
206             ec_enc_icdf( psRangeEnc, psIndices->LTPIndex[ k ], SKP_Silk_LTP_gain_iCDF_ptrs[ psIndices->PERIndex ], 8 );\r
207         }\r
208 \r
209         /**********************/\r
210         /* Encode LTP scaling */\r
211         /**********************/\r
212         if( !condCoding ) {\r
213             SKP_assert( psIndices->LTP_scaleIndex >= 0 && psIndices->LTP_scaleIndex < 3 );\r
214             ec_enc_icdf( psRangeEnc, psIndices->LTP_scaleIndex, SKP_Silk_LTPscale_iCDF, 8 );\r
215         }\r
216         SKP_assert( !condCoding || psIndices->LTP_scaleIndex == 0 );\r
217 \r
218 #ifdef SAVE_ALL_INTERNAL_DATA\r
219         nBytes_after = SKP_RSHIFT( ec_tell( psRangeEnc ) + 7, 3 );\r
220         nBytes_LTP = nBytes_after - nBytes_before; // bytes just added\r
221 #endif\r
222     }\r
223 #ifdef SAVE_ALL_INTERNAL_DATA\r
224     else { \r
225         // Unvoiced speech\r
226         nBytes_lagIndex     = 0;\r
227         nBytes_contourIndex = 0;\r
228         nBytes_LTP          = 0;\r
229     }\r
230     DEBUG_STORE_DATA( nBytes_lagIndex.dat,      &nBytes_lagIndex,       sizeof( SKP_int ) );\r
231     DEBUG_STORE_DATA( nBytes_contourIndex.dat,  &nBytes_contourIndex,   sizeof( SKP_int ) );\r
232     DEBUG_STORE_DATA( nBytes_LTP.dat,           &nBytes_LTP,            sizeof( SKP_int ) );\r
233 #endif\r
234 \r
235     psEncC->ec_prevSignalType = psIndices->signalType;\r
236 \r
237 #ifdef SAVE_ALL_INTERNAL_DATA\r
238     nBytes_before = SKP_RSHIFT( ec_tell( psRangeEnc ) + 7, 3 );\r
239 #endif\r
240 \r
241     /***************/\r
242     /* Encode seed */\r
243     /***************/\r
244     SKP_assert( psIndices->Seed >= 0 && psIndices->Seed < 4 );\r
245     ec_enc_icdf( psRangeEnc, psIndices->Seed, SKP_Silk_uniform4_iCDF, 8 );\r
246 }\r