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