opus_decoder.c 28.1 KB
Newer Older
1
2
/* Copyright (c) 2010 Xiph.Org Foundation, Skype Limited
   Written by Jean-Marc Valin and Koen Vos */
Jean-Marc Valin's avatar
Jean-Marc Valin committed
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
/*
   Redistribution and use in source and binary forms, with or without
   modification, are permitted provided that the following conditions
   are met:

   - Redistributions of source code must retain the above copyright
   notice, this list of conditions and the following disclaimer.

   - Redistributions in binary form must reproduce the above copyright
   notice, this list of conditions and the following disclaimer in the
   documentation and/or other materials provided with the distribution.

   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
   ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
   LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
18
19
   A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER
   OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
Jean-Marc Valin's avatar
Jean-Marc Valin committed
20
21
22
23
24
25
26
27
28
   EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
   PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
   PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
   LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
   NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
   SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/

#ifdef HAVE_CONFIG_H
29
# include "config.h"
Jean-Marc Valin's avatar
Jean-Marc Valin committed
30
31
#endif

32
#ifndef OPUS_BUILD
33
34
35
# error "OPUS_BUILD _MUST_ be defined to build Opus. This probably means you need other defines as well, as in a config.h. See the included build files for details."
#endif

36
#if defined(__GNUC__) && (__GNUC__ >= 2) && !defined(__OPTIMIZE__) && !defined(OPUS_WILL_BE_SLOW)
37
# pragma message "You appear to be compiling without optimization, if so opus will be very slow."
38
39
#endif

40
#include <stdarg.h>
41
#include "celt.h"
42
#include "opus.h"
Jean-Marc Valin's avatar
Jean-Marc Valin committed
43
44
#include "entdec.h"
#include "modes.h"
45
#include "API.h"
46
47
#include "stack_alloc.h"
#include "float_cast.h"
48
#include "opus_private.h"
49
#include "os_support.h"
50
51
#include "structs.h"
#include "define.h"
52
#include "mathops.h"
53
#include "cpu_support.h"
54

55
56
57
58
struct OpusDecoder {
   int          celt_dec_offset;
   int          silk_dec_offset;
   int          channels;
59
   opus_int32   Fs;          /** Sampling rate (at the API level) */
60
   silk_DecControlStruct DecControl;
61
   int          decode_gain;
62
63
64

   /* Everything beyond this point gets cleared on a reset */
#define OPUS_DECODER_RESET_START stream_channels
65
66
   int          stream_channels;

67
68
69
70
71
   int          bandwidth;
   int          mode;
   int          prev_mode;
   int          frame_size;
   int          prev_redundancy;
72
   int          last_packet_duration;
73
74
75
#ifndef FIXED_POINT
   opus_val16   softclip_mem[2];
#endif
76

77
   opus_uint32  rangeFinal;
78
79
};

Jean-Marc Valin's avatar
Jean-Marc Valin committed
80

81
82
int opus_decoder_get_size(int channels)
{
83
84
   int silkDecSizeBytes, celtDecSizeBytes;
   int ret;
85
86
   if (channels<1 || channels > 2)
      return 0;
87
88
89
90
91
92
   ret = silk_Get_Decoder_Size( &silkDecSizeBytes );
   if(ret)
      return 0;
   silkDecSizeBytes = align(silkDecSizeBytes);
   celtDecSizeBytes = celt_decoder_get_size(channels);
   return align(sizeof(OpusDecoder))+silkDecSizeBytes+celtDecSizeBytes;
93
94
}

95
int opus_decoder_init(OpusDecoder *st, opus_int32 Fs, int channels)
Jean-Marc Valin's avatar
Jean-Marc Valin committed
96
{
97
98
99
   void *silk_dec;
   CELTDecoder *celt_dec;
   int ret, silkDecSizeBytes;
100

101
102
   if ((Fs!=48000&&Fs!=24000&&Fs!=16000&&Fs!=12000&&Fs!=8000)
    || (channels!=1&&channels!=2))
103
      return OPUS_BAD_ARG;
104

105
106
   OPUS_CLEAR((char*)st, opus_decoder_get_size(channels));
   /* Initialize SILK encoder */
107
   ret = silk_Get_Decoder_Size(&silkDecSizeBytes);
108
109
   if (ret)
      return OPUS_INTERNAL_ERROR;
110

111
112
113
114
115
116
117
118
   silkDecSizeBytes = align(silkDecSizeBytes);
   st->silk_dec_offset = align(sizeof(OpusDecoder));
   st->celt_dec_offset = st->silk_dec_offset+silkDecSizeBytes;
   silk_dec = (char*)st+st->silk_dec_offset;
   celt_dec = (CELTDecoder*)((char*)st+st->celt_dec_offset);
   st->stream_channels = st->channels = channels;

   st->Fs = Fs;
119
120
   st->DecControl.API_sampleRate = st->Fs;
   st->DecControl.nChannelsAPI      = st->channels;
121
122
123

   /* Reset decoder */
   ret = silk_InitDecoder( silk_dec );
124
   if(ret)return OPUS_INTERNAL_ERROR;
Jean-Marc Valin's avatar
Jean-Marc Valin committed
125

126
127
   /* Initialize CELT decoder */
   ret = celt_decoder_init(celt_dec, Fs, channels);
128
129
   if(ret!=OPUS_OK)return OPUS_INTERNAL_ERROR;

130
   celt_decoder_ctl(celt_dec, CELT_SET_SIGNALLING(0));
Jean-Marc Valin's avatar
Jean-Marc Valin committed
131

132
133
134
   st->prev_mode = 0;
   st->frame_size = Fs/400;
   return OPUS_OK;
135
136
}

