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. */
warped_gain(const opus_int32 * coefs_Q24,opus_int lambda_Q16,opus_int order)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 */
limit_warped_coefs(opus_int32 * coefs_syn_Q24,opus_int32 * coefs_ana_Q24,opus_int lambda_Q16,opus_int32 limit_Q24,opus_int order)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
silk_noise_shape_analysis_FIX(silk_encoder_state_FIX * psEnc,silk_encoder_control_FIX * psEncCtrl,const opus_int16 * pitch_res,const opus_int16 * x,int arch)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