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