137
OpusDecoder *opus_decoder_create(opus_int32 Fs, int channels, int *error)
138
{
139
   int ret;
140
   OpusDecoder *st;
141
142
   if ((Fs!=48000&&Fs!=24000&&Fs!=16000&&Fs!=12000&&Fs!=8000)
    || (channels!=1&&channels!=2))
143
144
145
146
147
   {
      if (error)
         *error = OPUS_BAD_ARG;
      return NULL;
   }
148
   st = (OpusDecoder *)opus_alloc(opus_decoder_get_size(channels));
149
   if (st == NULL)
150
151
152
153
154
   {
      if (error)
         *error = OPUS_ALLOC_FAIL;
      return NULL;
   }
155
   ret = opus_decoder_init(st, Fs, channels);
156
157
   if (error)
      *error = ret;
158
159
   if (ret != OPUS_OK)
   {
160
161
      opus_free(st);
      st = NULL;
162
   }
163
   return st;
Jean-Marc Valin's avatar
Jean-Marc Valin committed
164
}
Koen Vos's avatar
Koen Vos committed
165

166
167
168
static void smooth_fade(const opus_val16 *in1, const opus_val16 *in2,
      opus_val16 *out, int overlap, int channels,
      const opus_val16 *window, opus_int32 Fs)
169
{
170
171
172
173
174
175
176
177
178
179
180
   int i, c;
   int inc = 48000/Fs;
   for (c=0;c<channels;c++)
   {
      for (i=0;i<overlap;i++)
      {
         opus_val16 w = MULT16_16_Q15(window[i*inc], window[i*inc]);
         out[i*channels+c] = SHR32(MAC16_16(MULT16_16(w,in2[i*channels+c]),
                                   Q15ONE-w, in1[i*channels+c]), 15);
      }
   }
181
182
}

183
184
static int opus_packet_get_mode(const unsigned char *data)
{
185
186
187
188
189
190
191
192
193
194
195
   int mode;
   if (data[0]&0x80)
   {
      mode = MODE_CELT_ONLY;
   } else if ((data[0]&0x60) == 0x60)
   {
      mode = MODE_HYBRID;
   } else {
      mode = MODE_SILK_ONLY;
   }
   return mode;
196
197
}

198
static int opus_decode_frame(OpusDecoder *st, const unsigned char *data,
199
      opus_int32 len, opus_val16 *pcm, int frame_size, int decode_fec)
