Initial Skype commit taken from FreeSwitch, which got it from the IETF draft.
[opus.git] / src / SKP_Silk_dec_API.c
1 /***********************************************************************\r
2 Copyright (c) 2006-2010, 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 #include "SKP_Silk_SDK_API.h"\r
29 #include "SKP_Silk_main_FIX.h"\r
30 \r
31 /*********************/\r
32 /* Decoder functions */\r
33 /*********************/\r
34 \r
35 SKP_int SKP_Silk_SDK_Get_Decoder_Size( SKP_int32 *decSizeBytes ) \r
36 {\r
37     SKP_int ret = 0;\r
38 \r
39     *decSizeBytes = sizeof( SKP_Silk_decoder_state );\r
40 \r
41     return ret;\r
42 }\r
43 \r
44 /* Reset decoder state */\r
45 SKP_int SKP_Silk_SDK_InitDecoder(\r
46     void* decState                                      /* I/O: State                                          */\r
47 )\r
48 {\r
49     SKP_int ret = 0;\r
50     SKP_Silk_decoder_state *struc;\r
51 \r
52     struc = (SKP_Silk_decoder_state *)decState;\r
53 \r
54     ret  = SKP_Silk_init_decoder( struc );\r
55 \r
56     return ret;\r
57 }\r
58 \r
59 /* Decode a frame */\r
60 SKP_int SKP_Silk_SDK_Decode(\r
61     void*                               decState,       /* I/O: State                                           */\r
62     SKP_SILK_SDK_DecControlStruct*      decControl,     /* I/O: Control structure                               */\r
63     SKP_int                             lostFlag,       /* I:   0: no loss, 1 loss                              */\r
64     const SKP_uint8                     *inData,        /* I:   Encoded input vector                            */\r
65     const SKP_int                       nBytesIn,       /* I:   Number of input Bytes                           */\r
66     SKP_int16                           *samplesOut,    /* O:   Decoded output speech vector                    */\r
67     SKP_int16                           *nSamplesOut    /* I/O: Number of samples (vector/decoded)              */\r
68 )\r
69 {\r
70     SKP_int ret = 0, used_bytes, prev_fs_kHz;\r
71     SKP_Silk_decoder_state *psDec;\r
72 \r
73     psDec = (SKP_Silk_decoder_state *)decState;\r
74 \r
75     /**********************************/\r
76     /* Test if first frame in payload */\r
77     /**********************************/\r
78     if( psDec->moreInternalDecoderFrames == 0 ) {\r
79         /* First Frame in Payload */\r
80         psDec->nFramesDecoded = 0;  /* Used to count frames in packet */\r
81     }\r
82 \r
83     if( psDec->moreInternalDecoderFrames == 0 &&    /* First frame in packet    */\r
84         lostFlag == 0 &&                            /* Not packet loss          */\r
85         nBytesIn > MAX_ARITHM_BYTES ) {             /* Too long payload         */\r
86             /* Avoid trying to decode a too large packet */\r
87             lostFlag = 1;\r
88             ret = SKP_SILK_DEC_PAYLOAD_TOO_LARGE;\r
89     }\r
90             \r
91     /* Save previous sample frequency */\r
92     prev_fs_kHz = psDec->fs_kHz;\r
93     \r
94     /* Call decoder for one frame */\r
95     ret += SKP_Silk_decode_frame( psDec, samplesOut, nSamplesOut, inData, nBytesIn, \r
96             lostFlag, &used_bytes );\r
97     \r
98     if( used_bytes ) { /* Only Call if not a packet loss */\r
99         if( psDec->nBytesLeft > 0 && psDec->FrameTermination == SKP_SILK_MORE_FRAMES && psDec->nFramesDecoded < 5 ) {\r
100             /* We have more frames in the Payload */\r
101             psDec->moreInternalDecoderFrames = 1;\r
102         } else {\r
103             /* Last frame in Payload */\r
104             psDec->moreInternalDecoderFrames = 0;\r
105             psDec->nFramesInPacket = psDec->nFramesDecoded;\r
106         \r
107             /* Track inband FEC usage */\r
108             if( psDec->vadFlag == VOICE_ACTIVITY ) {\r
109                 if( psDec->FrameTermination == SKP_SILK_LAST_FRAME ) {\r
110                     psDec->no_FEC_counter++;\r
111                     if( psDec->no_FEC_counter > NO_LBRR_THRES ) {\r
112                         psDec->inband_FEC_offset = 0;\r
113                     }\r
114                 } else if( psDec->FrameTermination == SKP_SILK_LBRR_VER1 ) {\r
115                     psDec->inband_FEC_offset = 1; /* FEC info with 1 packet delay */\r
116                     psDec->no_FEC_counter    = 0;\r
117                 } else if( psDec->FrameTermination == SKP_SILK_LBRR_VER2 ) {\r
118                     psDec->inband_FEC_offset = 2; /* FEC info with 2 packets delay */\r
119                     psDec->no_FEC_counter    = 0;\r
120                 }\r
121             }\r
122         }\r
123     }\r
124 \r
125     if( psDec->fs_kHz * 1000 > decControl->sampleRate ) {\r
126         ret = SKP_SILK_DEC_WRONG_SAMPLING_FREQUENCY;\r
127     }\r
128 \r
129     /* Do any resampling if needed */\r
130     if( psDec->fs_kHz * 1000 != decControl->sampleRate ) { \r
131         SKP_int16 samplesOut_tmp[ 2 * MAX_FRAME_LENGTH ];\r
132         SKP_int32 scratch[        3 * MAX_FRAME_LENGTH ];\r
133 \r
134         /* Copy to a tmpbuffer as the resampling writes to samplesOut */\r
135         memcpy( samplesOut_tmp, samplesOut, *nSamplesOut * sizeof( SKP_int16 ) ); \r
136 \r
137         /* Clear resampler state when switching internal sampling frequency */\r
138         if( prev_fs_kHz != psDec->fs_kHz ) {\r
139             SKP_memset( psDec->resampleState, 0, sizeof( psDec->resampleState ) );\r
140         }\r
141 \r
142         if( psDec->fs_kHz == 16 && decControl->sampleRate == 24000 ) { \r
143             /* Resample from 16 kHz to 24 kHz */\r
144             SKP_Silk_resample_3_2( samplesOut, psDec->resampleState, samplesOut_tmp, *nSamplesOut );\r
145         } else if( psDec->fs_kHz == 12 && decControl->sampleRate == 24000 ) { \r
146             /* Resample from 12 kHz to 24 kHz */\r
147             SKP_Silk_resample_2_1_coarse( samplesOut_tmp, psDec->resampleState, samplesOut, scratch, *nSamplesOut );\r
148         } else if( psDec->fs_kHz == 8 && decControl->sampleRate == 24000 ) { \r
149             /* Resample from 8 kHz to 24 kHz */\r
150             SKP_Silk_resample_3_1( samplesOut, psDec->resampleState, samplesOut_tmp, *nSamplesOut );\r
151         } else if( psDec->fs_kHz == 12 && decControl->sampleRate == 16000 ) { \r
152             /* Resample from 12 kHz to 16 kHz */\r
153             SKP_Silk_resample_4_3( samplesOut, psDec->resampleState, samplesOut_tmp, *nSamplesOut );\r
154         } else if( psDec->fs_kHz == 8 && decControl->sampleRate == 16000 ) { \r
155             /* Resample from 8 kHz to 16 kHz */\r
156             SKP_Silk_resample_2_1_coarse( samplesOut_tmp, psDec->resampleState, samplesOut, scratch, *nSamplesOut );\r
157         } else if( psDec->fs_kHz == 8 && decControl->sampleRate == 12000 ) { \r
158             /* Resample from 8 kHz to 12 kHz */\r
159             SKP_Silk_resample_3_2( samplesOut, psDec->resampleState, samplesOut_tmp, *nSamplesOut );\r
160         }\r
161 \r
162         *nSamplesOut = SKP_DIV32( ( SKP_int32 )*nSamplesOut * decControl->sampleRate, psDec->fs_kHz * 1000 );\r
163     }\r
164 \r
165     /* Copy all parameters that are needed out of internal structure to the control stucture */\r
166     decControl->frameSize                 = ( SKP_int )psDec->frame_length;\r
167     decControl->framesPerPacket           = ( SKP_int )psDec->nFramesInPacket;\r
168     decControl->inBandFECOffset           = ( SKP_int )psDec->inband_FEC_offset;\r
169     decControl->moreInternalDecoderFrames = ( SKP_int )psDec->moreInternalDecoderFrames;\r
170 \r
171     return ret;\r
172 }\r
173 \r
174 /* Function to find LBRR information in a packet */\r
175 void SKP_Silk_SDK_search_for_LBRR(\r
176     void                                        *decState,      /* I:   Decoder state, to select bitstream version only */\r
177     const SKP_uint8                     *inData,        /* I:   Encoded input vector                            */\r
178     const SKP_int16                     nBytesIn,       /* I:   Number of input Bytes                           */\r
179     SKP_int                             lost_offset,    /* I:   Offset from lost packet                         */\r
180     SKP_uint8                           *LBRRData,      /* O:   LBRR payload                                    */\r
181     SKP_int16                           *nLBRRBytes     /* O:   Number of LBRR Bytes                            */\r
182 )\r
183 {\r
184     SKP_Silk_decoder_state   *psDec;\r
185     SKP_Silk_decoder_state   sDec; // Local decoder state to avoid interfering with running decoder */\r
186     SKP_Silk_decoder_control sDecCtrl;\r
187     SKP_int i, TempQ[ MAX_FRAME_LENGTH ];\r
188 \r
189     psDec = ( SKP_Silk_decoder_state * )decState;\r
190 \r
191     if( lost_offset < 1 || lost_offset > MAX_LBRR_DELAY ) {\r
192         /* No useful FEC in this packet */\r
193         *nLBRRBytes = 0;\r
194         return;\r
195     }\r
196 \r
197     sDec.nFramesDecoded = 0;\r
198     sDec.fs_kHz         = 0; /* Force update parameters LPC_order etc */\r
199     SKP_memset( sDec.prevNLSF_Q15, 0, MAX_LPC_ORDER * sizeof( SKP_int ) );\r
200     SKP_Silk_range_dec_init( &sDec.sRC, inData, ( SKP_int32 )nBytesIn );\r
201 \r
202     if( psDec->bitstream_v == BIT_STREAM_V4 ) { /* Silk_v4 payload */\r
203         /* Decode all parameter indices for the whole packet*/\r
204         SKP_Silk_decode_indices_v4( &sDec );\r
205 \r
206         /* Is there usable LBRR in this packet */\r
207         *nLBRRBytes = 0;\r
208         if( ( sDec.FrameTermination - 1 ) & lost_offset && sDec.FrameTermination > 0 && sDec.nBytesLeft >= 0 ) {\r
209             /* The wanted FEC is present in the packet */\r
210             for( i = 0; i < sDec.nFramesInPacket; i++ ) {\r
211                 SKP_Silk_decode_parameters_v4( &sDec, &sDecCtrl, TempQ, 0 );\r
212                 \r
213                 if( sDec.nBytesLeft <= 0 || sDec.sRC.error ) {\r
214                     /* Corrupt stream */\r
215                     LBRRData = NULL;\r
216                     *nLBRRBytes = 0;\r
217                     break;\r
218                 } else {\r
219                     sDec.nFramesDecoded++;\r
220                 }\r
221             }\r
222         \r
223             if( LBRRData != NULL ) {\r
224                 /* The wanted FEC is present in the packet */\r
225                 *nLBRRBytes = sDec.nBytesLeft;\r
226                 SKP_memcpy( LBRRData, &inData[ nBytesIn - sDec.nBytesLeft ], sDec.nBytesLeft * sizeof( SKP_uint8 ) );\r
227             }\r
228         }\r
229     } else { /* Silk_v3 payload */\r
230         while(1) {\r
231             SKP_Silk_decode_parameters( &sDec, &sDecCtrl, TempQ, 0 );\r
232 \r
233             if( sDec.sRC.error ) {\r
234                 /* Corrupt stream */\r
235                 *nLBRRBytes = 0;\r
236                 return;\r
237             };\r
238 \r
239             if( ( sDec.FrameTermination - 1 ) & lost_offset && sDec.FrameTermination > 0 && sDec.nBytesLeft >= 0 ) {\r
240                 /* The wanted FEC is present in the packet */\r
241                 *nLBRRBytes = sDec.nBytesLeft;\r
242                 SKP_memcpy( LBRRData, &inData[ nBytesIn - sDec.nBytesLeft ], sDec.nBytesLeft * sizeof( SKP_uint8 ) );\r
243                 break;\r
244             }\r
245             if( sDec.nBytesLeft > 0 && sDec.FrameTermination == SKP_SILK_MORE_FRAMES ) {\r
246                 sDec.nFramesDecoded++;\r
247             } else {\r
248                 LBRRData = NULL;\r
249                 *nLBRRBytes = 0;\r
250                 break;\r
251             }\r
252         }\r
253     }\r
254 }\r
255 \r
256 /* Getting type of content for a packet */\r
257 void SKP_Silk_SDK_get_TOC(\r
258     void                                *decState,      /* I/O: Decoder state, to select bitstream version only */\r
259     const SKP_uint8                     *inData,        /* I:   Encoded input vector                            */\r
260     const SKP_int16                     nBytesIn,       /* I:   Number of input bytes                           */\r
261     SKP_Silk_TOC_struct                 *Silk_TOC       /* O:   Type of content                                 */\r
262 )\r
263 {\r
264     SKP_Silk_decoder_state      *psDec;\r
265     SKP_Silk_decoder_state      sDec; // Local Decoder state to avoid interfering with running decoder */\r
266     SKP_Silk_decoder_control    sDecCtrl;\r
267     SKP_int i, TempQ[ MAX_FRAME_LENGTH ];\r
268 \r
269     psDec = (SKP_Silk_decoder_state *)decState;\r
270 \r
271     sDec.nFramesDecoded = 0;\r
272     sDec.fs_kHz         = 0; /* Force update parameters LPC_order etc */\r
273     SKP_Silk_range_dec_init( &sDec.sRC, inData, ( SKP_int32 )nBytesIn );\r
274 \r
275     if( psDec->bitstream_v == BIT_STREAM_V4 ) { /* Silk_v4 payload */\r
276         /* Decode all parameter indices for the whole packet*/\r
277         SKP_Silk_decode_indices_v4( &sDec );\r
278         \r
279         if( sDec.nFramesInPacket > SILK_MAX_FRAMES_PER_PACKET || sDec.sRC.error ) {\r
280             /* Corrupt packet */\r
281             SKP_memset( Silk_TOC, 0, sizeof( SKP_Silk_TOC_struct ) );\r
282             Silk_TOC->corrupt = 1;\r
283         } else {\r
284             Silk_TOC->corrupt = 0;\r
285             Silk_TOC->framesInPacket = sDec.nFramesInPacket;\r
286             Silk_TOC->fs_kHz         = sDec.fs_kHz;\r
287             if( sDec.FrameTermination == SKP_SILK_LAST_FRAME ) {\r
288                 Silk_TOC->inbandLBRR = sDec.FrameTermination;\r
289             } else {\r
290                 Silk_TOC->inbandLBRR = sDec.FrameTermination - 1;\r
291             }\r
292             /* Copy data */\r
293             for( i = 0; i < sDec.nFramesInPacket; i++ ) {\r
294                 Silk_TOC->vadFlags[ i ]     = sDec.vadFlagBuf[ i ];\r
295                 Silk_TOC->sigtypeFlags[ i ] = sDec.sigtype[ i ];\r
296             }\r
297         }\r
298     } else { /* Silk_v3 payload */\r
299         Silk_TOC->corrupt = 0;\r
300         while( 1 ) {\r
301             SKP_Silk_decode_parameters( &sDec, &sDecCtrl, TempQ, 0 );\r
302             \r
303             Silk_TOC->vadFlags[     sDec.nFramesDecoded ] = sDec.vadFlag;\r
304             Silk_TOC->sigtypeFlags[ sDec.nFramesDecoded ] = sDecCtrl.sigtype;\r
305 \r
306             if( sDec.sRC.error ) {\r
307                 /* Corrupt stream */\r
308                 Silk_TOC->corrupt = 1;\r
309                 break;\r
310             };\r
311 \r
312             if( sDec.nBytesLeft > 0 && sDec.FrameTermination == SKP_SILK_MORE_FRAMES ) {\r
313                 sDec.nFramesDecoded++;\r
314             } else {\r
315                 break;\r
316             }\r
317         }\r
318         if( Silk_TOC->corrupt || sDec.FrameTermination == SKP_SILK_MORE_FRAMES || \r
319             sDec.nFramesInPacket > SILK_MAX_FRAMES_PER_PACKET ) {\r
320             /* Corrupt packet */\r
321             SKP_memset( Silk_TOC, 0, sizeof( SKP_Silk_TOC_struct ) );\r
322             Silk_TOC->corrupt = 1;\r
323         } else {\r
324             Silk_TOC->framesInPacket = sDec.nFramesDecoded;\r
325             Silk_TOC->fs_kHz         = sDec.fs_kHz;\r
326             if( sDec.FrameTermination == SKP_SILK_LAST_FRAME ) {\r
327                 Silk_TOC->inbandLBRR = sDec.FrameTermination;\r
328             } else {\r
329                 Silk_TOC->inbandLBRR = sDec.FrameTermination - 1;\r
330             }\r
331         }\r
332     }\r
333 }\r
334 \r
335 /**************************/\r
336 /* Get the version number */\r
337 /**************************/\r
338 /* Return a pointer to string specifying the version */ \r
339 const char *SKP_Silk_SDK_get_version()\r
340 {\r
341     static const char version[] = "1.0.2";\r
342     return version;\r
343 }\r