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