Including config.h (fixes the fixed-point)
[opus.git] / silk / SKP_Silk_NLSF_del_dec_quant.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 /* Delayed-decision quantizer for NLSF residuals */\r
31 SKP_int32 SKP_Silk_NLSF_del_dec_quant(                  /* O    Returns RD value in Q25                     */\r
32     SKP_int8                    indices[],              /* O    Quantization indices [ order ]              */\r
33     const SKP_int16             x_Q10[],                /* I    Input [ order ]                             */\r
34     const SKP_int16             w_Q5[],                 /* I    Weights [ order ]                           */\r
35     const SKP_uint8             pred_coef_Q8[],         /* I    Backward predictor coefs [ order ]          */\r
36     const SKP_int16             ec_ix[],                /* I    Indices to entropy coding tables [ order ]  */\r
37     const SKP_uint8             ec_rates_Q5[],          /* I    Rates []                                    */\r
38     const SKP_int               quant_step_size_Q16,    /* I    Quantization step size                      */\r
39     const SKP_int16             inv_quant_step_size_Q6, /* I    Inverse quantization step size              */\r
40     const SKP_int32             mu_Q20,                 /* I    R/D tradeoff                                */\r
41     const SKP_int16             order                   /* I    Number of input values                      */\r
42 )\r
43 {\r
44     SKP_int         i, j, nStates, ind_tmp, ind_min_max, ind_max_min, in_Q10, res_Q10;\r
45     SKP_int         pred_Q10, diff_Q10, out0_Q10, out1_Q10, rate0_Q5, rate1_Q5;\r
46     SKP_int32       RD_tmp_Q25, min_Q25, min_max_Q25, max_min_Q25, pred_coef_Q16;\r
47     SKP_int         ind_sort[         NLSF_QUANT_DEL_DEC_STATES ];\r
48     SKP_int8        ind[              NLSF_QUANT_DEL_DEC_STATES ][ MAX_LPC_ORDER ];\r
49     SKP_int16       prev_out_Q10[ 2 * NLSF_QUANT_DEL_DEC_STATES ];\r
50     SKP_int32       RD_Q25[       2 * NLSF_QUANT_DEL_DEC_STATES ];\r
51     SKP_int32       RD_min_Q25[       NLSF_QUANT_DEL_DEC_STATES ];\r
52     SKP_int32       RD_max_Q25[       NLSF_QUANT_DEL_DEC_STATES ];\r
53     const SKP_uint8 *rates_Q5;\r
54     \r
55     SKP_assert( (NLSF_QUANT_DEL_DEC_STATES & (NLSF_QUANT_DEL_DEC_STATES-1)) == 0 );     /* must be power of two */\r
56 \r
57     nStates = 1;\r
58     RD_Q25[ 0 ] = 0;\r
59     prev_out_Q10[ 0 ] = 0;\r
60     for( i = order - 1; ; i-- ) {\r
61         rates_Q5 = &ec_rates_Q5[ ec_ix[ i ] ];\r
62         pred_coef_Q16 = SKP_LSHIFT( (SKP_int32)pred_coef_Q8[ i ], 8 );\r
63         in_Q10 = x_Q10[ i ];\r
64         for( j = 0; j < nStates; j++ ) {\r
65             pred_Q10 = SKP_SMULWB( pred_coef_Q16, prev_out_Q10[ j ] );\r
66             res_Q10  = SKP_SUB16( in_Q10, pred_Q10 );\r
67             ind_tmp  = SKP_SMULWB( inv_quant_step_size_Q6, res_Q10 );\r
68             ind_tmp  = SKP_LIMIT( ind_tmp, -NLSF_QUANT_MAX_AMPLITUDE_EXT, NLSF_QUANT_MAX_AMPLITUDE_EXT-1 );\r
69             ind[ j ][ i ] = (SKP_int8)ind_tmp;\r
70 \r
71             /* compute outputs for ind_tmp and ind_tmp + 1 */\r
72             out0_Q10 = SKP_LSHIFT( ind_tmp, 10 );\r
73             out1_Q10 = SKP_ADD16( out0_Q10, 1024 );\r
74             if( ind_tmp > 0 ) {\r
75                 out0_Q10 = SKP_SUB16( out0_Q10, SKP_FIX_CONST( NLSF_QUANT_LEVEL_ADJ, 10 ) );\r
76                 out1_Q10 = SKP_SUB16( out1_Q10, SKP_FIX_CONST( NLSF_QUANT_LEVEL_ADJ, 10 ) );\r
77             } else if( ind_tmp == 0 ) {\r
78                 out1_Q10 = SKP_SUB16( out1_Q10, SKP_FIX_CONST( NLSF_QUANT_LEVEL_ADJ, 10 ) );\r
79             } else if( ind_tmp == -1 ) {\r
80                 out0_Q10 = SKP_ADD16( out0_Q10, SKP_FIX_CONST( NLSF_QUANT_LEVEL_ADJ, 10 ) );\r
81             } else {\r
82                 out0_Q10 = SKP_ADD16( out0_Q10, SKP_FIX_CONST( NLSF_QUANT_LEVEL_ADJ, 10 ) );\r
83                 out1_Q10 = SKP_ADD16( out1_Q10, SKP_FIX_CONST( NLSF_QUANT_LEVEL_ADJ, 10 ) );\r
84             }\r
85             out0_Q10  = SKP_SMULWB( out0_Q10, quant_step_size_Q16 );\r
86             out1_Q10  = SKP_SMULWB( out1_Q10, quant_step_size_Q16 );\r
87             out0_Q10  = SKP_ADD16( out0_Q10, pred_Q10 );\r
88             out1_Q10  = SKP_ADD16( out1_Q10, pred_Q10 );\r
89             prev_out_Q10[ j           ] = out0_Q10;\r
90             prev_out_Q10[ j + nStates ] = out1_Q10;\r
91 \r
92             /* compute RD for ind_tmp and ind_tmp + 1 */\r
93             if( ind_tmp + 1 >= NLSF_QUANT_MAX_AMPLITUDE ) {\r
94                 if( ind_tmp + 1 == NLSF_QUANT_MAX_AMPLITUDE ) {\r
95                     rate0_Q5 = rates_Q5[ ind_tmp + NLSF_QUANT_MAX_AMPLITUDE ];\r
96                     rate1_Q5 = 280;\r
97                 } else {\r
98                     rate0_Q5 = SKP_SMLABB( 280 - 43 * NLSF_QUANT_MAX_AMPLITUDE, 43, ind_tmp );\r
99                     rate1_Q5 = SKP_ADD16( rate0_Q5, 43 ); \r
100                 }\r
101             } else if( ind_tmp <= -NLSF_QUANT_MAX_AMPLITUDE ) {\r
102                 if( ind_tmp == -NLSF_QUANT_MAX_AMPLITUDE ) {\r
103                     rate0_Q5 = 280;\r
104                     rate1_Q5 = rates_Q5[ ind_tmp + 1 + NLSF_QUANT_MAX_AMPLITUDE ]; \r
105                 } else {\r
106                     rate0_Q5 = SKP_SMLABB( 280 - 43 * NLSF_QUANT_MAX_AMPLITUDE, -43, ind_tmp );\r
107                     rate1_Q5 = SKP_SUB16( rate0_Q5, 43 ); \r
108                 }\r
109             } else {\r
110                 rate0_Q5 = rates_Q5[ ind_tmp +     NLSF_QUANT_MAX_AMPLITUDE ];\r
111                 rate1_Q5 = rates_Q5[ ind_tmp + 1 + NLSF_QUANT_MAX_AMPLITUDE ];\r
112             }\r
113             RD_tmp_Q25            = RD_Q25[ j ];\r
114             diff_Q10              = SKP_SUB16( in_Q10, out0_Q10 );\r
115             RD_Q25[ j ]           = SKP_SMLABB( SKP_MLA( RD_tmp_Q25, SKP_SMULBB( diff_Q10, diff_Q10 ), w_Q5[ i ] ), mu_Q20, rate0_Q5 );\r
116             diff_Q10              = SKP_SUB16( in_Q10, out1_Q10 );\r
117             RD_Q25[ j + nStates ] = SKP_SMLABB( SKP_MLA( RD_tmp_Q25, SKP_SMULBB( diff_Q10, diff_Q10 ), w_Q5[ i ] ), mu_Q20, rate1_Q5 );\r
118         }\r
119 \r
120         if( nStates < NLSF_QUANT_DEL_DEC_STATES ) {\r
121             /* double number of states and copy */\r
122             for( j = 0; j < nStates; j++ ) {\r
123                 ind[ j + nStates ][ i ] = ind[ j ][ i ] + 1;\r
124             }\r
125             nStates = SKP_LSHIFT( nStates, 1 );\r
126             for( j = nStates; j < NLSF_QUANT_DEL_DEC_STATES; j++ ) {\r
127                 ind[ j ][ i ] = ind[ j - nStates ][ i ];\r
128             }\r
129         } else if( i > 0 ) {\r
130             /* sort lower and upper half of RD_Q25, pairwise */\r
131             for( j = 0; j < NLSF_QUANT_DEL_DEC_STATES; j++ ) {\r
132                 if( RD_Q25[ j ] > RD_Q25[ j + NLSF_QUANT_DEL_DEC_STATES ] ) {\r
133                     RD_max_Q25[ j ]                         = RD_Q25[ j ];\r
134                     RD_min_Q25[ j ]                         = RD_Q25[ j + NLSF_QUANT_DEL_DEC_STATES ];\r
135                     RD_Q25[ j ]                             = RD_min_Q25[ j ];\r
136                     RD_Q25[ j + NLSF_QUANT_DEL_DEC_STATES ] = RD_max_Q25[ j ];\r
137                     /* swap prev_out values */\r
138                     out0_Q10 = prev_out_Q10[ j ];\r
139                     prev_out_Q10[ j ] = prev_out_Q10[ j + NLSF_QUANT_DEL_DEC_STATES ];\r
140                     prev_out_Q10[ j + NLSF_QUANT_DEL_DEC_STATES ] = out0_Q10;\r
141                     ind_sort[ j ] = j + NLSF_QUANT_DEL_DEC_STATES;\r
142                 } else {\r
143                     RD_min_Q25[ j ] = RD_Q25[ j ];\r
144                     RD_max_Q25[ j ] = RD_Q25[ j + NLSF_QUANT_DEL_DEC_STATES ];\r
145                     ind_sort[ j ] = j;\r
146                 }\r
147             }\r
148             /* compare the highest RD values of the winning half with the lowest one in the losing half, and copy if necessary */\r
149             /* afterwards ind_sort[] will contain the indices of the NLSF_QUANT_DEL_DEC_STATES winning RD values */\r
150             while( 1 ) {\r
151                 min_max_Q25 = SKP_int32_MAX;\r
152                 max_min_Q25 = 0;\r
153                 ind_min_max = 0;\r
154                 ind_max_min = 0;\r
155                 for( j = 0; j < NLSF_QUANT_DEL_DEC_STATES; j++ ) {\r
156                     if( min_max_Q25 > RD_max_Q25[ j ] ) {\r
157                         min_max_Q25 = RD_max_Q25[ j ];\r
158                         ind_min_max = j;\r
159                     }\r
160                     if( max_min_Q25 < RD_min_Q25[ j ] ) {\r
161                         max_min_Q25 = RD_min_Q25[ j ];\r
162                         ind_max_min = j;\r
163                     }\r
164                 }\r
165                 if( min_max_Q25 >= max_min_Q25 ) {\r
166                     break;\r
167                 }\r
168                 /* copy ind_min_max to ind_max_min */\r
169                 ind_sort[     ind_max_min ] = ind_sort[     ind_min_max ] ^ NLSF_QUANT_DEL_DEC_STATES;\r
170                 RD_Q25[       ind_max_min ] = RD_Q25[       ind_min_max + NLSF_QUANT_DEL_DEC_STATES ];\r
171                 prev_out_Q10[ ind_max_min ] = prev_out_Q10[ ind_min_max + NLSF_QUANT_DEL_DEC_STATES ];\r
172                 RD_min_Q25[   ind_max_min ] = 0;\r
173                 RD_max_Q25[   ind_min_max ] = SKP_int32_MAX;\r
174                 SKP_memcpy( ind[ ind_max_min ], ind[ ind_min_max ], MAX_LPC_ORDER * sizeof( SKP_int8 ) );\r
175             }\r
176             /* increment index if it comes from the upper half */\r
177             for( j = 0; j < NLSF_QUANT_DEL_DEC_STATES; j++ ) {\r
178                 ind[ j ][ i ] += SKP_RSHIFT( ind_sort[ j ], NLSF_QUANT_DEL_DEC_STATES_LOG2 );\r
179             }\r
180         } else {  /* i == 0 */\r
181             /* last sample: find winner, copy indices and return RD value */\r
182             ind_tmp = 0;\r
183             min_Q25 = SKP_int32_MAX;\r
184             for( j = 0; j < 2 * NLSF_QUANT_DEL_DEC_STATES; j++ ) {\r
185                 if( min_Q25 > RD_Q25[ j ] ) {\r
186                     min_Q25 = RD_Q25[ j ];\r
187                     ind_tmp = j;\r
188                 }\r
189             }\r
190             for( j = 0; j < order; j++ ) {\r
191                 indices[ j ] = ind[ ind_tmp & ( NLSF_QUANT_DEL_DEC_STATES - 1 ) ][ j ];\r
192                 SKP_assert( indices[ j ] >= -NLSF_QUANT_MAX_AMPLITUDE_EXT );\r
193                 SKP_assert( indices[ j ] <=  NLSF_QUANT_MAX_AMPLITUDE_EXT );\r
194             }\r
195             indices[ 0 ] += SKP_RSHIFT( ind_tmp, NLSF_QUANT_DEL_DEC_STATES_LOG2 );\r
196             SKP_assert( indices[ 0 ] <= NLSF_QUANT_MAX_AMPLITUDE_EXT );\r
197             SKP_assert( min_Q25 >= 0 );\r
198             return min_Q25;\r
199         }\r
200     }\r
201 }\r