Avoiding the term "mode" in opus_demo
[opus.git] / silk / NLSF_del_dec_quant.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, are permitted provided that the following conditions
5 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 Internet Society, IETF or IETF Trust, nor the
12 names of specific contributors, may be used to endorse or promote
13 products derived from this software without specific prior written
14 permission.
15 THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
16 AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
17 IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
18 ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
19 LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
20 CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
21 SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
22 INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
23 CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
24 ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
25 POSSIBILITY OF SUCH DAMAGE.
26 ***********************************************************************/
27
28 #ifdef HAVE_CONFIG_H
29 #include "config.h"
30 #endif
31
32 #include "main.h"
33
34 /* Delayed-decision quantizer for NLSF residuals */
35 opus_int32 silk_NLSF_del_dec_quant(                             /* O    Returns RD value in Q25                     */
36     opus_int8                   indices[],                      /* O    Quantization indices [ order ]              */
37     const opus_int16            x_Q10[],                        /* I    Input [ order ]                             */
38     const opus_int16            w_Q5[],                         /* I    Weights [ order ]                           */
39     const opus_uint8            pred_coef_Q8[],                 /* I    Backward predictor coefs [ order ]          */
40     const opus_int16            ec_ix[],                        /* I    Indices to entropy coding tables [ order ]  */
41     const opus_uint8            ec_rates_Q5[],                  /* I    Rates []                                    */
42     const opus_int              quant_step_size_Q16,            /* I    Quantization step size                      */
43     const opus_int16            inv_quant_step_size_Q6,         /* I    Inverse quantization step size              */
44     const opus_int32            mu_Q20,                         /* I    R/D tradeoff                                */
45     const opus_int16            order                           /* I    Number of input values                      */
46 )
47 {
48     opus_int         i, j, nStates, ind_tmp, ind_min_max, ind_max_min, in_Q10, res_Q10;
49     opus_int         pred_Q10, diff_Q10, out0_Q10, out1_Q10, rate0_Q5, rate1_Q5;
50     opus_int32       RD_tmp_Q25, min_Q25, min_max_Q25, max_min_Q25, pred_coef_Q16;
51     opus_int         ind_sort[         NLSF_QUANT_DEL_DEC_STATES ];
52     opus_int8        ind[              NLSF_QUANT_DEL_DEC_STATES ][ MAX_LPC_ORDER ];
53     opus_int16       prev_out_Q10[ 2 * NLSF_QUANT_DEL_DEC_STATES ];
54     opus_int32       RD_Q25[       2 * NLSF_QUANT_DEL_DEC_STATES ];
55     opus_int32       RD_min_Q25[       NLSF_QUANT_DEL_DEC_STATES ];
56     opus_int32       RD_max_Q25[       NLSF_QUANT_DEL_DEC_STATES ];
57     const opus_uint8 *rates_Q5;
58
59     opus_int out0_Q10_table[2 * NLSF_QUANT_MAX_AMPLITUDE_EXT];
60     opus_int out1_Q10_table[2 * NLSF_QUANT_MAX_AMPLITUDE_EXT];
61
62     for (i = -NLSF_QUANT_MAX_AMPLITUDE_EXT; i <= NLSF_QUANT_MAX_AMPLITUDE_EXT-1; i++)
63     {
64         out0_Q10 = silk_LSHIFT( i, 10 );
65         out1_Q10 = silk_ADD16( out0_Q10, 1024 );
66         if( i > 0 ) {
67             out0_Q10 = silk_SUB16( out0_Q10, SILK_FIX_CONST( NLSF_QUANT_LEVEL_ADJ, 10 ) );
68             out1_Q10 = silk_SUB16( out1_Q10, SILK_FIX_CONST( NLSF_QUANT_LEVEL_ADJ, 10 ) );
69         } else if( i == 0 ) {
70             out1_Q10 = silk_SUB16( out1_Q10, SILK_FIX_CONST( NLSF_QUANT_LEVEL_ADJ, 10 ) );
71         } else if( i == -1 ) {
72             out0_Q10 = silk_ADD16( out0_Q10, SILK_FIX_CONST( NLSF_QUANT_LEVEL_ADJ, 10 ) );
73         } else {
74             out0_Q10 = silk_ADD16( out0_Q10, SILK_FIX_CONST( NLSF_QUANT_LEVEL_ADJ, 10 ) );
75             out1_Q10 = silk_ADD16( out1_Q10, SILK_FIX_CONST( NLSF_QUANT_LEVEL_ADJ, 10 ) );
76         }
77         out0_Q10_table[ i + NLSF_QUANT_MAX_AMPLITUDE_EXT ] = silk_SMULWB( (opus_int32)out0_Q10, quant_step_size_Q16 );
78         out1_Q10_table[ i + NLSF_QUANT_MAX_AMPLITUDE_EXT ] = silk_SMULWB( (opus_int32)out1_Q10, quant_step_size_Q16 );
79     }
80
81     silk_assert( (NLSF_QUANT_DEL_DEC_STATES & (NLSF_QUANT_DEL_DEC_STATES-1)) == 0 );     /* must be power of two */
82
83     nStates = 1;
84     RD_Q25[ 0 ] = 0;
85     prev_out_Q10[ 0 ] = 0;
86     for( i = order - 1; ; i-- ) {
87         rates_Q5 = &ec_rates_Q5[ ec_ix[ i ] ];
88         pred_coef_Q16 = silk_LSHIFT( (opus_int32)pred_coef_Q8[ i ], 8 );
89         in_Q10 = x_Q10[ i ];
90         for( j = 0; j < nStates; j++ ) {
91             pred_Q10 = silk_SMULWB( pred_coef_Q16, prev_out_Q10[ j ] );
92             res_Q10  = silk_SUB16( in_Q10, pred_Q10 );
93             ind_tmp  = silk_SMULWB( (opus_int32)inv_quant_step_size_Q6, res_Q10 );
94             ind_tmp  = silk_LIMIT( ind_tmp, -NLSF_QUANT_MAX_AMPLITUDE_EXT, NLSF_QUANT_MAX_AMPLITUDE_EXT-1 );
95             ind[ j ][ i ] = (opus_int8)ind_tmp;
96
97             /* compute outputs for ind_tmp and ind_tmp + 1 */
98             out0_Q10 = out0_Q10_table[ ind_tmp + NLSF_QUANT_MAX_AMPLITUDE_EXT ];
99             out1_Q10 = out1_Q10_table[ ind_tmp + NLSF_QUANT_MAX_AMPLITUDE_EXT ];
100
101             out0_Q10  = silk_ADD16( out0_Q10, pred_Q10 );
102             out1_Q10  = silk_ADD16( out1_Q10, pred_Q10 );
103             prev_out_Q10[ j           ] = out0_Q10;
104             prev_out_Q10[ j + nStates ] = out1_Q10;
105
106             /* compute RD for ind_tmp and ind_tmp + 1 */
107             if( ind_tmp + 1 >= NLSF_QUANT_MAX_AMPLITUDE ) {
108                 if( ind_tmp + 1 == NLSF_QUANT_MAX_AMPLITUDE ) {
109                     rate0_Q5 = rates_Q5[ ind_tmp + NLSF_QUANT_MAX_AMPLITUDE ];
110                     rate1_Q5 = 280;
111                 } else {
112                     rate0_Q5 = silk_SMLABB( 280 - 43 * NLSF_QUANT_MAX_AMPLITUDE, 43, ind_tmp );
113                     rate1_Q5 = silk_ADD16( rate0_Q5, 43 );
114                 }
115             } else if( ind_tmp <= -NLSF_QUANT_MAX_AMPLITUDE ) {
116                 if( ind_tmp == -NLSF_QUANT_MAX_AMPLITUDE ) {
117                     rate0_Q5 = 280;
118                     rate1_Q5 = rates_Q5[ ind_tmp + 1 + NLSF_QUANT_MAX_AMPLITUDE ];
119                 } else {
120                     rate0_Q5 = silk_SMLABB( 280 - 43 * NLSF_QUANT_MAX_AMPLITUDE, -43, ind_tmp );
121                     rate1_Q5 = silk_SUB16( rate0_Q5, 43 );
122                 }
123             } else {
124                 rate0_Q5 = rates_Q5[ ind_tmp +     NLSF_QUANT_MAX_AMPLITUDE ];
125                 rate1_Q5 = rates_Q5[ ind_tmp + 1 + NLSF_QUANT_MAX_AMPLITUDE ];
126             }
127             RD_tmp_Q25            = RD_Q25[ j ];
128             diff_Q10              = silk_SUB16( in_Q10, out0_Q10 );
129             RD_Q25[ j ]           = silk_SMLABB( silk_MLA( RD_tmp_Q25, silk_SMULBB( diff_Q10, diff_Q10 ), w_Q5[ i ] ), mu_Q20, rate0_Q5 );
130             diff_Q10              = silk_SUB16( in_Q10, out1_Q10 );
131             RD_Q25[ j + nStates ] = silk_SMLABB( silk_MLA( RD_tmp_Q25, silk_SMULBB( diff_Q10, diff_Q10 ), w_Q5[ i ] ), mu_Q20, rate1_Q5 );
132         }
133
134         if( nStates <= ( NLSF_QUANT_DEL_DEC_STATES >> 1 ) ) {
135             /* double number of states and copy */
136             for( j = 0; j < nStates; j++ ) {
137                 ind[ j + nStates ][ i ] = ind[ j ][ i ] + 1;
138             }
139             nStates = silk_LSHIFT( nStates, 1 );
140             for( j = nStates; j < NLSF_QUANT_DEL_DEC_STATES; j++ ) {
141                 ind[ j ][ i ] = ind[ j - nStates ][ i ];
142             }
143         } else if( i > 0 ) {
144             /* sort lower and upper half of RD_Q25, pairwise */
145             for( j = 0; j < NLSF_QUANT_DEL_DEC_STATES; j++ ) {
146                 if( RD_Q25[ j ] > RD_Q25[ j + NLSF_QUANT_DEL_DEC_STATES ] ) {
147                     RD_max_Q25[ j ]                         = RD_Q25[ j ];
148                     RD_min_Q25[ j ]                         = RD_Q25[ j + NLSF_QUANT_DEL_DEC_STATES ];
149                     RD_Q25[ j ]                             = RD_min_Q25[ j ];
150                     RD_Q25[ j + NLSF_QUANT_DEL_DEC_STATES ] = RD_max_Q25[ j ];
151                     /* swap prev_out values */
152                     out0_Q10 = prev_out_Q10[ j ];
153                     prev_out_Q10[ j ] = prev_out_Q10[ j + NLSF_QUANT_DEL_DEC_STATES ];
154                     prev_out_Q10[ j + NLSF_QUANT_DEL_DEC_STATES ] = out0_Q10;
155                     ind_sort[ j ] = j + NLSF_QUANT_DEL_DEC_STATES;
156                 } else {
157                     RD_min_Q25[ j ] = RD_Q25[ j ];
158                     RD_max_Q25[ j ] = RD_Q25[ j + NLSF_QUANT_DEL_DEC_STATES ];
159                     ind_sort[ j ] = j;
160                 }
161             }
162             /* compare the highest RD values of the winning half with the lowest one in the losing half, and copy if necessary */
163             /* afterwards ind_sort[] will contain the indices of the NLSF_QUANT_DEL_DEC_STATES winning RD values */
164             while( 1 ) {
165                 min_max_Q25 = silk_int32_MAX;
166                 max_min_Q25 = 0;
167                 ind_min_max = 0;
168                 ind_max_min = 0;
169                 for( j = 0; j < NLSF_QUANT_DEL_DEC_STATES; j++ ) {
170                     if( min_max_Q25 > RD_max_Q25[ j ] ) {
171                         min_max_Q25 = RD_max_Q25[ j ];
172                         ind_min_max = j;
173                     }
174                     if( max_min_Q25 < RD_min_Q25[ j ] ) {
175                         max_min_Q25 = RD_min_Q25[ j ];
176                         ind_max_min = j;
177                     }
178                 }
179                 if( min_max_Q25 >= max_min_Q25 ) {
180                     break;
181                 }
182                 /* copy ind_min_max to ind_max_min */
183                 ind_sort[     ind_max_min ] = ind_sort[     ind_min_max ] ^ NLSF_QUANT_DEL_DEC_STATES;
184                 RD_Q25[       ind_max_min ] = RD_Q25[       ind_min_max + NLSF_QUANT_DEL_DEC_STATES ];
185                 prev_out_Q10[ ind_max_min ] = prev_out_Q10[ ind_min_max + NLSF_QUANT_DEL_DEC_STATES ];
186                 RD_min_Q25[   ind_max_min ] = 0;
187                 RD_max_Q25[   ind_min_max ] = silk_int32_MAX;
188                 silk_memcpy( ind[ ind_max_min ], ind[ ind_min_max ], MAX_LPC_ORDER * sizeof( opus_int8 ) );
189             }
190             /* increment index if it comes from the upper half */
191             for( j = 0; j < NLSF_QUANT_DEL_DEC_STATES; j++ ) {
192                 ind[ j ][ i ] += silk_RSHIFT( ind_sort[ j ], NLSF_QUANT_DEL_DEC_STATES_LOG2 );
193             }
194         } else {  /* i == 0 */
195             break;
196         }
197     }
198
199     /* last sample: find winner, copy indices and return RD value */
200     ind_tmp = 0;
201     min_Q25 = silk_int32_MAX;
202     for( j = 0; j < 2 * NLSF_QUANT_DEL_DEC_STATES; j++ ) {
203         if( min_Q25 > RD_Q25[ j ] ) {
204             min_Q25 = RD_Q25[ j ];
205             ind_tmp = j;
206         }
207     }
208     for( j = 0; j < order; j++ ) {
209         indices[ j ] = ind[ ind_tmp & ( NLSF_QUANT_DEL_DEC_STATES - 1 ) ][ j ];
210         silk_assert( indices[ j ] >= -NLSF_QUANT_MAX_AMPLITUDE_EXT );
211         silk_assert( indices[ j ] <=  NLSF_QUANT_MAX_AMPLITUDE_EXT );
212     }
213     indices[ 0 ] += silk_RSHIFT( ind_tmp, NLSF_QUANT_DEL_DEC_STATES_LOG2 );
214     silk_assert( indices[ 0 ] <= NLSF_QUANT_MAX_AMPLITUDE_EXT );
215     silk_assert( min_Q25 >= 0 );
216     return min_Q25;
217 }