Jean-Marc Valin's avatar
Jean-Marc Valin committed
200
{
201
202
203
204
205
   void *silk_dec;
   CELTDecoder *celt_dec;
   int i, silk_ret=0, celt_ret=0;
   ec_dec dec;
   opus_int32 silk_frame_size;
Jean-Marc Valin's avatar
Jean-Marc Valin committed
206
   int pcm_silk_size;
207
   VARDECL(opus_int16, pcm_silk);
Jean-Marc Valin's avatar
Jean-Marc Valin committed
208
209
210
211
   int pcm_transition_silk_size;
   VARDECL(opus_val16, pcm_transition_silk);
   int pcm_transition_celt_size;
   VARDECL(opus_val16, pcm_transition_celt);
212
   opus_val16 *pcm_transition=NULL;
Jean-Marc Valin's avatar
Jean-Marc Valin committed
213
   int redundant_audio_size;
214
215
216
217
218
219
220
221
222
223
224
225
226
   VARDECL(opus_val16, redundant_audio);

   int audiosize;
   int mode;
   int transition=0;
   int start_band;
   int redundancy=0;
   int redundancy_bytes = 0;
   int celt_to_silk=0;
   int c;
   int F2_5, F5, F10, F20;
   const opus_val16 *window;
   opus_uint32 redundant_rng = 0;
227
   int celt_accum;
228
   ALLOC_STACK;
229

230
231
232
233
234
235
236
   silk_dec = (char*)st+st->silk_dec_offset;
   celt_dec = (CELTDecoder*)((char*)st+st->celt_dec_offset);
   F20 = st->Fs/50;
   F10 = F20>>1;
   F5 = F10>>1;
   F2_5 = F5>>1;
   if (frame_size < F2_5)
237
238
   {
      RESTORE_STACK;
239
      return OPUS_BUFFER_TOO_SMALL;
240
   }
241
242
   /* Limit frame_size to avoid excessive stack allocations. */
   frame_size = IMIN(frame_size, st->Fs/25*3);
243
244
245
246
247
248
249
250
251
252
253
254
255
256
   /* Payloads of 1 (2 including ToC) or 0 trigger the PLC/DTX */
   if (len<=1)
   {
      data = NULL;
      /* In that case, don't conceal more than what the ToC says */
      frame_size = IMIN(frame_size, st->frame_size);
   }
   if (data != NULL)
   {
      audiosize = st->frame_size;
      mode = st->mode;
      ec_dec_init(&dec,(unsigned char*)data,len);
   } else {
      audiosize = frame_size;
257
      mode = st->prev_mode;
258

259
      if (mode == 0)
260
261
262
263
264
265
266
267
      {
         /* If we haven't got any packet yet, all we can do is return zeros */
         for (i=0;i<audiosize*st->channels;i++)
            pcm[i] = 0;
         RESTORE_STACK;
         return audiosize;
      }

268
269
270
      /* Avoids trying to run the PLC on sizes other than 2.5 (CELT), 5 (CELT),
         10, or 20 (e.g. 12.5 or 30 ms). */
      if (audiosize > F20)
271
272
273
274
275
276
277
278
279
280
281
282
283
      {
         do {
            int ret = opus_decode_frame(st, NULL, 0, pcm, IMIN(audiosize, F20), 0);
            if (ret<0)
            {
               RESTORE_STACK;
               return ret;
            }
            pcm += ret*st->channels;
            audiosize -= ret;
         } while (audiosize > 0);
         RESTORE_STACK;
         return frame_size;
284
285
286
287
288
289
      } else if (audiosize < F20)
      {
         if (audiosize > F10)
            audiosize = F10;
         else if (mode != MODE_SILK_ONLY && audiosize > F5 && audiosize < F10)
            audiosize = F5;
290
291
      }
   }
292

293
294
295
296
297
298
299
300
   /* In fixed-point, we can tell CELT to do the accumulation on top of the
      SILK PCM buffer. This saves some stack space. */
#ifdef FIXED_POINT
   celt_accum = (mode != MODE_CELT_ONLY) && (frame_size >= F10);
#else
   celt_accum = 0;
#endif

301
302
   pcm_transition_silk_size = ALLOC_NONE;
   pcm_transition_celt_size = ALLOC_NONE;
303
304
305
306
307
308
   if (data!=NULL && st->prev_mode > 0 && (
       (mode == MODE_CELT_ONLY && st->prev_mode != MODE_CELT_ONLY && !st->prev_redundancy)
    || (mode != MODE_CELT_ONLY && st->prev_mode == MODE_CELT_ONLY) )
      )
   {
      transition = 1;
Jean-Marc Valin's avatar
Jean-Marc Valin committed
309
      /* Decide where to allocate the stack memory for pcm_transition */
310
      if (mode == MODE_CELT_ONLY)
Jean-Marc Valin's avatar
Jean-Marc Valin committed
311
312
313
314
315
316
317
318
319
         pcm_transition_celt_size = F5*st->channels;
      else
         pcm_transition_silk_size = F5*st->channels;
   }
   ALLOC(pcm_transition_celt, pcm_transition_celt_size, opus_val16);
   if (transition && mode == MODE_CELT_ONLY)
   {
      pcm_transition = pcm_transition_celt;
      opus_decode_frame(st, NULL, 0, pcm_transition, IMIN(F5, audiosize), 0);
320
321
322
323
324
325
326
327
328
329
   }
   if (audiosize > frame_size)
   {
      /*fprintf(stderr, "PCM buffer too small: %d vs %d (mode = %d)\n", audiosize, frame_size, mode);*/
      RESTORE_STACK;
      return OPUS_BAD_ARG;
   } else {
      frame_size = audiosize;
   }

Jean-Marc Valin's avatar
Jean-Marc Valin committed
330
   /* Don't allocate any memory when in CELT-only mode */
331
   pcm_silk_size = (mode != MODE_CELT_ONLY && !celt_accum) ? IMAX(F10, frame_size)*st->channels : ALLOC_NONE;
Jean-Marc Valin's avatar
Jean-Marc Valin committed
332
   ALLOC(pcm_silk, pcm_silk_size, opus_int16);
333
334
335
336
337

   /* SILK processing */
   if (mode != MODE_CELT_ONLY)
   {
      int lost_flag, decoded_samples;
338
339
340
341
342
343
344
      opus_int16 *pcm_ptr;
#ifdef FIXED_POINT
      if (celt_accum)
         pcm_ptr = pcm;
      else
#endif
         pcm_ptr = pcm_silk;
345
346
347
348

      if (st->prev_mode==MODE_CELT_ONLY)
         silk_InitDecoder( silk_dec );

349
      /* The SILK PLC cannot produce frames of less than 10 ms */
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
      st->DecControl.payloadSize_ms = IMAX(10, 1000 * audiosize / st->Fs);

      if (data != NULL)
      {
        st->DecControl.nChannelsInternal = st->stream_channels;
        if( mode == MODE_SILK_ONLY ) {
           if( st->bandwidth == OPUS_BANDWIDTH_NARROWBAND ) {
              st->DecControl.internalSampleRate = 8000;
           } else if( st->bandwidth == OPUS_BANDWIDTH_MEDIUMBAND ) {
              st->DecControl.internalSampleRate = 12000;
           } else if( st->bandwidth == OPUS_BANDWIDTH_WIDEBAND ) {
              st->DecControl.internalSampleRate = 16000;
           } else {
              st->DecControl.internalSampleRate = 16000;
              silk_assert( 0 );
           }
        } else {
           /* Hybrid mode */
           st->DecControl.internalSampleRate = 16000;
369
        }
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
     }

     lost_flag = data == NULL ? 1 : 2 * decode_fec;
     decoded_samples = 0;
     do {
        /* Call SILK decoder */
        int first_frame = decoded_samples == 0;
        silk_ret = silk_Decode( silk_dec, &st->DecControl,
                                lost_flag, first_frame, &dec, pcm_ptr, &silk_frame_size );
        if( silk_ret ) {
           if (lost_flag) {
              /* PLC failure should not be fatal */
              silk_frame_size = frame_size;
              for (i=0;i<frame_size*st->channels;i++)
                 pcm_ptr[i] = 0;
           } else {
             RESTORE_STACK;
387
             return OPUS_INTERNAL_ERROR;
388
           }
389
        }
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
        pcm_ptr += silk_frame_size * st->channels;
        decoded_samples += silk_frame_size;
      } while( decoded_samples < frame_size );
   }

   start_band = 0;
   if (!decode_fec && mode != MODE_CELT_ONLY && data != NULL
    && ec_tell(&dec)+17+20*(st->mode == MODE_HYBRID) <= 8*len)
   {
      /* Check if we have a redundant 0-8 kHz band */
      if (mode == MODE_HYBRID)
         redundancy = ec_dec_bit_logp(&dec, 12);
      else
         redundancy = 1;
      if (redundancy)
      {
         celt_to_silk = ec_dec_bit_logp(&dec, 1);
         /* redundancy_bytes will be at least two, in the non-hybrid
            case due to the ec_tell() check above */
         redundancy_bytes = mode==MODE_HYBRID ?
               (opus_int32)ec_dec_uint(&dec, 256)+2 :
               len-((ec_tell(&dec)+7)>>3);
         len -= redundancy_bytes;
         /* This is a sanity check. It should never happen for a valid
            packet, so the exact behaviour is not normative. */
         if (len*8 < ec_tell(&dec))
         {
            len = 0;
            redundancy_bytes = 0;
            redundancy = 0;
         }
         /* Shrink decoder because of raw bits */
         dec.storage -= redundancy_bytes;
      }
   }
   if (mode != MODE_CELT_ONLY)
      start_band = 17;

   {
      int endband=21;

      switch(st->bandwidth)
      {
      case OPUS_BANDWIDTH_NARROWBAND:
         endband = 13;
         break;
      case OPUS_BANDWIDTH_MEDIUMBAND:
      case OPUS_BANDWIDTH_WIDEBAND:
         endband = 17;
         break;
      case OPUS_BANDWIDTH_SUPERWIDEBAND:
         endband = 19;
         break;
      case OPUS_BANDWIDTH_FULLBAND:
         endband = 21;
         break;
      }
      celt_decoder_ctl(celt_dec, CELT_SET_END_BAND(endband));
      celt_decoder_ctl(celt_dec, CELT_SET_CHANNELS(st->stream_channels));
   }

   if (redundancy)
Jean-Marc Valin's avatar
Jean-Marc Valin committed
452
   {
453
      transition = 0;
454
      pcm_transition_silk_size=ALLOC_NONE;
Jean-Marc Valin's avatar
Jean-Marc Valin committed
455
456
457
   }

   ALLOC(pcm_transition_silk, pcm_transition_silk_size, opus_val16);
458
459

   if (transition && mode != MODE_CELT_ONLY)
Jean-Marc Valin's avatar
Jean-Marc Valin committed
460
461
   {
      pcm_transition = pcm_transition_silk;
462
      opus_decode_frame(st, NULL, 0, pcm_transition, IMIN(F5, audiosize), 0);
Jean-Marc Valin's avatar
Jean-Marc Valin committed
463
464
465
   }

   /* Only allocation memory for redundancy if/when needed */
466
   redundant_audio_size = redundancy ? F5*st->channels : ALLOC_NONE;
Jean-Marc Valin's avatar
Jean-Marc Valin committed
467
   ALLOC(redundant_audio, redundant_audio_size, opus_val16);
468
469
470
471
472
473

   /* 5 ms redundant frame for CELT->SILK*/
   if (redundancy && celt_to_silk)
   {
      celt_decoder_ctl(celt_dec, CELT_SET_START_BAND(0));
      celt_decode_with_ec(celt_dec, data+len, redundancy_bytes,
474
                          redundant_audio, F5, NULL, 0);
475
476
477
478
479
480
481
482
483
484
485
486
487
488
      celt_decoder_ctl(celt_dec, OPUS_GET_FINAL_RANGE(&redundant_rng));
   }

   /* MUST be after PLC */
   celt_decoder_ctl(celt_dec, CELT_SET_START_BAND(start_band));

   if (mode != MODE_SILK_ONLY)
   {
      int celt_frame_size = IMIN(F20, frame_size);
      /* Make sure to discard any previous CELT state */
      if (mode != st->prev_mode && st->prev_mode > 0 && !st->prev_redundancy)
         celt_decoder_ctl(celt_dec, OPUS_RESET_STATE);
      /* Decode CELT */
      celt_ret = celt_decode_with_ec(celt_dec, decode_fec ? NULL : data,
489
                                     len, pcm, celt_frame_size, &dec, celt_accum);
490
491
   } else {
      unsigned char silence[2] = {0xFF, 0xFF};
492
493
494
495
496
      if (!celt_accum)
      {
         for (i=0;i<frame_size*st->channels;i++)
            pcm[i] = 0;
      }
497
498
      /* For hybrid -> SILK transitions, we let the CELT MDCT
         do a fade-out by decoding a silence frame */
Jean-Marc Valin's avatar
Jean-Marc Valin committed
499
      if (st->prev_mode == MODE_HYBRID && !(redundancy && celt_to_silk && st->prev_redundancy) )
500
501
      {
         celt_decoder_ctl(celt_dec, CELT_SET_START_BAND(0));
502
         celt_decode_with_ec(celt_dec, silence, 2, pcm, F2_5, NULL, celt_accum);
503
504
505
      }
   }

506
   if (mode != MODE_CELT_ONLY && !celt_accum)
507
   {
508
#ifdef FIXED_POINT
509
      for (i=0;i<frame_size*st->channels;i++)
510
         pcm[i] = SAT16(ADD32(pcm[i], pcm_silk[i]));
511
#else
512
      for (i=0;i<frame_size*st->channels;i++)
513
         pcm[i] = pcm[i] + (opus_val16)((1.f/32768.f)*pcm_silk[i]);
514
#endif
515
516
517
518
519
520
521
522
523
524
525
526
527
528
   }

   {
      const CELTMode *celt_mode;
      celt_decoder_ctl(celt_dec, CELT_GET_MODE(&celt_mode));
      window = celt_mode->window;
   }

   /* 5 ms redundant frame for SILK->CELT */
   if (redundancy && !celt_to_silk)
   {
      celt_decoder_ctl(celt_dec, OPUS_RESET_STATE);
      celt_decoder_ctl(celt_dec, CELT_SET_START_BAND(0));

529
      celt_decode_with_ec(celt_dec, data+len, redundancy_bytes, redundant_audio, F5, NULL, 0);
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
      celt_decoder_ctl(celt_dec, OPUS_GET_FINAL_RANGE(&redundant_rng));
      smooth_fade(pcm+st->channels*(frame_size-F2_5), redundant_audio+st->channels*F2_5,
                  pcm+st->channels*(frame_size-F2_5), F2_5, st->channels, window, st->Fs);
   }
   if (redundancy && celt_to_silk)
   {
      for (c=0;c<st->channels;c++)
      {
         for (i=0;i<F2_5;i++)
            pcm[st->channels*i+c] = redundant_audio[st->channels*i+c];
      }
      smooth_fade(redundant_audio+st->channels*F2_5, pcm+st->channels*F2_5,
                  pcm+st->channels*F2_5, F2_5, st->channels, window, st->Fs);
   }
   if (transition)
   {
      if (audiosize >= F5)
      {
         for (i=0;i<st->channels*F2_5;i++)
            pcm[i] = pcm_transition[i];
         smooth_fade(pcm_transition+st->channels*F2_5, pcm+st->channels*F2_5,
                     pcm+st->channels*F2_5, F2_5,
                     st->channels, window, st->Fs);
      } else {
         /* Not enough time to do a clean transition, but we do it anyway
            This will not preserve amplitude perfectly and may introduce
            a bit of temporal aliasing, but it shouldn't be too bad and
            that's pretty much the best we can do. In any case, generating this
            transition it pretty silly in the first place */
         smooth_fade(pcm_transition, pcm,
                     pcm, F2_5,
                     st->channels, window, st->Fs);
      }
   }

565
566
567
568
569
570
571
572
573
574
575
576
   if(st->decode_gain)
   {
      opus_val32 gain;
      gain = celt_exp2(MULT16_16_P15(QCONST16(6.48814081e-4f, 25), st->decode_gain));
      for (i=0;i<frame_size*st->channels;i++)
      {
         opus_val32 x;
         x = MULT16_32_P16(pcm[i],gain);
         pcm[i] = SATURATE(x, 32767);
      }
   }

577
578
579
580
581
582
583
   if (len <= 1)
      st->rangeFinal = 0;
   else
      st->rangeFinal = dec.rng ^ redundant_rng;

   st->prev_mode = mode;
   st->prev_redundancy = redundancy && !celt_to_silk;
584
585
586
587
588
589
590

   if (celt_ret>=0)
   {
      if (OPUS_CHECK_ARRAY(pcm, audiosize*st->channels))
         OPUS_PRINT_INT(audiosize);
   }

591
592
   RESTORE_STACK;
   return celt_ret < 0 ? celt_ret : audiosize;
Jean-Marc Valin's avatar
Jean-Marc Valin committed
593
594
595

}

