The Tor Browser / file comparison

comparison: media/libopus/silk/PLC.c

media/libopus/silk/PLC.c

changeset 0
6474c204b198
equal deleted inserted replaced
-1:000000000000 0:5c6ef6ad0794
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.h"
33 #include "stack_alloc.h"
34 #include "PLC.h"
35
36 #define NB_ATT 2
37 static const opus_int16 HARM_ATT_Q15[NB_ATT] = { 32440, 31130 }; /* 0.99, 0.95 */
38 static const opus_int16 PLC_RAND_ATTENUATE_V_Q15[NB_ATT] = { 31130, 26214 }; /* 0.95, 0.8 */
39 static const opus_int16 PLC_RAND_ATTENUATE_UV_Q15[NB_ATT] = { 32440, 29491 }; /* 0.99, 0.9 */
40
41 static OPUS_INLINE void silk_PLC_update(
42 silk_decoder_state *psDec, /* I/O Decoder state */
43 silk_decoder_control *psDecCtrl /* I/O Decoder control */
44 );
45
46 static OPUS_INLINE void silk_PLC_conceal(
47 silk_decoder_state *psDec, /* I/O Decoder state */
48 silk_decoder_control *psDecCtrl, /* I/O Decoder control */
49 opus_int16 frame[] /* O LPC residual signal */
50 );
51
52
53 void silk_PLC_Reset(
54 silk_decoder_state *psDec /* I/O Decoder state */
55 )
56 {
57 psDec->sPLC.pitchL_Q8 = silk_LSHIFT( psDec->frame_length, 8 - 1 );
58 psDec->sPLC.prevGain_Q16[ 0 ] = SILK_FIX_CONST( 1, 16 );
59 psDec->sPLC.prevGain_Q16[ 1 ] = SILK_FIX_CONST( 1, 16 );
60 psDec->sPLC.subfr_length = 20;
61 psDec->sPLC.nb_subfr = 2;
62 }
63
64 void silk_PLC(
65 silk_decoder_state *psDec, /* I/O Decoder state */
66 silk_decoder_control *psDecCtrl, /* I/O Decoder control */
67 opus_int16 frame[], /* I/O signal */
68 opus_int lost /* I Loss flag */
69 )
70 {
71 /* PLC control function */
72 if( psDec->fs_kHz != psDec->sPLC.fs_kHz ) {
73 silk_PLC_Reset( psDec );
74 psDec->sPLC.fs_kHz = psDec->fs_kHz;
75 }
76
77 if( lost ) {
78 /****************************/
79 /* Generate Signal */
80 /****************************/
81 silk_PLC_conceal( psDec, psDecCtrl, frame );
82
83 psDec->lossCnt++;
84 } else {
85 /****************************/
86 /* Update state */
87 /****************************/
88 silk_PLC_update( psDec, psDecCtrl );
89 }
90 }
91
92 /**************************************************/
93 /* Update state of PLC */
94 /**************************************************/
95 static OPUS_INLINE void silk_PLC_update(
96 silk_decoder_state *psDec, /* I/O Decoder state */
97 silk_decoder_control *psDecCtrl /* I/O Decoder control */
98 )
99 {
100 opus_int32 LTP_Gain_Q14, temp_LTP_Gain_Q14;
101 opus_int i, j;
102 silk_PLC_struct *psPLC;
103
104 psPLC = &psDec->sPLC;
105
106 /* Update parameters used in case of packet loss */
107 psDec->prevSignalType = psDec->indices.signalType;
108 LTP_Gain_Q14 = 0;
109 if( psDec->indices.signalType == TYPE_VOICED ) {
110 /* Find the parameters for the last subframe which contains a pitch pulse */
111 for( j = 0; j * psDec->subfr_length < psDecCtrl->pitchL[ psDec->nb_subfr - 1 ]; j++ ) {
112 if( j == psDec->nb_subfr ) {
113 break;
114 }
115 temp_LTP_Gain_Q14 = 0;
116 for( i = 0; i < LTP_ORDER; i++ ) {
117 temp_LTP_Gain_Q14 += psDecCtrl->LTPCoef_Q14[ ( psDec->nb_subfr - 1 - j ) * LTP_ORDER + i ];
118 }
119 if( temp_LTP_Gain_Q14 > LTP_Gain_Q14 ) {
120 LTP_Gain_Q14 = temp_LTP_Gain_Q14;
121 silk_memcpy( psPLC->LTPCoef_Q14,
122 &psDecCtrl->LTPCoef_Q14[ silk_SMULBB( psDec->nb_subfr - 1 - j, LTP_ORDER ) ],
123 LTP_ORDER * sizeof( opus_int16 ) );
124
125 psPLC->pitchL_Q8 = silk_LSHIFT( psDecCtrl->pitchL[ psDec->nb_subfr - 1 - j ], 8 );
126 }
127 }
128
129 silk_memset( psPLC->LTPCoef_Q14, 0, LTP_ORDER * sizeof( opus_int16 ) );
130 psPLC->LTPCoef_Q14[ LTP_ORDER / 2 ] = LTP_Gain_Q14;
131
132 /* Limit LT coefs */
133 if( LTP_Gain_Q14 < V_PITCH_GAIN_START_MIN_Q14 ) {
134 opus_int scale_Q10;
135 opus_int32 tmp;
136
137 tmp = silk_LSHIFT( V_PITCH_GAIN_START_MIN_Q14, 10 );
138 scale_Q10 = silk_DIV32( tmp, silk_max( LTP_Gain_Q14, 1 ) );
139 for( i = 0; i < LTP_ORDER; i++ ) {
140 psPLC->LTPCoef_Q14[ i ] = silk_RSHIFT( silk_SMULBB( psPLC->LTPCoef_Q14[ i ], scale_Q10 ), 10 );
141 }
142 } else if( LTP_Gain_Q14 > V_PITCH_GAIN_START_MAX_Q14 ) {
143 opus_int scale_Q14;
144 opus_int32 tmp;
145
146 tmp = silk_LSHIFT( V_PITCH_GAIN_START_MAX_Q14, 14 );
147 scale_Q14 = silk_DIV32( tmp, silk_max( LTP_Gain_Q14, 1 ) );
148 for( i = 0; i < LTP_ORDER; i++ ) {
149 psPLC->LTPCoef_Q14[ i ] = silk_RSHIFT( silk_SMULBB( psPLC->LTPCoef_Q14[ i ], scale_Q14 ), 14 );
150 }
151 }
152 } else {
153 psPLC->pitchL_Q8 = silk_LSHIFT( silk_SMULBB( psDec->fs_kHz, 18 ), 8 );
154 silk_memset( psPLC->LTPCoef_Q14, 0, LTP_ORDER * sizeof( opus_int16 ));
155 }
156
157 /* Save LPC coeficients */
158 silk_memcpy( psPLC->prevLPC_Q12, psDecCtrl->PredCoef_Q12[ 1 ], psDec->LPC_order * sizeof( opus_int16 ) );
159 psPLC->prevLTP_scale_Q14 = psDecCtrl->LTP_scale_Q14;
160
161 /* Save last two gains */
162 silk_memcpy( psPLC->prevGain_Q16, &psDecCtrl->Gains_Q16[ psDec->nb_subfr - 2 ], 2 * sizeof( opus_int32 ) );
163
164 psPLC->subfr_length = psDec->subfr_length;
165 psPLC->nb_subfr = psDec->nb_subfr;
166 }
167
168 static OPUS_INLINE void silk_PLC_conceal(
169 silk_decoder_state *psDec, /* I/O Decoder state */
170 silk_decoder_control *psDecCtrl, /* I/O Decoder control */
171 opus_int16 frame[] /* O LPC residual signal */
172 )
173 {
174 opus_int i, j, k;
175 opus_int lag, idx, sLTP_buf_idx, shift1, shift2;
176 opus_int32 rand_seed, harm_Gain_Q15, rand_Gain_Q15, inv_gain_Q30;
177 opus_int32 energy1, energy2, *rand_ptr, *pred_lag_ptr;
178 opus_int32 LPC_pred_Q10, LTP_pred_Q12;
179 opus_int16 rand_scale_Q14;
180 opus_int16 *B_Q14, *exc_buf_ptr;
181 opus_int32 *sLPC_Q14_ptr;
182 VARDECL( opus_int16, exc_buf );
183 opus_int16 A_Q12[ MAX_LPC_ORDER ];
184 VARDECL( opus_int16, sLTP );
185 VARDECL( opus_int32, sLTP_Q14 );
186 silk_PLC_struct *psPLC = &psDec->sPLC;
187 opus_int32 prevGain_Q10[2];
188 SAVE_STACK;
189
190 ALLOC( exc_buf, 2*psPLC->subfr_length, opus_int16 );
191 ALLOC( sLTP, psDec->ltp_mem_length, opus_int16 );
192 ALLOC( sLTP_Q14, psDec->ltp_mem_length + psDec->frame_length, opus_int32 );
193
194 prevGain_Q10[0] = silk_RSHIFT( psPLC->prevGain_Q16[ 0 ], 6);
195 prevGain_Q10[1] = silk_RSHIFT( psPLC->prevGain_Q16[ 1 ], 6);
196
197 if( psDec->first_frame_after_reset ) {
198 silk_memset( psPLC->prevLPC_Q12, 0, sizeof( psPLC->prevLPC_Q12 ) );
199 }
200
201 /* Find random noise component */
202 /* Scale previous excitation signal */
203 exc_buf_ptr = exc_buf;
204 for( k = 0; k < 2; k++ ) {
205 for( i = 0; i < psPLC->subfr_length; i++ ) {
206 exc_buf_ptr[ i ] = (opus_int16)silk_SAT16( silk_RSHIFT(
207 silk_SMULWW( psDec->exc_Q14[ i + ( k + psPLC->nb_subfr - 2 ) * psPLC->subfr_length ], prevGain_Q10[ k ] ), 8 ) );
208 }
209 exc_buf_ptr += psPLC->subfr_length;
210 }
211 /* Find the subframe with lowest energy of the last two and use that as random noise generator */
212 silk_sum_sqr_shift( &energy1, &shift1, exc_buf, psPLC->subfr_length );
213 silk_sum_sqr_shift( &energy2, &shift2, &exc_buf[ psPLC->subfr_length ], psPLC->subfr_length );
214
215 if( silk_RSHIFT( energy1, shift2 ) < silk_RSHIFT( energy2, shift1 ) ) {
216 /* First sub-frame has lowest energy */
217 rand_ptr = &psDec->exc_Q14[ silk_max_int( 0, ( psPLC->nb_subfr - 1 ) * psPLC->subfr_length - RAND_BUF_SIZE ) ];
218 } else {
219 /* Second sub-frame has lowest energy */
220 rand_ptr = &psDec->exc_Q14[ silk_max_int( 0, psPLC->nb_subfr * psPLC->subfr_length - RAND_BUF_SIZE ) ];
221 }
222
223 /* Set up Gain to random noise component */
224 B_Q14 = psPLC->LTPCoef_Q14;
225 rand_scale_Q14 = psPLC->randScale_Q14;
226
227 /* Set up attenuation gains */
228 harm_Gain_Q15 = HARM_ATT_Q15[ silk_min_int( NB_ATT - 1, psDec->lossCnt ) ];
229 if( psDec->prevSignalType == TYPE_VOICED ) {
230 rand_Gain_Q15 = PLC_RAND_ATTENUATE_V_Q15[ silk_min_int( NB_ATT - 1, psDec->lossCnt ) ];
231 } else {
232 rand_Gain_Q15 = PLC_RAND_ATTENUATE_UV_Q15[ silk_min_int( NB_ATT - 1, psDec->lossCnt ) ];
233 }
234
235 /* LPC concealment. Apply BWE to previous LPC */
236 silk_bwexpander( psPLC->prevLPC_Q12, psDec->LPC_order, SILK_FIX_CONST( BWE_COEF, 16 ) );
237
238 /* Preload LPC coeficients to array on stack. Gives small performance gain */
239 silk_memcpy( A_Q12, psPLC->prevLPC_Q12, psDec->LPC_order * sizeof( opus_int16 ) );
240
241 /* First Lost frame */
242 if( psDec->lossCnt == 0 ) {
243 rand_scale_Q14 = 1 << 14;
244
245 /* Reduce random noise Gain for voiced frames */
246 if( psDec->prevSignalType == TYPE_VOICED ) {
247 for( i = 0; i < LTP_ORDER; i++ ) {
248 rand_scale_Q14 -= B_Q14[ i ];
249 }
250 rand_scale_Q14 = silk_max_16( 3277, rand_scale_Q14 ); /* 0.2 */
251 rand_scale_Q14 = (opus_int16)silk_RSHIFT( silk_SMULBB( rand_scale_Q14, psPLC->prevLTP_scale_Q14 ), 14 );
252 } else {
253 /* Reduce random noise for unvoiced frames with high LPC gain */
254 opus_int32 invGain_Q30, down_scale_Q30;
255
256 invGain_Q30 = silk_LPC_inverse_pred_gain( psPLC->prevLPC_Q12, psDec->LPC_order );
257
258 down_scale_Q30 = silk_min_32( silk_RSHIFT( (opus_int32)1 << 30, LOG2_INV_LPC_GAIN_HIGH_THRES ), invGain_Q30 );
259 down_scale_Q30 = silk_max_32( silk_RSHIFT( (opus_int32)1 << 30, LOG2_INV_LPC_GAIN_LOW_THRES ), down_scale_Q30 );
260 down_scale_Q30 = silk_LSHIFT( down_scale_Q30, LOG2_INV_LPC_GAIN_HIGH_THRES );
261
262 rand_Gain_Q15 = silk_RSHIFT( silk_SMULWB( down_scale_Q30, rand_Gain_Q15 ), 14 );
263 }
264 }
265
266 rand_seed = psPLC->rand_seed;
267 lag = silk_RSHIFT_ROUND( psPLC->pitchL_Q8, 8 );
268 sLTP_buf_idx = psDec->ltp_mem_length;
269
270 /* Rewhiten LTP state */
271 idx = psDec->ltp_mem_length - lag - psDec->LPC_order - LTP_ORDER / 2;
272 silk_assert( idx > 0 );
273 silk_LPC_analysis_filter( &sLTP[ idx ], &psDec->outBuf[ idx ], A_Q12, psDec->ltp_mem_length - idx, psDec->LPC_order );
274 /* Scale LTP state */
275 inv_gain_Q30 = silk_INVERSE32_varQ( psPLC->prevGain_Q16[ 1 ], 46 );
276 inv_gain_Q30 = silk_min( inv_gain_Q30, silk_int32_MAX >> 1 );
277 for( i = idx + psDec->LPC_order; i < psDec->ltp_mem_length; i++ ) {
278 sLTP_Q14[ i ] = silk_SMULWB( inv_gain_Q30, sLTP[ i ] );
279 }
280
281 /***************************/
282 /* LTP synthesis filtering */
283 /***************************/
284 for( k = 0; k < psDec->nb_subfr; k++ ) {
285 /* Set up pointer */
286 pred_lag_ptr = &sLTP_Q14[ sLTP_buf_idx - lag + LTP_ORDER / 2 ];
287 for( i = 0; i < psDec->subfr_length; i++ ) {
288 /* Unrolled loop */
289 /* Avoids introducing a bias because silk_SMLAWB() always rounds to -inf */
290 LTP_pred_Q12 = 2;
291 LTP_pred_Q12 = silk_SMLAWB( LTP_pred_Q12, pred_lag_ptr[ 0 ], B_Q14[ 0 ] );
292 LTP_pred_Q12 = silk_SMLAWB( LTP_pred_Q12, pred_lag_ptr[ -1 ], B_Q14[ 1 ] );
293 LTP_pred_Q12 = silk_SMLAWB( LTP_pred_Q12, pred_lag_ptr[ -2 ], B_Q14[ 2 ] );
294 LTP_pred_Q12 = silk_SMLAWB( LTP_pred_Q12, pred_lag_ptr[ -3 ], B_Q14[ 3 ] );
295 LTP_pred_Q12 = silk_SMLAWB( LTP_pred_Q12, pred_lag_ptr[ -4 ], B_Q14[ 4 ] );
296 pred_lag_ptr++;
297
298 /* Generate LPC excitation */
299 rand_seed = silk_RAND( rand_seed );
300 idx = silk_RSHIFT( rand_seed, 25 ) & RAND_BUF_MASK;
301 sLTP_Q14[ sLTP_buf_idx ] = silk_LSHIFT32( silk_SMLAWB( LTP_pred_Q12, rand_ptr[ idx ], rand_scale_Q14 ), 2 );
302 sLTP_buf_idx++;
303 }
304
305 /* Gradually reduce LTP gain */
306 for( j = 0; j < LTP_ORDER; j++ ) {
307 B_Q14[ j ] = silk_RSHIFT( silk_SMULBB( harm_Gain_Q15, B_Q14[ j ] ), 15 );
308 }
309 /* Gradually reduce excitation gain */
310 rand_scale_Q14 = silk_RSHIFT( silk_SMULBB( rand_scale_Q14, rand_Gain_Q15 ), 15 );
311
312 /* Slowly increase pitch lag */
313 psPLC->pitchL_Q8 = silk_SMLAWB( psPLC->pitchL_Q8, psPLC->pitchL_Q8, PITCH_DRIFT_FAC_Q16 );
314 psPLC->pitchL_Q8 = silk_min_32( psPLC->pitchL_Q8, silk_LSHIFT( silk_SMULBB( MAX_PITCH_LAG_MS, psDec->fs_kHz ), 8 ) );
315 lag = silk_RSHIFT_ROUND( psPLC->pitchL_Q8, 8 );
316 }
317
318 /***************************/
319 /* LPC synthesis filtering */
320 /***************************/
321 sLPC_Q14_ptr = &sLTP_Q14[ psDec->ltp_mem_length - MAX_LPC_ORDER ];
322
323 /* Copy LPC state */
324 silk_memcpy( sLPC_Q14_ptr, psDec->sLPC_Q14_buf, MAX_LPC_ORDER * sizeof( opus_int32 ) );
325
326 silk_assert( psDec->LPC_order >= 10 ); /* check that unrolling works */
327 for( i = 0; i < psDec->frame_length; i++ ) {
328 /* partly unrolled */
329 /* Avoids introducing a bias because silk_SMLAWB() always rounds to -inf */
330 LPC_pred_Q10 = silk_RSHIFT( psDec->LPC_order, 1 );
331 LPC_pred_Q10 = silk_SMLAWB( LPC_pred_Q10, sLPC_Q14_ptr[ MAX_LPC_ORDER + i - 1 ], A_Q12[ 0 ] );
332 LPC_pred_Q10 = silk_SMLAWB( LPC_pred_Q10, sLPC_Q14_ptr[ MAX_LPC_ORDER + i - 2 ], A_Q12[ 1 ] );
333 LPC_pred_Q10 = silk_SMLAWB( LPC_pred_Q10, sLPC_Q14_ptr[ MAX_LPC_ORDER + i - 3 ], A_Q12[ 2 ] );
334 LPC_pred_Q10 = silk_SMLAWB( LPC_pred_Q10, sLPC_Q14_ptr[ MAX_LPC_ORDER + i - 4 ], A_Q12[ 3 ] );
335 LPC_pred_Q10 = silk_SMLAWB( LPC_pred_Q10, sLPC_Q14_ptr[ MAX_LPC_ORDER + i - 5 ], A_Q12[ 4 ] );
336 LPC_pred_Q10 = silk_SMLAWB( LPC_pred_Q10, sLPC_Q14_ptr[ MAX_LPC_ORDER + i - 6 ], A_Q12[ 5 ] );
337 LPC_pred_Q10 = silk_SMLAWB( LPC_pred_Q10, sLPC_Q14_ptr[ MAX_LPC_ORDER + i - 7 ], A_Q12[ 6 ] );
338 LPC_pred_Q10 = silk_SMLAWB( LPC_pred_Q10, sLPC_Q14_ptr[ MAX_LPC_ORDER + i - 8 ], A_Q12[ 7 ] );
339 LPC_pred_Q10 = silk_SMLAWB( LPC_pred_Q10, sLPC_Q14_ptr[ MAX_LPC_ORDER + i - 9 ], A_Q12[ 8 ] );
340 LPC_pred_Q10 = silk_SMLAWB( LPC_pred_Q10, sLPC_Q14_ptr[ MAX_LPC_ORDER + i - 10 ], A_Q12[ 9 ] );
341 for( j = 10; j < psDec->LPC_order; j++ ) {
342 LPC_pred_Q10 = silk_SMLAWB( LPC_pred_Q10, sLPC_Q14_ptr[ MAX_LPC_ORDER + i - j - 1 ], A_Q12[ j ] );
343 }
344
345 /* Add prediction to LPC excitation */
346 sLPC_Q14_ptr[ MAX_LPC_ORDER + i ] = silk_ADD_LSHIFT32( sLPC_Q14_ptr[ MAX_LPC_ORDER + i ], LPC_pred_Q10, 4 );
347
348 /* Scale with Gain */
349 frame[ i ] = (opus_int16)silk_SAT16( silk_SAT16( silk_RSHIFT_ROUND( silk_SMULWW( sLPC_Q14_ptr[ MAX_LPC_ORDER + i ], prevGain_Q10[ 1 ] ), 8 ) ) );
350 }
351
352 /* Save LPC state */
353 silk_memcpy( psDec->sLPC_Q14_buf, &sLPC_Q14_ptr[ psDec->frame_length ], MAX_LPC_ORDER * sizeof( opus_int32 ) );
354
355 /**************************************/
356 /* Update states */
357 /**************************************/
358 psPLC->rand_seed = rand_seed;
359 psPLC->randScale_Q14 = rand_scale_Q14;
360 for( i = 0; i < MAX_NB_SUBFR; i++ ) {
361 psDecCtrl->pitchL[ i ] = lag;
362 }
363 RESTORE_STACK;
364 }
365
366 /* Glues concealed frames with new good received frames */
367 void silk_PLC_glue_frames(
368 silk_decoder_state *psDec, /* I/O decoder state */
369 opus_int16 frame[], /* I/O signal */
370 opus_int length /* I length of signal */
371 )
372 {
373 opus_int i, energy_shift;
374 opus_int32 energy;
375 silk_PLC_struct *psPLC;
376 psPLC = &psDec->sPLC;
377
378 if( psDec->lossCnt ) {
379 /* Calculate energy in concealed residual */
380 silk_sum_sqr_shift( &psPLC->conc_energy, &psPLC->conc_energy_shift, frame, length );
381
382 psPLC->last_frame_lost = 1;
383 } else {
384 if( psDec->sPLC.last_frame_lost ) {
385 /* Calculate residual in decoded signal if last frame was lost */
386 silk_sum_sqr_shift( &energy, &energy_shift, frame, length );
387
388 /* Normalize energies */
389 if( energy_shift > psPLC->conc_energy_shift ) {
390 psPLC->conc_energy = silk_RSHIFT( psPLC->conc_energy, energy_shift - psPLC->conc_energy_shift );
391 } else if( energy_shift < psPLC->conc_energy_shift ) {
392 energy = silk_RSHIFT( energy, psPLC->conc_energy_shift - energy_shift );
393 }
394
395 /* Fade in the energy difference */
396 if( energy > psPLC->conc_energy ) {
397 opus_int32 frac_Q24, LZ;
398 opus_int32 gain_Q16, slope_Q16;
399
400 LZ = silk_CLZ32( psPLC->conc_energy );
401 LZ = LZ - 1;
402 psPLC->conc_energy = silk_LSHIFT( psPLC->conc_energy, LZ );
403 energy = silk_RSHIFT( energy, silk_max_32( 24 - LZ, 0 ) );
404
405 frac_Q24 = silk_DIV32( psPLC->conc_energy, silk_max( energy, 1 ) );
406
407 gain_Q16 = silk_LSHIFT( silk_SQRT_APPROX( frac_Q24 ), 4 );
408 slope_Q16 = silk_DIV32_16( ( (opus_int32)1 << 16 ) - gain_Q16, length );
409 /* Make slope 4x steeper to avoid missing onsets after DTX */
410 slope_Q16 = silk_LSHIFT( slope_Q16, 2 );
411
412 for( i = 0; i < length; i++ ) {
413 frame[ i ] = silk_SMULWB( gain_Q16, frame[ i ] );
414 gain_Q16 += slope_Q16;
415 if( gain_Q16 > (opus_int32)1 << 16 ) {
416 break;
417 }
418 }
419 }
420 }
421 psPLC->last_frame_lost = 0;
422 }
423 }

Mercurial Repository: The Tor Browser

Europalab SCM Repository Server

mercurial