diff options
Diffstat (limited to 'lib/rbcodec/codecs/libopus/silk/dec_API.c')
-rw-r--r-- | lib/rbcodec/codecs/libopus/silk/dec_API.c | 392 |
1 files changed, 392 insertions, 0 deletions
diff --git a/lib/rbcodec/codecs/libopus/silk/dec_API.c b/lib/rbcodec/codecs/libopus/silk/dec_API.c new file mode 100644 index 0000000000..908e6033b1 --- /dev/null +++ b/lib/rbcodec/codecs/libopus/silk/dec_API.c | |||
@@ -0,0 +1,392 @@ | |||
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 "opus_config.h" | ||
30 | #endif | ||
31 | #include "API.h" | ||
32 | #include "main.h" | ||
33 | #include "stack_alloc.h" | ||
34 | |||
35 | /************************/ | ||
36 | /* Decoder Super Struct */ | ||
37 | /************************/ | ||
38 | typedef struct { | ||
39 | silk_decoder_state channel_state[ DECODER_NUM_CHANNELS ]; | ||
40 | stereo_dec_state sStereo; | ||
41 | opus_int nChannelsAPI; | ||
42 | opus_int nChannelsInternal; | ||
43 | opus_int prev_decode_only_middle; | ||
44 | } silk_decoder; | ||
45 | |||
46 | /*********************/ | ||
47 | /* Decoder functions */ | ||
48 | /*********************/ | ||
49 | |||
50 | opus_int silk_Get_Decoder_Size( /* O Returns error code */ | ||
51 | opus_int *decSizeBytes /* O Number of bytes in SILK decoder state */ | ||
52 | ) | ||
53 | { | ||
54 | opus_int ret = SILK_NO_ERROR; | ||
55 | |||
56 | *decSizeBytes = sizeof( silk_decoder ); | ||
57 | |||
58 | return ret; | ||
59 | } | ||
60 | |||
61 | /* Reset decoder state */ | ||
62 | opus_int silk_InitDecoder( /* O Returns error code */ | ||
63 | void *decState /* I/O State */ | ||
64 | ) | ||
65 | { | ||
66 | opus_int n, ret = SILK_NO_ERROR; | ||
67 | silk_decoder_state *channel_state = ((silk_decoder *)decState)->channel_state; | ||
68 | |||
69 | for( n = 0; n < DECODER_NUM_CHANNELS; n++ ) { | ||
70 | ret = silk_init_decoder( &channel_state[ n ] ); | ||
71 | } | ||
72 | |||
73 | return ret; | ||
74 | } | ||
75 | |||
76 | /* Decode a frame */ | ||
77 | opus_int silk_Decode( /* O Returns error code */ | ||
78 | void* decState, /* I/O State */ | ||
79 | silk_DecControlStruct* decControl, /* I/O Control Structure */ | ||
80 | opus_int lostFlag, /* I 0: no loss, 1 loss, 2 decode fec */ | ||
81 | opus_int newPacketFlag, /* I Indicates first decoder call for this packet */ | ||
82 | ec_dec *psRangeDec, /* I/O Compressor data structure */ | ||
83 | opus_int16 *samplesOut, /* O Decoded output speech vector */ | ||
84 | opus_int32 *nSamplesOut /* O Number of samples decoded */ | ||
85 | ) | ||
86 | { | ||
87 | opus_int i, n, decode_only_middle = 0, ret = SILK_NO_ERROR; | ||
88 | opus_int32 nSamplesOutDec, LBRR_symbol; | ||
89 | opus_int16 *samplesOut1_tmp[ 2 ]; | ||
90 | VARDECL( opus_int16, samplesOut1_tmp_storage ); | ||
91 | VARDECL( opus_int16, samplesOut2_tmp ); | ||
92 | opus_int32 MS_pred_Q13[ 2 ] = { 0 }; | ||
93 | opus_int16 *resample_out_ptr; | ||
94 | silk_decoder *psDec = ( silk_decoder * )decState; | ||
95 | silk_decoder_state *channel_state = psDec->channel_state; | ||
96 | opus_int has_side; | ||
97 | opus_int stereo_to_mono; | ||
98 | SAVE_STACK; | ||
99 | |||
100 | /**********************************/ | ||
101 | /* Test if first frame in payload */ | ||
102 | /**********************************/ | ||
103 | if( newPacketFlag ) { | ||
104 | for( n = 0; n < decControl->nChannelsInternal; n++ ) { | ||
105 | channel_state[ n ].nFramesDecoded = 0; /* Used to count frames in packet */ | ||
106 | } | ||
107 | } | ||
108 | |||
109 | /* If Mono -> Stereo transition in bitstream: init state of second channel */ | ||
110 | if( decControl->nChannelsInternal > psDec->nChannelsInternal ) { | ||
111 | ret += silk_init_decoder( &channel_state[ 1 ] ); | ||
112 | } | ||
113 | |||
114 | stereo_to_mono = decControl->nChannelsInternal == 1 && psDec->nChannelsInternal == 2 && | ||
115 | ( decControl->internalSampleRate == 1000*channel_state[ 0 ].fs_kHz ); | ||
116 | |||
117 | if( channel_state[ 0 ].nFramesDecoded == 0 ) { | ||
118 | for( n = 0; n < decControl->nChannelsInternal; n++ ) { | ||
119 | opus_int fs_kHz_dec; | ||
120 | if( decControl->payloadSize_ms == 0 ) { | ||
121 | /* Assuming packet loss, use 10 ms */ | ||
122 | channel_state[ n ].nFramesPerPacket = 1; | ||
123 | channel_state[ n ].nb_subfr = 2; | ||
124 | } else if( decControl->payloadSize_ms == 10 ) { | ||
125 | channel_state[ n ].nFramesPerPacket = 1; | ||
126 | channel_state[ n ].nb_subfr = 2; | ||
127 | } else if( decControl->payloadSize_ms == 20 ) { | ||
128 | channel_state[ n ].nFramesPerPacket = 1; | ||
129 | channel_state[ n ].nb_subfr = 4; | ||
130 | } else if( decControl->payloadSize_ms == 40 ) { | ||
131 | channel_state[ n ].nFramesPerPacket = 2; | ||
132 | channel_state[ n ].nb_subfr = 4; | ||
133 | } else if( decControl->payloadSize_ms == 60 ) { | ||
134 | channel_state[ n ].nFramesPerPacket = 3; | ||
135 | channel_state[ n ].nb_subfr = 4; | ||
136 | } else { | ||
137 | silk_assert( 0 ); | ||
138 | RESTORE_STACK; | ||
139 | return SILK_DEC_INVALID_FRAME_SIZE; | ||
140 | } | ||
141 | fs_kHz_dec = ( decControl->internalSampleRate >> 10 ) + 1; | ||
142 | if( fs_kHz_dec != 8 && fs_kHz_dec != 12 && fs_kHz_dec != 16 ) { | ||
143 | silk_assert( 0 ); | ||
144 | RESTORE_STACK; | ||
145 | return SILK_DEC_INVALID_SAMPLING_FREQUENCY; | ||
146 | } | ||
147 | ret += silk_decoder_set_fs( &channel_state[ n ], fs_kHz_dec, decControl->API_sampleRate ); | ||
148 | } | ||
149 | } | ||
150 | |||
151 | if( decControl->nChannelsAPI == 2 && decControl->nChannelsInternal == 2 && ( psDec->nChannelsAPI == 1 || psDec->nChannelsInternal == 1 ) ) { | ||
152 | silk_memset( psDec->sStereo.pred_prev_Q13, 0, sizeof( psDec->sStereo.pred_prev_Q13 ) ); | ||
153 | silk_memset( psDec->sStereo.sSide, 0, sizeof( psDec->sStereo.sSide ) ); | ||
154 | silk_memcpy( &channel_state[ 1 ].resampler_state, &channel_state[ 0 ].resampler_state, sizeof( silk_resampler_state_struct ) ); | ||
155 | } | ||
156 | psDec->nChannelsAPI = decControl->nChannelsAPI; | ||
157 | psDec->nChannelsInternal = decControl->nChannelsInternal; | ||
158 | |||
159 | if( decControl->API_sampleRate > (opus_int32)MAX_API_FS_KHZ * 1000 || decControl->API_sampleRate < 8000 ) { | ||
160 | ret = SILK_DEC_INVALID_SAMPLING_FREQUENCY; | ||
161 | RESTORE_STACK; | ||
162 | return( ret ); | ||
163 | } | ||
164 | |||
165 | if( lostFlag != FLAG_PACKET_LOST && channel_state[ 0 ].nFramesDecoded == 0 ) { | ||
166 | /* First decoder call for this payload */ | ||
167 | /* Decode VAD flags and LBRR flag */ | ||
168 | for( n = 0; n < decControl->nChannelsInternal; n++ ) { | ||
169 | for( i = 0; i < channel_state[ n ].nFramesPerPacket; i++ ) { | ||
170 | channel_state[ n ].VAD_flags[ i ] = ec_dec_bit_logp(psRangeDec, 1); | ||
171 | } | ||
172 | channel_state[ n ].LBRR_flag = ec_dec_bit_logp(psRangeDec, 1); | ||
173 | } | ||
174 | /* Decode LBRR flags */ | ||
175 | for( n = 0; n < decControl->nChannelsInternal; n++ ) { | ||
176 | silk_memset( channel_state[ n ].LBRR_flags, 0, sizeof( channel_state[ n ].LBRR_flags ) ); | ||
177 | if( channel_state[ n ].LBRR_flag ) { | ||
178 | if( channel_state[ n ].nFramesPerPacket == 1 ) { | ||
179 | channel_state[ n ].LBRR_flags[ 0 ] = 1; | ||
180 | } else { | ||
181 | LBRR_symbol = ec_dec_icdf( psRangeDec, silk_LBRR_flags_iCDF_ptr[ channel_state[ n ].nFramesPerPacket - 2 ], 8 ) + 1; | ||
182 | for( i = 0; i < channel_state[ n ].nFramesPerPacket; i++ ) { | ||
183 | channel_state[ n ].LBRR_flags[ i ] = silk_RSHIFT( LBRR_symbol, i ) & 1; | ||
184 | } | ||
185 | } | ||
186 | } | ||
187 | } | ||
188 | |||
189 | if( lostFlag == FLAG_DECODE_NORMAL ) { | ||
190 | /* Regular decoding: skip all LBRR data */ | ||
191 | for( i = 0; i < channel_state[ 0 ].nFramesPerPacket; i++ ) { | ||
192 | for( n = 0; n < decControl->nChannelsInternal; n++ ) { | ||
193 | if( channel_state[ n ].LBRR_flags[ i ] ) { | ||
194 | opus_int pulses[ MAX_FRAME_LENGTH ]; | ||
195 | opus_int condCoding; | ||
196 | |||
197 | if( decControl->nChannelsInternal == 2 && n == 0 ) { | ||
198 | silk_stereo_decode_pred( psRangeDec, MS_pred_Q13 ); | ||
199 | if( channel_state[ 1 ].LBRR_flags[ i ] == 0 ) { | ||
200 | silk_stereo_decode_mid_only( psRangeDec, &decode_only_middle ); | ||
201 | } | ||
202 | } | ||
203 | /* Use conditional coding if previous frame available */ | ||
204 | if( i > 0 && channel_state[ n ].LBRR_flags[ i - 1 ] ) { | ||
205 | condCoding = CODE_CONDITIONALLY; | ||
206 | } else { | ||
207 | condCoding = CODE_INDEPENDENTLY; | ||
208 | } | ||
209 | silk_decode_indices( &channel_state[ n ], psRangeDec, i, 1, condCoding ); | ||
210 | silk_decode_pulses( psRangeDec, pulses, channel_state[ n ].indices.signalType, | ||
211 | channel_state[ n ].indices.quantOffsetType, channel_state[ n ].frame_length ); | ||
212 | } | ||
213 | } | ||
214 | } | ||
215 | } | ||
216 | } | ||
217 | |||
218 | /* Get MS predictor index */ | ||
219 | if( decControl->nChannelsInternal == 2 ) { | ||
220 | if( lostFlag == FLAG_DECODE_NORMAL || | ||
221 | ( lostFlag == FLAG_DECODE_LBRR && channel_state[ 0 ].LBRR_flags[ channel_state[ 0 ].nFramesDecoded ] == 1 ) ) | ||
222 | { | ||
223 | silk_stereo_decode_pred( psRangeDec, MS_pred_Q13 ); | ||
224 | /* For LBRR data, decode mid-only flag only if side-channel's LBRR flag is false */ | ||
225 | if( ( lostFlag == FLAG_DECODE_NORMAL && channel_state[ 1 ].VAD_flags[ channel_state[ 0 ].nFramesDecoded ] == 0 ) || | ||
226 | ( lostFlag == FLAG_DECODE_LBRR && channel_state[ 1 ].LBRR_flags[ channel_state[ 0 ].nFramesDecoded ] == 0 ) ) | ||
227 | { | ||
228 | silk_stereo_decode_mid_only( psRangeDec, &decode_only_middle ); | ||
229 | } else { | ||
230 | decode_only_middle = 0; | ||
231 | } | ||
232 | } else { | ||
233 | for( n = 0; n < 2; n++ ) { | ||
234 | MS_pred_Q13[ n ] = psDec->sStereo.pred_prev_Q13[ n ]; | ||
235 | } | ||
236 | } | ||
237 | } | ||
238 | |||
239 | /* Reset side channel decoder prediction memory for first frame with side coding */ | ||
240 | if( decControl->nChannelsInternal == 2 && decode_only_middle == 0 && psDec->prev_decode_only_middle == 1 ) { | ||
241 | silk_memset( psDec->channel_state[ 1 ].outBuf, 0, sizeof(psDec->channel_state[ 1 ].outBuf) ); | ||
242 | silk_memset( psDec->channel_state[ 1 ].sLPC_Q14_buf, 0, sizeof(psDec->channel_state[ 1 ].sLPC_Q14_buf) ); | ||
243 | psDec->channel_state[ 1 ].lagPrev = 100; | ||
244 | psDec->channel_state[ 1 ].LastGainIndex = 10; | ||
245 | psDec->channel_state[ 1 ].prevSignalType = TYPE_NO_VOICE_ACTIVITY; | ||
246 | psDec->channel_state[ 1 ].first_frame_after_reset = 1; | ||
247 | } | ||
248 | |||
249 | ALLOC( samplesOut1_tmp_storage, | ||
250 | decControl->nChannelsInternal*( | ||
251 | channel_state[ 0 ].frame_length + 2 ), | ||
252 | opus_int16 ); | ||
253 | samplesOut1_tmp[ 0 ] = samplesOut1_tmp_storage; | ||
254 | samplesOut1_tmp[ 1 ] = samplesOut1_tmp_storage | ||
255 | + channel_state[ 0 ].frame_length + 2; | ||
256 | |||
257 | if( lostFlag == FLAG_DECODE_NORMAL ) { | ||
258 | has_side = !decode_only_middle; | ||
259 | } else { | ||
260 | has_side = !psDec->prev_decode_only_middle | ||
261 | || (decControl->nChannelsInternal == 2 && lostFlag == FLAG_DECODE_LBRR && channel_state[1].LBRR_flags[ channel_state[1].nFramesDecoded ] == 1 ); | ||
262 | } | ||
263 | /* Call decoder for one frame */ | ||
264 | for( n = 0; n < decControl->nChannelsInternal; n++ ) { | ||
265 | if( n == 0 || has_side ) { | ||
266 | opus_int FrameIndex; | ||
267 | opus_int condCoding; | ||
268 | |||
269 | FrameIndex = channel_state[ 0 ].nFramesDecoded - n; | ||
270 | /* Use independent coding if no previous frame available */ | ||
271 | if( FrameIndex <= 0 ) { | ||
272 | condCoding = CODE_INDEPENDENTLY; | ||
273 | } else if( lostFlag == FLAG_DECODE_LBRR ) { | ||
274 | condCoding = channel_state[ n ].LBRR_flags[ FrameIndex - 1 ] ? CODE_CONDITIONALLY : CODE_INDEPENDENTLY; | ||
275 | } else if( n > 0 && psDec->prev_decode_only_middle ) { | ||
276 | /* If we skipped a side frame in this packet, we don't | ||
277 | need LTP scaling; the LTP state is well-defined. */ | ||
278 | condCoding = CODE_INDEPENDENTLY_NO_LTP_SCALING; | ||
279 | } else { | ||
280 | condCoding = CODE_CONDITIONALLY; | ||
281 | } | ||
282 | ret += silk_decode_frame( &channel_state[ n ], psRangeDec, &samplesOut1_tmp[ n ][ 2 ], &nSamplesOutDec, lostFlag, condCoding); | ||
283 | } else { | ||
284 | silk_memset( &samplesOut1_tmp[ n ][ 2 ], 0, nSamplesOutDec * sizeof( opus_int16 ) ); | ||
285 | } | ||
286 | channel_state[ n ].nFramesDecoded++; | ||
287 | } | ||
288 | |||
289 | if( decControl->nChannelsAPI == 2 && decControl->nChannelsInternal == 2 ) { | ||
290 | /* Convert Mid/Side to Left/Right */ | ||
291 | silk_stereo_MS_to_LR( &psDec->sStereo, samplesOut1_tmp[ 0 ], samplesOut1_tmp[ 1 ], MS_pred_Q13, channel_state[ 0 ].fs_kHz, nSamplesOutDec ); | ||
292 | } else { | ||
293 | /* Buffering */ | ||
294 | silk_memcpy( samplesOut1_tmp[ 0 ], psDec->sStereo.sMid, 2 * sizeof( opus_int16 ) ); | ||
295 | silk_memcpy( psDec->sStereo.sMid, &samplesOut1_tmp[ 0 ][ nSamplesOutDec ], 2 * sizeof( opus_int16 ) ); | ||
296 | } | ||
297 | |||
298 | /* Number of output samples */ | ||
299 | *nSamplesOut = silk_DIV32( nSamplesOutDec * decControl->API_sampleRate, silk_SMULBB( channel_state[ 0 ].fs_kHz, 1000 ) ); | ||
300 | |||
301 | /* Set up pointers to temp buffers */ | ||
302 | ALLOC( samplesOut2_tmp, | ||
303 | decControl->nChannelsAPI == 2 ? *nSamplesOut : 0, opus_int16 ); | ||
304 | if( decControl->nChannelsAPI == 2 ) { | ||
305 | resample_out_ptr = samplesOut2_tmp; | ||
306 | } else { | ||
307 | resample_out_ptr = samplesOut; | ||
308 | } | ||
309 | |||
310 | for( n = 0; n < silk_min( decControl->nChannelsAPI, decControl->nChannelsInternal ); n++ ) { | ||
311 | |||
312 | /* Resample decoded signal to API_sampleRate */ | ||
313 | ret += silk_resampler( &channel_state[ n ].resampler_state, resample_out_ptr, &samplesOut1_tmp[ n ][ 1 ], nSamplesOutDec ); | ||
314 | |||
315 | /* Interleave if stereo output and stereo stream */ | ||
316 | if( decControl->nChannelsAPI == 2 ) { | ||
317 | for( i = 0; i < *nSamplesOut; i++ ) { | ||
318 | samplesOut[ n + 2 * i ] = resample_out_ptr[ i ]; | ||
319 | } | ||
320 | } | ||
321 | } | ||
322 | |||
323 | /* Create two channel output from mono stream */ | ||
324 | if( decControl->nChannelsAPI == 2 && decControl->nChannelsInternal == 1 ) { | ||
325 | if ( stereo_to_mono ){ | ||
326 | /* Resample right channel for newly collapsed stereo just in case | ||
327 | we weren't doing collapsing when switching to mono */ | ||
328 | ret += silk_resampler( &channel_state[ 1 ].resampler_state, resample_out_ptr, &samplesOut1_tmp[ 0 ][ 1 ], nSamplesOutDec ); | ||
329 | |||
330 | for( i = 0; i < *nSamplesOut; i++ ) { | ||
331 | samplesOut[ 1 + 2 * i ] = resample_out_ptr[ i ]; | ||
332 | } | ||
333 | } else { | ||
334 | for( i = 0; i < *nSamplesOut; i++ ) { | ||
335 | samplesOut[ 1 + 2 * i ] = samplesOut[ 0 + 2 * i ]; | ||
336 | } | ||
337 | } | ||
338 | } | ||
339 | |||
340 | /* Export pitch lag, measured at 48 kHz sampling rate */ | ||
341 | if( channel_state[ 0 ].prevSignalType == TYPE_VOICED ) { | ||
342 | int mult_tab[ 3 ] = { 6, 4, 3 }; | ||
343 | decControl->prevPitchLag = channel_state[ 0 ].lagPrev * mult_tab[ ( channel_state[ 0 ].fs_kHz - 8 ) >> 2 ]; | ||
344 | } else { | ||
345 | decControl->prevPitchLag = 0; | ||
346 | } | ||
347 | |||
348 | if( lostFlag == FLAG_PACKET_LOST ) { | ||
349 | /* On packet loss, remove the gain clamping to prevent having the energy "bounce back" | ||
350 | if we lose packets when the energy is going down */ | ||
351 | for ( i = 0; i < psDec->nChannelsInternal; i++ ) | ||
352 | psDec->channel_state[ i ].LastGainIndex = 10; | ||
353 | } else { | ||
354 | psDec->prev_decode_only_middle = decode_only_middle; | ||
355 | } | ||
356 | RESTORE_STACK; | ||
357 | return ret; | ||
358 | } | ||
359 | |||
360 | #if 0 | ||
361 | /* Getting table of contents for a packet */ | ||
362 | opus_int silk_get_TOC( | ||
363 | const opus_uint8 *payload, /* I Payload data */ | ||
364 | const opus_int nBytesIn, /* I Number of input bytes */ | ||
365 | const opus_int nFramesPerPayload, /* I Number of SILK frames per payload */ | ||
366 | silk_TOC_struct *Silk_TOC /* O Type of content */ | ||
367 | ) | ||
368 | { | ||
369 | opus_int i, flags, ret = SILK_NO_ERROR; | ||
370 | |||
371 | if( nBytesIn < 1 ) { | ||
372 | return -1; | ||
373 | } | ||
374 | if( nFramesPerPayload < 0 || nFramesPerPayload > 3 ) { | ||
375 | return -1; | ||
376 | } | ||
377 | |||
378 | silk_memset( Silk_TOC, 0, sizeof( *Silk_TOC ) ); | ||
379 | |||
380 | /* For stereo, extract the flags for the mid channel */ | ||
381 | flags = silk_RSHIFT( payload[ 0 ], 7 - nFramesPerPayload ) & ( silk_LSHIFT( 1, nFramesPerPayload + 1 ) - 1 ); | ||
382 | |||
383 | Silk_TOC->inbandFECFlag = flags & 1; | ||
384 | for( i = nFramesPerPayload - 1; i >= 0 ; i-- ) { | ||
385 | flags = silk_RSHIFT( flags, 1 ); | ||
386 | Silk_TOC->VADFlags[ i ] = flags & 1; | ||
387 | Silk_TOC->VADFlag |= flags & 1; | ||
388 | } | ||
389 | |||
390 | return ret; | ||
391 | } | ||
392 | #endif | ||