596
int opus_decode_native(OpusDecoder *st, const unsigned char *data,
597
      opus_int32 len, opus_val16 *pcm, int frame_size, int decode_fec,
598
      int self_delimited, opus_int32 *packet_offset, int soft_clip)
599
{
600
601
602
   int i, nb_samples;
   int count, offset;
   unsigned char toc;
603
   int packet_frame_size, packet_bandwidth, packet_mode, packet_stream_channels;
604
   /* 48 x 2.5 ms = 120 ms */
605
   opus_int16 size[48];
606
607
   if (decode_fec<0 || decode_fec>1)
      return OPUS_BAD_ARG;
608
609
610
   /* For FEC/PLC, frame_size has to be to have a multiple of 2.5 ms */
   if ((decode_fec || len==0 || data==NULL) && frame_size%(st->Fs/400)!=0)
      return OPUS_BAD_ARG;
611
   if (len==0 || data==NULL)
612
613
614
615
   {
      int pcm_count=0;
      do {
         int ret;
616
         ret = opus_decode_frame(st, NULL, 0, pcm+pcm_count*st->channels, frame_size-pcm_count, 0);
617
618
619
620
         if (ret<0)
            return ret;
         pcm_count += ret;
      } while (pcm_count < frame_size);
621
622
623
      celt_assert(pcm_count == frame_size);
      if (OPUS_CHECK_ARRAY(pcm, pcm_count*st->channels))
         OPUS_PRINT_INT(pcm_count);
624
      st->last_packet_duration = pcm_count;
625
626
      return pcm_count;
   } else if (len<0)
627
628
      return OPUS_BAD_ARG;

629
630
631
632
   packet_mode = opus_packet_get_mode(data);
   packet_bandwidth = opus_packet_get_bandwidth(data);
   packet_frame_size = opus_packet_get_samples_per_frame(data, st->Fs);
   packet_stream_channels = opus_packet_get_nb_channels(data);
633

634
635
   count = opus_packet_parse_impl(data, len, self_delimited, &toc, NULL,
                                  size, &offset, packet_offset);
636
637
638
   if (count<0)
      return count;

639
640
641
642
   data += offset;

   if (decode_fec)
   {
643
      int duration_copy;
644
645
      int ret;
      /* If no FEC can be present, run the PLC (recursive call) */
646
      if (frame_size < packet_frame_size || packet_mode == MODE_CELT_ONLY || st->mode == MODE_CELT_ONLY)
647
         return opus_decode_native(st, NULL, 0, pcm, frame_size, 0, 0, NULL, soft_clip);
648
      /* Otherwise, run the PLC on everything except the size for which we might have FEC */
649
      duration_copy = st->last_packet_duration;
650
      if (frame_size-packet_frame_size!=0)
651
      {
652
653
654
655
656
657
658
         ret = opus_decode_native(st, NULL, 0, pcm, frame_size-packet_frame_size, 0, 0, NULL, soft_clip);
         if (ret<0)
         {
            st->last_packet_duration = duration_copy;
            return ret;
         }
         celt_assert(ret==frame_size-packet_frame_size);
659
      }
660
661
662
663
664
665
666
667
668
      /* Complete with FEC */
      st->mode = packet_mode;
      st->bandwidth = packet_bandwidth;
      st->frame_size = packet_frame_size;
      st->stream_channels = packet_stream_channels;
      ret = opus_decode_frame(st, data, size[0], pcm+st->channels*(frame_size-packet_frame_size),
            packet_frame_size, 1);
      if (ret<0)
         return ret;
669
670
671
      else {
         if (OPUS_CHECK_ARRAY(pcm, frame_size*st->channels))
            OPUS_PRINT_INT(frame_size);
672
         st->last_packet_duration = frame_size;
673
         return frame_size;
674
      }
675
   }
676

677
   if (count*packet_frame_size > frame_size)
678
      return OPUS_BUFFER_TOO_SMALL;
679
680
681
682
683
684
685

   /* Update the state as the last step to avoid updating it on an invalid packet */
   st->mode = packet_mode;
   st->bandwidth = packet_bandwidth;
   st->frame_size = packet_frame_size;
   st->stream_channels = packet_stream_channels;

686
687
688
689
   nb_samples=0;
   for (i=0;i<count;i++)
   {
      int ret;
690
      ret = opus_decode_frame(st, data, size[i], pcm+nb_samples*st->channels, frame_size-nb_samples, 0);
691
692
      if (ret<0)
         return ret;
693
      celt_assert(ret==packet_frame_size);
694
695
696
      data += size[i];
      nb_samples += ret;
   }
697
   st->last_packet_duration = nb_samples;
698
699
   if (OPUS_CHECK_ARRAY(pcm, nb_samples*st->channels))
      OPUS_PRINT_INT(nb_samples);
700
701
702
703
704
705
#ifndef FIXED_POINT
   if (soft_clip)
      opus_pcm_soft_clip(pcm, nb_samples, st->channels, st->softclip_mem);
   else
      st->softclip_mem[0]=st->softclip_mem[1]=0;
#endif
706
   return nb_samples;
707
}
708

