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