michael@0: /***********************************************************************
michael@0: Copyright (c) 2006-2011, Skype Limited. All rights reserved.
michael@0: Redistribution and use in source and binary forms, with or without
michael@0: modification, are permitted provided that the following conditions
michael@0: are met:
michael@0: - Redistributions of source code must retain the above copyright notice,
michael@0: this list of conditions and the following disclaimer.
michael@0: - Redistributions in binary form must reproduce the above copyright
michael@0: notice, this list of conditions and the following disclaimer in the
michael@0: documentation and/or other materials provided with the distribution.
michael@0: - Neither the name of Internet Society, IETF or IETF Trust, nor the
michael@0: names of specific contributors, may be used to endorse or promote
michael@0: products derived from this software without specific prior written
michael@0: permission.
michael@0: THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
michael@0: AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
michael@0: IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
michael@0: ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
michael@0: LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
michael@0: CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
michael@0: SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
michael@0: INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
michael@0: CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
michael@0: ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
michael@0: POSSIBILITY OF SUCH DAMAGE.
michael@0: ***********************************************************************/
michael@0: 
michael@0: #ifdef HAVE_CONFIG_H
michael@0: #include "config.h"
michael@0: #endif
michael@0: 
michael@0: #include "main.h"
michael@0: 
michael@0: /* Delayed-decision quantizer for NLSF residuals */
michael@0: opus_int32 silk_NLSF_del_dec_quant(                             /* O    Returns RD value in Q25                     */
michael@0:     opus_int8                   indices[],                      /* O    Quantization indices [ order ]              */
michael@0:     const opus_int16            x_Q10[],                        /* I    Input [ order ]                             */
michael@0:     const opus_int16            w_Q5[],                         /* I    Weights [ order ]                           */
michael@0:     const opus_uint8            pred_coef_Q8[],                 /* I    Backward predictor coefs [ order ]          */
michael@0:     const opus_int16            ec_ix[],                        /* I    Indices to entropy coding tables [ order ]  */
michael@0:     const opus_uint8            ec_rates_Q5[],                  /* I    Rates []                                    */
michael@0:     const opus_int              quant_step_size_Q16,            /* I    Quantization step size                      */
michael@0:     const opus_int16            inv_quant_step_size_Q6,         /* I    Inverse quantization step size              */
michael@0:     const opus_int32            mu_Q20,                         /* I    R/D tradeoff                                */
michael@0:     const opus_int16            order                           /* I    Number of input values                      */
michael@0: )
michael@0: {
michael@0:     opus_int         i, j, nStates, ind_tmp, ind_min_max, ind_max_min, in_Q10, res_Q10;
michael@0:     opus_int         pred_Q10, diff_Q10, out0_Q10, out1_Q10, rate0_Q5, rate1_Q5;
michael@0:     opus_int32       RD_tmp_Q25, min_Q25, min_max_Q25, max_min_Q25, pred_coef_Q16;
michael@0:     opus_int         ind_sort[         NLSF_QUANT_DEL_DEC_STATES ];
michael@0:     opus_int8        ind[              NLSF_QUANT_DEL_DEC_STATES ][ MAX_LPC_ORDER ];
michael@0:     opus_int16       prev_out_Q10[ 2 * NLSF_QUANT_DEL_DEC_STATES ];
michael@0:     opus_int32       RD_Q25[       2 * NLSF_QUANT_DEL_DEC_STATES ];
michael@0:     opus_int32       RD_min_Q25[       NLSF_QUANT_DEL_DEC_STATES ];
michael@0:     opus_int32       RD_max_Q25[       NLSF_QUANT_DEL_DEC_STATES ];
michael@0:     const opus_uint8 *rates_Q5;
michael@0: 
michael@0:     silk_assert( (NLSF_QUANT_DEL_DEC_STATES & (NLSF_QUANT_DEL_DEC_STATES-1)) == 0 );     /* must be power of two */
michael@0: 
michael@0:     nStates = 1;
michael@0:     RD_Q25[ 0 ] = 0;
michael@0:     prev_out_Q10[ 0 ] = 0;
michael@0:     for( i = order - 1; ; i-- ) {
michael@0:         rates_Q5 = &ec_rates_Q5[ ec_ix[ i ] ];
michael@0:         pred_coef_Q16 = silk_LSHIFT( (opus_int32)pred_coef_Q8[ i ], 8 );
michael@0:         in_Q10 = x_Q10[ i ];
michael@0:         for( j = 0; j < nStates; j++ ) {
michael@0:             pred_Q10 = silk_SMULWB( pred_coef_Q16, prev_out_Q10[ j ] );
michael@0:             res_Q10  = silk_SUB16( in_Q10, pred_Q10 );
michael@0:             ind_tmp  = silk_SMULWB( (opus_int32)inv_quant_step_size_Q6, res_Q10 );
michael@0:             ind_tmp  = silk_LIMIT( ind_tmp, -NLSF_QUANT_MAX_AMPLITUDE_EXT, NLSF_QUANT_MAX_AMPLITUDE_EXT-1 );
michael@0:             ind[ j ][ i ] = (opus_int8)ind_tmp;
michael@0: 
michael@0:             /* compute outputs for ind_tmp and ind_tmp + 1 */
michael@0:             out0_Q10 = silk_LSHIFT( ind_tmp, 10 );
michael@0:             out1_Q10 = silk_ADD16( out0_Q10, 1024 );
michael@0:             if( ind_tmp > 0 ) {
michael@0:                 out0_Q10 = silk_SUB16( out0_Q10, SILK_FIX_CONST( NLSF_QUANT_LEVEL_ADJ, 10 ) );
michael@0:                 out1_Q10 = silk_SUB16( out1_Q10, SILK_FIX_CONST( NLSF_QUANT_LEVEL_ADJ, 10 ) );
michael@0:             } else if( ind_tmp == 0 ) {
michael@0:                 out1_Q10 = silk_SUB16( out1_Q10, SILK_FIX_CONST( NLSF_QUANT_LEVEL_ADJ, 10 ) );
michael@0:             } else if( ind_tmp == -1 ) {
michael@0:                 out0_Q10 = silk_ADD16( out0_Q10, SILK_FIX_CONST( NLSF_QUANT_LEVEL_ADJ, 10 ) );
michael@0:             } else {
michael@0:                 out0_Q10 = silk_ADD16( out0_Q10, SILK_FIX_CONST( NLSF_QUANT_LEVEL_ADJ, 10 ) );
michael@0:                 out1_Q10 = silk_ADD16( out1_Q10, SILK_FIX_CONST( NLSF_QUANT_LEVEL_ADJ, 10 ) );
michael@0:             }
michael@0:             out0_Q10  = silk_SMULWB( (opus_int32)out0_Q10, quant_step_size_Q16 );
michael@0:             out1_Q10  = silk_SMULWB( (opus_int32)out1_Q10, quant_step_size_Q16 );
michael@0:             out0_Q10  = silk_ADD16( out0_Q10, pred_Q10 );
michael@0:             out1_Q10  = silk_ADD16( out1_Q10, pred_Q10 );
michael@0:             prev_out_Q10[ j           ] = out0_Q10;
michael@0:             prev_out_Q10[ j + nStates ] = out1_Q10;
michael@0: 
michael@0:             /* compute RD for ind_tmp and ind_tmp + 1 */
michael@0:             if( ind_tmp + 1 >= NLSF_QUANT_MAX_AMPLITUDE ) {
michael@0:                 if( ind_tmp + 1 == NLSF_QUANT_MAX_AMPLITUDE ) {
michael@0:                     rate0_Q5 = rates_Q5[ ind_tmp + NLSF_QUANT_MAX_AMPLITUDE ];
michael@0:                     rate1_Q5 = 280;
michael@0:                 } else {
michael@0:                     rate0_Q5 = silk_SMLABB( 280 - 43 * NLSF_QUANT_MAX_AMPLITUDE, 43, ind_tmp );
michael@0:                     rate1_Q5 = silk_ADD16( rate0_Q5, 43 );
michael@0:                 }
michael@0:             } else if( ind_tmp <= -NLSF_QUANT_MAX_AMPLITUDE ) {
michael@0:                 if( ind_tmp == -NLSF_QUANT_MAX_AMPLITUDE ) {
michael@0:                     rate0_Q5 = 280;
michael@0:                     rate1_Q5 = rates_Q5[ ind_tmp + 1 + NLSF_QUANT_MAX_AMPLITUDE ];
michael@0:                 } else {
michael@0:                     rate0_Q5 = silk_SMLABB( 280 - 43 * NLSF_QUANT_MAX_AMPLITUDE, -43, ind_tmp );
michael@0:                     rate1_Q5 = silk_SUB16( rate0_Q5, 43 );
michael@0:                 }
michael@0:             } else {
michael@0:                 rate0_Q5 = rates_Q5[ ind_tmp +     NLSF_QUANT_MAX_AMPLITUDE ];
michael@0:                 rate1_Q5 = rates_Q5[ ind_tmp + 1 + NLSF_QUANT_MAX_AMPLITUDE ];
michael@0:             }
michael@0:             RD_tmp_Q25            = RD_Q25[ j ];
michael@0:             diff_Q10              = silk_SUB16( in_Q10, out0_Q10 );
michael@0:             RD_Q25[ j ]           = silk_SMLABB( silk_MLA( RD_tmp_Q25, silk_SMULBB( diff_Q10, diff_Q10 ), w_Q5[ i ] ), mu_Q20, rate0_Q5 );
michael@0:             diff_Q10              = silk_SUB16( in_Q10, out1_Q10 );
michael@0:             RD_Q25[ j + nStates ] = silk_SMLABB( silk_MLA( RD_tmp_Q25, silk_SMULBB( diff_Q10, diff_Q10 ), w_Q5[ i ] ), mu_Q20, rate1_Q5 );
michael@0:         }
michael@0: 
michael@0:         if( nStates <= ( NLSF_QUANT_DEL_DEC_STATES >> 1 ) ) {
michael@0:             /* double number of states and copy */
michael@0:             for( j = 0; j < nStates; j++ ) {
michael@0:                 ind[ j + nStates ][ i ] = ind[ j ][ i ] + 1;
michael@0:             }
michael@0:             nStates = silk_LSHIFT( nStates, 1 );
michael@0:             for( j = nStates; j < NLSF_QUANT_DEL_DEC_STATES; j++ ) {
michael@0:                 ind[ j ][ i ] = ind[ j - nStates ][ i ];
michael@0:             }
michael@0:         } else if( i > 0 ) {
michael@0:             /* sort lower and upper half of RD_Q25, pairwise */
michael@0:             for( j = 0; j < NLSF_QUANT_DEL_DEC_STATES; j++ ) {
michael@0:                 if( RD_Q25[ j ] > RD_Q25[ j + NLSF_QUANT_DEL_DEC_STATES ] ) {
michael@0:                     RD_max_Q25[ j ]                         = RD_Q25[ j ];
michael@0:                     RD_min_Q25[ j ]                         = RD_Q25[ j + NLSF_QUANT_DEL_DEC_STATES ];
michael@0:                     RD_Q25[ j ]                             = RD_min_Q25[ j ];
michael@0:                     RD_Q25[ j + NLSF_QUANT_DEL_DEC_STATES ] = RD_max_Q25[ j ];
michael@0:                     /* swap prev_out values */
michael@0:                     out0_Q10 = prev_out_Q10[ j ];
michael@0:                     prev_out_Q10[ j ] = prev_out_Q10[ j + NLSF_QUANT_DEL_DEC_STATES ];
michael@0:                     prev_out_Q10[ j + NLSF_QUANT_DEL_DEC_STATES ] = out0_Q10;
michael@0:                     ind_sort[ j ] = j + NLSF_QUANT_DEL_DEC_STATES;
michael@0:                 } else {
michael@0:                     RD_min_Q25[ j ] = RD_Q25[ j ];
michael@0:                     RD_max_Q25[ j ] = RD_Q25[ j + NLSF_QUANT_DEL_DEC_STATES ];
michael@0:                     ind_sort[ j ] = j;
michael@0:                 }
michael@0:             }
michael@0:             /* compare the highest RD values of the winning half with the lowest one in the losing half, and copy if necessary */
michael@0:             /* afterwards ind_sort[] will contain the indices of the NLSF_QUANT_DEL_DEC_STATES winning RD values */
michael@0:             while( 1 ) {
michael@0:                 min_max_Q25 = silk_int32_MAX;
michael@0:                 max_min_Q25 = 0;
michael@0:                 ind_min_max = 0;
michael@0:                 ind_max_min = 0;
michael@0:                 for( j = 0; j < NLSF_QUANT_DEL_DEC_STATES; j++ ) {
michael@0:                     if( min_max_Q25 > RD_max_Q25[ j ] ) {
michael@0:                         min_max_Q25 = RD_max_Q25[ j ];
michael@0:                         ind_min_max = j;
michael@0:                     }
michael@0:                     if( max_min_Q25 < RD_min_Q25[ j ] ) {
michael@0:                         max_min_Q25 = RD_min_Q25[ j ];
michael@0:                         ind_max_min = j;
michael@0:                     }
michael@0:                 }
michael@0:                 if( min_max_Q25 >= max_min_Q25 ) {
michael@0:                     break;
michael@0:                 }
michael@0:                 /* copy ind_min_max to ind_max_min */
michael@0:                 ind_sort[     ind_max_min ] = ind_sort[     ind_min_max ] ^ NLSF_QUANT_DEL_DEC_STATES;
michael@0:                 RD_Q25[       ind_max_min ] = RD_Q25[       ind_min_max + NLSF_QUANT_DEL_DEC_STATES ];
michael@0:                 prev_out_Q10[ ind_max_min ] = prev_out_Q10[ ind_min_max + NLSF_QUANT_DEL_DEC_STATES ];
michael@0:                 RD_min_Q25[   ind_max_min ] = 0;
michael@0:                 RD_max_Q25[   ind_min_max ] = silk_int32_MAX;
michael@0:                 silk_memcpy( ind[ ind_max_min ], ind[ ind_min_max ], MAX_LPC_ORDER * sizeof( opus_int8 ) );
michael@0:             }
michael@0:             /* increment index if it comes from the upper half */
michael@0:             for( j = 0; j < NLSF_QUANT_DEL_DEC_STATES; j++ ) {
michael@0:                 ind[ j ][ i ] += silk_RSHIFT( ind_sort[ j ], NLSF_QUANT_DEL_DEC_STATES_LOG2 );
michael@0:             }
michael@0:         } else {  /* i == 0 */
michael@0:             break;
michael@0:         }
michael@0:     }
michael@0: 
michael@0:     /* last sample: find winner, copy indices and return RD value */
michael@0:     ind_tmp = 0;
michael@0:     min_Q25 = silk_int32_MAX;
michael@0:     for( j = 0; j < 2 * NLSF_QUANT_DEL_DEC_STATES; j++ ) {
michael@0:         if( min_Q25 > RD_Q25[ j ] ) {
michael@0:             min_Q25 = RD_Q25[ j ];
michael@0:             ind_tmp = j;
michael@0:         }
michael@0:     }
michael@0:     for( j = 0; j < order; j++ ) {
michael@0:         indices[ j ] = ind[ ind_tmp & ( NLSF_QUANT_DEL_DEC_STATES - 1 ) ][ j ];
michael@0:         silk_assert( indices[ j ] >= -NLSF_QUANT_MAX_AMPLITUDE_EXT );
michael@0:         silk_assert( indices[ j ] <=  NLSF_QUANT_MAX_AMPLITUDE_EXT );
michael@0:     }
michael@0:     indices[ 0 ] += silk_RSHIFT( ind_tmp, NLSF_QUANT_DEL_DEC_STATES_LOG2 );
michael@0:     silk_assert( indices[ 0 ] <= NLSF_QUANT_MAX_AMPLITUDE_EXT );
michael@0:     silk_assert( min_Q25 >= 0 );
michael@0:     return min_Q25;
michael@0: }