709
710
#ifdef FIXED_POINT

711
int opus_decode(OpusDecoder *st, const unsigned char *data,
712
      opus_int32 len, opus_val16 *pcm, int frame_size, int decode_fec)
713
{
714
715
   if(frame_size<=0)
      return OPUS_BAD_ARG;
716
   return opus_decode_native(st, data, len, pcm, frame_size, decode_fec, 0, NULL, 0);
717
718
}

719
720
#ifndef DISABLE_FLOAT_API
int opus_decode_float(OpusDecoder *st, const unsigned char *data,
721
      opus_int32 len, float *pcm, int frame_size, int decode_fec)
722
723
724
{
   VARDECL(opus_int16, out);
   int ret, i;
725
   int nb_samples;
726
727
   ALLOC_STACK;

728
729
730
731
732
   if(frame_size<=0)
   {
      RESTORE_STACK;
      return OPUS_BAD_ARG;
   }
733
   if (data != NULL && len > 0 && !decode_fec)
734
735
736
737
738
739
740
   {
      nb_samples = opus_decoder_get_nb_samples(st, data, len);
      if (nb_samples>0)
         frame_size = IMIN(frame_size, nb_samples);
      else
         return OPUS_INVALID_PACKET;
   }
741
742
   ALLOC(out, frame_size*st->channels, opus_int16);

743
   ret = opus_decode_native(st, data, len, out, frame_size, decode_fec, 0, NULL, 0);
744
745
746
   if (ret > 0)
   {
      for (i=0;i<ret*st->channels;i++)
Jean-Marc Valin's avatar
Jean-Marc Valin committed
747
         pcm[i] = (1.f/32768.f)*(out[i]);
748
749
750
751
752
753
   }
   RESTORE_STACK;
   return ret;
}
#endif

