1.1 --- /dev/null Thu Jan 01 00:00:00 1970 +0000
1.2 +++ b/media/libopus/silk/fixed/noise_shape_analysis_FIX.c Wed Dec 31 06:09:35 2014 +0100
1.3 @@ -0,0 +1,445 @@
1.4 +/***********************************************************************
1.5 +Copyright (c) 2006-2011, Skype Limited. All rights reserved.
1.6 +Redistribution and use in source and binary forms, with or without
1.7 +modification, are permitted provided that the following conditions
1.8 +are met:
1.9 +- Redistributions of source code must retain the above copyright notice,
1.10 +this list of conditions and the following disclaimer.
1.11 +- Redistributions in binary form must reproduce the above copyright
1.12 +notice, this list of conditions and the following disclaimer in the
1.13 +documentation and/or other materials provided with the distribution.
1.14 +- Neither the name of Internet Society, IETF or IETF Trust, nor the
1.15 +names of specific contributors, may be used to endorse or promote
1.16 +products derived from this software without specific prior written
1.17 +permission.
1.18 +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
1.19 +AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
1.20 +IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
1.21 +ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
1.22 +LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
1.23 +CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
1.24 +SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
1.25 +INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
1.26 +CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
1.27 +ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
1.28 +POSSIBILITY OF SUCH DAMAGE.
1.29 +***********************************************************************/
1.30 +
1.31 +#ifdef HAVE_CONFIG_H
1.32 +#include "config.h"
1.33 +#endif
1.34 +
1.35 +#include "main_FIX.h"
1.36 +#include "stack_alloc.h"
1.37 +#include "tuning_parameters.h"
1.38 +
1.39 +/* Compute gain to make warped filter coefficients have a zero mean log frequency response on a */
1.40 +/* non-warped frequency scale. (So that it can be implemented with a minimum-phase monic filter.) */
1.41 +/* Note: A monic filter is one with the first coefficient equal to 1.0. In Silk we omit the first */
1.42 +/* coefficient in an array of coefficients, for monic filters. */
1.43 +static OPUS_INLINE opus_int32 warped_gain( /* gain in Q16*/
1.44 + const opus_int32 *coefs_Q24,
1.45 + opus_int lambda_Q16,
1.46 + opus_int order
1.47 +) {
1.48 + opus_int i;
1.49 + opus_int32 gain_Q24;
1.50 +
1.51 + lambda_Q16 = -lambda_Q16;
1.52 + gain_Q24 = coefs_Q24[ order - 1 ];
1.53 + for( i = order - 2; i >= 0; i-- ) {
1.54 + gain_Q24 = silk_SMLAWB( coefs_Q24[ i ], gain_Q24, lambda_Q16 );
1.55 + }
1.56 + gain_Q24 = silk_SMLAWB( SILK_FIX_CONST( 1.0, 24 ), gain_Q24, -lambda_Q16 );
1.57 + return silk_INVERSE32_varQ( gain_Q24, 40 );
1.58 +}
1.59 +
1.60 +/* Convert warped filter coefficients to monic pseudo-warped coefficients and limit maximum */
1.61 +/* amplitude of monic warped coefficients by using bandwidth expansion on the true coefficients */
1.62 +static OPUS_INLINE void limit_warped_coefs(
1.63 + opus_int32 *coefs_syn_Q24,
1.64 + opus_int32 *coefs_ana_Q24,
1.65 + opus_int lambda_Q16,
1.66 + opus_int32 limit_Q24,
1.67 + opus_int order
1.68 +) {
1.69 + opus_int i, iter, ind = 0;
1.70 + opus_int32 tmp, maxabs_Q24, chirp_Q16, gain_syn_Q16, gain_ana_Q16;
1.71 + opus_int32 nom_Q16, den_Q24;
1.72 +
1.73 + /* Convert to monic coefficients */
1.74 + lambda_Q16 = -lambda_Q16;
1.75 + for( i = order - 1; i > 0; i-- ) {
1.76 + coefs_syn_Q24[ i - 1 ] = silk_SMLAWB( coefs_syn_Q24[ i - 1 ], coefs_syn_Q24[ i ], lambda_Q16 );
1.77 + coefs_ana_Q24[ i - 1 ] = silk_SMLAWB( coefs_ana_Q24[ i - 1 ], coefs_ana_Q24[ i ], lambda_Q16 );
1.78 + }
1.79 + lambda_Q16 = -lambda_Q16;
1.80 + nom_Q16 = silk_SMLAWB( SILK_FIX_CONST( 1.0, 16 ), -(opus_int32)lambda_Q16, lambda_Q16 );
1.81 + den_Q24 = silk_SMLAWB( SILK_FIX_CONST( 1.0, 24 ), coefs_syn_Q24[ 0 ], lambda_Q16 );
1.82 + gain_syn_Q16 = silk_DIV32_varQ( nom_Q16, den_Q24, 24 );
1.83 + den_Q24 = silk_SMLAWB( SILK_FIX_CONST( 1.0, 24 ), coefs_ana_Q24[ 0 ], lambda_Q16 );
1.84 + gain_ana_Q16 = silk_DIV32_varQ( nom_Q16, den_Q24, 24 );
1.85 + for( i = 0; i < order; i++ ) {
1.86 + coefs_syn_Q24[ i ] = silk_SMULWW( gain_syn_Q16, coefs_syn_Q24[ i ] );
1.87 + coefs_ana_Q24[ i ] = silk_SMULWW( gain_ana_Q16, coefs_ana_Q24[ i ] );
1.88 + }
1.89 +
1.90 + for( iter = 0; iter < 10; iter++ ) {
1.91 + /* Find maximum absolute value */
1.92 + maxabs_Q24 = -1;
1.93 + for( i = 0; i < order; i++ ) {
1.94 + tmp = silk_max( silk_abs_int32( coefs_syn_Q24[ i ] ), silk_abs_int32( coefs_ana_Q24[ i ] ) );
1.95 + if( tmp > maxabs_Q24 ) {
1.96 + maxabs_Q24 = tmp;
1.97 + ind = i;
1.98 + }
1.99 + }
1.100 + if( maxabs_Q24 <= limit_Q24 ) {
1.101 + /* Coefficients are within range - done */
1.102 + return;
1.103 + }
1.104 +
1.105 + /* Convert back to true warped coefficients */
1.106 + for( i = 1; i < order; i++ ) {
1.107 + coefs_syn_Q24[ i - 1 ] = silk_SMLAWB( coefs_syn_Q24[ i - 1 ], coefs_syn_Q24[ i ], lambda_Q16 );
1.108 + coefs_ana_Q24[ i - 1 ] = silk_SMLAWB( coefs_ana_Q24[ i - 1 ], coefs_ana_Q24[ i ], lambda_Q16 );
1.109 + }
1.110 + gain_syn_Q16 = silk_INVERSE32_varQ( gain_syn_Q16, 32 );
1.111 + gain_ana_Q16 = silk_INVERSE32_varQ( gain_ana_Q16, 32 );
1.112 + for( i = 0; i < order; i++ ) {
1.113 + coefs_syn_Q24[ i ] = silk_SMULWW( gain_syn_Q16, coefs_syn_Q24[ i ] );
1.114 + coefs_ana_Q24[ i ] = silk_SMULWW( gain_ana_Q16, coefs_ana_Q24[ i ] );
1.115 + }
1.116 +
1.117 + /* Apply bandwidth expansion */
1.118 + chirp_Q16 = SILK_FIX_CONST( 0.99, 16 ) - silk_DIV32_varQ(
1.119 + silk_SMULWB( maxabs_Q24 - limit_Q24, silk_SMLABB( SILK_FIX_CONST( 0.8, 10 ), SILK_FIX_CONST( 0.1, 10 ), iter ) ),
1.120 + silk_MUL( maxabs_Q24, ind + 1 ), 22 );
1.121 + silk_bwexpander_32( coefs_syn_Q24, order, chirp_Q16 );
1.122 + silk_bwexpander_32( coefs_ana_Q24, order, chirp_Q16 );
1.123 +
1.124 + /* Convert to monic warped coefficients */
1.125 + lambda_Q16 = -lambda_Q16;
1.126 + for( i = order - 1; i > 0; i-- ) {
1.127 + coefs_syn_Q24[ i - 1 ] = silk_SMLAWB( coefs_syn_Q24[ i - 1 ], coefs_syn_Q24[ i ], lambda_Q16 );
1.128 + coefs_ana_Q24[ i - 1 ] = silk_SMLAWB( coefs_ana_Q24[ i - 1 ], coefs_ana_Q24[ i ], lambda_Q16 );
1.129 + }
1.130 + lambda_Q16 = -lambda_Q16;
1.131 + nom_Q16 = silk_SMLAWB( SILK_FIX_CONST( 1.0, 16 ), -(opus_int32)lambda_Q16, lambda_Q16 );
1.132 + den_Q24 = silk_SMLAWB( SILK_FIX_CONST( 1.0, 24 ), coefs_syn_Q24[ 0 ], lambda_Q16 );
1.133 + gain_syn_Q16 = silk_DIV32_varQ( nom_Q16, den_Q24, 24 );
1.134 + den_Q24 = silk_SMLAWB( SILK_FIX_CONST( 1.0, 24 ), coefs_ana_Q24[ 0 ], lambda_Q16 );
1.135 + gain_ana_Q16 = silk_DIV32_varQ( nom_Q16, den_Q24, 24 );
1.136 + for( i = 0; i < order; i++ ) {
1.137 + coefs_syn_Q24[ i ] = silk_SMULWW( gain_syn_Q16, coefs_syn_Q24[ i ] );
1.138 + coefs_ana_Q24[ i ] = silk_SMULWW( gain_ana_Q16, coefs_ana_Q24[ i ] );
1.139 + }
1.140 + }
1.141 + silk_assert( 0 );
1.142 +}
1.143 +
1.144 +/**************************************************************/
1.145 +/* Compute noise shaping coefficients and initial gain values */
1.146 +/**************************************************************/
1.147 +void silk_noise_shape_analysis_FIX(
1.148 + silk_encoder_state_FIX *psEnc, /* I/O Encoder state FIX */
1.149 + silk_encoder_control_FIX *psEncCtrl, /* I/O Encoder control FIX */
1.150 + const opus_int16 *pitch_res, /* I LPC residual from pitch analysis */
1.151 + const opus_int16 *x, /* I Input signal [ frame_length + la_shape ] */
1.152 + int arch /* I Run-time architecture */
1.153 +)
1.154 +{
1.155 + silk_shape_state_FIX *psShapeSt = &psEnc->sShape;
1.156 + opus_int k, i, nSamples, Qnrg, b_Q14, warping_Q16, scale = 0;
1.157 + opus_int32 SNR_adj_dB_Q7, HarmBoost_Q16, HarmShapeGain_Q16, Tilt_Q16, tmp32;
1.158 + opus_int32 nrg, pre_nrg_Q30, log_energy_Q7, log_energy_prev_Q7, energy_variation_Q7;
1.159 + opus_int32 delta_Q16, BWExp1_Q16, BWExp2_Q16, gain_mult_Q16, gain_add_Q16, strength_Q16, b_Q8;
1.160 + opus_int32 auto_corr[ MAX_SHAPE_LPC_ORDER + 1 ];
1.161 + opus_int32 refl_coef_Q16[ MAX_SHAPE_LPC_ORDER ];
1.162 + opus_int32 AR1_Q24[ MAX_SHAPE_LPC_ORDER ];
1.163 + opus_int32 AR2_Q24[ MAX_SHAPE_LPC_ORDER ];
1.164 + VARDECL( opus_int16, x_windowed );
1.165 + const opus_int16 *x_ptr, *pitch_res_ptr;
1.166 + SAVE_STACK;
1.167 +
1.168 + /* Point to start of first LPC analysis block */
1.169 + x_ptr = x - psEnc->sCmn.la_shape;
1.170 +
1.171 + /****************/
1.172 + /* GAIN CONTROL */
1.173 + /****************/
1.174 + SNR_adj_dB_Q7 = psEnc->sCmn.SNR_dB_Q7;
1.175 +
1.176 + /* Input quality is the average of the quality in the lowest two VAD bands */
1.177 + psEncCtrl->input_quality_Q14 = ( opus_int )silk_RSHIFT( (opus_int32)psEnc->sCmn.input_quality_bands_Q15[ 0 ]
1.178 + + psEnc->sCmn.input_quality_bands_Q15[ 1 ], 2 );
1.179 +
1.180 + /* Coding quality level, between 0.0_Q0 and 1.0_Q0, but in Q14 */
1.181 + psEncCtrl->coding_quality_Q14 = silk_RSHIFT( silk_sigm_Q15( silk_RSHIFT_ROUND( SNR_adj_dB_Q7 -
1.182 + SILK_FIX_CONST( 20.0, 7 ), 4 ) ), 1 );
1.183 +
1.184 + /* Reduce coding SNR during low speech activity */
1.185 + if( psEnc->sCmn.useCBR == 0 ) {
1.186 + b_Q8 = SILK_FIX_CONST( 1.0, 8 ) - psEnc->sCmn.speech_activity_Q8;
1.187 + b_Q8 = silk_SMULWB( silk_LSHIFT( b_Q8, 8 ), b_Q8 );
1.188 + SNR_adj_dB_Q7 = silk_SMLAWB( SNR_adj_dB_Q7,
1.189 + silk_SMULBB( SILK_FIX_CONST( -BG_SNR_DECR_dB, 7 ) >> ( 4 + 1 ), b_Q8 ), /* Q11*/
1.190 + silk_SMULWB( SILK_FIX_CONST( 1.0, 14 ) + psEncCtrl->input_quality_Q14, psEncCtrl->coding_quality_Q14 ) ); /* Q12*/
1.191 + }
1.192 +
1.193 + if( psEnc->sCmn.indices.signalType == TYPE_VOICED ) {
1.194 + /* Reduce gains for periodic signals */
1.195 + SNR_adj_dB_Q7 = silk_SMLAWB( SNR_adj_dB_Q7, SILK_FIX_CONST( HARM_SNR_INCR_dB, 8 ), psEnc->LTPCorr_Q15 );
1.196 + } else {
1.197 + /* For unvoiced signals and low-quality input, adjust the quality slower than SNR_dB setting */
1.198 + SNR_adj_dB_Q7 = silk_SMLAWB( SNR_adj_dB_Q7,
1.199 + silk_SMLAWB( SILK_FIX_CONST( 6.0, 9 ), -SILK_FIX_CONST( 0.4, 18 ), psEnc->sCmn.SNR_dB_Q7 ),
1.200 + SILK_FIX_CONST( 1.0, 14 ) - psEncCtrl->input_quality_Q14 );
1.201 + }
1.202 +
1.203 + /*************************/
1.204 + /* SPARSENESS PROCESSING */
1.205 + /*************************/
1.206 + /* Set quantizer offset */
1.207 + if( psEnc->sCmn.indices.signalType == TYPE_VOICED ) {
1.208 + /* Initially set to 0; may be overruled in process_gains(..) */
1.209 + psEnc->sCmn.indices.quantOffsetType = 0;
1.210 + psEncCtrl->sparseness_Q8 = 0;
1.211 + } else {
1.212 + /* Sparseness measure, based on relative fluctuations of energy per 2 milliseconds */
1.213 + nSamples = silk_LSHIFT( psEnc->sCmn.fs_kHz, 1 );
1.214 + energy_variation_Q7 = 0;
1.215 + log_energy_prev_Q7 = 0;
1.216 + pitch_res_ptr = pitch_res;
1.217 + for( k = 0; k < silk_SMULBB( SUB_FRAME_LENGTH_MS, psEnc->sCmn.nb_subfr ) / 2; k++ ) {
1.218 + silk_sum_sqr_shift( &nrg, &scale, pitch_res_ptr, nSamples );
1.219 + nrg += silk_RSHIFT( nSamples, scale ); /* Q(-scale)*/
1.220 +
1.221 + log_energy_Q7 = silk_lin2log( nrg );
1.222 + if( k > 0 ) {
1.223 + energy_variation_Q7 += silk_abs( log_energy_Q7 - log_energy_prev_Q7 );
1.224 + }
1.225 + log_energy_prev_Q7 = log_energy_Q7;
1.226 + pitch_res_ptr += nSamples;
1.227 + }
1.228 +
1.229 + psEncCtrl->sparseness_Q8 = silk_RSHIFT( silk_sigm_Q15( silk_SMULWB( energy_variation_Q7 -
1.230 + SILK_FIX_CONST( 5.0, 7 ), SILK_FIX_CONST( 0.1, 16 ) ) ), 7 );
1.231 +
1.232 + /* Set quantization offset depending on sparseness measure */
1.233 + if( psEncCtrl->sparseness_Q8 > SILK_FIX_CONST( SPARSENESS_THRESHOLD_QNT_OFFSET, 8 ) ) {
1.234 + psEnc->sCmn.indices.quantOffsetType = 0;
1.235 + } else {
1.236 + psEnc->sCmn.indices.quantOffsetType = 1;
1.237 + }
1.238 +
1.239 + /* Increase coding SNR for sparse signals */
1.240 + SNR_adj_dB_Q7 = silk_SMLAWB( SNR_adj_dB_Q7, SILK_FIX_CONST( SPARSE_SNR_INCR_dB, 15 ), psEncCtrl->sparseness_Q8 - SILK_FIX_CONST( 0.5, 8 ) );
1.241 + }
1.242 +
1.243 + /*******************************/
1.244 + /* Control bandwidth expansion */
1.245 + /*******************************/
1.246 + /* More BWE for signals with high prediction gain */
1.247 + strength_Q16 = silk_SMULWB( psEncCtrl->predGain_Q16, SILK_FIX_CONST( FIND_PITCH_WHITE_NOISE_FRACTION, 16 ) );
1.248 + BWExp1_Q16 = BWExp2_Q16 = silk_DIV32_varQ( SILK_FIX_CONST( BANDWIDTH_EXPANSION, 16 ),
1.249 + silk_SMLAWW( SILK_FIX_CONST( 1.0, 16 ), strength_Q16, strength_Q16 ), 16 );
1.250 + delta_Q16 = silk_SMULWB( SILK_FIX_CONST( 1.0, 16 ) - silk_SMULBB( 3, psEncCtrl->coding_quality_Q14 ),
1.251 + SILK_FIX_CONST( LOW_RATE_BANDWIDTH_EXPANSION_DELTA, 16 ) );
1.252 + BWExp1_Q16 = silk_SUB32( BWExp1_Q16, delta_Q16 );
1.253 + BWExp2_Q16 = silk_ADD32( BWExp2_Q16, delta_Q16 );
1.254 + /* BWExp1 will be applied after BWExp2, so make it relative */
1.255 + BWExp1_Q16 = silk_DIV32_16( silk_LSHIFT( BWExp1_Q16, 14 ), silk_RSHIFT( BWExp2_Q16, 2 ) );
1.256 +
1.257 + if( psEnc->sCmn.warping_Q16 > 0 ) {
1.258 + /* Slightly more warping in analysis will move quantization noise up in frequency, where it's better masked */
1.259 + warping_Q16 = silk_SMLAWB( psEnc->sCmn.warping_Q16, (opus_int32)psEncCtrl->coding_quality_Q14, SILK_FIX_CONST( 0.01, 18 ) );
1.260 + } else {
1.261 + warping_Q16 = 0;
1.262 + }
1.263 +
1.264 + /********************************************/
1.265 + /* Compute noise shaping AR coefs and gains */
1.266 + /********************************************/
1.267 + ALLOC( x_windowed, psEnc->sCmn.shapeWinLength, opus_int16 );
1.268 + for( k = 0; k < psEnc->sCmn.nb_subfr; k++ ) {
1.269 + /* Apply window: sine slope followed by flat part followed by cosine slope */
1.270 + opus_int shift, slope_part, flat_part;
1.271 + flat_part = psEnc->sCmn.fs_kHz * 3;
1.272 + slope_part = silk_RSHIFT( psEnc->sCmn.shapeWinLength - flat_part, 1 );
1.273 +
1.274 + silk_apply_sine_window( x_windowed, x_ptr, 1, slope_part );
1.275 + shift = slope_part;
1.276 + silk_memcpy( x_windowed + shift, x_ptr + shift, flat_part * sizeof(opus_int16) );
1.277 + shift += flat_part;
1.278 + silk_apply_sine_window( x_windowed + shift, x_ptr + shift, 2, slope_part );
1.279 +
1.280 + /* Update pointer: next LPC analysis block */
1.281 + x_ptr += psEnc->sCmn.subfr_length;
1.282 +
1.283 + if( psEnc->sCmn.warping_Q16 > 0 ) {
1.284 + /* Calculate warped auto correlation */
1.285 + silk_warped_autocorrelation_FIX( auto_corr, &scale, x_windowed, warping_Q16, psEnc->sCmn.shapeWinLength, psEnc->sCmn.shapingLPCOrder );
1.286 + } else {
1.287 + /* Calculate regular auto correlation */
1.288 + silk_autocorr( auto_corr, &scale, x_windowed, psEnc->sCmn.shapeWinLength, psEnc->sCmn.shapingLPCOrder + 1, arch );
1.289 + }
1.290 +
1.291 + /* Add white noise, as a fraction of energy */
1.292 + auto_corr[0] = silk_ADD32( auto_corr[0], silk_max_32( silk_SMULWB( silk_RSHIFT( auto_corr[ 0 ], 4 ),
1.293 + SILK_FIX_CONST( SHAPE_WHITE_NOISE_FRACTION, 20 ) ), 1 ) );
1.294 +
1.295 + /* Calculate the reflection coefficients using schur */
1.296 + nrg = silk_schur64( refl_coef_Q16, auto_corr, psEnc->sCmn.shapingLPCOrder );
1.297 + silk_assert( nrg >= 0 );
1.298 +
1.299 + /* Convert reflection coefficients to prediction coefficients */
1.300 + silk_k2a_Q16( AR2_Q24, refl_coef_Q16, psEnc->sCmn.shapingLPCOrder );
1.301 +
1.302 + Qnrg = -scale; /* range: -12...30*/
1.303 + silk_assert( Qnrg >= -12 );
1.304 + silk_assert( Qnrg <= 30 );
1.305 +
1.306 + /* Make sure that Qnrg is an even number */
1.307 + if( Qnrg & 1 ) {
1.308 + Qnrg -= 1;
1.309 + nrg >>= 1;
1.310 + }
1.311 +
1.312 + tmp32 = silk_SQRT_APPROX( nrg );
1.313 + Qnrg >>= 1; /* range: -6...15*/
1.314 +
1.315 + psEncCtrl->Gains_Q16[ k ] = silk_LSHIFT_SAT32( tmp32, 16 - Qnrg );
1.316 +
1.317 + if( psEnc->sCmn.warping_Q16 > 0 ) {
1.318 + /* Adjust gain for warping */
1.319 + gain_mult_Q16 = warped_gain( AR2_Q24, warping_Q16, psEnc->sCmn.shapingLPCOrder );
1.320 + silk_assert( psEncCtrl->Gains_Q16[ k ] >= 0 );
1.321 + if ( silk_SMULWW( silk_RSHIFT_ROUND( psEncCtrl->Gains_Q16[ k ], 1 ), gain_mult_Q16 ) >= ( silk_int32_MAX >> 1 ) ) {
1.322 + psEncCtrl->Gains_Q16[ k ] = silk_int32_MAX;
1.323 + } else {
1.324 + psEncCtrl->Gains_Q16[ k ] = silk_SMULWW( psEncCtrl->Gains_Q16[ k ], gain_mult_Q16 );
1.325 + }
1.326 + }
1.327 +
1.328 + /* Bandwidth expansion for synthesis filter shaping */
1.329 + silk_bwexpander_32( AR2_Q24, psEnc->sCmn.shapingLPCOrder, BWExp2_Q16 );
1.330 +
1.331 + /* Compute noise shaping filter coefficients */
1.332 + silk_memcpy( AR1_Q24, AR2_Q24, psEnc->sCmn.shapingLPCOrder * sizeof( opus_int32 ) );
1.333 +
1.334 + /* Bandwidth expansion for analysis filter shaping */
1.335 + silk_assert( BWExp1_Q16 <= SILK_FIX_CONST( 1.0, 16 ) );
1.336 + silk_bwexpander_32( AR1_Q24, psEnc->sCmn.shapingLPCOrder, BWExp1_Q16 );
1.337 +
1.338 + /* Ratio of prediction gains, in energy domain */
1.339 + pre_nrg_Q30 = silk_LPC_inverse_pred_gain_Q24( AR2_Q24, psEnc->sCmn.shapingLPCOrder );
1.340 + nrg = silk_LPC_inverse_pred_gain_Q24( AR1_Q24, psEnc->sCmn.shapingLPCOrder );
1.341 +
1.342 + /*psEncCtrl->GainsPre[ k ] = 1.0f - 0.7f * ( 1.0f - pre_nrg / nrg ) = 0.3f + 0.7f * pre_nrg / nrg;*/
1.343 + pre_nrg_Q30 = silk_LSHIFT32( silk_SMULWB( pre_nrg_Q30, SILK_FIX_CONST( 0.7, 15 ) ), 1 );
1.344 + psEncCtrl->GainsPre_Q14[ k ] = ( opus_int ) SILK_FIX_CONST( 0.3, 14 ) + silk_DIV32_varQ( pre_nrg_Q30, nrg, 14 );
1.345 +
1.346 + /* Convert to monic warped prediction coefficients and limit absolute values */
1.347 + limit_warped_coefs( AR2_Q24, AR1_Q24, warping_Q16, SILK_FIX_CONST( 3.999, 24 ), psEnc->sCmn.shapingLPCOrder );
1.348 +
1.349 + /* Convert from Q24 to Q13 and store in int16 */
1.350 + for( i = 0; i < psEnc->sCmn.shapingLPCOrder; i++ ) {
1.351 + psEncCtrl->AR1_Q13[ k * MAX_SHAPE_LPC_ORDER + i ] = (opus_int16)silk_SAT16( silk_RSHIFT_ROUND( AR1_Q24[ i ], 11 ) );
1.352 + psEncCtrl->AR2_Q13[ k * MAX_SHAPE_LPC_ORDER + i ] = (opus_int16)silk_SAT16( silk_RSHIFT_ROUND( AR2_Q24[ i ], 11 ) );
1.353 + }
1.354 + }
1.355 +
1.356 + /*****************/
1.357 + /* Gain tweaking */
1.358 + /*****************/
1.359 + /* Increase gains during low speech activity and put lower limit on gains */
1.360 + gain_mult_Q16 = silk_log2lin( -silk_SMLAWB( -SILK_FIX_CONST( 16.0, 7 ), SNR_adj_dB_Q7, SILK_FIX_CONST( 0.16, 16 ) ) );
1.361 + gain_add_Q16 = silk_log2lin( silk_SMLAWB( SILK_FIX_CONST( 16.0, 7 ), SILK_FIX_CONST( MIN_QGAIN_DB, 7 ), SILK_FIX_CONST( 0.16, 16 ) ) );
1.362 + silk_assert( gain_mult_Q16 > 0 );
1.363 + for( k = 0; k < psEnc->sCmn.nb_subfr; k++ ) {
1.364 + psEncCtrl->Gains_Q16[ k ] = silk_SMULWW( psEncCtrl->Gains_Q16[ k ], gain_mult_Q16 );
1.365 + silk_assert( psEncCtrl->Gains_Q16[ k ] >= 0 );
1.366 + psEncCtrl->Gains_Q16[ k ] = silk_ADD_POS_SAT32( psEncCtrl->Gains_Q16[ k ], gain_add_Q16 );
1.367 + }
1.368 +
1.369 + gain_mult_Q16 = SILK_FIX_CONST( 1.0, 16 ) + silk_RSHIFT_ROUND( silk_MLA( SILK_FIX_CONST( INPUT_TILT, 26 ),
1.370 + psEncCtrl->coding_quality_Q14, SILK_FIX_CONST( HIGH_RATE_INPUT_TILT, 12 ) ), 10 );
1.371 + for( k = 0; k < psEnc->sCmn.nb_subfr; k++ ) {
1.372 + psEncCtrl->GainsPre_Q14[ k ] = silk_SMULWB( gain_mult_Q16, psEncCtrl->GainsPre_Q14[ k ] );
1.373 + }
1.374 +
1.375 + /************************************************/
1.376 + /* Control low-frequency shaping and noise tilt */
1.377 + /************************************************/
1.378 + /* Less low frequency shaping for noisy inputs */
1.379 + strength_Q16 = silk_MUL( SILK_FIX_CONST( LOW_FREQ_SHAPING, 4 ), silk_SMLAWB( SILK_FIX_CONST( 1.0, 12 ),
1.380 + SILK_FIX_CONST( LOW_QUALITY_LOW_FREQ_SHAPING_DECR, 13 ), psEnc->sCmn.input_quality_bands_Q15[ 0 ] - SILK_FIX_CONST( 1.0, 15 ) ) );
1.381 + strength_Q16 = silk_RSHIFT( silk_MUL( strength_Q16, psEnc->sCmn.speech_activity_Q8 ), 8 );
1.382 + if( psEnc->sCmn.indices.signalType == TYPE_VOICED ) {
1.383 + /* Reduce low frequencies quantization noise for periodic signals, depending on pitch lag */
1.384 + /*f = 400; freqz([1, -0.98 + 2e-4 * f], [1, -0.97 + 7e-4 * f], 2^12, Fs); axis([0, 1000, -10, 1])*/
1.385 + opus_int fs_kHz_inv = silk_DIV32_16( SILK_FIX_CONST( 0.2, 14 ), psEnc->sCmn.fs_kHz );
1.386 + for( k = 0; k < psEnc->sCmn.nb_subfr; k++ ) {
1.387 + b_Q14 = fs_kHz_inv + silk_DIV32_16( SILK_FIX_CONST( 3.0, 14 ), psEncCtrl->pitchL[ k ] );
1.388 + /* Pack two coefficients in one int32 */
1.389 + psEncCtrl->LF_shp_Q14[ k ] = silk_LSHIFT( SILK_FIX_CONST( 1.0, 14 ) - b_Q14 - silk_SMULWB( strength_Q16, b_Q14 ), 16 );
1.390 + psEncCtrl->LF_shp_Q14[ k ] |= (opus_uint16)( b_Q14 - SILK_FIX_CONST( 1.0, 14 ) );
1.391 + }
1.392 + silk_assert( SILK_FIX_CONST( HARM_HP_NOISE_COEF, 24 ) < SILK_FIX_CONST( 0.5, 24 ) ); /* Guarantees that second argument to SMULWB() is within range of an opus_int16*/
1.393 + Tilt_Q16 = - SILK_FIX_CONST( HP_NOISE_COEF, 16 ) -
1.394 + silk_SMULWB( SILK_FIX_CONST( 1.0, 16 ) - SILK_FIX_CONST( HP_NOISE_COEF, 16 ),
1.395 + silk_SMULWB( SILK_FIX_CONST( HARM_HP_NOISE_COEF, 24 ), psEnc->sCmn.speech_activity_Q8 ) );
1.396 + } else {
1.397 + b_Q14 = silk_DIV32_16( 21299, psEnc->sCmn.fs_kHz ); /* 1.3_Q0 = 21299_Q14*/
1.398 + /* Pack two coefficients in one int32 */
1.399 + psEncCtrl->LF_shp_Q14[ 0 ] = silk_LSHIFT( SILK_FIX_CONST( 1.0, 14 ) - b_Q14 -
1.400 + silk_SMULWB( strength_Q16, silk_SMULWB( SILK_FIX_CONST( 0.6, 16 ), b_Q14 ) ), 16 );
1.401 + psEncCtrl->LF_shp_Q14[ 0 ] |= (opus_uint16)( b_Q14 - SILK_FIX_CONST( 1.0, 14 ) );
1.402 + for( k = 1; k < psEnc->sCmn.nb_subfr; k++ ) {
1.403 + psEncCtrl->LF_shp_Q14[ k ] = psEncCtrl->LF_shp_Q14[ 0 ];
1.404 + }
1.405 + Tilt_Q16 = -SILK_FIX_CONST( HP_NOISE_COEF, 16 );
1.406 + }
1.407 +
1.408 + /****************************/
1.409 + /* HARMONIC SHAPING CONTROL */
1.410 + /****************************/
1.411 + /* Control boosting of harmonic frequencies */
1.412 + HarmBoost_Q16 = silk_SMULWB( silk_SMULWB( SILK_FIX_CONST( 1.0, 17 ) - silk_LSHIFT( psEncCtrl->coding_quality_Q14, 3 ),
1.413 + psEnc->LTPCorr_Q15 ), SILK_FIX_CONST( LOW_RATE_HARMONIC_BOOST, 16 ) );
1.414 +
1.415 + /* More harmonic boost for noisy input signals */
1.416 + HarmBoost_Q16 = silk_SMLAWB( HarmBoost_Q16,
1.417 + SILK_FIX_CONST( 1.0, 16 ) - silk_LSHIFT( psEncCtrl->input_quality_Q14, 2 ), SILK_FIX_CONST( LOW_INPUT_QUALITY_HARMONIC_BOOST, 16 ) );
1.418 +
1.419 + if( USE_HARM_SHAPING && psEnc->sCmn.indices.signalType == TYPE_VOICED ) {
1.420 + /* More harmonic noise shaping for high bitrates or noisy input */
1.421 + HarmShapeGain_Q16 = silk_SMLAWB( SILK_FIX_CONST( HARMONIC_SHAPING, 16 ),
1.422 + SILK_FIX_CONST( 1.0, 16 ) - silk_SMULWB( SILK_FIX_CONST( 1.0, 18 ) - silk_LSHIFT( psEncCtrl->coding_quality_Q14, 4 ),
1.423 + psEncCtrl->input_quality_Q14 ), SILK_FIX_CONST( HIGH_RATE_OR_LOW_QUALITY_HARMONIC_SHAPING, 16 ) );
1.424 +
1.425 + /* Less harmonic noise shaping for less periodic signals */
1.426 + HarmShapeGain_Q16 = silk_SMULWB( silk_LSHIFT( HarmShapeGain_Q16, 1 ),
1.427 + silk_SQRT_APPROX( silk_LSHIFT( psEnc->LTPCorr_Q15, 15 ) ) );
1.428 + } else {
1.429 + HarmShapeGain_Q16 = 0;
1.430 + }
1.431 +
1.432 + /*************************/
1.433 + /* Smooth over subframes */
1.434 + /*************************/
1.435 + for( k = 0; k < MAX_NB_SUBFR; k++ ) {
1.436 + psShapeSt->HarmBoost_smth_Q16 =
1.437 + silk_SMLAWB( psShapeSt->HarmBoost_smth_Q16, HarmBoost_Q16 - psShapeSt->HarmBoost_smth_Q16, SILK_FIX_CONST( SUBFR_SMTH_COEF, 16 ) );
1.438 + psShapeSt->HarmShapeGain_smth_Q16 =
1.439 + silk_SMLAWB( psShapeSt->HarmShapeGain_smth_Q16, HarmShapeGain_Q16 - psShapeSt->HarmShapeGain_smth_Q16, SILK_FIX_CONST( SUBFR_SMTH_COEF, 16 ) );
1.440 + psShapeSt->Tilt_smth_Q16 =
1.441 + silk_SMLAWB( psShapeSt->Tilt_smth_Q16, Tilt_Q16 - psShapeSt->Tilt_smth_Q16, SILK_FIX_CONST( SUBFR_SMTH_COEF, 16 ) );
1.442 +
1.443 + psEncCtrl->HarmBoost_Q14[ k ] = ( opus_int )silk_RSHIFT_ROUND( psShapeSt->HarmBoost_smth_Q16, 2 );
1.444 + psEncCtrl->HarmShapeGain_Q14[ k ] = ( opus_int )silk_RSHIFT_ROUND( psShapeSt->HarmShapeGain_smth_Q16, 2 );
1.445 + psEncCtrl->Tilt_Q14[ k ] = ( opus_int )silk_RSHIFT_ROUND( psShapeSt->Tilt_smth_Q16, 2 );
1.446 + }
1.447 + RESTORE_STACK;
1.448 +}
