Update SILK code using the CELT range coder
[opus.git] / src_common / SKP_Silk_dec_SDK_API.c
1 #include "SKP_Silk_SDK_API.h"\r
2 #include "SKP_Silk_main.h"\r
3 \r
4 /*********************/\r
5 /* Decoder functions */\r
6 /*********************/\r
7 \r
8 SKP_int SKP_Silk_SDK_Get_Decoder_Size( SKP_int32 *decSizeBytes ) \r
9 {\r
10     SKP_int ret = SKP_SILK_NO_ERROR;\r
11 \r
12     *decSizeBytes = sizeof( SKP_Silk_decoder_state );\r
13 \r
14     return ret;\r
15 }\r
16 \r
17 /* Reset decoder state */\r
18 SKP_int SKP_Silk_SDK_InitDecoder(\r
19     void* decState                                      /* I/O: State                                          */\r
20 )\r
21 {\r
22     SKP_int ret = SKP_SILK_NO_ERROR;\r
23     SKP_Silk_decoder_state *struc;\r
24 \r
25     struc = (SKP_Silk_decoder_state *)decState;\r
26 \r
27     ret  = SKP_Silk_init_decoder( struc );\r
28 \r
29     return ret;\r
30 }\r
31 \r
32 /* Decode a frame */\r
33 SKP_int SKP_Silk_SDK_Decode(\r
34     void*                               decState,       /* I/O: State                                           */\r
35     SKP_SILK_SDK_DecControlStruct*      decControl,     /* I/O: Control structure                               */\r
36     SKP_int                             lostFlag,       /* I:   0: no loss, 1 loss                              */\r
37     const SKP_uint8                     *inData,        /* I:   Encoded input vector                            */\r
38     const SKP_int                       nBytesIn,       /* I:   Number of input Bytes                           */\r
39     SKP_int16                           *samplesOut,    /* O:   Decoded output speech vector                    */\r
40     SKP_int16                           *nSamplesOut    /* I/O: Number of samples (vector/decoded)              */\r
41 )\r
42 {\r
43     SKP_int ret = SKP_SILK_NO_ERROR, used_bytes, prev_fs_kHz;\r
44     SKP_Silk_decoder_state *psDec;\r
45 \r
46     psDec = (SKP_Silk_decoder_state *)decState;\r
47 \r
48     /**********************************/\r
49     /* Test if first frame in payload */\r
50     /**********************************/\r
51     if( psDec->moreInternalDecoderFrames == 0 ) {\r
52         /* First Frame in Payload */\r
53         psDec->nFramesDecoded = 0;  /* Used to count frames in packet */\r
54     }\r
55 \r
56     if( psDec->moreInternalDecoderFrames == 0 &&    /* First frame in packet    */\r
57         lostFlag == 0 &&                            /* Not packet loss          */\r
58         nBytesIn > MAX_ARITHM_BYTES ) {             /* Too long payload         */\r
59             /* Avoid trying to decode a too large packet */\r
60             lostFlag = 1;\r
61             ret = SKP_SILK_DEC_PAYLOAD_TOO_LARGE;\r
62     }\r
63             \r
64     /* Save previous sample frequency */\r
65     prev_fs_kHz = psDec->fs_kHz;\r
66     \r
67     /* Call decoder for one frame */\r
68     ret += SKP_Silk_decode_frame( psDec, samplesOut, nSamplesOut, inData, nBytesIn, \r
69             lostFlag, &used_bytes );\r
70     \r
71     if( used_bytes ) { /* Only Call if not a packet loss */\r
72         if( psDec->nBytesLeft > 0 && psDec->FrameTermination == SKP_SILK_MORE_FRAMES && psDec->nFramesDecoded < 5 ) {\r
73             /* We have more frames in the Payload */\r
74             psDec->moreInternalDecoderFrames = 1;\r
75         } else {\r
76             /* Last frame in Payload */\r
77             psDec->moreInternalDecoderFrames = 0;\r
78             psDec->nFramesInPacket = psDec->nFramesDecoded;\r
79         \r
80             /* Track inband FEC usage */\r
81             if( psDec->vadFlag == VOICE_ACTIVITY ) {\r
82                 if( psDec->FrameTermination == SKP_SILK_LAST_FRAME ) {\r
83                     psDec->no_FEC_counter++;\r
84                     if( psDec->no_FEC_counter > NO_LBRR_THRES ) {\r
85                         psDec->inband_FEC_offset = 0;\r
86                     }\r
87                 } else if( psDec->FrameTermination == SKP_SILK_LBRR_VER1 ) {\r
88                     psDec->inband_FEC_offset = 1; /* FEC info with 1 packet delay */\r
89                     psDec->no_FEC_counter    = 0;\r
90                 } else if( psDec->FrameTermination == SKP_SILK_LBRR_VER2 ) {\r
91                     psDec->inband_FEC_offset = 2; /* FEC info with 2 packets delay */\r
92                     psDec->no_FEC_counter    = 0;\r
93                 }\r
94             }\r
95         }\r
96     }\r
97 \r
98     if( MAX_API_FS_KHZ * 1000 < decControl->API_sampleRate ||\r
99         8000       > decControl->API_sampleRate ) {\r
100         ret = SKP_SILK_DEC_INVALID_SAMPLING_FREQUENCY;\r
101         return( ret );\r
102     }\r
103 \r
104     /* Resample if needed */\r
105     if( psDec->fs_kHz * 1000 != decControl->API_sampleRate ) { \r
106         SKP_int16 samplesOut_tmp[ MAX_API_FS_KHZ * MAX_FRAME_LENGTH_MS ];\r
107         SKP_assert( psDec->fs_kHz <= MAX_API_FS_KHZ );\r
108 \r
109         /* Copy to a tmp buffer as the resampling writes to samplesOut */\r
110         SKP_memcpy( samplesOut_tmp, samplesOut, *nSamplesOut * sizeof( SKP_int16 ) );\r
111 \r
112         /* (Re-)initialize resampler state when switching internal sampling frequency */\r
113         if( prev_fs_kHz != psDec->fs_kHz || psDec->prev_API_sampleRate != decControl->API_sampleRate ) {\r
114             ret = SKP_Silk_resampler_init( &psDec->resampler_state, SKP_SMULBB( psDec->fs_kHz, 1000 ), decControl->API_sampleRate );\r
115         }\r
116 \r
117         /* Resample the output to API_sampleRate */\r
118         ret += SKP_Silk_resampler( &psDec->resampler_state, samplesOut, samplesOut_tmp, *nSamplesOut );\r
119 \r
120         /* Update the number of output samples */\r
121         *nSamplesOut = SKP_DIV32( ( SKP_int32 )*nSamplesOut * decControl->API_sampleRate, psDec->fs_kHz * 1000 );\r
122     }\r
123 \r
124     psDec->prev_API_sampleRate = decControl->API_sampleRate;\r
125 \r
126     /* Copy all parameters that are needed out of internal structure to the control stucture */\r
127     decControl->frameSize                 = ( SKP_int )psDec->frame_length;\r
128     decControl->framesPerPacket           = ( SKP_int )psDec->nFramesInPacket;\r
129     decControl->inBandFECOffset           = ( SKP_int )psDec->inband_FEC_offset;\r
130     decControl->moreInternalDecoderFrames = ( SKP_int )psDec->moreInternalDecoderFrames;\r
131 \r
132     return ret;\r
133 }\r
134 \r
135 /* Function to find LBRR information in a packet */\r
136 void SKP_Silk_SDK_search_for_LBRR(\r
137     const SKP_uint8                     *inData,        /* I:   Encoded input vector                            */\r
138     const SKP_int16                     nBytesIn,       /* I:   Number of input Bytes                           */\r
139     SKP_int                             lost_offset,    /* I:   Offset from lost packet                         */\r
140     SKP_uint8                           *LBRRData,      /* O:   LBRR payload                                    */\r
141     SKP_int16                           *nLBRRBytes     /* O:   Number of LBRR Bytes                            */\r
142 )\r
143 {\r
144     SKP_int ret = SKP_SILK_NO_ERROR;\r
145     SKP_Silk_decoder_state   sDec; // Local decoder state to avoid interfering with running decoder */\r
146     SKP_Silk_decoder_control sDecCtrl;\r
147     SKP_int i, TempQ[ MAX_FRAME_LENGTH ];\r
148 \r
149     if( lost_offset < 1 || lost_offset > MAX_LBRR_DELAY ) {\r
150         /* No useful FEC in this packet */\r
151         *nLBRRBytes = 0;\r
152         return;\r
153     }\r
154 \r
155     sDec.nFramesDecoded = 0;\r
156     sDec.fs_kHz         = 0; /* Force update parameters LPC_order etc */\r
157     SKP_memset( sDec.prevNLSF_Q15, 0, MAX_LPC_ORDER * sizeof( SKP_int ) );\r
158     SKP_Silk_range_dec_init( &sDec.sRC, inData, ( SKP_int32 )nBytesIn );\r
159 \r
160     /* Decode all parameter indices for the whole packet*/\r
161     SKP_Silk_decode_indices_v4( &sDec );\r
162 \r
163     /* Is there usable LBRR in this packet */\r
164     *nLBRRBytes = 0;\r
165     if( ( sDec.FrameTermination - 1 ) & lost_offset && sDec.FrameTermination > 0 && sDec.nBytesLeft >= 0 ) {\r
166         /* The wanted FEC is present in the packet */\r
167         for( i = 0; i < sDec.nFramesInPacket; i++ ) {\r
168             SKP_Silk_decode_parameters_v4( &sDec, &sDecCtrl, TempQ, 0 );\r
169             \r
170             if( sDec.nBytesLeft <= 0 || sDec.sRC.error ) {\r
171                 /* Corrupt stream */\r
172                 LBRRData = NULL;\r
173                 *nLBRRBytes = 0;\r
174                 break;\r
175             } else {\r
176                 sDec.nFramesDecoded++;\r
177             }\r
178         }\r
179     \r
180         if( LBRRData != NULL ) {\r
181             /* The wanted FEC is present in the packet */\r
182             *nLBRRBytes = sDec.nBytesLeft;\r
183             SKP_memcpy( LBRRData, &inData[ nBytesIn - sDec.nBytesLeft ], sDec.nBytesLeft * sizeof( SKP_uint8 ) );\r
184         }\r
185     }\r
186 }\r
187 \r
188 /* Getting type of content for a packet */\r
189 void SKP_Silk_SDK_get_TOC(\r
190     const SKP_uint8                     *inData,        /* I:   Encoded input vector                            */\r
191     const SKP_int16                     nBytesIn,       /* I:   Number of input bytes                           */\r
192     SKP_Silk_TOC_struct                 *Silk_TOC       /* O:   Type of content                                 */\r
193 )\r
194 {\r
195     SKP_Silk_decoder_state      sDec; // Local Decoder state to avoid interfering with running decoder */\r
196     SKP_int i, ret = SKP_SILK_NO_ERROR;\r
197 \r
198     sDec.nFramesDecoded = 0;\r
199     sDec.fs_kHz         = 0; /* Force update parameters LPC_order etc */\r
200     SKP_Silk_range_dec_init( &sDec.sRC, inData, ( SKP_int32 )nBytesIn );\r
201 \r
202     /* Decode all parameter indices for the whole packet*/\r
203     SKP_Silk_decode_indices_v4( &sDec );\r
204     \r
205     if( sDec.nFramesInPacket > SILK_MAX_FRAMES_PER_PACKET || sDec.sRC.error ) {\r
206         /* Corrupt packet */\r
207         SKP_memset( Silk_TOC, 0, sizeof( SKP_Silk_TOC_struct ) );\r
208         Silk_TOC->corrupt = 1;\r
209     } else {\r
210         Silk_TOC->corrupt = 0;\r
211         Silk_TOC->framesInPacket = sDec.nFramesInPacket;\r
212         Silk_TOC->fs_kHz         = sDec.fs_kHz;\r
213         if( sDec.FrameTermination == SKP_SILK_LAST_FRAME ) {\r
214             Silk_TOC->inbandLBRR = sDec.FrameTermination;\r
215         } else {\r
216             Silk_TOC->inbandLBRR = sDec.FrameTermination - 1;\r
217         }\r
218         /* Copy data */\r
219         for( i = 0; i < sDec.nFramesInPacket; i++ ) {\r
220             Silk_TOC->vadFlags[ i ]     = sDec.vadFlagBuf[ i ];\r
221             Silk_TOC->sigtypeFlags[ i ] = sDec.sigtype[ i ];\r
222         }\r
223     }\r
224 }\r
225 \r
226 /**************************/\r
227 /* Get the version number */\r
228 /**************************/\r
229 /* Return a pointer to string specifying the version */ \r
230 const char *SKP_Silk_SDK_get_version()\r
231 {\r
232     static const char version[] = "1.0.4";\r
233     return version;\r
234 }