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_FIX.h" 33 #include "stack_alloc.h" 34 #include "tuning_parameters.h" 35 36 /* Compute gain to make warped filter coefficients have a zero mean log frequency response on a */ 37 /* non-warped frequency scale. (So that it can be implemented with a minimum-phase monic filter.) */ 38 /* Note: A monic filter is one with the first coefficient equal to 1.0. In Silk we omit the first */ 39 /* coefficient in an array of coefficients, for monic filters. */ 40 static inline opus_int32 warped_gain( /* gain in Q16*/ 41 const opus_int32 *coefs_Q24, 42 opus_int lambda_Q16, 43 opus_int order 44 ) { 45 opus_int i; 46 opus_int32 gain_Q24; 47 48 lambda_Q16 = -lambda_Q16; 49 gain_Q24 = coefs_Q24[ order - 1 ]; 50 for( i = order - 2; i >= 0; i-- ) { 51 gain_Q24 = silk_SMLAWB( coefs_Q24[ i ], gain_Q24, lambda_Q16 ); 52 } 53 gain_Q24 = silk_SMLAWB( SILK_FIX_CONST( 1.0, 24 ), gain_Q24, -lambda_Q16 ); 54 return silk_INVERSE32_varQ( gain_Q24, 40 ); 55 } 56 57 /* Convert warped filter coefficients to monic pseudo-warped coefficients and limit maximum */ 58 /* amplitude of monic warped coefficients by using bandwidth expansion on the true coefficients */ 59 static inline void limit_warped_coefs( 60 opus_int32 *coefs_syn_Q24, 61 opus_int32 *coefs_ana_Q24, 62 opus_int lambda_Q16, 63 opus_int32 limit_Q24, 64 opus_int order 65 ) { 66 opus_int i, iter, ind = 0; 67 opus_int32 tmp, maxabs_Q24, chirp_Q16, gain_syn_Q16, gain_ana_Q16; 68 opus_int32 nom_Q16, den_Q24; 69 70 /* Convert to monic coefficients */ 71 lambda_Q16 = -lambda_Q16; 72 for( i = order - 1; i > 0; i-- ) { 73 coefs_syn_Q24[ i - 1 ] = silk_SMLAWB( coefs_syn_Q24[ i - 1 ], coefs_syn_Q24[ i ], lambda_Q16 ); 74 coefs_ana_Q24[ i - 1 ] = silk_SMLAWB( coefs_ana_Q24[ i - 1 ], coefs_ana_Q24[ i ], lambda_Q16 ); 75 } 76 lambda_Q16 = -lambda_Q16; 77 nom_Q16 = silk_SMLAWB( SILK_FIX_CONST( 1.0, 16 ), -(opus_int32)lambda_Q16, lambda_Q16 ); 78 den_Q24 = silk_SMLAWB( SILK_FIX_CONST( 1.0, 24 ), coefs_syn_Q24[ 0 ], lambda_Q16 ); 79 gain_syn_Q16 = silk_DIV32_varQ( nom_Q16, den_Q24, 24 ); 80 den_Q24 = silk_SMLAWB( SILK_FIX_CONST( 1.0, 24 ), coefs_ana_Q24[ 0 ], lambda_Q16 ); 81 gain_ana_Q16 = silk_DIV32_varQ( nom_Q16, den_Q24, 24 ); 82 for( i = 0; i < order; i++ ) { 83 coefs_syn_Q24[ i ] = silk_SMULWW( gain_syn_Q16, coefs_syn_Q24[ i ] ); 84 coefs_ana_Q24[ i ] = silk_SMULWW( gain_ana_Q16, coefs_ana_Q24[ i ] ); 85 } 86 87 for( iter = 0; iter < 10; iter++ ) { 88 /* Find maximum absolute value */ 89 maxabs_Q24 = -1; 90 for( i = 0; i < order; i++ ) { 91 tmp = silk_max( silk_abs_int32( coefs_syn_Q24[ i ] ), silk_abs_int32( coefs_ana_Q24[ i ] ) ); 92 if( tmp > maxabs_Q24 ) { 93 maxabs_Q24 = tmp; 94 ind = i; 95 } 96 } 97 if( maxabs_Q24 <= limit_Q24 ) { 98 /* Coefficients are within range - done */ 99 return; 100 } 101 102 /* Convert back to true warped coefficients */ 103 for( i = 1; i < order; i++ ) { 104 coefs_syn_Q24[ i - 1 ] = silk_SMLAWB( coefs_syn_Q24[ i - 1 ], coefs_syn_Q24[ i ], lambda_Q16 ); 105 coefs_ana_Q24[ i - 1 ] = silk_SMLAWB( coefs_ana_Q24[ i - 1 ], coefs_ana_Q24[ i ], lambda_Q16 ); 106 } 107 gain_syn_Q16 = silk_INVERSE32_varQ( gain_syn_Q16, 32 ); 108 gain_ana_Q16 = silk_INVERSE32_varQ( gain_ana_Q16, 32 ); 109 for( i = 0; i < order; i++ ) { 110 coefs_syn_Q24[ i ] = silk_SMULWW( gain_syn_Q16, coefs_syn_Q24[ i ] ); 111 coefs_ana_Q24[ i ] = silk_SMULWW( gain_ana_Q16, coefs_ana_Q24[ i ] ); 112 } 113 114 /* Apply bandwidth expansion */ 115 chirp_Q16 = SILK_FIX_CONST( 0.99, 16 ) - silk_DIV32_varQ( 116 silk_SMULWB( maxabs_Q24 - limit_Q24, silk_SMLABB( SILK_FIX_CONST( 0.8, 10 ), SILK_FIX_CONST( 0.1, 10 ), iter ) ), 117 silk_MUL( maxabs_Q24, ind + 1 ), 22 ); 118 silk_bwexpander_32( coefs_syn_Q24, order, chirp_Q16 ); 119 silk_bwexpander_32( coefs_ana_Q24, order, chirp_Q16 ); 120 121 /* Convert to monic warped coefficients */ 122 lambda_Q16 = -lambda_Q16; 123 for( i = order - 1; i > 0; i-- ) { 124 coefs_syn_Q24[ i - 1 ] = silk_SMLAWB( coefs_syn_Q24[ i - 1 ], coefs_syn_Q24[ i ], lambda_Q16 ); 125 coefs_ana_Q24[ i - 1 ] = silk_SMLAWB( coefs_ana_Q24[ i - 1 ], coefs_ana_Q24[ i ], lambda_Q16 ); 126 } 127 lambda_Q16 = -lambda_Q16; 128 nom_Q16 = silk_SMLAWB( SILK_FIX_CONST( 1.0, 16 ), -(opus_int32)lambda_Q16, lambda_Q16 ); 129 den_Q24 = silk_SMLAWB( SILK_FIX_CONST( 1.0, 24 ), coefs_syn_Q24[ 0 ], lambda_Q16 ); 130 gain_syn_Q16 = silk_DIV32_varQ( nom_Q16, den_Q24, 24 ); 131 den_Q24 = silk_SMLAWB( SILK_FIX_CONST( 1.0, 24 ), coefs_ana_Q24[ 0 ], lambda_Q16 ); 132 gain_ana_Q16 = silk_DIV32_varQ( nom_Q16, den_Q24, 24 ); 133 for( i = 0; i < order; i++ ) { 134 coefs_syn_Q24[ i ] = silk_SMULWW( gain_syn_Q16, coefs_syn_Q24[ i ] ); 135 coefs_ana_Q24[ i ] = silk_SMULWW( gain_ana_Q16, coefs_ana_Q24[ i ] ); 136 } 137 } 138 silk_assert( 0 ); 139 } 140 141 /**************************************************************/ 142 /* Compute noise shaping coefficients and initial gain values */ 143 /**************************************************************/ 144 void silk_noise_shape_analysis_FIX( 145 silk_encoder_state_FIX *psEnc, /* I/O Encoder state FIX */ 146 silk_encoder_control_FIX *psEncCtrl, /* I/O Encoder control FIX */ 147 const opus_int16 *pitch_res, /* I LPC residual from pitch analysis */ 148 const opus_int16 *x /* I Input signal [ frame_length + la_shape ] */ 149 ) 150 { 151 silk_shape_state_FIX *psShapeSt = &psEnc->sShape; 152 opus_int k, i, nSamples, Qnrg, b_Q14, warping_Q16, scale = 0; 153 opus_int32 SNR_adj_dB_Q7, HarmBoost_Q16, HarmShapeGain_Q16, Tilt_Q16, tmp32; 154 opus_int32 nrg, pre_nrg_Q30, log_energy_Q7, log_energy_prev_Q7, energy_variation_Q7; 155 opus_int32 delta_Q16, BWExp1_Q16, BWExp2_Q16, gain_mult_Q16, gain_add_Q16, strength_Q16, b_Q8; 156 opus_int32 auto_corr[ MAX_SHAPE_LPC_ORDER + 1 ]; 157 opus_int32 refl_coef_Q16[ MAX_SHAPE_LPC_ORDER ]; 158 opus_int32 AR1_Q24[ MAX_SHAPE_LPC_ORDER ]; 159 opus_int32 AR2_Q24[ MAX_SHAPE_LPC_ORDER ]; 160 VARDECL( opus_int16, x_windowed ); 161 const opus_int16 *x_ptr, *pitch_res_ptr; 162 SAVE_STACK; 163 164 /* Point to start of first LPC analysis block */ 165 x_ptr = x - psEnc->sCmn.la_shape; 166 167 /****************/ 168 /* GAIN CONTROL */ 169 /****************/ 170 SNR_adj_dB_Q7 = psEnc->sCmn.SNR_dB_Q7; 171 172 /* Input quality is the average of the quality in the lowest two VAD bands */ 173 psEncCtrl->input_quality_Q14 = ( opus_int )silk_RSHIFT( (opus_int32)psEnc->sCmn.input_quality_bands_Q15[ 0 ] 174 + psEnc->sCmn.input_quality_bands_Q15[ 1 ], 2 ); 175 176 /* Coding quality level, between 0.0_Q0 and 1.0_Q0, but in Q14 */ 177 psEncCtrl->coding_quality_Q14 = silk_RSHIFT( silk_sigm_Q15( silk_RSHIFT_ROUND( SNR_adj_dB_Q7 - 178 SILK_FIX_CONST( 20.0, 7 ), 4 ) ), 1 ); 179 180 /* Reduce coding SNR during low speech activity */ 181 if( psEnc->sCmn.useCBR == 0 ) { 182 b_Q8 = SILK_FIX_CONST( 1.0, 8 ) - psEnc->sCmn.speech_activity_Q8; 183 b_Q8 = silk_SMULWB( silk_LSHIFT( b_Q8, 8 ), b_Q8 ); 184 SNR_adj_dB_Q7 = silk_SMLAWB( SNR_adj_dB_Q7, 185 silk_SMULBB( SILK_FIX_CONST( -BG_SNR_DECR_dB, 7 ) >> ( 4 + 1 ), b_Q8 ), /* Q11*/ 186 silk_SMULWB( SILK_FIX_CONST( 1.0, 14 ) + psEncCtrl->input_quality_Q14, psEncCtrl->coding_quality_Q14 ) ); /* Q12*/ 187 } 188 189 if( psEnc->sCmn.indices.signalType == TYPE_VOICED ) { 190 /* Reduce gains for periodic signals */ 191 SNR_adj_dB_Q7 = silk_SMLAWB( SNR_adj_dB_Q7, SILK_FIX_CONST( HARM_SNR_INCR_dB, 8 ), psEnc->LTPCorr_Q15 ); 192 } else { 193 /* For unvoiced signals and low-quality input, adjust the quality slower than SNR_dB setting */ 194 SNR_adj_dB_Q7 = silk_SMLAWB( SNR_adj_dB_Q7, 195 silk_SMLAWB( SILK_FIX_CONST( 6.0, 9 ), -SILK_FIX_CONST( 0.4, 18 ), psEnc->sCmn.SNR_dB_Q7 ), 196 SILK_FIX_CONST( 1.0, 14 ) - psEncCtrl->input_quality_Q14 ); 197 } 198 199 /*************************/ 200 /* SPARSENESS PROCESSING */ 201 /*************************/ 202 /* Set quantizer offset */ 203 if( psEnc->sCmn.indices.signalType == TYPE_VOICED ) { 204 /* Initially set to 0; may be overruled in process_gains(..) */ 205 psEnc->sCmn.indices.quantOffsetType = 0; 206 psEncCtrl->sparseness_Q8 = 0; 207 } else { 208 /* Sparseness measure, based on relative fluctuations of energy per 2 milliseconds */ 209 nSamples = silk_LSHIFT( psEnc->sCmn.fs_kHz, 1 ); 210 energy_variation_Q7 = 0; 211 log_energy_prev_Q7 = 0; 212 pitch_res_ptr = pitch_res; 213 for( k = 0; k < silk_SMULBB( SUB_FRAME_LENGTH_MS, psEnc->sCmn.nb_subfr ) / 2; k++ ) { 214 silk_sum_sqr_shift( &nrg, &scale, pitch_res_ptr, nSamples ); 215 nrg += silk_RSHIFT( nSamples, scale ); /* Q(-scale)*/ 216 217 log_energy_Q7 = silk_lin2log( nrg ); 218 if( k > 0 ) { 219 energy_variation_Q7 += silk_abs( log_energy_Q7 - log_energy_prev_Q7 ); 220 } 221 log_energy_prev_Q7 = log_energy_Q7; 222 pitch_res_ptr += nSamples; 223 } 224 225 psEncCtrl->sparseness_Q8 = silk_RSHIFT( silk_sigm_Q15( silk_SMULWB( energy_variation_Q7 - 226 SILK_FIX_CONST( 5.0, 7 ), SILK_FIX_CONST( 0.1, 16 ) ) ), 7 ); 227 228 /* Set quantization offset depending on sparseness measure */ 229 if( psEncCtrl->sparseness_Q8 > SILK_FIX_CONST( SPARSENESS_THRESHOLD_QNT_OFFSET, 8 ) ) { 230 psEnc->sCmn.indices.quantOffsetType = 0; 231 } else { 232 psEnc->sCmn.indices.quantOffsetType = 1; 233 } 234 235 /* Increase coding SNR for sparse signals */ 236 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 ) ); 237 } 238 239 /*******************************/ 240 /* Control bandwidth expansion */ 241 /*******************************/ 242 /* More BWE for signals with high prediction gain */ 243 strength_Q16 = silk_SMULWB( psEncCtrl->predGain_Q16, SILK_FIX_CONST( FIND_PITCH_WHITE_NOISE_FRACTION, 16 ) ); 244 BWExp1_Q16 = BWExp2_Q16 = silk_DIV32_varQ( SILK_FIX_CONST( BANDWIDTH_EXPANSION, 16 ), 245 silk_SMLAWW( SILK_FIX_CONST( 1.0, 16 ), strength_Q16, strength_Q16 ), 16 ); 246 delta_Q16 = silk_SMULWB( SILK_FIX_CONST( 1.0, 16 ) - silk_SMULBB( 3, psEncCtrl->coding_quality_Q14 ), 247 SILK_FIX_CONST( LOW_RATE_BANDWIDTH_EXPANSION_DELTA, 16 ) ); 248 BWExp1_Q16 = silk_SUB32( BWExp1_Q16, delta_Q16 ); 249 BWExp2_Q16 = silk_ADD32( BWExp2_Q16, delta_Q16 ); 250 /* BWExp1 will be applied after BWExp2, so make it relative */ 251 BWExp1_Q16 = silk_DIV32_16( silk_LSHIFT( BWExp1_Q16, 14 ), silk_RSHIFT( BWExp2_Q16, 2 ) ); 252 253 if( psEnc->sCmn.warping_Q16 > 0 ) { 254 /* Slightly more warping in analysis will move quantization noise up in frequency, where it's better masked */ 255 warping_Q16 = silk_SMLAWB( psEnc->sCmn.warping_Q16, (opus_int32)psEncCtrl->coding_quality_Q14, SILK_FIX_CONST( 0.01, 18 ) ); 256 } else { 257 warping_Q16 = 0; 258 } 259 260 /********************************************/ 261 /* Compute noise shaping AR coefs and gains */ 262 /********************************************/ 263 ALLOC( x_windowed, psEnc->sCmn.shapeWinLength, opus_int16 ); 264 for( k = 0; k < psEnc->sCmn.nb_subfr; k++ ) { 265 /* Apply window: sine slope followed by flat part followed by cosine slope */ 266 opus_int shift, slope_part, flat_part; 267 flat_part = psEnc->sCmn.fs_kHz * 3; 268 slope_part = silk_RSHIFT( psEnc->sCmn.shapeWinLength - flat_part, 1 ); 269 270 silk_apply_sine_window( x_windowed, x_ptr, 1, slope_part ); 271 shift = slope_part; 272 silk_memcpy( x_windowed + shift, x_ptr + shift, flat_part * sizeof(opus_int16) ); 273 shift += flat_part; 274 silk_apply_sine_window( x_windowed + shift, x_ptr + shift, 2, slope_part ); 275 276 /* Update pointer: next LPC analysis block */ 277 x_ptr += psEnc->sCmn.subfr_length; 278 279 if( psEnc->sCmn.warping_Q16 > 0 ) { 280 /* Calculate warped auto correlation */ 281 silk_warped_autocorrelation_FIX( auto_corr, &scale, x_windowed, warping_Q16, psEnc->sCmn.shapeWinLength, psEnc->sCmn.shapingLPCOrder ); 282 } else { 283 /* Calculate regular auto correlation */ 284 silk_autocorr( auto_corr, &scale, x_windowed, psEnc->sCmn.shapeWinLength, psEnc->sCmn.shapingLPCOrder + 1 ); 285 } 286 287 /* Add white noise, as a fraction of energy */ 288 auto_corr[0] = silk_ADD32( auto_corr[0], silk_max_32( silk_SMULWB( silk_RSHIFT( auto_corr[ 0 ], 4 ), 289 SILK_FIX_CONST( SHAPE_WHITE_NOISE_FRACTION, 20 ) ), 1 ) ); 290 291 /* Calculate the reflection coefficients using schur */ 292 nrg = silk_schur64( refl_coef_Q16, auto_corr, psEnc->sCmn.shapingLPCOrder ); 293 silk_assert( nrg >= 0 ); 294 295 /* Convert reflection coefficients to prediction coefficients */ 296 silk_k2a_Q16( AR2_Q24, refl_coef_Q16, psEnc->sCmn.shapingLPCOrder ); 297 298 Qnrg = -scale; /* range: -12...30*/ 299 silk_assert( Qnrg >= -12 ); 300 silk_assert( Qnrg <= 30 ); 301 302 /* Make sure that Qnrg is an even number */ 303 if( Qnrg & 1 ) { 304 Qnrg -= 1; 305 nrg >>= 1; 306 } 307 308 tmp32 = silk_SQRT_APPROX( nrg ); 309 Qnrg >>= 1; /* range: -6...15*/ 310 311 psEncCtrl->Gains_Q16[ k ] = silk_LSHIFT_SAT32( tmp32, 16 - Qnrg ); 312 313 if( psEnc->sCmn.warping_Q16 > 0 ) { 314 /* Adjust gain for warping */ 315 gain_mult_Q16 = warped_gain( AR2_Q24, warping_Q16, psEnc->sCmn.shapingLPCOrder ); 316 silk_assert( psEncCtrl->Gains_Q16[ k ] >= 0 ); 317 if ( silk_SMULWW( silk_RSHIFT_ROUND( psEncCtrl->Gains_Q16[ k ], 1 ), gain_mult_Q16 ) >= ( silk_int32_MAX >> 1 ) ) { 318 psEncCtrl->Gains_Q16[ k ] = silk_int32_MAX; 319 } else { 320 psEncCtrl->Gains_Q16[ k ] = silk_SMULWW( psEncCtrl->Gains_Q16[ k ], gain_mult_Q16 ); 321 } 322 } 323 324 /* Bandwidth expansion for synthesis filter shaping */ 325 silk_bwexpander_32( AR2_Q24, psEnc->sCmn.shapingLPCOrder, BWExp2_Q16 ); 326 327 /* Compute noise shaping filter coefficients */ 328 silk_memcpy( AR1_Q24, AR2_Q24, psEnc->sCmn.shapingLPCOrder * sizeof( opus_int32 ) ); 329 330 /* Bandwidth expansion for analysis filter shaping */ 331 silk_assert( BWExp1_Q16 <= SILK_FIX_CONST( 1.0, 16 ) ); 332 silk_bwexpander_32( AR1_Q24, psEnc->sCmn.shapingLPCOrder, BWExp1_Q16 ); 333 334 /* Ratio of prediction gains, in energy domain */ 335 pre_nrg_Q30 = silk_LPC_inverse_pred_gain_Q24( AR2_Q24, psEnc->sCmn.shapingLPCOrder ); 336 nrg = silk_LPC_inverse_pred_gain_Q24( AR1_Q24, psEnc->sCmn.shapingLPCOrder ); 337 338 /*psEncCtrl->GainsPre[ k ] = 1.0f - 0.7f * ( 1.0f - pre_nrg / nrg ) = 0.3f + 0.7f * pre_nrg / nrg;*/ 339 pre_nrg_Q30 = silk_LSHIFT32( silk_SMULWB( pre_nrg_Q30, SILK_FIX_CONST( 0.7, 15 ) ), 1 ); 340 psEncCtrl->GainsPre_Q14[ k ] = ( opus_int ) SILK_FIX_CONST( 0.3, 14 ) + silk_DIV32_varQ( pre_nrg_Q30, nrg, 14 ); 341 342 /* Convert to monic warped prediction coefficients and limit absolute values */ 343 limit_warped_coefs( AR2_Q24, AR1_Q24, warping_Q16, SILK_FIX_CONST( 3.999, 24 ), psEnc->sCmn.shapingLPCOrder ); 344 345 /* Convert from Q24 to Q13 and store in int16 */ 346 for( i = 0; i < psEnc->sCmn.shapingLPCOrder; i++ ) { 347 psEncCtrl->AR1_Q13[ k * MAX_SHAPE_LPC_ORDER + i ] = (opus_int16)silk_SAT16( silk_RSHIFT_ROUND( AR1_Q24[ i ], 11 ) ); 348 psEncCtrl->AR2_Q13[ k * MAX_SHAPE_LPC_ORDER + i ] = (opus_int16)silk_SAT16( silk_RSHIFT_ROUND( AR2_Q24[ i ], 11 ) ); 349 } 350 } 351 352 /*****************/ 353 /* Gain tweaking */ 354 /*****************/ 355 /* Increase gains during low speech activity and put lower limit on gains */ 356 gain_mult_Q16 = silk_log2lin( -silk_SMLAWB( -SILK_FIX_CONST( 16.0, 7 ), SNR_adj_dB_Q7, SILK_FIX_CONST( 0.16, 16 ) ) ); 357 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 ) ) ); 358 silk_assert( gain_mult_Q16 > 0 ); 359 for( k = 0; k < psEnc->sCmn.nb_subfr; k++ ) { 360 psEncCtrl->Gains_Q16[ k ] = silk_SMULWW( psEncCtrl->Gains_Q16[ k ], gain_mult_Q16 ); 361 silk_assert( psEncCtrl->Gains_Q16[ k ] >= 0 ); 362 psEncCtrl->Gains_Q16[ k ] = silk_ADD_POS_SAT32( psEncCtrl->Gains_Q16[ k ], gain_add_Q16 ); 363 } 364 365 gain_mult_Q16 = SILK_FIX_CONST( 1.0, 16 ) + silk_RSHIFT_ROUND( silk_MLA( SILK_FIX_CONST( INPUT_TILT, 26 ), 366 psEncCtrl->coding_quality_Q14, SILK_FIX_CONST( HIGH_RATE_INPUT_TILT, 12 ) ), 10 ); 367 for( k = 0; k < psEnc->sCmn.nb_subfr; k++ ) { 368 psEncCtrl->GainsPre_Q14[ k ] = silk_SMULWB( gain_mult_Q16, psEncCtrl->GainsPre_Q14[ k ] ); 369 } 370 371 /************************************************/ 372 /* Control low-frequency shaping and noise tilt */ 373 /************************************************/ 374 /* Less low frequency shaping for noisy inputs */ 375 strength_Q16 = silk_MUL( SILK_FIX_CONST( LOW_FREQ_SHAPING, 4 ), silk_SMLAWB( SILK_FIX_CONST( 1.0, 12 ), 376 SILK_FIX_CONST( LOW_QUALITY_LOW_FREQ_SHAPING_DECR, 13 ), psEnc->sCmn.input_quality_bands_Q15[ 0 ] - SILK_FIX_CONST( 1.0, 15 ) ) ); 377 strength_Q16 = silk_RSHIFT( silk_MUL( strength_Q16, psEnc->sCmn.speech_activity_Q8 ), 8 ); 378 if( psEnc->sCmn.indices.signalType == TYPE_VOICED ) { 379 /* Reduce low frequencies quantization noise for periodic signals, depending on pitch lag */ 380 /*f = 400; freqz([1, -0.98 + 2e-4 * f], [1, -0.97 + 7e-4 * f], 2^12, Fs); axis([0, 1000, -10, 1])*/ 381 opus_int fs_kHz_inv = silk_DIV32_16( SILK_FIX_CONST( 0.2, 14 ), psEnc->sCmn.fs_kHz ); 382 for( k = 0; k < psEnc->sCmn.nb_subfr; k++ ) { 383 b_Q14 = fs_kHz_inv + silk_DIV32_16( SILK_FIX_CONST( 3.0, 14 ), psEncCtrl->pitchL[ k ] ); 384 /* Pack two coefficients in one int32 */ 385 psEncCtrl->LF_shp_Q14[ k ] = silk_LSHIFT( SILK_FIX_CONST( 1.0, 14 ) - b_Q14 - silk_SMULWB( strength_Q16, b_Q14 ), 16 ); 386 psEncCtrl->LF_shp_Q14[ k ] |= (opus_uint16)( b_Q14 - SILK_FIX_CONST( 1.0, 14 ) ); 387 } 388 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*/ 389 Tilt_Q16 = - SILK_FIX_CONST( HP_NOISE_COEF, 16 ) - 390 silk_SMULWB( SILK_FIX_CONST( 1.0, 16 ) - SILK_FIX_CONST( HP_NOISE_COEF, 16 ), 391 silk_SMULWB( SILK_FIX_CONST( HARM_HP_NOISE_COEF, 24 ), psEnc->sCmn.speech_activity_Q8 ) ); 392 } else { 393 b_Q14 = silk_DIV32_16( 21299, psEnc->sCmn.fs_kHz ); /* 1.3_Q0 = 21299_Q14*/ 394 /* Pack two coefficients in one int32 */ 395 psEncCtrl->LF_shp_Q14[ 0 ] = silk_LSHIFT( SILK_FIX_CONST( 1.0, 14 ) - b_Q14 - 396 silk_SMULWB( strength_Q16, silk_SMULWB( SILK_FIX_CONST( 0.6, 16 ), b_Q14 ) ), 16 ); 397 psEncCtrl->LF_shp_Q14[ 0 ] |= (opus_uint16)( b_Q14 - SILK_FIX_CONST( 1.0, 14 ) ); 398 for( k = 1; k < psEnc->sCmn.nb_subfr; k++ ) { 399 psEncCtrl->LF_shp_Q14[ k ] = psEncCtrl->LF_shp_Q14[ 0 ]; 400 } 401 Tilt_Q16 = -SILK_FIX_CONST( HP_NOISE_COEF, 16 ); 402 } 403 404 /****************************/ 405 /* HARMONIC SHAPING CONTROL */ 406 /****************************/ 407 /* Control boosting of harmonic frequencies */ 408 HarmBoost_Q16 = silk_SMULWB( silk_SMULWB( SILK_FIX_CONST( 1.0, 17 ) - silk_LSHIFT( psEncCtrl->coding_quality_Q14, 3 ), 409 psEnc->LTPCorr_Q15 ), SILK_FIX_CONST( LOW_RATE_HARMONIC_BOOST, 16 ) ); 410 411 /* More harmonic boost for noisy input signals */ 412 HarmBoost_Q16 = silk_SMLAWB( HarmBoost_Q16, 413 SILK_FIX_CONST( 1.0, 16 ) - silk_LSHIFT( psEncCtrl->input_quality_Q14, 2 ), SILK_FIX_CONST( LOW_INPUT_QUALITY_HARMONIC_BOOST, 16 ) ); 414 415 if( USE_HARM_SHAPING && psEnc->sCmn.indices.signalType == TYPE_VOICED ) { 416 /* More harmonic noise shaping for high bitrates or noisy input */ 417 HarmShapeGain_Q16 = silk_SMLAWB( SILK_FIX_CONST( HARMONIC_SHAPING, 16 ), 418 SILK_FIX_CONST( 1.0, 16 ) - silk_SMULWB( SILK_FIX_CONST( 1.0, 18 ) - silk_LSHIFT( psEncCtrl->coding_quality_Q14, 4 ), 419 psEncCtrl->input_quality_Q14 ), SILK_FIX_CONST( HIGH_RATE_OR_LOW_QUALITY_HARMONIC_SHAPING, 16 ) ); 420 421 /* Less harmonic noise shaping for less periodic signals */ 422 HarmShapeGain_Q16 = silk_SMULWB( silk_LSHIFT( HarmShapeGain_Q16, 1 ), 423 silk_SQRT_APPROX( silk_LSHIFT( psEnc->LTPCorr_Q15, 15 ) ) ); 424 } else { 425 HarmShapeGain_Q16 = 0; 426 } 427 428 /*************************/ 429 /* Smooth over subframes */ 430 /*************************/ 431 for( k = 0; k < MAX_NB_SUBFR; k++ ) { 432 psShapeSt->HarmBoost_smth_Q16 = 433 silk_SMLAWB( psShapeSt->HarmBoost_smth_Q16, HarmBoost_Q16 - psShapeSt->HarmBoost_smth_Q16, SILK_FIX_CONST( SUBFR_SMTH_COEF, 16 ) ); 434 psShapeSt->HarmShapeGain_smth_Q16 = 435 silk_SMLAWB( psShapeSt->HarmShapeGain_smth_Q16, HarmShapeGain_Q16 - psShapeSt->HarmShapeGain_smth_Q16, SILK_FIX_CONST( SUBFR_SMTH_COEF, 16 ) ); 436 psShapeSt->Tilt_smth_Q16 = 437 silk_SMLAWB( psShapeSt->Tilt_smth_Q16, Tilt_Q16 - psShapeSt->Tilt_smth_Q16, SILK_FIX_CONST( SUBFR_SMTH_COEF, 16 ) ); 438 439 psEncCtrl->HarmBoost_Q14[ k ] = ( opus_int )silk_RSHIFT_ROUND( psShapeSt->HarmBoost_smth_Q16, 2 ); 440 psEncCtrl->HarmShapeGain_Q14[ k ] = ( opus_int )silk_RSHIFT_ROUND( psShapeSt->HarmShapeGain_smth_Q16, 2 ); 441 psEncCtrl->Tilt_Q14[ k ] = ( opus_int )silk_RSHIFT_ROUND( psShapeSt->Tilt_smth_Q16, 2 ); 442 } 443 RESTORE_STACK; 444 } 445
