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 OPUS_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 OPUS_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 #if defined(MIPSr1_ASM) 142 #include "mips/noise_shape_analysis_FIX_mipsr1.h" 143 #endif 144 145 /**************************************************************/ 146 /* Compute noise shaping coefficients and initial gain values */ 147 /**************************************************************/ 148 #ifndef OVERRIDE_silk_noise_shape_analysis_FIX 149 void silk_noise_shape_analysis_FIX( 150 silk_encoder_state_FIX *psEnc, /* I/O Encoder state FIX */ 151 silk_encoder_control_FIX *psEncCtrl, /* I/O Encoder control FIX */ 152 const opus_int16 *pitch_res, /* I LPC residual from pitch analysis */ 153 const opus_int16 *x, /* I Input signal [ frame_length + la_shape ] */ 154 int arch /* I Run-time architecture */ 155 ) 156 { 157 silk_shape_state_FIX *psShapeSt = &psEnc->sShape; 158 opus_int k, i, nSamples, Qnrg, b_Q14, warping_Q16, scale = 0; 159 opus_int32 SNR_adj_dB_Q7, HarmBoost_Q16, HarmShapeGain_Q16, Tilt_Q16, tmp32; 160 opus_int32 nrg, pre_nrg_Q30, log_energy_Q7, log_energy_prev_Q7, energy_variation_Q7; 161 opus_int32 delta_Q16, BWExp1_Q16, BWExp2_Q16, gain_mult_Q16, gain_add_Q16, strength_Q16, b_Q8; 162 opus_int32 auto_corr[ MAX_SHAPE_LPC_ORDER + 1 ]; 163 opus_int32 refl_coef_Q16[ MAX_SHAPE_LPC_ORDER ]; 164 opus_int32 AR1_Q24[ MAX_SHAPE_LPC_ORDER ]; 165 opus_int32 AR2_Q24[ MAX_SHAPE_LPC_ORDER ]; 166 VARDECL( opus_int16, x_windowed ); 167 const opus_int16 *x_ptr, *pitch_res_ptr; 168 SAVE_STACK; 169 170 /* Point to start of first LPC analysis block */ 171 x_ptr = x - psEnc->sCmn.la_shape; 172 173 /****************/ 174 /* GAIN CONTROL */ 175 /****************/ 176 SNR_adj_dB_Q7 = psEnc->sCmn.SNR_dB_Q7; 177 178 /* Input quality is the average of the quality in the lowest two VAD bands */ 179 psEncCtrl->input_quality_Q14 = ( opus_int )silk_RSHIFT( (opus_int32)psEnc->sCmn.input_quality_bands_Q15[ 0 ] 180 + psEnc->sCmn.input_quality_bands_Q15[ 1 ], 2 ); 181 182 /* Coding quality level, between 0.0_Q0 and 1.0_Q0, but in Q14 */ 183 psEncCtrl->coding_quality_Q14 = silk_RSHIFT( silk_sigm_Q15( silk_RSHIFT_ROUND( SNR_adj_dB_Q7 - 184 SILK_FIX_CONST( 20.0, 7 ), 4 ) ), 1 ); 185 186 /* Reduce coding SNR during low speech activity */ 187 if( psEnc->sCmn.useCBR == 0 ) { 188 b_Q8 = SILK_FIX_CONST( 1.0, 8 ) - psEnc->sCmn.speech_activity_Q8; 189 b_Q8 = silk_SMULWB( silk_LSHIFT( b_Q8, 8 ), b_Q8 ); 190 SNR_adj_dB_Q7 = silk_SMLAWB( SNR_adj_dB_Q7, 191 silk_SMULBB( SILK_FIX_CONST( -BG_SNR_DECR_dB, 7 ) >> ( 4 + 1 ), b_Q8 ), /* Q11*/ 192 silk_SMULWB( SILK_FIX_CONST( 1.0, 14 ) + psEncCtrl->input_quality_Q14, psEncCtrl->coding_quality_Q14 ) ); /* Q12*/ 193 } 194 195 if( psEnc->sCmn.indices.signalType == TYPE_VOICED ) { 196 /* Reduce gains for periodic signals */ 197 SNR_adj_dB_Q7 = silk_SMLAWB( SNR_adj_dB_Q7, SILK_FIX_CONST( HARM_SNR_INCR_dB, 8 ), psEnc->LTPCorr_Q15 ); 198 } else { 199 /* For unvoiced signals and low-quality input, adjust the quality slower than SNR_dB setting */ 200 SNR_adj_dB_Q7 = silk_SMLAWB( SNR_adj_dB_Q7, 201 silk_SMLAWB( SILK_FIX_CONST( 6.0, 9 ), -SILK_FIX_CONST( 0.4, 18 ), psEnc->sCmn.SNR_dB_Q7 ), 202 SILK_FIX_CONST( 1.0, 14 ) - psEncCtrl->input_quality_Q14 ); 203 } 204 205 /*************************/ 206 /* SPARSENESS PROCESSING */ 207 /*************************/ 208 /* Set quantizer offset */ 209 if( psEnc->sCmn.indices.signalType == TYPE_VOICED ) { 210 /* Initially set to 0; may be overruled in process_gains(..) */ 211 psEnc->sCmn.indices.quantOffsetType = 0; 212 psEncCtrl->sparseness_Q8 = 0; 213 } else { 214 /* Sparseness measure, based on relative fluctuations of energy per 2 milliseconds */ 215 nSamples = silk_LSHIFT( psEnc->sCmn.fs_kHz, 1 ); 216 energy_variation_Q7 = 0; 217 log_energy_prev_Q7 = 0; 218 pitch_res_ptr = pitch_res; 219 for( k = 0; k < silk_SMULBB( SUB_FRAME_LENGTH_MS, psEnc->sCmn.nb_subfr ) / 2; k++ ) { 220 silk_sum_sqr_shift( &nrg, &scale, pitch_res_ptr, nSamples ); 221 nrg += silk_RSHIFT( nSamples, scale ); /* Q(-scale)*/ 222 223 log_energy_Q7 = silk_lin2log( nrg ); 224 if( k > 0 ) { 225 energy_variation_Q7 += silk_abs( log_energy_Q7 - log_energy_prev_Q7 ); 226 } 227 log_energy_prev_Q7 = log_energy_Q7; 228 pitch_res_ptr += nSamples; 229 } 230 231 psEncCtrl->sparseness_Q8 = silk_RSHIFT( silk_sigm_Q15( silk_SMULWB( energy_variation_Q7 - 232 SILK_FIX_CONST( 5.0, 7 ), SILK_FIX_CONST( 0.1, 16 ) ) ), 7 ); 233 234 /* Set quantization offset depending on sparseness measure */ 235 if( psEncCtrl->sparseness_Q8 > SILK_FIX_CONST( SPARSENESS_THRESHOLD_QNT_OFFSET, 8 ) ) { 236 psEnc->sCmn.indices.quantOffsetType = 0; 237 } else { 238 psEnc->sCmn.indices.quantOffsetType = 1; 239 } 240 241 /* Increase coding SNR for sparse signals */ 242 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 ) ); 243 } 244 245 /*******************************/ 246 /* Control bandwidth expansion */ 247 /*******************************/ 248 /* More BWE for signals with high prediction gain */ 249 strength_Q16 = silk_SMULWB( psEncCtrl->predGain_Q16, SILK_FIX_CONST( FIND_PITCH_WHITE_NOISE_FRACTION, 16 ) ); 250 BWExp1_Q16 = BWExp2_Q16 = silk_DIV32_varQ( SILK_FIX_CONST( BANDWIDTH_EXPANSION, 16 ), 251 silk_SMLAWW( SILK_FIX_CONST( 1.0, 16 ), strength_Q16, strength_Q16 ), 16 ); 252 delta_Q16 = silk_SMULWB( SILK_FIX_CONST( 1.0, 16 ) - silk_SMULBB( 3, psEncCtrl->coding_quality_Q14 ), 253 SILK_FIX_CONST( LOW_RATE_BANDWIDTH_EXPANSION_DELTA, 16 ) ); 254 BWExp1_Q16 = silk_SUB32( BWExp1_Q16, delta_Q16 ); 255 BWExp2_Q16 = silk_ADD32( BWExp2_Q16, delta_Q16 ); 256 /* BWExp1 will be applied after BWExp2, so make it relative */ 257 BWExp1_Q16 = silk_DIV32_16( silk_LSHIFT( BWExp1_Q16, 14 ), silk_RSHIFT( BWExp2_Q16, 2 ) ); 258 259 if( psEnc->sCmn.warping_Q16 > 0 ) { 260 /* Slightly more warping in analysis will move quantization noise up in frequency, where it's better masked */ 261 warping_Q16 = silk_SMLAWB( psEnc->sCmn.warping_Q16, (opus_int32)psEncCtrl->coding_quality_Q14, SILK_FIX_CONST( 0.01, 18 ) ); 262 } else { 263 warping_Q16 = 0; 264 } 265 266 /********************************************/ 267 /* Compute noise shaping AR coefs and gains */ 268 /********************************************/ 269 ALLOC( x_windowed, psEnc->sCmn.shapeWinLength, opus_int16 ); 270 for( k = 0; k < psEnc->sCmn.nb_subfr; k++ ) { 271 /* Apply window: sine slope followed by flat part followed by cosine slope */ 272 opus_int shift, slope_part, flat_part; 273 flat_part = psEnc->sCmn.fs_kHz * 3; 274 slope_part = silk_RSHIFT( psEnc->sCmn.shapeWinLength - flat_part, 1 ); 275 276 silk_apply_sine_window( x_windowed, x_ptr, 1, slope_part ); 277 shift = slope_part; 278 silk_memcpy( x_windowed + shift, x_ptr + shift, flat_part * sizeof(opus_int16) ); 279 shift += flat_part; 280 silk_apply_sine_window( x_windowed + shift, x_ptr + shift, 2, slope_part ); 281 282 /* Update pointer: next LPC analysis block */ 283 x_ptr += psEnc->sCmn.subfr_length; 284 285 if( psEnc->sCmn.warping_Q16 > 0 ) { 286 /* Calculate warped auto correlation */ 287 silk_warped_autocorrelation_FIX( auto_corr, &scale, x_windowed, warping_Q16, psEnc->sCmn.shapeWinLength, psEnc->sCmn.shapingLPCOrder ); 288 } else { 289 /* Calculate regular auto correlation */ 290 silk_autocorr( auto_corr, &scale, x_windowed, psEnc->sCmn.shapeWinLength, psEnc->sCmn.shapingLPCOrder + 1, arch ); 291 } 292 293 /* Add white noise, as a fraction of energy */ 294 auto_corr[0] = silk_ADD32( auto_corr[0], silk_max_32( silk_SMULWB( silk_RSHIFT( auto_corr[ 0 ], 4 ), 295 SILK_FIX_CONST( SHAPE_WHITE_NOISE_FRACTION, 20 ) ), 1 ) ); 296 297 /* Calculate the reflection coefficients using schur */ 298 nrg = silk_schur64( refl_coef_Q16, auto_corr, psEnc->sCmn.shapingLPCOrder ); 299 silk_assert( nrg >= 0 ); 300 301 /* Convert reflection coefficients to prediction coefficients */ 302 silk_k2a_Q16( AR2_Q24, refl_coef_Q16, psEnc->sCmn.shapingLPCOrder ); 303 304 Qnrg = -scale; /* range: -12...30*/ 305 silk_assert( Qnrg >= -12 ); 306 silk_assert( Qnrg <= 30 ); 307 308 /* Make sure that Qnrg is an even number */ 309 if( Qnrg & 1 ) { 310 Qnrg -= 1; 311 nrg >>= 1; 312 } 313 314 tmp32 = silk_SQRT_APPROX( nrg ); 315 Qnrg >>= 1; /* range: -6...15*/ 316 317 psEncCtrl->Gains_Q16[ k ] = silk_LSHIFT_SAT32( tmp32, 16 - Qnrg ); 318 319 if( psEnc->sCmn.warping_Q16 > 0 ) { 320 /* Adjust gain for warping */ 321 gain_mult_Q16 = warped_gain( AR2_Q24, warping_Q16, psEnc->sCmn.shapingLPCOrder ); 322 silk_assert( psEncCtrl->Gains_Q16[ k ] >= 0 ); 323 if ( silk_SMULWW( silk_RSHIFT_ROUND( psEncCtrl->Gains_Q16[ k ], 1 ), gain_mult_Q16 ) >= ( silk_int32_MAX >> 1 ) ) { 324 psEncCtrl->Gains_Q16[ k ] = silk_int32_MAX; 325 } else { 326 psEncCtrl->Gains_Q16[ k ] = silk_SMULWW( psEncCtrl->Gains_Q16[ k ], gain_mult_Q16 ); 327 } 328 } 329 330 /* Bandwidth expansion for synthesis filter shaping */ 331 silk_bwexpander_32( AR2_Q24, psEnc->sCmn.shapingLPCOrder, BWExp2_Q16 ); 332 333 /* Compute noise shaping filter coefficients */ 334 silk_memcpy( AR1_Q24, AR2_Q24, psEnc->sCmn.shapingLPCOrder * sizeof( opus_int32 ) ); 335 336 /* Bandwidth expansion for analysis filter shaping */ 337 silk_assert( BWExp1_Q16 <= SILK_FIX_CONST( 1.0, 16 ) ); 338 silk_bwexpander_32( AR1_Q24, psEnc->sCmn.shapingLPCOrder, BWExp1_Q16 ); 339 340 /* Ratio of prediction gains, in energy domain */ 341 pre_nrg_Q30 = silk_LPC_inverse_pred_gain_Q24( AR2_Q24, psEnc->sCmn.shapingLPCOrder ); 342 nrg = silk_LPC_inverse_pred_gain_Q24( AR1_Q24, psEnc->sCmn.shapingLPCOrder ); 343 344 /*psEncCtrl->GainsPre[ k ] = 1.0f - 0.7f * ( 1.0f - pre_nrg / nrg ) = 0.3f + 0.7f * pre_nrg / nrg;*/ 345 pre_nrg_Q30 = silk_LSHIFT32( silk_SMULWB( pre_nrg_Q30, SILK_FIX_CONST( 0.7, 15 ) ), 1 ); 346 psEncCtrl->GainsPre_Q14[ k ] = ( opus_int ) SILK_FIX_CONST( 0.3, 14 ) + silk_DIV32_varQ( pre_nrg_Q30, nrg, 14 ); 347 348 /* Convert to monic warped prediction coefficients and limit absolute values */ 349 limit_warped_coefs( AR2_Q24, AR1_Q24, warping_Q16, SILK_FIX_CONST( 3.999, 24 ), psEnc->sCmn.shapingLPCOrder ); 350 351 /* Convert from Q24 to Q13 and store in int16 */ 352 for( i = 0; i < psEnc->sCmn.shapingLPCOrder; i++ ) { 353 psEncCtrl->AR1_Q13[ k * MAX_SHAPE_LPC_ORDER + i ] = (opus_int16)silk_SAT16( silk_RSHIFT_ROUND( AR1_Q24[ i ], 11 ) ); 354 psEncCtrl->AR2_Q13[ k * MAX_SHAPE_LPC_ORDER + i ] = (opus_int16)silk_SAT16( silk_RSHIFT_ROUND( AR2_Q24[ i ], 11 ) ); 355 } 356 } 357 358 /*****************/ 359 /* Gain tweaking */ 360 /*****************/ 361 /* Increase gains during low speech activity and put lower limit on gains */ 362 gain_mult_Q16 = silk_log2lin( -silk_SMLAWB( -SILK_FIX_CONST( 16.0, 7 ), SNR_adj_dB_Q7, SILK_FIX_CONST( 0.16, 16 ) ) ); 363 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 ) ) ); 364 silk_assert( gain_mult_Q16 > 0 ); 365 for( k = 0; k < psEnc->sCmn.nb_subfr; k++ ) { 366 psEncCtrl->Gains_Q16[ k ] = silk_SMULWW( psEncCtrl->Gains_Q16[ k ], gain_mult_Q16 ); 367 silk_assert( psEncCtrl->Gains_Q16[ k ] >= 0 ); 368 psEncCtrl->Gains_Q16[ k ] = silk_ADD_POS_SAT32( psEncCtrl->Gains_Q16[ k ], gain_add_Q16 ); 369 } 370 371 gain_mult_Q16 = SILK_FIX_CONST( 1.0, 16 ) + silk_RSHIFT_ROUND( silk_MLA( SILK_FIX_CONST( INPUT_TILT, 26 ), 372 psEncCtrl->coding_quality_Q14, SILK_FIX_CONST( HIGH_RATE_INPUT_TILT, 12 ) ), 10 ); 373 for( k = 0; k < psEnc->sCmn.nb_subfr; k++ ) { 374 psEncCtrl->GainsPre_Q14[ k ] = silk_SMULWB( gain_mult_Q16, psEncCtrl->GainsPre_Q14[ k ] ); 375 } 376 377 /************************************************/ 378 /* Control low-frequency shaping and noise tilt */ 379 /************************************************/ 380 /* Less low frequency shaping for noisy inputs */ 381 strength_Q16 = silk_MUL( SILK_FIX_CONST( LOW_FREQ_SHAPING, 4 ), silk_SMLAWB( SILK_FIX_CONST( 1.0, 12 ), 382 SILK_FIX_CONST( LOW_QUALITY_LOW_FREQ_SHAPING_DECR, 13 ), psEnc->sCmn.input_quality_bands_Q15[ 0 ] - SILK_FIX_CONST( 1.0, 15 ) ) ); 383 strength_Q16 = silk_RSHIFT( silk_MUL( strength_Q16, psEnc->sCmn.speech_activity_Q8 ), 8 ); 384 if( psEnc->sCmn.indices.signalType == TYPE_VOICED ) { 385 /* Reduce low frequencies quantization noise for periodic signals, depending on pitch lag */ 386 /*f = 400; freqz([1, -0.98 + 2e-4 * f], [1, -0.97 + 7e-4 * f], 2^12, Fs); axis([0, 1000, -10, 1])*/ 387 opus_int fs_kHz_inv = silk_DIV32_16( SILK_FIX_CONST( 0.2, 14 ), psEnc->sCmn.fs_kHz ); 388 for( k = 0; k < psEnc->sCmn.nb_subfr; k++ ) { 389 b_Q14 = fs_kHz_inv + silk_DIV32_16( SILK_FIX_CONST( 3.0, 14 ), psEncCtrl->pitchL[ k ] ); 390 /* Pack two coefficients in one int32 */ 391 psEncCtrl->LF_shp_Q14[ k ] = silk_LSHIFT( SILK_FIX_CONST( 1.0, 14 ) - b_Q14 - silk_SMULWB( strength_Q16, b_Q14 ), 16 ); 392 psEncCtrl->LF_shp_Q14[ k ] |= (opus_uint16)( b_Q14 - SILK_FIX_CONST( 1.0, 14 ) ); 393 } 394 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*/ 395 Tilt_Q16 = - SILK_FIX_CONST( HP_NOISE_COEF, 16 ) - 396 silk_SMULWB( SILK_FIX_CONST( 1.0, 16 ) - SILK_FIX_CONST( HP_NOISE_COEF, 16 ), 397 silk_SMULWB( SILK_FIX_CONST( HARM_HP_NOISE_COEF, 24 ), psEnc->sCmn.speech_activity_Q8 ) ); 398 } else { 399 b_Q14 = silk_DIV32_16( 21299, psEnc->sCmn.fs_kHz ); /* 1.3_Q0 = 21299_Q14*/ 400 /* Pack two coefficients in one int32 */ 401 psEncCtrl->LF_shp_Q14[ 0 ] = silk_LSHIFT( SILK_FIX_CONST( 1.0, 14 ) - b_Q14 - 402 silk_SMULWB( strength_Q16, silk_SMULWB( SILK_FIX_CONST( 0.6, 16 ), b_Q14 ) ), 16 ); 403 psEncCtrl->LF_shp_Q14[ 0 ] |= (opus_uint16)( b_Q14 - SILK_FIX_CONST( 1.0, 14 ) ); 404 for( k = 1; k < psEnc->sCmn.nb_subfr; k++ ) { 405 psEncCtrl->LF_shp_Q14[ k ] = psEncCtrl->LF_shp_Q14[ 0 ]; 406 } 407 Tilt_Q16 = -SILK_FIX_CONST( HP_NOISE_COEF, 16 ); 408 } 409 410 /****************************/ 411 /* HARMONIC SHAPING CONTROL */ 412 /****************************/ 413 /* Control boosting of harmonic frequencies */ 414 HarmBoost_Q16 = silk_SMULWB( silk_SMULWB( SILK_FIX_CONST( 1.0, 17 ) - silk_LSHIFT( psEncCtrl->coding_quality_Q14, 3 ), 415 psEnc->LTPCorr_Q15 ), SILK_FIX_CONST( LOW_RATE_HARMONIC_BOOST, 16 ) ); 416 417 /* More harmonic boost for noisy input signals */ 418 HarmBoost_Q16 = silk_SMLAWB( HarmBoost_Q16, 419 SILK_FIX_CONST( 1.0, 16 ) - silk_LSHIFT( psEncCtrl->input_quality_Q14, 2 ), SILK_FIX_CONST( LOW_INPUT_QUALITY_HARMONIC_BOOST, 16 ) ); 420 421 if( USE_HARM_SHAPING && psEnc->sCmn.indices.signalType == TYPE_VOICED ) { 422 /* More harmonic noise shaping for high bitrates or noisy input */ 423 HarmShapeGain_Q16 = silk_SMLAWB( SILK_FIX_CONST( HARMONIC_SHAPING, 16 ), 424 SILK_FIX_CONST( 1.0, 16 ) - silk_SMULWB( SILK_FIX_CONST( 1.0, 18 ) - silk_LSHIFT( psEncCtrl->coding_quality_Q14, 4 ), 425 psEncCtrl->input_quality_Q14 ), SILK_FIX_CONST( HIGH_RATE_OR_LOW_QUALITY_HARMONIC_SHAPING, 16 ) ); 426 427 /* Less harmonic noise shaping for less periodic signals */ 428 HarmShapeGain_Q16 = silk_SMULWB( silk_LSHIFT( HarmShapeGain_Q16, 1 ), 429 silk_SQRT_APPROX( silk_LSHIFT( psEnc->LTPCorr_Q15, 15 ) ) ); 430 } else { 431 HarmShapeGain_Q16 = 0; 432 } 433 434 /*************************/ 435 /* Smooth over subframes */ 436 /*************************/ 437 for( k = 0; k < MAX_NB_SUBFR; k++ ) { 438 psShapeSt->HarmBoost_smth_Q16 = 439 silk_SMLAWB( psShapeSt->HarmBoost_smth_Q16, HarmBoost_Q16 - psShapeSt->HarmBoost_smth_Q16, SILK_FIX_CONST( SUBFR_SMTH_COEF, 16 ) ); 440 psShapeSt->HarmShapeGain_smth_Q16 = 441 silk_SMLAWB( psShapeSt->HarmShapeGain_smth_Q16, HarmShapeGain_Q16 - psShapeSt->HarmShapeGain_smth_Q16, SILK_FIX_CONST( SUBFR_SMTH_COEF, 16 ) ); 442 psShapeSt->Tilt_smth_Q16 = 443 silk_SMLAWB( psShapeSt->Tilt_smth_Q16, Tilt_Q16 - psShapeSt->Tilt_smth_Q16, SILK_FIX_CONST( SUBFR_SMTH_COEF, 16 ) ); 444 445 psEncCtrl->HarmBoost_Q14[ k ] = ( opus_int )silk_RSHIFT_ROUND( psShapeSt->HarmBoost_smth_Q16, 2 ); 446 psEncCtrl->HarmShapeGain_Q14[ k ] = ( opus_int )silk_RSHIFT_ROUND( psShapeSt->HarmShapeGain_smth_Q16, 2 ); 447 psEncCtrl->Tilt_Q14[ k ] = ( opus_int )silk_RSHIFT_ROUND( psShapeSt->Tilt_smth_Q16, 2 ); 448 } 449 RESTORE_STACK; 450 } 451 #endif /* OVERRIDE_silk_noise_shape_analysis_FIX */ 452
