dec_API.c (22827B)
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 #include "API.h" 32 #include "main.h" 33 #include "stack_alloc.h" 34 #include "os_support.h" 35 36 #ifdef ENABLE_OSCE 37 #include "osce.h" 38 #include "osce_structs.h" 39 #ifdef ENABLE_OSCE_BWE 40 #include "osce_features.h" 41 #endif 42 #endif 43 44 /************************/ 45 /* Decoder Super Struct */ 46 /************************/ 47 typedef struct { 48 silk_decoder_state channel_state[ DECODER_NUM_CHANNELS ]; 49 stereo_dec_state sStereo; 50 opus_int nChannelsAPI; 51 opus_int nChannelsInternal; 52 opus_int prev_decode_only_middle; 53 #ifdef ENABLE_OSCE 54 OSCEModel osce_model; 55 #endif 56 } silk_decoder; 57 58 /*********************/ 59 /* Decoder functions */ 60 /*********************/ 61 62 63 64 opus_int silk_LoadOSCEModels(void *decState, const unsigned char *data, int len) 65 { 66 #ifdef ENABLE_OSCE 67 opus_int ret = SILK_NO_ERROR; 68 69 ret = osce_load_models(&((silk_decoder *)decState)->osce_model, data, len); 70 ((silk_decoder *)decState)->osce_model.loaded = (ret == 0); 71 return ret; 72 #else 73 (void) decState; 74 (void) data; 75 (void) len; 76 return SILK_NO_ERROR; 77 #endif 78 } 79 80 opus_int silk_Get_Decoder_Size( /* O Returns error code */ 81 opus_int *decSizeBytes /* O Number of bytes in SILK decoder state */ 82 ) 83 { 84 opus_int ret = SILK_NO_ERROR; 85 86 *decSizeBytes = sizeof( silk_decoder ); 87 88 return ret; 89 } 90 91 /* Reset decoder state */ 92 opus_int silk_ResetDecoder( /* O Returns error code */ 93 void *decState /* I/O State */ 94 ) 95 { 96 opus_int n, ret = SILK_NO_ERROR; 97 silk_decoder_state *channel_state = ((silk_decoder *)decState)->channel_state; 98 99 for( n = 0; n < DECODER_NUM_CHANNELS; n++ ) { 100 ret = silk_reset_decoder( &channel_state[ n ] ); 101 } 102 silk_memset(&((silk_decoder *)decState)->sStereo, 0, sizeof(((silk_decoder *)decState)->sStereo)); 103 /* Not strictly needed, but it's cleaner that way */ 104 ((silk_decoder *)decState)->prev_decode_only_middle = 0; 105 106 return ret; 107 } 108 109 110 opus_int silk_InitDecoder( /* O Returns error code */ 111 void *decState /* I/O State */ 112 ) 113 { 114 opus_int n, ret = SILK_NO_ERROR; 115 silk_decoder_state *channel_state = ((silk_decoder *)decState)->channel_state; 116 #ifdef ENABLE_OSCE 117 ((silk_decoder *)decState)->osce_model.loaded = 0; 118 #endif 119 #ifndef USE_WEIGHTS_FILE 120 /* load osce models */ 121 silk_LoadOSCEModels(decState, NULL, 0); 122 #endif 123 124 for( n = 0; n < DECODER_NUM_CHANNELS; n++ ) { 125 ret = silk_init_decoder( &channel_state[ n ] ); 126 } 127 silk_memset(&((silk_decoder *)decState)->sStereo, 0, sizeof(((silk_decoder *)decState)->sStereo)); 128 /* Not strictly needed, but it's cleaner that way */ 129 ((silk_decoder *)decState)->prev_decode_only_middle = 0; 130 131 return ret; 132 } 133 134 /* Decode a frame */ 135 opus_int silk_Decode( /* O Returns error code */ 136 void* decState, /* I/O State */ 137 silk_DecControlStruct* decControl, /* I/O Control Structure */ 138 opus_int lostFlag, /* I 0: no loss, 1 loss, 2 decode fec */ 139 opus_int newPacketFlag, /* I Indicates first decoder call for this packet */ 140 ec_dec *psRangeDec, /* I/O Compressor data structure */ 141 opus_res *samplesOut, /* O Decoded output speech vector */ 142 opus_int32 *nSamplesOut, /* O Number of samples decoded */ 143 #ifdef ENABLE_DEEP_PLC 144 LPCNetPLCState *lpcnet, 145 #endif 146 int arch /* I Run-time architecture */ 147 ) 148 { 149 opus_int i, n, decode_only_middle = 0, ret = SILK_NO_ERROR; 150 opus_int32 nSamplesOutDec, LBRR_symbol; 151 opus_int16 *samplesOut1_tmp[ 2 ]; 152 VARDECL( opus_int16, samplesOut1_tmp_storage1 ); 153 VARDECL( opus_int16, samplesOut2_tmp ); 154 opus_int32 MS_pred_Q13[ 2 ] = { 0 }; 155 opus_int16 *resample_out_ptr; 156 silk_decoder *psDec = ( silk_decoder * )decState; 157 silk_decoder_state *channel_state = psDec->channel_state; 158 opus_int has_side; 159 opus_int stereo_to_mono; 160 #ifdef ENABLE_OSCE_BWE 161 VARDECL( opus_int16, resamp_buffer ); 162 #endif 163 SAVE_STACK; 164 165 celt_assert( decControl->nChannelsInternal == 1 || decControl->nChannelsInternal == 2 ); 166 167 /**********************************/ 168 /* Test if first frame in payload */ 169 /**********************************/ 170 if( newPacketFlag ) { 171 for( n = 0; n < decControl->nChannelsInternal; n++ ) { 172 channel_state[ n ].nFramesDecoded = 0; /* Used to count frames in packet */ 173 } 174 } 175 176 /* If Mono -> Stereo transition in bitstream: init state of second channel */ 177 if( decControl->nChannelsInternal > psDec->nChannelsInternal ) { 178 ret += silk_init_decoder( &channel_state[ 1 ] ); 179 } 180 181 stereo_to_mono = decControl->nChannelsInternal == 1 && psDec->nChannelsInternal == 2 && 182 ( decControl->internalSampleRate == 1000*channel_state[ 0 ].fs_kHz ); 183 184 if( channel_state[ 0 ].nFramesDecoded == 0 ) { 185 for( n = 0; n < decControl->nChannelsInternal; n++ ) { 186 opus_int fs_kHz_dec; 187 if( decControl->payloadSize_ms == 0 ) { 188 /* Assuming packet loss, use 10 ms */ 189 channel_state[ n ].nFramesPerPacket = 1; 190 channel_state[ n ].nb_subfr = 2; 191 } else if( decControl->payloadSize_ms == 10 ) { 192 channel_state[ n ].nFramesPerPacket = 1; 193 channel_state[ n ].nb_subfr = 2; 194 } else if( decControl->payloadSize_ms == 20 ) { 195 channel_state[ n ].nFramesPerPacket = 1; 196 channel_state[ n ].nb_subfr = 4; 197 } else if( decControl->payloadSize_ms == 40 ) { 198 channel_state[ n ].nFramesPerPacket = 2; 199 channel_state[ n ].nb_subfr = 4; 200 } else if( decControl->payloadSize_ms == 60 ) { 201 channel_state[ n ].nFramesPerPacket = 3; 202 channel_state[ n ].nb_subfr = 4; 203 } else { 204 celt_assert( 0 ); 205 RESTORE_STACK; 206 return SILK_DEC_INVALID_FRAME_SIZE; 207 } 208 fs_kHz_dec = ( decControl->internalSampleRate >> 10 ) + 1; 209 if( fs_kHz_dec != 8 && fs_kHz_dec != 12 && fs_kHz_dec != 16 ) { 210 celt_assert( 0 ); 211 RESTORE_STACK; 212 return SILK_DEC_INVALID_SAMPLING_FREQUENCY; 213 } 214 ret += silk_decoder_set_fs( &channel_state[ n ], fs_kHz_dec, decControl->API_sampleRate ); 215 } 216 } 217 218 if( decControl->nChannelsAPI == 2 && decControl->nChannelsInternal == 2 && ( psDec->nChannelsAPI == 1 || psDec->nChannelsInternal == 1 ) ) { 219 silk_memset( psDec->sStereo.pred_prev_Q13, 0, sizeof( psDec->sStereo.pred_prev_Q13 ) ); 220 silk_memset( psDec->sStereo.sSide, 0, sizeof( psDec->sStereo.sSide ) ); 221 silk_memcpy( &channel_state[ 1 ].resampler_state, &channel_state[ 0 ].resampler_state, sizeof( silk_resampler_state_struct ) ); 222 } 223 psDec->nChannelsAPI = decControl->nChannelsAPI; 224 psDec->nChannelsInternal = decControl->nChannelsInternal; 225 226 if( decControl->API_sampleRate > (opus_int32)MAX_API_FS_KHZ * 1000 || decControl->API_sampleRate < 8000 ) { 227 ret = SILK_DEC_INVALID_SAMPLING_FREQUENCY; 228 RESTORE_STACK; 229 return( ret ); 230 } 231 232 if( lostFlag != FLAG_PACKET_LOST && channel_state[ 0 ].nFramesDecoded == 0 ) { 233 /* First decoder call for this payload */ 234 /* Decode VAD flags and LBRR flag */ 235 for( n = 0; n < decControl->nChannelsInternal; n++ ) { 236 for( i = 0; i < channel_state[ n ].nFramesPerPacket; i++ ) { 237 channel_state[ n ].VAD_flags[ i ] = ec_dec_bit_logp(psRangeDec, 1); 238 } 239 channel_state[ n ].LBRR_flag = ec_dec_bit_logp(psRangeDec, 1); 240 } 241 /* Decode LBRR flags */ 242 for( n = 0; n < decControl->nChannelsInternal; n++ ) { 243 silk_memset( channel_state[ n ].LBRR_flags, 0, sizeof( channel_state[ n ].LBRR_flags ) ); 244 if( channel_state[ n ].LBRR_flag ) { 245 if( channel_state[ n ].nFramesPerPacket == 1 ) { 246 channel_state[ n ].LBRR_flags[ 0 ] = 1; 247 } else { 248 LBRR_symbol = ec_dec_icdf( psRangeDec, silk_LBRR_flags_iCDF_ptr[ channel_state[ n ].nFramesPerPacket - 2 ], 8 ) + 1; 249 for( i = 0; i < channel_state[ n ].nFramesPerPacket; i++ ) { 250 channel_state[ n ].LBRR_flags[ i ] = silk_RSHIFT( LBRR_symbol, i ) & 1; 251 } 252 } 253 } 254 } 255 256 if( lostFlag == FLAG_DECODE_NORMAL ) { 257 /* Regular decoding: skip all LBRR data */ 258 for( i = 0; i < channel_state[ 0 ].nFramesPerPacket; i++ ) { 259 for( n = 0; n < decControl->nChannelsInternal; n++ ) { 260 if( channel_state[ n ].LBRR_flags[ i ] ) { 261 opus_int16 pulses[ MAX_FRAME_LENGTH ]; 262 opus_int condCoding; 263 264 if( decControl->nChannelsInternal == 2 && n == 0 ) { 265 silk_stereo_decode_pred( psRangeDec, MS_pred_Q13 ); 266 if( channel_state[ 1 ].LBRR_flags[ i ] == 0 ) { 267 silk_stereo_decode_mid_only( psRangeDec, &decode_only_middle ); 268 } 269 } 270 /* Use conditional coding if previous frame available */ 271 if( i > 0 && channel_state[ n ].LBRR_flags[ i - 1 ] ) { 272 condCoding = CODE_CONDITIONALLY; 273 } else { 274 condCoding = CODE_INDEPENDENTLY; 275 } 276 silk_decode_indices( &channel_state[ n ], psRangeDec, i, 1, condCoding ); 277 silk_decode_pulses( psRangeDec, pulses, channel_state[ n ].indices.signalType, 278 channel_state[ n ].indices.quantOffsetType, channel_state[ n ].frame_length ); 279 } 280 } 281 } 282 } 283 } 284 285 /* Get MS predictor index */ 286 if( decControl->nChannelsInternal == 2 ) { 287 if( lostFlag == FLAG_DECODE_NORMAL || 288 ( lostFlag == FLAG_DECODE_LBRR && channel_state[ 0 ].LBRR_flags[ channel_state[ 0 ].nFramesDecoded ] == 1 ) ) 289 { 290 silk_stereo_decode_pred( psRangeDec, MS_pred_Q13 ); 291 /* For LBRR data, decode mid-only flag only if side-channel's LBRR flag is false */ 292 if( ( lostFlag == FLAG_DECODE_NORMAL && channel_state[ 1 ].VAD_flags[ channel_state[ 0 ].nFramesDecoded ] == 0 ) || 293 ( lostFlag == FLAG_DECODE_LBRR && channel_state[ 1 ].LBRR_flags[ channel_state[ 0 ].nFramesDecoded ] == 0 ) ) 294 { 295 silk_stereo_decode_mid_only( psRangeDec, &decode_only_middle ); 296 } else { 297 decode_only_middle = 0; 298 } 299 } else { 300 for( n = 0; n < 2; n++ ) { 301 MS_pred_Q13[ n ] = psDec->sStereo.pred_prev_Q13[ n ]; 302 } 303 } 304 } 305 306 /* Reset side channel decoder prediction memory for first frame with side coding */ 307 if( decControl->nChannelsInternal == 2 && decode_only_middle == 0 && psDec->prev_decode_only_middle == 1 ) { 308 silk_memset( psDec->channel_state[ 1 ].outBuf, 0, sizeof(psDec->channel_state[ 1 ].outBuf) ); 309 silk_memset( psDec->channel_state[ 1 ].sLPC_Q14_buf, 0, sizeof(psDec->channel_state[ 1 ].sLPC_Q14_buf) ); 310 psDec->channel_state[ 1 ].lagPrev = 100; 311 psDec->channel_state[ 1 ].LastGainIndex = 10; 312 psDec->channel_state[ 1 ].prevSignalType = TYPE_NO_VOICE_ACTIVITY; 313 psDec->channel_state[ 1 ].first_frame_after_reset = 1; 314 } 315 316 /* Check if the temp buffer fits into the output PCM buffer. If it fits, 317 we can delay allocating the temp buffer until after the SILK peak stack 318 usage. We need to use a < and not a <= because of the two extra samples. */ 319 ALLOC( samplesOut1_tmp_storage1, decControl->nChannelsInternal*(channel_state[ 0 ].frame_length + 2 ), 320 opus_int16 ); 321 samplesOut1_tmp[ 0 ] = samplesOut1_tmp_storage1; 322 samplesOut1_tmp[ 1 ] = samplesOut1_tmp_storage1 + channel_state[ 0 ].frame_length + 2; 323 324 if( lostFlag == FLAG_DECODE_NORMAL ) { 325 has_side = !decode_only_middle; 326 } else { 327 has_side = !psDec->prev_decode_only_middle 328 || (decControl->nChannelsInternal == 2 && lostFlag == FLAG_DECODE_LBRR && channel_state[1].LBRR_flags[ channel_state[1].nFramesDecoded ] == 1 ); 329 } 330 channel_state[ 0 ].sPLC.enable_deep_plc = decControl->enable_deep_plc; 331 /* Call decoder for one frame */ 332 for( n = 0; n < decControl->nChannelsInternal; n++ ) { 333 if( n == 0 || has_side ) { 334 opus_int FrameIndex; 335 opus_int condCoding; 336 337 FrameIndex = channel_state[ 0 ].nFramesDecoded - n; 338 /* Use independent coding if no previous frame available */ 339 if( FrameIndex <= 0 ) { 340 condCoding = CODE_INDEPENDENTLY; 341 } else if( lostFlag == FLAG_DECODE_LBRR ) { 342 condCoding = channel_state[ n ].LBRR_flags[ FrameIndex - 1 ] ? CODE_CONDITIONALLY : CODE_INDEPENDENTLY; 343 } else if( n > 0 && psDec->prev_decode_only_middle ) { 344 /* If we skipped a side frame in this packet, we don't 345 need LTP scaling; the LTP state is well-defined. */ 346 condCoding = CODE_INDEPENDENTLY_NO_LTP_SCALING; 347 } else { 348 condCoding = CODE_CONDITIONALLY; 349 } 350 #ifdef ENABLE_OSCE 351 if ( channel_state[n].osce.method != decControl->osce_method ) { 352 osce_reset( &channel_state[n].osce, decControl->osce_method ); 353 } 354 #endif 355 ret += silk_decode_frame( &channel_state[ n ], psRangeDec, &samplesOut1_tmp[ n ][ 2 ], &nSamplesOutDec, lostFlag, condCoding, 356 #ifdef ENABLE_DEEP_PLC 357 n == 0 ? lpcnet : NULL, 358 #endif 359 #ifdef ENABLE_OSCE 360 &psDec->osce_model, 361 #endif 362 arch); 363 } else { 364 silk_memset( &samplesOut1_tmp[ n ][ 2 ], 0, nSamplesOutDec * sizeof( opus_int16 ) ); 365 } 366 channel_state[ n ].nFramesDecoded++; 367 } 368 369 if( decControl->nChannelsAPI == 2 && decControl->nChannelsInternal == 2 ) { 370 /* Convert Mid/Side to Left/Right */ 371 silk_stereo_MS_to_LR( &psDec->sStereo, samplesOut1_tmp[ 0 ], samplesOut1_tmp[ 1 ], MS_pred_Q13, channel_state[ 0 ].fs_kHz, nSamplesOutDec ); 372 } else { 373 /* Buffering */ 374 silk_memcpy( samplesOut1_tmp[ 0 ], psDec->sStereo.sMid, 2 * sizeof( opus_int16 ) ); 375 silk_memcpy( psDec->sStereo.sMid, &samplesOut1_tmp[ 0 ][ nSamplesOutDec ], 2 * sizeof( opus_int16 ) ); 376 } 377 378 /* Number of output samples */ 379 *nSamplesOut = silk_DIV32( nSamplesOutDec * decControl->API_sampleRate, silk_SMULBB( channel_state[ 0 ].fs_kHz, 1000 ) ); 380 381 /* Set up pointers to temp buffers */ 382 ALLOC( samplesOut2_tmp, *nSamplesOut, opus_int16 ); 383 resample_out_ptr = samplesOut2_tmp; 384 385 #ifdef ENABLE_OSCE_BWE 386 ALLOC(resamp_buffer, 3 * MAX_FRAME_LENGTH, opus_int16); 387 #endif 388 389 for( n = 0; n < silk_min( decControl->nChannelsAPI, decControl->nChannelsInternal ); n++ ) { 390 391 #ifdef ENABLE_OSCE_BWE 392 /* Resample or extend decoded signal to API_sampleRate */ 393 if (decControl->osce_extended_mode == OSCE_MODE_SILK_BBWE) { 394 silk_assert(decControl->API_sampleRate == 48000); 395 396 if (decControl->prev_osce_extended_mode != OSCE_MODE_SILK_BBWE) { 397 /* Reset the BWE state */ 398 osce_bwe_reset( &channel_state[ n ].osce_bwe ); 399 } 400 401 osce_bwe(&psDec->osce_model, &channel_state[ n ].osce_bwe, 402 resample_out_ptr, &samplesOut1_tmp[ n ][ 1 ], nSamplesOutDec, arch); 403 404 if (decControl->prev_osce_extended_mode == OSCE_MODE_SILK_ONLY || 405 decControl->prev_osce_extended_mode == OSCE_MODE_HYBRID) { 406 /* cross-fade with upsampled signal */ 407 silk_resampler( &channel_state[ n ].resampler_state, resamp_buffer, &samplesOut1_tmp[ n ][ 1 ], nSamplesOutDec ); 408 osce_bwe_cross_fade_10ms(resample_out_ptr, resamp_buffer, 480); 409 } 410 } else { 411 ret += silk_resampler( &channel_state[ n ].resampler_state, resample_out_ptr, &samplesOut1_tmp[ n ][ 1 ], nSamplesOutDec ); 412 if (decControl->prev_osce_extended_mode == OSCE_MODE_SILK_BBWE && decControl->internalSampleRate == 16000) { 413 /* fade out if internal sample rate did not change */ 414 osce_bwe(&psDec->osce_model, &channel_state[ n ].osce_bwe, 415 resamp_buffer, &samplesOut1_tmp[ n ][ 1 ], nSamplesOutDec, arch); 416 /* cross-fade with upsampled signal */ 417 osce_bwe_cross_fade_10ms(resample_out_ptr, resamp_buffer, 480); 418 } 419 } 420 #else 421 /* Resample decoded signal to API_sampleRate */ 422 ret += silk_resampler( &channel_state[ n ].resampler_state, resample_out_ptr, &samplesOut1_tmp[ n ][ 1 ], nSamplesOutDec ); 423 #endif 424 /* Interleave if stereo output and stereo stream */ 425 if( decControl->nChannelsAPI == 2 ) { 426 for( i = 0; i < *nSamplesOut; i++ ) { 427 samplesOut[ n + 2 * i ] = INT16TORES(resample_out_ptr[ i ]); 428 } 429 } else { 430 for( i = 0; i < *nSamplesOut; i++ ) { 431 samplesOut[ i ] = INT16TORES(resample_out_ptr[ i ]); 432 } 433 } 434 } 435 436 #ifdef ENABLE_OSCE_BWE 437 decControl->prev_osce_extended_mode = decControl->osce_extended_mode; 438 #endif 439 440 /* Create two channel output from mono stream */ 441 if( decControl->nChannelsAPI == 2 && decControl->nChannelsInternal == 1 ) { 442 if ( stereo_to_mono ){ 443 /* Resample right channel for newly collapsed stereo just in case 444 we weren't doing collapsing when switching to mono */ 445 ret += silk_resampler( &channel_state[ 1 ].resampler_state, resample_out_ptr, &samplesOut1_tmp[ 0 ][ 1 ], nSamplesOutDec ); 446 447 for( i = 0; i < *nSamplesOut; i++ ) { 448 samplesOut[ 1 + 2 * i ] = INT16TORES(resample_out_ptr[ i ]); 449 } 450 } else { 451 for( i = 0; i < *nSamplesOut; i++ ) { 452 samplesOut[ 1 + 2 * i ] = samplesOut[ 0 + 2 * i ]; 453 } 454 } 455 } 456 457 /* Export pitch lag, measured at 48 kHz sampling rate */ 458 if( channel_state[ 0 ].prevSignalType == TYPE_VOICED ) { 459 int mult_tab[ 3 ] = { 6, 4, 3 }; 460 decControl->prevPitchLag = channel_state[ 0 ].lagPrev * mult_tab[ ( channel_state[ 0 ].fs_kHz - 8 ) >> 2 ]; 461 } else { 462 decControl->prevPitchLag = 0; 463 } 464 465 if( lostFlag == FLAG_PACKET_LOST ) { 466 /* On packet loss, remove the gain clamping to prevent having the energy "bounce back" 467 if we lose packets when the energy is going down */ 468 for ( i = 0; i < psDec->nChannelsInternal; i++ ) 469 psDec->channel_state[ i ].LastGainIndex = 10; 470 } else { 471 psDec->prev_decode_only_middle = decode_only_middle; 472 } 473 RESTORE_STACK; 474 return ret; 475 } 476 477 #if 0 478 /* Getting table of contents for a packet */ 479 opus_int silk_get_TOC( 480 const opus_uint8 *payload, /* I Payload data */ 481 const opus_int nBytesIn, /* I Number of input bytes */ 482 const opus_int nFramesPerPayload, /* I Number of SILK frames per payload */ 483 silk_TOC_struct *Silk_TOC /* O Type of content */ 484 ) 485 { 486 opus_int i, flags, ret = SILK_NO_ERROR; 487 488 if( nBytesIn < 1 ) { 489 return -1; 490 } 491 if( nFramesPerPayload < 0 || nFramesPerPayload > 3 ) { 492 return -1; 493 } 494 495 silk_memset( Silk_TOC, 0, sizeof( *Silk_TOC ) ); 496 497 /* For stereo, extract the flags for the mid channel */ 498 flags = silk_RSHIFT( payload[ 0 ], 7 - nFramesPerPayload ) & ( silk_LSHIFT( 1, nFramesPerPayload + 1 ) - 1 ); 499 500 Silk_TOC->inbandFECFlag = flags & 1; 501 for( i = nFramesPerPayload - 1; i >= 0 ; i-- ) { 502 flags = silk_RSHIFT( flags, 1 ); 503 Silk_TOC->VADFlags[ i ] = flags & 1; 504 Silk_TOC->VADFlag |= flags & 1; 505 } 506 507 return ret; 508 } 509 #endif