Update SILK code using the CELT range coder
[opus.git] / src_common / SKP_Silk_encode_parameters_v4.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 /*******************************************/\r
31 /* Encode parameters to create the payload */\r
32 /*******************************************/\r
33 void SKP_Silk_encode_parameters_v4(\r
34     SKP_Silk_encoder_state          *psEncC,        /* I/O  Encoder state                   */\r
35     SKP_Silk_encoder_control        *psEncCtrlC,    /* I/O  Encoder control                 */\r
36     SKP_Silk_range_coder_state      *psRC           /* I/O  Range encoder state             */\r
37 )\r
38 {\r
39     SKP_int   i, k, typeOffset;\r
40     SKP_int   encode_absolute_lagIndex, delta_lagIndex;\r
41     const SKP_Silk_NLSF_CB_struct *psNLSF_CB;\r
42 \r
43 #ifdef 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     /*************************************/\r
49     /* Encode sampling rate and          */\r
50     /* number of subframes in each frame */\r
51     /*************************************/\r
52     /* only done for first frame in packet */\r
53     if( psEncC->nFramesInPayloadBuf == 0 ) {\r
54         /* get sampling rate index */\r
55         for( i = 0; i < 3; i++ ) {\r
56             if( SKP_Silk_SamplingRates_table[ i ] == psEncC->fs_kHz ) {\r
57                 break;\r
58             }\r
59         }\r
60         SKP_Silk_range_encoder( psRC, i, SKP_Silk_SamplingRates_CDF );\r
61 \r
62         /* Convert number of subframes to index */\r
63         SKP_assert( psEncC->nb_subfr == MAX_NB_SUBFR >> 1 || psEncC->nb_subfr == MAX_NB_SUBFR );\r
64         i = (psEncC->nb_subfr >> 1) - 1;\r
65         SKP_Silk_range_encoder( psRC, i, SKP_Silk_NbSubframes_CDF );\r
66     }\r
67 \r
68     /*********************************************/\r
69     /* Encode VAD flag                           */\r
70     /*********************************************/\r
71     SKP_Silk_range_encoder( psRC, psEncC->vadFlag, SKP_Silk_vadflag_CDF );\r
72 \r
73     /*******************************************/\r
74     /* Encode signal type and quantizer offset */\r
75     /*******************************************/\r
76     typeOffset = 2 * psEncCtrlC->sigtype + psEncCtrlC->QuantOffsetType;\r
77     if( psEncC->nFramesInPayloadBuf == 0 ) {\r
78         /* first frame in packet: independent coding */\r
79         SKP_Silk_range_encoder( psRC, typeOffset, SKP_Silk_type_offset_CDF );\r
80     } else {\r
81         /* condidtional coding */\r
82         SKP_Silk_range_encoder( psRC, typeOffset, SKP_Silk_type_offset_joint_CDF[ psEncC->typeOffsetPrev ] );\r
83     }\r
84     psEncC->typeOffsetPrev = typeOffset;\r
85 \r
86     /****************/\r
87     /* Encode gains */\r
88     /****************/\r
89 #ifdef SAVE_ALL_INTERNAL_DATA\r
90     SKP_Silk_range_encoder_get_length( psRC, &nBytes_before );\r
91 #endif\r
92     /* first subframe */\r
93     if( psEncC->nFramesInPayloadBuf == 0 ) {\r
94         /* first frame in packet: independent coding */\r
95         SKP_Silk_range_encoder( psRC, psEncCtrlC->GainsIndices[ 0 ], SKP_Silk_gain_CDF[ psEncCtrlC->sigtype ] );\r
96     } else {\r
97         /* condidtional coding */\r
98         SKP_Silk_range_encoder( psRC, psEncCtrlC->GainsIndices[ 0 ], SKP_Silk_delta_gain_CDF );\r
99     }\r
100 \r
101     /* remaining subframes */\r
102     for( i = 1; i < psEncC->nb_subfr; i++ ) {\r
103         SKP_Silk_range_encoder( psRC, psEncCtrlC->GainsIndices[ i ], SKP_Silk_delta_gain_CDF );\r
104     }\r
105 \r
106 #ifdef SAVE_ALL_INTERNAL_DATA\r
107     SKP_Silk_range_encoder_get_length( psRC, &nBytes_after );\r
108     nBytes_after -= nBytes_before; // bytes just added\r
109     DEBUG_STORE_DATA( nBytes_gains.dat, &nBytes_after, sizeof( SKP_int ) );\r
110 #endif\r
111 \r
112     /****************/\r
113     /* Encode NLSFs */\r
114     /****************/\r
115 #ifdef SAVE_ALL_INTERNAL_DATA\r
116     SKP_Silk_range_encoder_get_length( psRC, &nBytes_before );\r
117 #endif\r
118     /* Range encoding of the NLSF path */\r
119     psNLSF_CB = psEncC->psNLSF_CB[ psEncCtrlC->sigtype ];\r
120     SKP_Silk_range_encoder_multi( psRC, psEncCtrlC->NLSFIndices, psNLSF_CB->StartPtr, psNLSF_CB->nStages );\r
121 \r
122     /* Encode NLSF interpolation factor */\r
123     SKP_assert( psEncC->useInterpolatedNLSFs == 1 || psEncCtrlC->NLSFInterpCoef_Q2 == ( 1 << 2 ) );\r
124     SKP_Silk_range_encoder( psRC, psEncCtrlC->NLSFInterpCoef_Q2, SKP_Silk_NLSF_interpolation_factor_CDF );\r
125 \r
126 #ifdef SAVE_ALL_INTERNAL_DATA\r
127     SKP_Silk_range_encoder_get_length( psRC, &nBytes_after );\r
128     nBytes_after -= nBytes_before; // bytes just added\r
129     DEBUG_STORE_DATA( nBytes_LSF.dat, &nBytes_after, sizeof( SKP_int ) );\r
130 #endif\r
131 \r
132     if( psEncCtrlC->sigtype == SIG_TYPE_VOICED ) {\r
133         /*********************/\r
134         /* Encode pitch lags */\r
135         /*********************/\r
136 #ifdef SAVE_ALL_INTERNAL_DATA\r
137         SKP_Silk_range_encoder_get_length( psRC, &nBytes_before );\r
138 #endif\r
139         /* lag index */\r
140         encode_absolute_lagIndex = 1;\r
141         if( psEncC->nFramesInPayloadBuf > 0 && psEncC->prev_sigtype == SIG_TYPE_VOICED ) {\r
142             /* Delta Encoding */\r
143             delta_lagIndex = psEncCtrlC->lagIndex - psEncC->prev_lagIndex;\r
144             if( delta_lagIndex > MAX_DELTA_LAG ) {\r
145                 delta_lagIndex = ( MAX_DELTA_LAG << 1 ) + 1;\r
146             } else if ( delta_lagIndex < -MAX_DELTA_LAG ) {\r
147                 delta_lagIndex = ( MAX_DELTA_LAG << 1 ) + 1;\r
148             } else {\r
149                 delta_lagIndex = delta_lagIndex + MAX_DELTA_LAG;\r
150                 encode_absolute_lagIndex = 0; /* Only use delta */\r
151             }\r
152             SKP_Silk_range_encoder( psRC, delta_lagIndex, SKP_Silk_pitch_delta_CDF );\r
153         }\r
154         if( encode_absolute_lagIndex ) {\r
155             /* Absolute encoding */\r
156             if( psEncC->fs_kHz == 8 ) {\r
157                 SKP_Silk_range_encoder( psRC, psEncCtrlC->lagIndex, SKP_Silk_pitch_lag_NB_CDF );\r
158             } else if( psEncC->fs_kHz == 12 ) {\r
159                 SKP_Silk_range_encoder( psRC, psEncCtrlC->lagIndex, SKP_Silk_pitch_lag_MB_CDF );\r
160             } else if( psEncC->fs_kHz == 16 ) {\r
161                 SKP_Silk_range_encoder( psRC, psEncCtrlC->lagIndex, SKP_Silk_pitch_lag_WB_CDF );\r
162             } else {\r
163                 SKP_Silk_range_encoder( psRC, psEncCtrlC->lagIndex, SKP_Silk_pitch_lag_SWB_CDF );\r
164             }\r
165         }\r
166         psEncC->prev_lagIndex = psEncCtrlC->lagIndex;\r
167 \r
168 #ifdef SAVE_ALL_INTERNAL_DATA\r
169         SKP_Silk_range_encoder_get_length( psRC, &nBytes_after );\r
170         nBytes_lagIndex = nBytes_after - nBytes_before; // bytes just added\r
171 #endif\r
172 \r
173 #ifdef SAVE_ALL_INTERNAL_DATA\r
174         SKP_Silk_range_encoder_get_length( psRC, &nBytes_before );\r
175 #endif\r
176         /* countour index */\r
177         if( psEncC->fs_kHz == 8 ) {\r
178             /* Less codevectors used in 8 khz mode */\r
179             SKP_Silk_range_encoder( psRC, psEncCtrlC->contourIndex, SKP_Silk_pitch_contour_NB_CDF );\r
180         } else {\r
181             /* Joint for 12, 16, 24 khz */\r
182             SKP_Silk_range_encoder( psRC, psEncCtrlC->contourIndex, SKP_Silk_pitch_contour_CDF );\r
183         }\r
184 #ifdef SAVE_ALL_INTERNAL_DATA\r
185         SKP_Silk_range_encoder_get_length( psRC, &nBytes_after ); \r
186         nBytes_contourIndex = nBytes_after - nBytes_before; // bytes just added\r
187 #endif\r
188 \r
189         /********************/\r
190         /* Encode LTP gains */\r
191         /********************/\r
192 #ifdef SAVE_ALL_INTERNAL_DATA\r
193         SKP_Silk_range_encoder_get_length( psRC, &nBytes_before );\r
194 #endif\r
195         /* PERIndex value */\r
196         SKP_Silk_range_encoder( psRC, psEncCtrlC->PERIndex, SKP_Silk_LTP_per_index_CDF );\r
197 \r
198         /* Codebook Indices */\r
199         for( k = 0; k < psEncC->nb_subfr; k++ ) {\r
200             SKP_Silk_range_encoder( psRC, psEncCtrlC->LTPIndex[ k ], SKP_Silk_LTP_gain_CDF_ptrs[ psEncCtrlC->PERIndex ] );\r
201         }\r
202 \r
203         /**********************/\r
204         /* Encode LTP scaling */\r
205         /**********************/\r
206         SKP_Silk_range_encoder( psRC, psEncCtrlC->LTP_scaleIndex, SKP_Silk_LTPscale_CDF );\r
207 #ifdef SAVE_ALL_INTERNAL_DATA\r
208         SKP_Silk_range_encoder_get_length( psRC, &nBytes_after );\r
209         nBytes_LTP = nBytes_after - nBytes_before; // bytes just added\r
210 #endif\r
211     }\r
212 #ifdef SAVE_ALL_INTERNAL_DATA\r
213     else { \r
214         // Unvoiced speech\r
215         nBytes_lagIndex     = 0;\r
216         nBytes_contourIndex = 0;\r
217         nBytes_LTP          = 0;\r
218     }\r
219     DEBUG_STORE_DATA( nBytes_lagIndex.dat,      &nBytes_lagIndex,       sizeof( SKP_int ) );\r
220     DEBUG_STORE_DATA( nBytes_contourIndex.dat,  &nBytes_contourIndex,   sizeof( SKP_int ) );\r
221     DEBUG_STORE_DATA( nBytes_LTP.dat,           &nBytes_LTP,            sizeof( SKP_int ) );\r
222 #endif\r
223 \r
224 #ifdef SAVE_ALL_INTERNAL_DATA\r
225     SKP_Silk_range_encoder_get_length( psRC, &nBytes_before );\r
226 #endif\r
227 \r
228     /***************/\r
229     /* Encode seed */\r
230     /***************/\r
231     SKP_Silk_range_encoder( psRC, psEncCtrlC->Seed, SKP_Silk_Seed_CDF );\r
232 }\r