754

755
756
#else
int opus_decode(OpusDecoder *st, const unsigned char *data,
757
      opus_int32 len, opus_int16 *pcm, int frame_size, int decode_fec)
758
759
760
{
   VARDECL(float, out);
   int ret, i;
761
   int nb_samples;
762
763
   ALLOC_STACK;

764
   if(frame_size<=0)
765
766
767
768
   {
      RESTORE_STACK;
      return OPUS_BAD_ARG;
   }
769

770
   if (data != NULL && len > 0 && !decode_fec)
771
772
773
774
775
776
777
   {
      nb_samples = opus_decoder_get_nb_samples(st, data, len);
      if (nb_samples>0)
         frame_size = IMIN(frame_size, nb_samples);
      else
         return OPUS_INVALID_PACKET;
   }
778
779
   ALLOC(out, frame_size*st->channels, float);

780
   ret = opus_decode_native(st, data, len, out, frame_size, decode_fec, 0, NULL, 1);
781
782
783
784
785
786
787
788
   if (ret > 0)
   {
      for (i=0;i<ret*st->channels;i++)
         pcm[i] = FLOAT2INT16(out[i]);
   }
   RESTORE_STACK;
   return ret;
}
789
790

int opus_decode_float(OpusDecoder *st, const unsigned char *data,
791
      opus_int32 len, opus_val16 *pcm, int frame_size, int decode_fec)
