Fixing silk fixed point
[opus.git] / silk / silk_dec_API.c
1 /***********************************************************************\r
2 Copyright (c) 2006-2011, Skype Limited. All rights reserved. \r
3 Redistribution and use in source and binary forms, with or without \r
4 modification, (subject to the limitations in the disclaimer below) \r
5 are permitted provided that the following conditions are met:\r
6 - Redistributions of source code must retain the above copyright notice,\r
7 this list of conditions and the following disclaimer.\r
8 - Redistributions in binary form must reproduce the above copyright \r
9 notice, this list of conditions and the following disclaimer in the \r
10 documentation and/or other materials provided with the distribution.\r
11 - Neither the name of Skype Limited, nor the names of specific \r
12 contributors, may be used to endorse or promote products derived from \r
13 this software without specific prior written permission.\r
14 NO EXPRESS OR IMPLIED LICENSES TO ANY PARTY'S PATENT RIGHTS ARE GRANTED \r
15 BY THIS LICENSE. THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND \r
16 CONTRIBUTORS ''AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING,\r
17 BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND \r
18 FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE \r
19 COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, \r
20 INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT\r
21 NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF \r
22 USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON \r
23 ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT \r
24 (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE \r
25 OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\r
26 ***********************************************************************/\r
27 \r
28 #ifdef HAVE_CONFIG_H\r
29 #include "config.h"\r
30 #endif\r
31 #include "silk_API.h"\r
32 #include "silk_main.h"\r
33 \r
34 /************************/\r
35 /* Decoder Super Struct */\r
36 /************************/\r
37 typedef struct {\r
38     silk_decoder_state          channel_state[ DECODER_NUM_CHANNELS ];\r
39     stereo_dec_state                sStereo;\r
40     SKP_int                         nChannelsAPI;\r
41     SKP_int                         nChannelsInternal;\r
42 } silk_decoder;\r
43 \r
44 /*********************/\r
45 /* Decoder functions */\r
46 /*********************/\r
47 \r
48 SKP_int silk_Get_Decoder_Size( SKP_int32 *decSizeBytes ) \r
49 {\r
50     SKP_int ret = SILK_NO_ERROR;\r
51 \r
52     *decSizeBytes = sizeof( silk_decoder );\r
53 \r
54     return ret;\r
55 }\r
56 \r
57 /* Reset decoder state */\r
58 SKP_int silk_InitDecoder(\r
59     void* decState                                      /* I/O: State                                          */\r
60 )\r
61 {\r
62     SKP_int n, ret = SILK_NO_ERROR;\r
63     silk_decoder_state *channel_state = ((silk_decoder *)decState)->channel_state;\r
64 \r
65     for( n = 0; n < DECODER_NUM_CHANNELS; n++ ) {\r
66         ret  = silk_init_decoder( &channel_state[ n ] );\r
67     }\r
68 \r
69     return ret;\r
70 }\r
71 \r
72 /* Decode a frame */\r
73 SKP_int silk_Decode(\r
74     void*                               decState,       /* I/O: State                                           */\r
75     silk_DecControlStruct*      decControl,     /* I/O: Control Structure                               */\r
76     SKP_int                             lostFlag,       /* I:   0: no loss, 1 loss, 2 decode FEC                */\r
77     SKP_int                             newPacketFlag,  /* I:   Indicates first decoder call for this packet    */\r
78     ec_dec                              *psRangeDec,    /* I/O  Compressor data structure                       */\r
79     SKP_int16                           *samplesOut,    /* O:   Decoded output speech vector                    */\r
80     SKP_int32                           *nSamplesOut    /* O:   Number of samples decoded                       */\r
81 )\r
82 {\r
83     SKP_int   i, n, prev_fs_kHz, decode_only_middle = 0, ret = SILK_NO_ERROR;\r
84     SKP_int32 nSamplesOutDec, LBRR_symbol;\r
85     SKP_int16 samplesOut1_tmp[ 2 ][ MAX_FS_KHZ * MAX_FRAME_LENGTH_MS + 2 ];\r
86     SKP_int16 samplesOut2_tmp[ MAX_API_FS_KHZ * MAX_FRAME_LENGTH_MS ];\r
87     SKP_int   MS_pred_Q13[ 2 ] = { 0 };\r
88     SKP_int16 *resample_out_ptr;\r
89     silk_decoder *psDec = ( silk_decoder * )decState;\r
90     silk_decoder_state *channel_state = psDec->channel_state;\r
91 \r
92     /**********************************/\r
93     /* Test if first frame in payload */\r
94     /**********************************/\r
95     if( newPacketFlag ) {\r
96         for( n = 0; n < decControl->nChannelsInternal; n++ ) {\r
97             channel_state[ n ].nFramesDecoded = 0;  /* Used to count frames in packet */\r
98         }\r
99     }\r
100 \r
101     /* Save previous sample frequency */\r
102     prev_fs_kHz = channel_state[ 0 ].fs_kHz;\r
103 \r
104     /* If Mono -> Stereo transition in bitstream: init state of second channel */\r
105     if( decControl->nChannelsInternal > psDec->nChannelsInternal ) {\r
106         ret += silk_init_decoder( &channel_state[ 1 ] );\r
107         if( psDec->nChannelsAPI == 2 ) {\r
108             SKP_memcpy( &channel_state[ 1 ].resampler_state, &channel_state[ 0 ].resampler_state, sizeof( silk_resampler_state_struct ) );\r
109         }\r
110     }\r
111 \r
112     for( n = 0; n < decControl->nChannelsInternal; n++ ) {\r
113         if( channel_state[ n ].nFramesDecoded == 0 ) {\r
114             SKP_int fs_kHz_dec;\r
115             if( decControl->payloadSize_ms == 10 ) {\r
116                 channel_state[ n ].nFramesPerPacket = 1;\r
117                 channel_state[ n ].nb_subfr = 2;\r
118             } else if( decControl->payloadSize_ms == 20 ) {\r
119                 channel_state[ n ].nFramesPerPacket = 1;\r
120                 channel_state[ n ].nb_subfr = 4;\r
121             } else if( decControl->payloadSize_ms == 40 ) {\r
122                 channel_state[ n ].nFramesPerPacket = 2;\r
123                 channel_state[ n ].nb_subfr = 4;\r
124             } else if( decControl->payloadSize_ms == 60 ) {\r
125                 channel_state[ n ].nFramesPerPacket = 3;\r
126                 channel_state[ n ].nb_subfr = 4;\r
127             } else {\r
128                 SKP_assert( 0 );\r
129                 return SILK_DEC_INVALID_FRAME_SIZE;\r
130             } \r
131             fs_kHz_dec = ( decControl->internalSampleRate >> 10 ) + 1;\r
132             if( fs_kHz_dec != 8 && fs_kHz_dec != 12 && fs_kHz_dec != 16 ) {\r
133                 SKP_assert( 0 );\r
134                 return SILK_DEC_INVALID_SAMPLING_FREQUENCY;\r
135             }\r
136             silk_decoder_set_fs( &channel_state[ n ], fs_kHz_dec );\r
137         }\r
138     }\r
139 \r
140     /* Initialize resampler when switching internal or external sampling frequency */\r
141     if( prev_fs_kHz != channel_state[ 0 ].fs_kHz || channel_state[ 0 ].prev_API_sampleRate != decControl->API_sampleRate ) {\r
142         ret = silk_resampler_init( &channel_state[ 0 ].resampler_state, SKP_SMULBB( channel_state[ 0 ].fs_kHz, 1000 ), decControl->API_sampleRate );\r
143         if( decControl->nChannelsAPI == 2 && decControl->nChannelsInternal == 2 ) {\r
144             SKP_memcpy( &channel_state[ 1 ].resampler_state, &channel_state[ 0 ].resampler_state, sizeof( silk_resampler_state_struct ) );\r
145         }\r
146     }\r
147     channel_state[ 0 ].prev_API_sampleRate = decControl->API_sampleRate;\r
148     if( decControl->nChannelsAPI == 2 && decControl->nChannelsInternal == 2 && ( psDec->nChannelsAPI == 1 || psDec->nChannelsInternal == 1 ) ) {\r
149         SKP_memset( psDec->sStereo.pred_prev_Q13, 0, sizeof( psDec->sStereo.pred_prev_Q13 ) );\r
150         SKP_memset( psDec->sStereo.sSide, 0, sizeof( psDec->sStereo.sSide ) );\r
151     }\r
152     psDec->nChannelsAPI      = decControl->nChannelsAPI;\r
153     psDec->nChannelsInternal = decControl->nChannelsInternal;\r
154 \r
155     if( decControl->API_sampleRate > MAX_API_FS_KHZ * 1000 || decControl->API_sampleRate < 8000 ) {\r
156         ret = SILK_DEC_INVALID_SAMPLING_FREQUENCY;\r
157         return( ret );\r
158     }\r
159 \r
160     if( lostFlag != FLAG_PACKET_LOST && channel_state[ 0 ].nFramesDecoded == 0 ) {\r
161         /* First decoder call for this payload */\r
162         /* Decode VAD flags and LBRR flag */\r
163         for( n = 0; n < decControl->nChannelsInternal; n++ ) {\r
164             for( i = 0; i < channel_state[ n ].nFramesPerPacket; i++ ) {\r
165                 channel_state[ n ].VAD_flags[ i ] = ec_dec_bit_logp(psRangeDec, 1);\r
166             }\r
167             channel_state[ n ].LBRR_flag = ec_dec_bit_logp(psRangeDec, 1);\r
168         }        \r
169         /* Decode LBRR flags */\r
170         for( n = 0; n < decControl->nChannelsInternal; n++ ) {\r
171             SKP_memset( channel_state[ n ].LBRR_flags, 0, sizeof( channel_state[ n ].LBRR_flags ) );\r
172             if( channel_state[ n ].LBRR_flag ) {\r
173                 if( channel_state[ n ].nFramesPerPacket == 1 ) {\r
174                     channel_state[ n ].LBRR_flags[ 0 ] = 1;\r
175                 } else {\r
176                     LBRR_symbol = ec_dec_icdf( psRangeDec, silk_LBRR_flags_iCDF_ptr[ channel_state[ n ].nFramesPerPacket - 2 ], 8 ) + 1;\r
177                     for( i = 0; i < channel_state[ n ].nFramesPerPacket; i++ ) {\r
178                         channel_state[ n ].LBRR_flags[ i ] = SKP_RSHIFT( LBRR_symbol, i ) & 1;\r
179                     }\r
180                 }\r
181             }\r
182         }\r
183 \r
184         if( lostFlag == FLAG_DECODE_NORMAL ) {\r
185             /* Regular decoding: skip all LBRR data */\r
186             for( i = 0; i < channel_state[ 0 ].nFramesPerPacket; i++ ) {\r
187                 for( n = 0; n < decControl->nChannelsInternal; n++ ) {\r
188                     if( channel_state[ n ].LBRR_flags[ i ] ) {\r
189                         SKP_int pulses[ MAX_FRAME_LENGTH ];\r
190                         if( decControl->nChannelsInternal == 2 && n == 0 ) {\r
191                             silk_stereo_decode_pred( psRangeDec, &decode_only_middle, MS_pred_Q13 );\r
192                         }\r
193                         silk_decode_indices( &channel_state[ n ], psRangeDec, i, 1 );\r
194                         silk_decode_pulses( psRangeDec, pulses, channel_state[ n ].indices.signalType, \r
195                             channel_state[ n ].indices.quantOffsetType, channel_state[ n ].frame_length );\r
196                     }\r
197                 }\r
198             }\r
199         }\r
200     }\r
201 \r
202     /* Get MS predictor index */\r
203     if( decControl->nChannelsInternal == 2 ) {\r
204         if(   lostFlag == FLAG_DECODE_NORMAL || \r
205             ( lostFlag == FLAG_DECODE_LBRR && channel_state[ 0 ].LBRR_flags[ channel_state[ 0 ].nFramesDecoded ] == 1 ) ) \r
206         {\r
207             silk_stereo_decode_pred( psRangeDec, &decode_only_middle, MS_pred_Q13 );\r
208         } else {\r
209             SKP_memcpy( MS_pred_Q13, &psDec->sStereo.pred_prev_Q13, sizeof( MS_pred_Q13 ) );\r
210         }\r
211     }\r
212 \r
213     /* Call decoder for one frame */\r
214     for( n = 0; n < decControl->nChannelsInternal; n++ ) {\r
215         if( n == 0 || decode_only_middle == 0 ) {\r
216             ret += silk_decode_frame( &channel_state[ n ], psRangeDec, &samplesOut1_tmp[ n ][ 2 ], &nSamplesOutDec, lostFlag );\r
217         } else {\r
218             SKP_memset( &samplesOut1_tmp[ n ][ 2 ], 0, nSamplesOutDec * sizeof( SKP_int16 ) );\r
219         }\r
220     }\r
221 \r
222     if( decControl->nChannelsAPI == 2 && decControl->nChannelsInternal == 2 ) {\r
223         /* Convert Mid/Side to Left/Right */\r
224         silk_stereo_MS_to_LR( &psDec->sStereo, samplesOut1_tmp[ 0 ], samplesOut1_tmp[ 1 ], MS_pred_Q13, channel_state[ 0 ].fs_kHz, nSamplesOutDec );\r
225     } else {\r
226         /* Buffering */\r
227         SKP_memcpy( samplesOut1_tmp[ 0 ], psDec->sStereo.sMid, 2 * sizeof( SKP_int16 ) );\r
228         SKP_memcpy( psDec->sStereo.sMid, &samplesOut1_tmp[ 0 ][ nSamplesOutDec ], 2 * sizeof( SKP_int16 ) );\r
229     }\r
230 \r
231     /* Number of output samples */\r
232     *nSamplesOut = SKP_DIV32( nSamplesOutDec * decControl->API_sampleRate, SKP_SMULBB( channel_state[ 0 ].fs_kHz, 1000 ) );\r
233 \r
234     /* Set up pointers to temp buffers */\r
235     if( decControl->nChannelsAPI == 2 ) {\r
236         resample_out_ptr = samplesOut2_tmp;\r
237     } else {\r
238         resample_out_ptr = samplesOut;\r
239     }\r
240 \r
241     for( n = 0; n < SKP_min( decControl->nChannelsAPI, decControl->nChannelsInternal ); n++ ) {\r
242         /* Resample decoded signal to API_sampleRate */\r
243         ret += silk_resampler( &channel_state[ n ].resampler_state, resample_out_ptr, &samplesOut1_tmp[ n ][ 1 ], nSamplesOutDec );\r
244 \r
245         /* Interleave if stereo output and stereo stream */\r
246         if( decControl->nChannelsAPI == 2 && decControl->nChannelsInternal == 2 ) {\r
247             for( i = 0; i < *nSamplesOut; i++ ) {\r
248                 samplesOut[ n + 2 * i ] = resample_out_ptr[ i ];\r
249             }\r
250         }\r
251     }\r
252 \r
253     /* Create two channel output from mono stream */\r
254     if( decControl->nChannelsAPI == 2 && decControl->nChannelsInternal == 1 ) {\r
255         for( i = 0; i < *nSamplesOut; i++ ) {\r
256             samplesOut[ 0 + 2 * i ] = samplesOut[ 1 + 2 * i ] = resample_out_ptr[ i ];\r
257         }\r
258     }\r
259 \r
260     return ret;\r
261 }\r
262 \r
263 /* Getting table of contents for a packet */\r
264 SKP_int silk_get_TOC(\r
265     const SKP_uint8                     *payload,           /* I    Payload data                                */\r
266     const SKP_int                       nBytesIn,           /* I:   Number of input bytes                       */\r
267     const SKP_int                       nFramesPerPayload,  /* I:   Number of SILK frames per payload           */\r
268     silk_TOC_struct                 *Silk_TOC           /* O:   Type of content                             */\r
269 )\r
270 {\r
271     SKP_int i, flags, ret = SILK_NO_ERROR;\r
272 \r
273     if( nBytesIn < 1 ) {\r
274         return -1;\r
275     }\r
276     if( nFramesPerPayload < 0 || nFramesPerPayload > 3 ) {\r
277         return -1;\r
278     }\r
279 \r
280     SKP_memset( Silk_TOC, 0, sizeof( Silk_TOC ) );\r
281 \r
282     /* For stereo, extract the flags for the mid channel */\r
283     flags = SKP_RSHIFT( payload[ 0 ], 7 - nFramesPerPayload ) & ( SKP_LSHIFT( 1, nFramesPerPayload + 1 ) - 1 );\r
284 \r
285     Silk_TOC->inbandFECFlag = flags & 1;\r
286     for( i = nFramesPerPayload - 1; i >= 0 ; i-- ) {\r
287         flags = SKP_RSHIFT( flags, 1 );\r
288         Silk_TOC->VADFlags[ i ] = flags & 1;\r
289         Silk_TOC->VADFlag |= flags & 1;\r
290     }\r
291 \r
292     return ret;\r
293 }\r