Making mode switching use the same window as CELT (squared)
[opus.git] / src / opus_decoder.c
1 /* Copyright (c) 2010 Xiph.Org Foundation, Skype Limited
2    Written by Jean-Marc Valin and Koen Vos */
3 /*
4    Redistribution and use in source and binary forms, with or without
5    modification, are permitted provided that the following conditions
6    are met:
7
8    - Redistributions of source code must retain the above copyright
9    notice, this list of conditions and the following disclaimer.
10
11    - Redistributions in binary form must reproduce the above copyright
12    notice, this list of conditions and the following disclaimer in the
13    documentation and/or other materials provided with the distribution.
14
15    THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
16    ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
17    LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
18    A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR
19    CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
20    EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
21    PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
22    PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
23    LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
24    NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
25    SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
26 */
27
28 #ifdef HAVE_CONFIG_H
29 #include "config.h"
30 #endif
31
32 #include <stdlib.h>
33 #include <stdio.h>
34 #include <stdarg.h>
35 #include "celt.h"
36 #include "opus_decoder.h"
37 #include "entdec.h"
38 #include "modes.h"
39 #include "SKP_Silk_SDK_API.h"
40
41
42 OpusDecoder *opus_decoder_create(int Fs, int channels)
43 {
44     char *raw_state;
45         int ret, silkDecSizeBytes, celtDecSizeBytes;
46         OpusDecoder *st;
47
48         /* Initialize SILK encoder */
49     ret = SKP_Silk_SDK_Get_Decoder_Size( &silkDecSizeBytes );
50     if( ret ) {
51         /* Handle error */
52     }
53     celtDecSizeBytes = celt_decoder_get_size(channels);
54     raw_state = calloc(sizeof(OpusDecoder)+silkDecSizeBytes+celtDecSizeBytes, 1);
55     st = (OpusDecoder*)raw_state;
56     st->silk_dec = (void*)(raw_state+sizeof(OpusDecoder));
57     st->celt_dec = (CELTDecoder*)(raw_state+sizeof(OpusDecoder)+silkDecSizeBytes);
58     st->stream_channels = st->channels = channels;
59
60     st->Fs = Fs;
61
62     /* Reset decoder */
63     ret = SKP_Silk_SDK_InitDecoder( st->silk_dec );
64     if( ret ) {
65         /* Handle error */
66     }
67
68         /* Initialize CELT decoder */
69         st->celt_dec = celt_decoder_init(st->celt_dec, Fs, channels, NULL);
70     celt_decoder_ctl(st->celt_dec, CELT_SET_SIGNALLING(0));
71
72         st->prev_mode = 0;
73         return st;
74 }
75
76 static void smooth_fade(const short *in1, const short *in2, short *out,
77         int overlap, int channels, const celt_word16 *window, int Fs)
78 {
79         int i, c;
80         int inc = 48000/Fs;
81         for (c=0;c<channels;c++)
82         {
83                 for (i=0;i<overlap;i++)
84                 {
85                     celt_word16 w = MULT16_16_Q15(window[i*inc], window[i*inc]);
86                     out[i*channels+c] = SHR32(MAC16_16(MULT16_16(w,in2[i*channels+c]),
87                             Q15ONE-w, in1[i*channels+c]), 15);
88                 }
89         }
90 }
91
92 static int opus_packet_get_mode(const unsigned char *data)
93 {
94         int mode;
95     if (data[0]&0x80)
96     {
97         mode = MODE_CELT_ONLY;
98     } else if ((data[0]&0x60) == 0x60)
99     {
100         mode = MODE_HYBRID;
101     } else {
102
103         mode = MODE_SILK_ONLY;
104     }
105     return mode;
106 }
107
108 static int opus_decode_frame(OpusDecoder *st, const unsigned char *data,
109                 int len, short *pcm, int frame_size, int decode_fec)
110 {
111         int i, silk_ret=0, celt_ret=0;
112         ec_dec dec;
113     SKP_SILK_SDK_DecControlStruct DecControl;
114     SKP_int32 silk_frame_size;
115     short pcm_celt[960*2];
116     short pcm_transition[960*2];
117     int audiosize;
118     int mode;
119     int transition=0;
120     int start_band;
121     int redundancy=0;
122     int redundancy_bytes = 0;
123     int celt_to_silk=0;
124     short redundant_audio[240*2];
125     int c;
126     int F2_5, F5, F10;
127     const celt_word16 *window;
128
129     F10 = st->Fs/100;
130     F5 = F10>>1;
131     F2_5 = F5>>1;
132     /* Payloads of 1 (2 including ToC) or 0 trigger the PLC/DTX */
133     if (len<=1)
134         data = NULL;
135
136         audiosize = st->frame_size;
137     if (data != NULL)
138     {
139         mode = st->mode;
140         ec_dec_init(&dec,(unsigned char*)data,len);
141     } else {
142         mode = st->prev_mode;
143     }
144
145     if (st->stream_channels > st->channels)
146         return OPUS_CORRUPTED_DATA;
147
148     /* FIXME: Remove this when we add SILK stereo support */
149     if (st->stream_channels == 2 && mode != MODE_CELT_ONLY)
150         return OPUS_UNIMPLEMENTED;
151
152     if (data!=NULL && !st->prev_redundancy && mode != st->prev_mode && st->prev_mode > 0
153                 && !(mode == MODE_SILK_ONLY && st->prev_mode == MODE_HYBRID)
154                 && !(mode == MODE_HYBRID && st->prev_mode == MODE_SILK_ONLY))
155     {
156         transition = 1;
157         if (mode == MODE_CELT_ONLY)
158             opus_decode_frame(st, NULL, 0, pcm_transition, IMAX(F10, audiosize), 0);
159     }
160     if (audiosize > frame_size)
161     {
162         fprintf(stderr, "PCM buffer too small: %d vs %d (mode = %d)\n", audiosize, frame_size, mode);
163         return OPUS_BAD_ARG;
164     } else {
165         frame_size = audiosize;
166     }
167
168     /* SILK processing */
169     if (mode != MODE_CELT_ONLY)
170     {
171         int lost_flag, decoded_samples;
172         SKP_int16 *pcm_ptr = pcm;
173
174         if (st->prev_mode==MODE_CELT_ONLY)
175                 SKP_Silk_SDK_InitDecoder( st->silk_dec );
176
177         DecControl.API_sampleRate = st->Fs;
178         DecControl.payloadSize_ms = 1000 * audiosize / st->Fs;
179         if( mode == MODE_SILK_ONLY ) {
180             if( st->bandwidth == BANDWIDTH_NARROWBAND ) {
181                 DecControl.internalSampleRate = 8000;
182             } else if( st->bandwidth == BANDWIDTH_MEDIUMBAND ) {
183                 DecControl.internalSampleRate = 12000;
184             } else if( st->bandwidth == BANDWIDTH_WIDEBAND ) {
185                 DecControl.internalSampleRate = 16000;
186             } else {
187                 DecControl.internalSampleRate = 16000;
188                 SKP_assert( 0 );
189             }
190         } else {
191             /* Hybrid mode */
192             DecControl.internalSampleRate = 16000;
193         }
194
195         lost_flag = data == NULL ? 1 : 2 * decode_fec;
196         decoded_samples = 0;
197         do {
198             /* Call SILK decoder */
199             int first_frame = decoded_samples == 0;
200             silk_ret = SKP_Silk_SDK_Decode( st->silk_dec, &DecControl, 
201                 lost_flag, first_frame, &dec, len, pcm_ptr, &silk_frame_size );
202             if( silk_ret ) {
203                 fprintf (stderr, "SILK decode error\n");
204                 /* Handle error */
205             }
206             pcm_ptr += silk_frame_size;
207             decoded_samples += silk_frame_size;
208         } while( decoded_samples < frame_size );
209     } else {
210         for (i=0;i<frame_size*st->channels;i++)
211             pcm[i] = 0;
212     }
213
214     start_band = 0;
215     if (mode != MODE_CELT_ONLY && data != NULL)
216     {
217         /* Check if we have a redundant 0-8 kHz band */
218         redundancy = ec_dec_bit_logp(&dec, 12);
219         if (redundancy)
220         {
221             celt_to_silk = ec_dec_bit_logp(&dec, 1);
222             if (mode == MODE_HYBRID)
223                 redundancy_bytes = 2 + ec_dec_uint(&dec, 256);
224             else
225                 redundancy_bytes = len - ((ec_tell(&dec)+7)>>3);
226             len -= redundancy_bytes;
227             if (len<0)
228                 return CELT_CORRUPTED_DATA;
229             /* Shrink decoder because of raw bits */
230             dec.storage -= redundancy_bytes;
231         }
232     }
233     if (mode != MODE_CELT_ONLY)
234         start_band = 17;
235
236     if (mode != MODE_SILK_ONLY)
237     {
238         int endband=21;
239
240         switch(st->bandwidth)
241         {
242         case BANDWIDTH_NARROWBAND:
243             endband = 13;
244             break;
245         case BANDWIDTH_WIDEBAND:
246             endband = 17;
247             break;
248         case BANDWIDTH_SUPERWIDEBAND:
249             endband = 19;
250             break;
251         case BANDWIDTH_FULLBAND:
252             endband = 21;
253             break;
254         }
255         celt_decoder_ctl(st->celt_dec, CELT_SET_END_BAND(endband));
256         celt_decoder_ctl(st->celt_dec, CELT_SET_CHANNELS(st->stream_channels));
257     }
258
259     if (redundancy)
260         transition = 0;
261
262     if (transition && mode != MODE_CELT_ONLY)
263         opus_decode_frame(st, NULL, 0, pcm_transition, IMAX(F10, audiosize), 0);
264
265     /* 5 ms redundant frame for CELT->SILK*/
266     if (redundancy && celt_to_silk)
267     {
268         celt_decode(st->celt_dec, data+len, redundancy_bytes, redundant_audio, F5);
269         celt_decoder_ctl(st->celt_dec, CELT_RESET_STATE);
270     }
271
272     /* MUST be after PLC */
273     celt_decoder_ctl(st->celt_dec, CELT_SET_START_BAND(start_band));
274
275     if (transition)
276         celt_decoder_ctl(st->celt_dec, CELT_RESET_STATE);
277
278     if (mode != MODE_SILK_ONLY)
279     {
280         /* Decode CELT */
281         celt_ret = celt_decode_with_ec(st->celt_dec, decode_fec?NULL:data, len, pcm_celt, frame_size, &dec);
282         for (i=0;i<frame_size*st->channels;i++)
283             pcm[i] = ADD_SAT16(pcm[i], pcm_celt[i]);
284     }
285
286     {
287         const CELTMode *celt_mode;
288         celt_decoder_ctl(st->celt_dec, CELT_GET_MODE(&celt_mode));
289         window = celt_mode->window;
290     }
291     /* 5 ms redundant frame for SILK->CELT */
292     if (redundancy && !celt_to_silk)
293     {
294         celt_decoder_ctl(st->celt_dec, CELT_RESET_STATE);
295         celt_decoder_ctl(st->celt_dec, CELT_SET_START_BAND(0));
296
297         celt_decode(st->celt_dec, data+len, redundancy_bytes, redundant_audio, F5);
298         smooth_fade(pcm+st->channels*(frame_size-F2_5), redundant_audio+st->channels*F2_5,
299                         pcm+st->channels*(frame_size-F2_5), F2_5, st->channels, window, st->Fs);
300     }
301     if (redundancy && celt_to_silk)
302     {
303         for (c=0;c<st->channels;c++)
304         {
305             for (i=0;i<F2_5;i++)
306                 pcm[st->channels*i+c] = redundant_audio[st->channels*i];
307         }
308         smooth_fade(redundant_audio+st->channels*F2_5, pcm+st->channels*F2_5,
309                 pcm+st->channels*F2_5, F2_5, st->channels, window, st->Fs);
310     }
311     if (transition)
312     {
313         for (i=0;i<F2_5;i++)
314                 pcm[i] = pcm_transition[i];
315         if (audiosize >= F5)
316             smooth_fade(pcm_transition+F2_5, pcm+F2_5, pcm+F2_5, F2_5,
317                     st->channels, window, st->Fs);
318     }
319 #if OPUS_TEST_RANGE_CODER_STATE
320     st->rangeFinal = dec.rng;
321 #endif
322
323     st->prev_mode = mode;
324     st->prev_redundancy = redundancy;
325         return celt_ret<0 ? celt_ret : audiosize;
326
327 }
328
329 static int parse_size(const unsigned char *data, int len, short *size)
330 {
331         if (len<1)
332         {
333                 *size = -1;
334                 return -1;
335         } else if (data[0]<252)
336         {
337                 *size = data[0];
338                 return 1;
339         } else if (len<2)
340         {
341                 *size = -1;
342                 return -1;
343         } else {
344                 *size = 4*data[1] + data[0];
345                 return 2;
346         }
347 }
348
349 int opus_decode(OpusDecoder *st, const unsigned char *data,
350                 int len, short *pcm, int frame_size, int decode_fec)
351 {
352         int i, bytes, nb_samples;
353         int count;
354         unsigned char ch, toc;
355         /* 48 x 2.5 ms = 120 ms */
356         short size[48];
357         if (len==0 || data==NULL)
358             return opus_decode_frame(st, NULL, 0, pcm, frame_size, 0);
359         else if (len<0)
360                 return CELT_BAD_ARG;
361         st->mode = opus_packet_get_mode(data);
362         st->bandwidth = opus_packet_get_bandwidth(data);
363         st->frame_size = opus_packet_get_samples_per_frame(data, st->Fs);
364         st->stream_channels = opus_packet_get_nb_channels(data);
365         toc = *data++;
366         len--;
367         switch (toc&0x3)
368         {
369         /* One frame */
370         case 0:
371                 count=1;
372                 size[0] = len;
373                 break;
374                 /* Two CBR frames */
375         case 1:
376                 count=2;
377                 if (len&0x1)
378                         return OPUS_CORRUPTED_DATA;
379                 size[0] = size[1] = len/2;
380                 break;
381                 /* Two VBR frames */
382         case 2:
383                 count = 2;
384                 bytes = parse_size(data, len, size);
385                 len -= bytes;
386                 if (size[0]<0 || size[0] > len)
387                         return OPUS_CORRUPTED_DATA;
388                 data += bytes;
389                 size[1] = len-size[0];
390                 break;
391                 /* Multiple CBR/VBR frames (from 0 to 120 ms) */
392         case 3:
393                 if (len<1)
394                         return OPUS_CORRUPTED_DATA;
395                 /* Number of frames encoded in bits 0 to 5 */
396                 ch = *data++;
397                 count = ch&0x3F;
398                 if (st->frame_size*count*25 > 3*st->Fs)
399                     return OPUS_CORRUPTED_DATA;
400                 len--;
401                 /* Bit 7 is VBR flag (bit 6 is ignored) */
402                 if (ch&0x80)
403                 {
404                         /* VBR case */
405                         int last_size=len;
406                         for (i=0;i<count-1;i++)
407                         {
408                                 bytes = parse_size(data, len, size+i);
409                                 len -= bytes;
410                                 if (size[i]<0 || size[i] > len)
411                                         return OPUS_CORRUPTED_DATA;
412                                 data += bytes;
413                                 last_size -= bytes+size[i];
414                         }
415                         if (last_size<0)
416                                 return OPUS_CORRUPTED_DATA;
417                         if (count)
418                                 size[count-1]=last_size;
419                 } else {
420                         /* CBR case */
421                         int sz = count != 0 ? len/count : 0;
422                         if (sz*count!=len)
423                                 return OPUS_CORRUPTED_DATA;
424                         for (i=0;i<count;i++)
425                                 size[i] = sz;
426                 }
427                 break;
428         }
429         if (count*st->frame_size > frame_size)
430                 return OPUS_BAD_ARG;
431         nb_samples=0;
432         for (i=0;i<count;i++)
433         {
434                 int ret;
435                 ret = opus_decode_frame(st, data, len, pcm, frame_size-nb_samples, decode_fec);
436                 if (ret<0)
437                         return ret;
438                 data += size[i];
439                 pcm += ret;
440                 nb_samples += ret;
441         }
442         return nb_samples;
443 }
444 int opus_decoder_ctl(OpusDecoder *st, int request, ...)
445 {
446     va_list ap;
447
448     va_start(ap, request);
449
450     switch (request)
451     {
452         case OPUS_GET_MODE_REQUEST:
453         {
454             int *value = va_arg(ap, int*);
455             *value = st->prev_mode;
456         }
457         break;
458         case OPUS_SET_BANDWIDTH_REQUEST:
459         {
460             int value = va_arg(ap, int);
461             st->bandwidth = value;
462         }
463         break;
464         case OPUS_GET_BANDWIDTH_REQUEST:
465         {
466             int *value = va_arg(ap, int*);
467             *value = st->bandwidth;
468         }
469         break;
470         default:
471             fprintf(stderr, "unknown opus_decoder_ctl() request: %d", request);
472             break;
473     }
474
475     va_end(ap);
476     return OPUS_OK;
477 }
478
479 void opus_decoder_destroy(OpusDecoder *st)
480 {
481         free(st);
482 }
483
484 #if OPUS_TEST_RANGE_CODER_STATE
485 int opus_decoder_get_final_range(OpusDecoder *st)
486 {
487     return st->rangeFinal;
488 }
489 #endif
490
491
492 int opus_packet_get_bandwidth(const unsigned char *data)
493 {
494         int bandwidth;
495     if (data[0]&0x80)
496     {
497         bandwidth = BANDWIDTH_MEDIUMBAND + ((data[0]>>5)&0x3);
498         if (bandwidth == BANDWIDTH_MEDIUMBAND)
499             bandwidth = BANDWIDTH_NARROWBAND;
500     } else if ((data[0]&0x60) == 0x60)
501     {
502         bandwidth = (data[0]&0x10) ? BANDWIDTH_FULLBAND : BANDWIDTH_SUPERWIDEBAND;
503     } else {
504
505         bandwidth = BANDWIDTH_NARROWBAND + ((data[0]>>5)&0x3);
506     }
507     return bandwidth;
508 }
509
510 int opus_packet_get_samples_per_frame(const unsigned char *data, int Fs)
511 {
512         int audiosize;
513     if (data[0]&0x80)
514     {
515         audiosize = ((data[0]>>3)&0x3);
516         audiosize = (Fs<<audiosize)/400;
517     } else if ((data[0]&0x60) == 0x60)
518     {
519         audiosize = (data[0]&0x08) ? Fs/50 : Fs/100;
520     } else {
521
522         audiosize = ((data[0]>>3)&0x3);
523         if (audiosize == 3)
524             audiosize = Fs*60/1000;
525         else
526             audiosize = (Fs<<audiosize)/100;
527     }
528     return audiosize;
529 }
530
531 int opus_packet_get_nb_channels(const unsigned char *data)
532 {
533     return (data[0]&0x4) ? 2 : 1;
534 }
535
536 int opus_packet_get_nb_frames(const unsigned char packet[], int len)
537 {
538         int count;
539         if (len<1)
540                 return OPUS_BAD_ARG;
541         count = packet[0]&0x3;
542         if (count==0)
543                 return 1;
544         else if (count!=3)
545                 return 2;
546         else if (len<2)
547                 return OPUS_CORRUPTED_DATA;
548         else
549                 return packet[1]&0x3F;
550 }
551
552 int opus_decoder_get_nb_samples(const OpusDecoder *dec, const unsigned char packet[], int len)
553 {
554         int samples;
555         int count = opus_packet_get_nb_frames(packet, len);
556         samples = count*opus_packet_get_samples_per_frame(packet, dec->Fs);
557         /* Can't have more than 120 ms */
558         if (samples*25 > dec->Fs*3)
559                 return OPUS_CORRUPTED_DATA;
560         else
561                 return samples;
562 }
563