792
{
793
794
   if(frame_size<=0)
      return OPUS_BAD_ARG;
795
   return opus_decode_native(st, data, len, pcm, frame_size, decode_fec, 0, NULL, 0);
796
797
}

798
#endif
799

800
int opus_decoder_ctl(OpusDecoder *st, int request, ...)
801
{
802
803
   int ret = OPUS_OK;
   va_list ap;
804
805
806
807
808
809
   void *silk_dec;
   CELTDecoder *celt_dec;

   silk_dec = (char*)st+st->silk_dec_offset;
   celt_dec = (CELTDecoder*)((char*)st+st->celt_dec_offset);

810

811
   va_start(ap, request);
812

813
814
815
816
817
   switch (request)
   {
   case OPUS_GET_BANDWIDTH_REQUEST:
   {
      opus_int32 *value = va_arg(ap, opus_int32*);
Gregory Maxwell's avatar
Gregory Maxwell committed
818
819
      if (!value)
      {
820
821
         goto bad_arg;
      }
822
823
824
825
826
827
      *value = st->bandwidth;
   }
   break;
   case OPUS_GET_FINAL_RANGE_REQUEST:
   {
      opus_uint32 *value = va_arg(ap, opus_uint32*);
Gregory Maxwell's avatar
Gregory Maxwell committed
828
829
      if (!value)
      {
830
831
         goto bad_arg;
      }
832
833
834
      *value = st->rangeFinal;
   }
   break;
835
836
837
   case OPUS_RESET_STATE:
   {
      OPUS_CLEAR((char*)&st->OPUS_DECODER_RESET_START,
838
            sizeof(OpusDecoder)-
839
840
            ((char*)&st->OPUS_DECODER_RESET_START - (char*)st));

841
      celt_decoder_ctl(celt_dec, OPUS_RESET_STATE);
842
843
844
845
846
      silk_InitDecoder( silk_dec );
      st->stream_channels = st->channels;
      st->frame_size = st->Fs/400;
   }
   break;
847
848
849
   case OPUS_GET_SAMPLE_RATE_REQUEST:
   {
      opus_int32 *value = va_arg(ap, opus_int32*);
Gregory Maxwell's avatar
Gregory Maxwell committed
850
851
      if (!value)
      {
852
853
         goto bad_arg;
      }
854
855
856
      *value = st->Fs;
   }
   break;
857
858
   case OPUS_GET_PITCH_REQUEST:
   {
859
      opus_int32 *value = va_arg(ap, opus_int32*);
Gregory Maxwell's avatar
Gregory Maxwell committed
860
861
      if (!value)
      {
862
863
         goto bad_arg;
      }
864
865
866
      if (st->prev_mode == MODE_CELT_ONLY)
         celt_decoder_ctl(celt_dec, OPUS_GET_PITCH(value));
      else
Jean-Marc Valin's avatar
Jean-Marc Valin committed
867
         *value = st->DecControl.prevPitchLag;
868
869
   }
   break;
870
871
872
   case OPUS_GET_GAIN_REQUEST:
   {
      opus_int32 *value = va_arg(ap, opus_int32*);
Gregory Maxwell's avatar
Gregory Maxwell committed
873
874
      if (!value)
      {
875
876
         goto bad_arg;
      }
877
878
879
880
881
882
      *value = st->decode_gain;
   }
   break;
   case OPUS_SET_GAIN_REQUEST:
   {
       opus_int32 value = va_arg(ap, opus_int32);
Gregory Maxwell's avatar
Gregory Maxwell committed
883
884
       if (value<-32768 || value>32767)
       {
885
886
          goto bad_arg;
       }
887
888
889
       st->decode_gain = value;
   }
   break;
890
891
892
   case OPUS_GET_LAST_PACKET_DURATION_REQUEST:
   {
      opus_uint32 *value = va_arg(ap, opus_uint32*);
Gregory Maxwell's avatar
Gregory Maxwell committed
893
894
      if (!value)
      {
895
896
         goto bad_arg;
      }
897
898
899
      *value = st->last_packet_duration;
   }
   break;
900
901
   default:
      /*fprintf(stderr, "unknown opus_decoder_ctl() request: %d", request);*/
902
      ret = OPUS_UNIMPLEMENTED;
903
904
      break;
   }
Alfred E. Heggestad's avatar
Alfred E. Heggestad committed
905

906
907
   va_end(ap);
   return ret;
908
909
910
bad_arg:
   va_end(ap);
   return OPUS_BAD_ARG;
911
912
}

Jean-Marc Valin's avatar
Jean-Marc Valin committed
913
void opus_decoder_destroy(OpusDecoder *st)
Jean-Marc Valin's avatar
Jean-Marc Valin committed
914
{
915
   opus_free(st);
Jean-Marc Valin's avatar
Jean-Marc Valin committed
916
}
Koen Vos's avatar
Koen Vos committed
917

918
919
920

int opus_packet_get_bandwidth(const unsigned char *data)
{
921
922
923
924
925
926
927
928
929
930
931
932
933
934
   int bandwidth;
   if (data[0]&0x80)
   {
      bandwidth = OPUS_BANDWIDTH_MEDIUMBAND + ((data[0]>>5)&0x3);
      if (bandwidth == OPUS_BANDWIDTH_MEDIUMBAND)
         bandwidth = OPUS_BANDWIDTH_NARROWBAND;
   } else if ((data[0]&0x60) == 0x60)
   {
      bandwidth = (data[0]&0x10) ? OPUS_BANDWIDTH_FULLBAND :
                                   OPUS_BANDWIDTH_SUPERWIDEBAND;
   } else {
      bandwidth = OPUS_BANDWIDTH_NARROWBAND + ((data[0]>>5)&0x3);
   }
   return bandwidth;
935
936
937
938
}

int opus_packet_get_nb_channels(const unsigned char *data)
{
939
   return (data[0]&0x4) ? 2 : 1;
940
941
}

942
int opus_packet_get_nb_frames(const unsigned char packet[], opus_int32 len)
943
{
944
945
946
947
948
949
950
951
952
953
954
955
   int count;
   if (len<1)
      return OPUS_BAD_ARG;
   count = packet[0]&0x3;
   if (count==0)
      return 1;
   else if (count!=3)
      return 2;
   else if (len<2)
      return OPUS_INVALID_PACKET;
   else
      return packet[1]&0x3F;
956
957
}

958
959
int opus_packet_get_nb_samples(const unsigned char packet[], opus_int32 len,
      opus_int32 Fs)
960
{
961
962
   int samples;
   int count = opus_packet_get_nb_frames(packet, len);
963
964
965
966

   if (count<0)
      return count;

967
   samples = count*opus_packet_get_samples_per_frame(packet, Fs);
968
   /* Can't have more than 120 ms */
969
   if (samples*25 > Fs*3)
970
971
972
      return OPUS_INVALID_PACKET;
   else
      return samples;
973
}
974
975
976
977
978
979

int opus_decoder_get_nb_samples(const OpusDecoder *dec,
      const unsigned char packet[], opus_int32 len)
{
   return opus_packet_get_nb_samples(packet, len, dec->Fs);
}