c2cf970deda855d78d401cb15b34885b1c420fad
[opus.git] / libcelt / celt.c
1 /* Copyright (c) 2007-2008 CSIRO
2    Copyright (c) 2007-2010 Xiph.Org Foundation
3    Copyright (c) 2008 Gregory Maxwell 
4    Written by Jean-Marc Valin and Gregory Maxwell */
5 /*
6    Redistribution and use in source and binary forms, with or without
7    modification, are permitted provided that the following conditions
8    are met:
9    
10    - Redistributions of source code must retain the above copyright
11    notice, this list of conditions and the following disclaimer.
12    
13    - Redistributions in binary form must reproduce the above copyright
14    notice, this list of conditions and the following disclaimer in the
15    documentation and/or other materials provided with the distribution.
16    
17    THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
18    ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
19    LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
20    A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR
21    CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
22    EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
23    PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
24    PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
25    LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
26    NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
27    SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
28 */
29
30 #ifdef HAVE_CONFIG_H
31 #include "config.h"
32 #endif
33
34 #define CELT_C
35
36 /* Always enable postfilter for Opus */
37 #if defined(OPUS_BUILD) && !defined(ENABLE_POSTFILTER)
38 #define ENABLE_POSTFILTER
39 #endif
40
41 #include "os_support.h"
42 #include "mdct.h"
43 #include <math.h>
44 #include "celt.h"
45 #include "pitch.h"
46 #include "bands.h"
47 #include "modes.h"
48 #include "entcode.h"
49 #include "quant_bands.h"
50 #include "rate.h"
51 #include "stack_alloc.h"
52 #include "mathops.h"
53 #include "float_cast.h"
54 #include <stdarg.h>
55 #include "plc.h"
56 #include "vq.h"
57
58 static const unsigned char trim_icdf[11] = {126, 124, 119, 109, 87, 41, 19, 9, 4, 2, 0};
59 /* Probs: NONE: 21.875%, LIGHT: 6.25%, NORMAL: 65.625%, AGGRESSIVE: 6.25% */
60 static const unsigned char spread_icdf[4] = {25, 23, 2, 0};
61
62 static const unsigned char tapset_icdf[3]={2,1,0};
63
64 static const unsigned char toOpusTable[20] = {
65       0xE0, 0xE8, 0xF0, 0xF8,
66       0xC0, 0xC8, 0xD0, 0xD8,
67       0xA0, 0xA8, 0xB0, 0xB8,
68       0x00, 0x00, 0x00, 0x00,
69       0x80, 0x88, 0x90, 0x98,
70 };
71
72 static const unsigned char fromOpusTable[16] = {
73       0x80, 0x88, 0x90, 0x98,
74       0x40, 0x48, 0x50, 0x58,
75       0x20, 0x28, 0x30, 0x38,
76       0x00, 0x08, 0x10, 0x18
77 };
78
79 static inline int toOpus(unsigned char c)
80 {
81    int ret=0;
82    if (c<0xA0)
83       ret = toOpusTable[c>>3];
84    if (ret == 0)
85       return -1;
86    else
87       return ret|(c&0x7);
88 }
89
90 static inline int fromOpus(unsigned char c)
91 {
92    if (c<0x80)
93       return -1;
94    else
95       return fromOpusTable[(c>>3)-16] | (c&0x7);
96 }
97
98 #define COMBFILTER_MAXPERIOD 1024
99 #define COMBFILTER_MINPERIOD 15
100
101 static int resampling_factor(celt_int32 rate)
102 {
103    int ret;
104    switch (rate)
105    {
106    case 48000:
107       ret = 1;
108       break;
109    case 24000:
110       ret = 2;
111       break;
112    case 16000:
113       ret = 3;
114       break;
115    case 12000:
116       ret = 4;
117       break;
118    case 8000:
119       ret = 6;
120       break;
121    default:
122       ret = 0;
123    }
124    return ret;
125 }
126
127 /** Encoder state 
128  @brief Encoder state
129  */
130 struct CELTEncoder {
131    const CELTMode *mode;     /**< Mode used by the encoder */
132    int overlap;
133    int channels;
134    int stream_channels;
135    
136    int force_intra;
137    int clip;
138    int disable_pf;
139    int complexity;
140    int upsample;
141    int start, end;
142
143    celt_int32 bitrate;
144    int vbr;
145    int signalling;
146    int constrained_vbr;      /* If zero, VBR can do whatever it likes with the rate */
147    int loss_rate;
148
149    /* Everything beyond this point gets cleared on a reset */
150 #define ENCODER_RESET_START rng
151
152    celt_uint32 rng;
153    int spread_decision;
154    celt_word32 delayedIntra;
155    int tonal_average;
156    int lastCodedBands;
157    int hf_average;
158    int tapset_decision;
159
160    int prefilter_period;
161    celt_word16 prefilter_gain;
162    int prefilter_tapset;
163 #ifdef RESYNTH
164    int prefilter_period_old;
165    celt_word16 prefilter_gain_old;
166    int prefilter_tapset_old;
167 #endif
168    int consec_transient;
169
170    /* VBR-related parameters */
171    celt_int32 vbr_reservoir;
172    celt_int32 vbr_drift;
173    celt_int32 vbr_offset;
174    celt_int32 vbr_count;
175
176    celt_word32 preemph_memE[2];
177    celt_word32 preemph_memD[2];
178
179 #ifdef RESYNTH
180    celt_sig syn_mem[2][2*MAX_PERIOD];
181 #endif
182
183    celt_sig in_mem[1]; /* Size = channels*mode->overlap */
184    /* celt_sig prefilter_mem[],  Size = channels*COMBFILTER_PERIOD */
185    /* celt_sig overlap_mem[],  Size = channels*mode->overlap */
186    /* celt_word16 oldEBands[], Size = 2*channels*mode->nbEBands */
187 };
188
189 int celt_encoder_get_size(int channels)
190 {
191    CELTMode *mode = celt_mode_create(48000, 960, NULL);
192    return celt_encoder_get_size_custom(mode, channels);
193 }
194
195 int celt_encoder_get_size_custom(const CELTMode *mode, int channels)
196 {
197    int size = sizeof(struct CELTEncoder)
198          + (2*channels*mode->overlap-1)*sizeof(celt_sig)
199          + channels*COMBFILTER_MAXPERIOD*sizeof(celt_sig)
200          + 3*channels*mode->nbEBands*sizeof(celt_word16);
201    return size;
202 }
203
204 CELTEncoder *celt_encoder_create(int sampling_rate, int channels, int *error)
205 {
206    CELTEncoder *st;
207    st = (CELTEncoder *)celt_alloc(celt_encoder_get_size(channels));
208    if (st!=NULL && celt_encoder_init(st, sampling_rate, channels, error)==NULL)
209    {
210       celt_encoder_destroy(st);
211       st = NULL;
212    }
213    return st;
214 }
215
216 CELTEncoder *celt_encoder_create_custom(const CELTMode *mode, int channels, int *error)
217 {
218    CELTEncoder *st = (CELTEncoder *)celt_alloc(celt_encoder_get_size_custom(mode, channels));
219    if (st!=NULL && celt_encoder_init_custom(st, mode, channels, error)==NULL)
220    {
221       celt_encoder_destroy(st);
222       st = NULL;
223    }
224    return st;
225 }
226
227 CELTEncoder *celt_encoder_init(CELTEncoder *st, int sampling_rate, int channels, int *error)
228 {
229    celt_encoder_init_custom(st, celt_mode_create(48000, 960, NULL), channels, error);
230    st->upsample = resampling_factor(sampling_rate);
231    if (st->upsample==0)
232    {
233       if (error)
234          *error = CELT_BAD_ARG;
235       return NULL;
236    }
237    return st;
238 }
239
240 CELTEncoder *celt_encoder_init_custom(CELTEncoder *st, const CELTMode *mode, int channels, int *error)
241 {
242    if (channels < 0 || channels > 2)
243    {
244       if (error)
245          *error = CELT_BAD_ARG;
246       return NULL;
247    }
248
249    if (st==NULL || mode==NULL)
250    {
251       if (error)
252          *error = CELT_ALLOC_FAIL;
253       return NULL;
254    }
255
256    CELT_MEMSET((char*)st, 0, celt_encoder_get_size_custom(mode, channels));
257    
258    st->mode = mode;
259    st->overlap = mode->overlap;
260    st->stream_channels = st->channels = channels;
261
262    st->upsample = 1;
263    st->start = 0;
264    st->end = st->mode->effEBands;
265    st->signalling = 1;
266
267    st->constrained_vbr = 1;
268    st->clip = 1;
269
270    st->bitrate = 255000*channels;
271    st->vbr = 0;
272    st->vbr_offset = 0;
273    st->force_intra  = 0;
274    st->delayedIntra = 1;
275    st->tonal_average = 256;
276    st->spread_decision = SPREAD_NORMAL;
277    st->hf_average = 0;
278    st->tapset_decision = 0;
279    st->complexity = 5;
280
281    if (error)
282       *error = CELT_OK;
283    return st;
284 }
285
286 void celt_encoder_destroy(CELTEncoder *st)
287 {
288    celt_free(st);
289 }
290
291 static inline celt_int16 FLOAT2INT16(float x)
292 {
293    x = x*CELT_SIG_SCALE;
294    x = MAX32(x, -32768);
295    x = MIN32(x, 32767);
296    return (celt_int16)float2int(x);
297 }
298
299 static inline celt_word16 SIG2WORD16(celt_sig x)
300 {
301 #ifdef FIXED_POINT
302    x = PSHR32(x, SIG_SHIFT);
303    x = MAX32(x, -32768);
304    x = MIN32(x, 32767);
305    return EXTRACT16(x);
306 #else
307    return (celt_word16)x;
308 #endif
309 }
310
311 static int transient_analysis(const celt_word32 * restrict in, int len, int C,
312                               int overlap)
313 {
314    int i;
315    VARDECL(celt_word16, tmp);
316    celt_word32 mem0=0,mem1=0;
317    int is_transient = 0;
318    int block;
319    int N;
320    VARDECL(celt_word16, bins);
321    SAVE_STACK;
322    ALLOC(tmp, len, celt_word16);
323
324    block = overlap/2;
325    N=len/block;
326    ALLOC(bins, N, celt_word16);
327    if (C==1)
328    {
329       for (i=0;i<len;i++)
330          tmp[i] = SHR32(in[i],SIG_SHIFT);
331    } else {
332       for (i=0;i<len;i++)
333          tmp[i] = SHR32(ADD32(in[i],in[i+len]), SIG_SHIFT+1);
334    }
335
336    /* High-pass filter: (1 - 2*z^-1 + z^-2) / (1 - z^-1 + .5*z^-2) */
337    for (i=0;i<len;i++)
338    {
339       celt_word32 x,y;
340       x = tmp[i];
341       y = ADD32(mem0, x);
342 #ifdef FIXED_POINT
343       mem0 = mem1 + y - SHL32(x,1);
344       mem1 = x - SHR32(y,1);
345 #else
346       mem0 = mem1 + y - 2*x;
347       mem1 = x - .5f*y;
348 #endif
349       tmp[i] = EXTRACT16(SHR(y,2));
350    }
351    /* First few samples are bad because we don't propagate the memory */
352    for (i=0;i<12;i++)
353       tmp[i] = 0;
354
355    for (i=0;i<N;i++)
356    {
357       int j;
358       celt_word16 max_abs=0;
359       for (j=0;j<block;j++)
360          max_abs = MAX16(max_abs, ABS16(tmp[i*block+j]));
361       bins[i] = max_abs;
362    }
363    for (i=0;i<N;i++)
364    {
365       int j;
366       int conseq=0;
367       celt_word16 t1, t2, t3;
368
369       t1 = MULT16_16_Q15(QCONST16(.15f, 15), bins[i]);
370       t2 = MULT16_16_Q15(QCONST16(.4f, 15), bins[i]);
371       t3 = MULT16_16_Q15(QCONST16(.15f, 15), bins[i]);
372       for (j=0;j<i;j++)
373       {
374          if (bins[j] < t1)
375             conseq++;
376          if (bins[j] < t2)
377             conseq++;
378          else
379             conseq = 0;
380       }
381       if (conseq>=3)
382          is_transient=1;
383       conseq = 0;
384       for (j=i+1;j<N;j++)
385       {
386          if (bins[j] < t3)
387             conseq++;
388          else
389             conseq = 0;
390       }
391       if (conseq>=7)
392          is_transient=1;
393    }
394    RESTORE_STACK;
395    return is_transient;
396 }
397
398 /** Apply window and compute the MDCT for all sub-frames and 
399     all channels in a frame */
400 static void compute_mdcts(const CELTMode *mode, int shortBlocks, celt_sig * restrict in, celt_sig * restrict out, int _C, int LM)
401 {
402    const int C = CHANNELS(_C);
403    if (C==1 && !shortBlocks)
404    {
405       const int overlap = OVERLAP(mode);
406       clt_mdct_forward(&mode->mdct, in, out, mode->window, overlap, mode->maxLM-LM);
407    } else {
408       const int overlap = OVERLAP(mode);
409       int N = mode->shortMdctSize<<LM;
410       int B = 1;
411       int b, c;
412       VARDECL(celt_word32, tmp);
413       SAVE_STACK;
414       if (shortBlocks)
415       {
416          /*lookup = &mode->mdct[0];*/
417          N = mode->shortMdctSize;
418          B = shortBlocks;
419       }
420       ALLOC(tmp, N, celt_word32);
421       c=0; do {
422          for (b=0;b<B;b++)
423          {
424             int j;
425             clt_mdct_forward(&mode->mdct, in+c*(B*N+overlap)+b*N, tmp, mode->window, overlap, shortBlocks ? mode->maxLM : mode->maxLM-LM);
426             /* Interleaving the sub-frames */
427             for (j=0;j<N;j++)
428                out[(j*B+b)+c*N*B] = tmp[j];
429          }
430       } while (++c<C);
431       RESTORE_STACK;
432    }
433 }
434
435 /** Compute the IMDCT and apply window for all sub-frames and 
436     all channels in a frame */
437 static void compute_inv_mdcts(const CELTMode *mode, int shortBlocks, celt_sig *X,
438       celt_sig * restrict out_mem[],
439       celt_sig * restrict overlap_mem[], int _C, int LM)
440 {
441    int c;
442    const int C = CHANNELS(_C);
443    const int N = mode->shortMdctSize<<LM;
444    const int overlap = OVERLAP(mode);
445    c=0; do {
446       int j;
447          VARDECL(celt_word32, x);
448          VARDECL(celt_word32, tmp);
449          int b;
450          int N2 = N;
451          int B = 1;
452          SAVE_STACK;
453          
454          ALLOC(x, N+overlap, celt_word32);
455          ALLOC(tmp, N, celt_word32);
456
457          if (shortBlocks)
458          {
459             N2 = mode->shortMdctSize;
460             B = shortBlocks;
461          }
462          /* Prevents problems from the imdct doing the overlap-add */
463          CELT_MEMSET(x, 0, overlap);
464
465          for (b=0;b<B;b++)
466          {
467             /* De-interleaving the sub-frames */
468             for (j=0;j<N2;j++)
469                tmp[j] = X[(j*B+b)+c*N2*B];
470             clt_mdct_backward(&mode->mdct, tmp, x+N2*b, mode->window, overlap, shortBlocks ? mode->maxLM : mode->maxLM-LM);
471          }
472
473          for (j=0;j<overlap;j++)
474             out_mem[c][j] = x[j] + overlap_mem[c][j];
475          for (;j<N;j++)
476             out_mem[c][j] = x[j];
477          for (j=0;j<overlap;j++)
478             overlap_mem[c][j] = x[N+j];
479          RESTORE_STACK;
480    } while (++c<C);
481 }
482
483 static void deemphasis(celt_sig *in[], celt_word16 *pcm, int N, int _C, int downsample, const celt_word16 *coef, celt_sig *mem)
484 {
485    const int C = CHANNELS(_C);
486    int c;
487    int count=0;
488    c=0; do {
489       int j;
490       celt_sig * restrict x;
491       celt_word16  * restrict y;
492       celt_sig m = mem[c];
493       x =in[c];
494       y = pcm+c;
495       for (j=0;j<N;j++)
496       {
497          celt_sig tmp = *x + m;
498          m = MULT16_32_Q15(coef[0], tmp)
499            - MULT16_32_Q15(coef[1], *x);
500          tmp = SHL32(MULT16_32_Q15(coef[3], tmp), 2);
501          x++;
502          /* Technically the store could be moved outside of the if because
503             the stores we don't want will just be overwritten */
504          if (++count==downsample)
505          {
506             *y = SCALEOUT(SIG2WORD16(tmp));
507             y+=C;
508             count=0;
509          }
510       }
511       mem[c] = m;
512    } while (++c<C);
513 }
514
515 #ifdef ENABLE_POSTFILTER
516 static void comb_filter(celt_word32 *y, celt_word32 *x, int T0, int T1, int N,
517       celt_word16 g0, celt_word16 g1, int tapset0, int tapset1,
518       const celt_word16 *window, int overlap)
519 {
520    int i;
521    /* printf ("%d %d %f %f\n", T0, T1, g0, g1); */
522    celt_word16 g00, g01, g02, g10, g11, g12;
523    static const celt_word16 gains[3][3] = {
524          {QCONST16(0.3066406250f, 15), QCONST16(0.2170410156f, 15), QCONST16(0.1296386719f, 15)},
525          {QCONST16(0.4638671875f, 15), QCONST16(0.2680664062f, 15), QCONST16(0.f, 15)},
526          {QCONST16(0.7998046875f, 15), QCONST16(0.1000976562f, 15), QCONST16(0.f, 15)}};
527    g00 = MULT16_16_Q15(g0, gains[tapset0][0]);
528    g01 = MULT16_16_Q15(g0, gains[tapset0][1]);
529    g02 = MULT16_16_Q15(g0, gains[tapset0][2]);
530    g10 = MULT16_16_Q15(g1, gains[tapset1][0]);
531    g11 = MULT16_16_Q15(g1, gains[tapset1][1]);
532    g12 = MULT16_16_Q15(g1, gains[tapset1][2]);
533    for (i=0;i<overlap;i++)
534    {
535       celt_word16 f;
536       f = MULT16_16_Q15(window[i],window[i]);
537       y[i] = x[i]
538                + MULT16_32_Q15(MULT16_16_Q15((Q15ONE-f),g00),x[i-T0])
539                + MULT16_32_Q15(MULT16_16_Q15((Q15ONE-f),g01),x[i-T0-1])
540                + MULT16_32_Q15(MULT16_16_Q15((Q15ONE-f),g01),x[i-T0+1])
541                + MULT16_32_Q15(MULT16_16_Q15((Q15ONE-f),g02),x[i-T0-2])
542                + MULT16_32_Q15(MULT16_16_Q15((Q15ONE-f),g02),x[i-T0+2])
543                + MULT16_32_Q15(MULT16_16_Q15(f,g10),x[i-T1])
544                + MULT16_32_Q15(MULT16_16_Q15(f,g11),x[i-T1-1])
545                + MULT16_32_Q15(MULT16_16_Q15(f,g11),x[i-T1+1])
546                + MULT16_32_Q15(MULT16_16_Q15(f,g12),x[i-T1-2])
547                + MULT16_32_Q15(MULT16_16_Q15(f,g12),x[i-T1+2]);
548
549    }
550    for (i=overlap;i<N;i++)
551       y[i] = x[i]
552                + MULT16_32_Q15(g10,x[i-T1])
553                + MULT16_32_Q15(g11,x[i-T1-1])
554                + MULT16_32_Q15(g11,x[i-T1+1])
555                + MULT16_32_Q15(g12,x[i-T1-2])
556                + MULT16_32_Q15(g12,x[i-T1+2]);
557 }
558 #endif /* ENABLE_POSTFILTER */
559
560 static const signed char tf_select_table[4][8] = {
561       {0, -1, 0, -1,    0,-1, 0,-1},
562       {0, -1, 0, -2,    1, 0, 1,-1},
563       {0, -2, 0, -3,    2, 0, 1,-1},
564       {0, -2, 0, -3,    3, 0, 1,-1},
565 };
566
567 static celt_word32 l1_metric(const celt_norm *tmp, int N, int LM, int width)
568 {
569    int i, j;
570    static const celt_word16 sqrtM_1[4] = {Q15ONE, QCONST16(.70710678f,15), QCONST16(0.5f,15), QCONST16(0.35355339f,15)};
571    celt_word32 L1;
572    celt_word16 bias;
573    L1=0;
574    for (i=0;i<1<<LM;i++)
575    {
576       celt_word32 L2 = 0;
577       for (j=0;j<N>>LM;j++)
578          L2 = MAC16_16(L2, tmp[(j<<LM)+i], tmp[(j<<LM)+i]);
579       L1 += celt_sqrt(L2);
580    }
581    L1 = MULT16_32_Q15(sqrtM_1[LM], L1);
582    if (width==1)
583       bias = QCONST16(.12f,15)*LM;
584    else if (width==2)
585       bias = QCONST16(.05f,15)*LM;
586    else
587       bias = QCONST16(.02f,15)*LM;
588    L1 = MAC16_32_Q15(L1, bias, L1);
589    return L1;
590 }
591
592 static int tf_analysis(const CELTMode *m, celt_word16 *bandLogE, celt_word16 *oldBandE,
593       int len, int C, int isTransient, int *tf_res, int nbCompressedBytes, celt_norm *X,
594       int N0, int LM, int *tf_sum)
595 {
596    int i;
597    VARDECL(int, metric);
598    int cost0;
599    int cost1;
600    VARDECL(int, path0);
601    VARDECL(int, path1);
602    VARDECL(celt_norm, tmp);
603    int lambda;
604    int tf_select=0;
605    SAVE_STACK;
606
607    if (nbCompressedBytes<15*C)
608    {
609       *tf_sum = 0;
610       for (i=0;i<len;i++)
611          tf_res[i] = isTransient;
612       return 0;
613    }
614    if (nbCompressedBytes<40)
615       lambda = 12;
616    else if (nbCompressedBytes<60)
617       lambda = 6;
618    else if (nbCompressedBytes<100)
619       lambda = 4;
620    else
621       lambda = 3;
622
623    ALLOC(metric, len, int);
624    ALLOC(tmp, (m->eBands[len]-m->eBands[len-1])<<LM, celt_norm);
625    ALLOC(path0, len, int);
626    ALLOC(path1, len, int);
627
628    *tf_sum = 0;
629    for (i=0;i<len;i++)
630    {
631       int j, k, N;
632       celt_word32 L1, best_L1;
633       int best_level=0;
634       N = (m->eBands[i+1]-m->eBands[i])<<LM;
635       for (j=0;j<N;j++)
636          tmp[j] = X[j+(m->eBands[i]<<LM)];
637       /* Just add the right channel if we're in stereo */
638       if (C==2)
639          for (j=0;j<N;j++)
640             tmp[j] = ADD16(tmp[j],X[N0+j+(m->eBands[i]<<LM)]);
641       L1 = l1_metric(tmp, N, isTransient ? LM : 0, N>>LM);
642       best_L1 = L1;
643       /*printf ("%f ", L1);*/
644       for (k=0;k<LM;k++)
645       {
646          int B;
647
648          if (isTransient)
649             B = (LM-k-1);
650          else
651             B = k+1;
652
653          if (isTransient)
654             haar1(tmp, N>>(LM-k), 1<<(LM-k));
655          else
656             haar1(tmp, N>>k, 1<<k);
657
658          L1 = l1_metric(tmp, N, B, N>>LM);
659
660          if (L1 < best_L1)
661          {
662             best_L1 = L1;
663             best_level = k+1;
664          }
665       }
666       /*printf ("%d ", isTransient ? LM-best_level : best_level);*/
667       if (isTransient)
668          metric[i] = best_level;
669       else
670          metric[i] = -best_level;
671       *tf_sum += metric[i];
672    }
673    /*printf("\n");*/
674    /* TODO: Detect the extreme transients that require tf_select = 1 */
675    tf_select = 0;
676
677    cost0 = 0;
678    cost1 = isTransient ? 0 : lambda;
679    /* Viterbi forward pass */
680    for (i=1;i<len;i++)
681    {
682       int curr0, curr1;
683       int from0, from1;
684
685       from0 = cost0;
686       from1 = cost1 + lambda;
687       if (from0 < from1)
688       {
689          curr0 = from0;
690          path0[i]= 0;
691       } else {
692          curr0 = from1;
693          path0[i]= 1;
694       }
695
696       from0 = cost0 + lambda;
697       from1 = cost1;
698       if (from0 < from1)
699       {
700          curr1 = from0;
701          path1[i]= 0;
702       } else {
703          curr1 = from1;
704          path1[i]= 1;
705       }
706       cost0 = curr0 + abs(metric[i]-tf_select_table[LM][4*isTransient+2*tf_select+0]);
707       cost1 = curr1 + abs(metric[i]-tf_select_table[LM][4*isTransient+2*tf_select+1]);
708    }
709    tf_res[len-1] = cost0 < cost1 ? 0 : 1;
710    /* Viterbi backward pass to check the decisions */
711    for (i=len-2;i>=0;i--)
712    {
713       if (tf_res[i+1] == 1)
714          tf_res[i] = path1[i+1];
715       else
716          tf_res[i] = path0[i+1];
717    }
718    RESTORE_STACK;
719    return tf_select;
720 }
721
722 static void tf_encode(int start, int end, int isTransient, int *tf_res, int LM, int tf_select, ec_enc *enc)
723 {
724    int curr, i;
725    int tf_select_rsv;
726    int tf_changed;
727    int logp;
728    celt_uint32 budget;
729    celt_uint32 tell;
730    budget = enc->storage*8;
731    tell = ec_tell(enc);
732    logp = isTransient ? 2 : 4;
733    /* Reserve space to code the tf_select decision. */
734    tf_select_rsv = LM>0 && tell+logp+1 <= budget;
735    budget -= tf_select_rsv;
736    curr = tf_changed = 0;
737    for (i=start;i<end;i++)
738    {
739       if (tell+logp<=budget)
740       {
741          ec_enc_bit_logp(enc, tf_res[i] ^ curr, logp);
742          tell = ec_tell(enc);
743          curr = tf_res[i];
744          tf_changed |= curr;
745       }
746       else
747          tf_res[i] = curr;
748       logp = isTransient ? 4 : 5;
749    }
750    /* Only code tf_select if it would actually make a difference. */
751    if (tf_select_rsv &&
752          tf_select_table[LM][4*isTransient+0+tf_changed]!=
753          tf_select_table[LM][4*isTransient+2+tf_changed])
754       ec_enc_bit_logp(enc, tf_select, 1);
755    else
756       tf_select = 0;
757    for (i=start;i<end;i++)
758       tf_res[i] = tf_select_table[LM][4*isTransient+2*tf_select+tf_res[i]];
759    /*printf("%d %d ", isTransient, tf_select); for(i=0;i<end;i++)printf("%d ", tf_res[i]);printf("\n");*/
760 }
761
762 static void tf_decode(int start, int end, int isTransient, int *tf_res, int LM, ec_dec *dec)
763 {
764    int i, curr, tf_select;
765    int tf_select_rsv;
766    int tf_changed;
767    int logp;
768    celt_uint32 budget;
769    celt_uint32 tell;
770
771    budget = dec->storage*8;
772    tell = ec_tell(dec);
773    logp = isTransient ? 2 : 4;
774    tf_select_rsv = LM>0 && tell+logp+1<=budget;
775    budget -= tf_select_rsv;
776    tf_changed = curr = 0;
777    for (i=start;i<end;i++)
778    {
779       if (tell+logp<=budget)
780       {
781          curr ^= ec_dec_bit_logp(dec, logp);
782          tell = ec_tell(dec);
783          tf_changed |= curr;
784       }
785       tf_res[i] = curr;
786       logp = isTransient ? 4 : 5;
787    }
788    tf_select = 0;
789    if (tf_select_rsv &&
790      tf_select_table[LM][4*isTransient+0+tf_changed] !=
791      tf_select_table[LM][4*isTransient+2+tf_changed])
792    {
793       tf_select = ec_dec_bit_logp(dec, 1);
794    }
795    for (i=start;i<end;i++)
796    {
797       tf_res[i] = tf_select_table[LM][4*isTransient+2*tf_select+tf_res[i]];
798    }
799 }
800
801 static void init_caps(const CELTMode *m,int *cap,int LM,int C)
802 {
803    int i;
804    for (i=0;i<m->nbEBands;i++)
805    {
806       int N;
807       N=(m->eBands[i+1]-m->eBands[i])<<LM;
808       cap[i] = (m->cache.caps[m->nbEBands*(2*LM+C-1)+i]+64)*C*N>>2;
809    }
810 }
811
812 static int alloc_trim_analysis(const CELTMode *m, const celt_norm *X,
813       const celt_word16 *bandLogE, int end, int LM, int C, int N0)
814 {
815    int i;
816    celt_word32 diff=0;
817    int c;
818    int trim_index = 5;
819    if (C==2)
820    {
821       celt_word16 sum = 0; /* Q10 */
822       /* Compute inter-channel correlation for low frequencies */
823       for (i=0;i<8;i++)
824       {
825          int j;
826          celt_word32 partial = 0;
827          for (j=m->eBands[i]<<LM;j<m->eBands[i+1]<<LM;j++)
828             partial = MAC16_16(partial, X[j], X[N0+j]);
829          sum = ADD16(sum, EXTRACT16(SHR32(partial, 18)));
830       }
831       sum = MULT16_16_Q15(QCONST16(1.f/8, 15), sum);
832       /*printf ("%f\n", sum);*/
833       if (sum > QCONST16(.995f,10))
834          trim_index-=4;
835       else if (sum > QCONST16(.92f,10))
836          trim_index-=3;
837       else if (sum > QCONST16(.85f,10))
838          trim_index-=2;
839       else if (sum > QCONST16(.8f,10))
840          trim_index-=1;
841    }
842
843    /* Estimate spectral tilt */
844    c=0; do {
845       for (i=0;i<end-1;i++)
846       {
847          diff += bandLogE[i+c*m->nbEBands]*(celt_int32)(2+2*i-m->nbEBands);
848       }
849    } while (++c<0);
850    diff /= C*(end-1);
851    /*printf("%f\n", diff);*/
852    if (diff > QCONST16(2.f, DB_SHIFT))
853       trim_index--;
854    if (diff > QCONST16(8.f, DB_SHIFT))
855       trim_index--;
856    if (diff < -QCONST16(4.f, DB_SHIFT))
857       trim_index++;
858    if (diff < -QCONST16(10.f, DB_SHIFT))
859       trim_index++;
860
861    if (trim_index<0)
862       trim_index = 0;
863    if (trim_index>10)
864       trim_index = 10;
865    return trim_index;
866 }
867
868 static int stereo_analysis(const CELTMode *m, const celt_norm *X,
869       int LM, int N0)
870 {
871    int i;
872    int thetas;
873    celt_word32 sumLR = EPSILON, sumMS = EPSILON;
874
875    /* Use the L1 norm to model the entropy of the L/R signal vs the M/S signal */
876    for (i=0;i<13;i++)
877    {
878       int j;
879       for (j=m->eBands[i]<<LM;j<m->eBands[i+1]<<LM;j++)
880       {
881          celt_word16 L, R, M, S;
882          L = X[j];
883          R = X[N0+j];
884          M = L+R;
885          S = L-R;
886          sumLR += EXTEND32(ABS16(L)) + EXTEND32(ABS16(R));
887          sumMS += EXTEND32(ABS16(M)) + EXTEND32(ABS16(S));
888       }
889    }
890    sumMS = MULT16_32_Q15(QCONST16(0.707107f, 15), sumMS);
891    thetas = 13;
892    /* We don't need thetas for lower bands with LM<=1 */
893    if (LM<=1)
894       thetas -= 8;
895    return MULT16_32_Q15((m->eBands[13]<<(LM+1))+thetas, sumMS)
896          > MULT16_32_Q15(m->eBands[13]<<(LM+1), sumLR);
897 }
898
899 #ifdef FIXED_POINT
900 CELT_STATIC
901 int celt_encode_with_ec(CELTEncoder * restrict st, const celt_int16 * pcm, int frame_size, unsigned char *compressed, int nbCompressedBytes, ec_enc *enc)
902 {
903 #else
904 CELT_STATIC
905 int celt_encode_with_ec_float(CELTEncoder * restrict st, const celt_sig * pcm, int frame_size, unsigned char *compressed, int nbCompressedBytes, ec_enc *enc)
906 {
907 #endif
908    int i, c, N;
909    celt_int32 bits;
910    ec_enc _enc;
911    VARDECL(celt_sig, in);
912    VARDECL(celt_sig, freq);
913    VARDECL(celt_norm, X);
914    VARDECL(celt_ener, bandE);
915    VARDECL(celt_word16, bandLogE);
916    VARDECL(int, fine_quant);
917    VARDECL(celt_word16, error);
918    VARDECL(int, pulses);
919    VARDECL(int, cap);
920    VARDECL(int, offsets);
921    VARDECL(int, fine_priority);
922    VARDECL(int, tf_res);
923    VARDECL(unsigned char, collapse_masks);
924    celt_sig *_overlap_mem;
925    celt_sig *prefilter_mem;
926    celt_word16 *oldBandE, *oldLogE, *oldLogE2;
927    int shortBlocks=0;
928    int isTransient=0;
929    int resynth;
930    const int CC = CHANNELS(st->channels);
931    const int C = CHANNELS(st->stream_channels);
932    int LM, M;
933    int tf_select;
934    int nbFilledBytes, nbAvailableBytes;
935    int effEnd;
936    int codedBands;
937    int tf_sum;
938    int alloc_trim;
939    int pitch_index=COMBFILTER_MINPERIOD;
940    celt_word16 gain1 = 0;
941    int intensity=0;
942    int dual_stereo=0;
943    int effectiveBytes;
944    celt_word16 pf_threshold;
945    int dynalloc_logp;
946    celt_int32 vbr_rate;
947    celt_int32 total_bits;
948    celt_int32 total_boost;
949    celt_int32 balance;
950    celt_int32 tell;
951    int prefilter_tapset=0;
952    int pf_on;
953    int anti_collapse_rsv;
954    int anti_collapse_on=0;
955    int silence=0;
956    ALLOC_STACK;
957
958    if (nbCompressedBytes<2 || pcm==NULL)
959      return CELT_BAD_ARG;
960
961    frame_size *= st->upsample;
962    for (LM=0;LM<=st->mode->maxLM;LM++)
963       if (st->mode->shortMdctSize<<LM==frame_size)
964          break;
965    if (LM>st->mode->maxLM)
966       return CELT_BAD_ARG;
967    M=1<<LM;
968    N = M*st->mode->shortMdctSize;
969
970    prefilter_mem = st->in_mem+CC*(st->overlap);
971    _overlap_mem = prefilter_mem+CC*COMBFILTER_MAXPERIOD;
972    /*_overlap_mem = st->in_mem+C*(st->overlap);*/
973    oldBandE = (celt_word16*)(st->in_mem+CC*(2*st->overlap+COMBFILTER_MAXPERIOD));
974    oldLogE = oldBandE + CC*st->mode->nbEBands;
975    oldLogE2 = oldLogE + CC*st->mode->nbEBands;
976
977    if (enc==NULL)
978    {
979       tell=1;
980       nbFilledBytes=0;
981    } else {
982       tell=ec_tell(enc);
983       nbFilledBytes=(tell+4)>>3;
984    }
985
986    if (st->signalling && enc==NULL)
987    {
988       int tmp = (st->mode->effEBands-st->end)>>1;
989       st->end = IMAX(1, st->mode->effEBands-tmp);
990       compressed[0] = tmp<<5;
991       compressed[0] |= LM<<3;
992       compressed[0] |= (C==2)<<2;
993       /* Convert "standard mode" to Opus header */
994       if (st->mode->Fs==48000 && st->mode->shortMdctSize==120)
995       {
996          int c0 = toOpus(compressed[0]);
997          if (c0<0)
998             return CELT_BAD_ARG;
999          compressed[0] = c0;
1000       }
1001       compressed++;
1002       nbCompressedBytes--;
1003    }
1004
1005    /* Can't produce more than 1275 output bytes */
1006    nbCompressedBytes = IMIN(nbCompressedBytes,1275);
1007    nbAvailableBytes = nbCompressedBytes - nbFilledBytes;
1008
1009    if (st->vbr)
1010    {
1011       celt_int32 den=st->mode->Fs>>BITRES;
1012       vbr_rate=(st->bitrate*frame_size+(den>>1))/den;
1013       if (st->signalling)
1014          vbr_rate -= 8<<BITRES;
1015       effectiveBytes = vbr_rate>>(3+BITRES);
1016    } else {
1017       celt_int32 tmp;
1018       vbr_rate = 0;
1019       tmp = st->bitrate*frame_size;
1020       if (tell>1)
1021          tmp += tell;
1022       nbCompressedBytes = IMAX(2, IMIN(nbCompressedBytes,
1023             (tmp+4*st->mode->Fs)/(8*st->mode->Fs)-!!st->signalling));
1024       effectiveBytes = nbCompressedBytes;
1025    }
1026
1027    if (enc==NULL)
1028    {
1029       ec_enc_init(&_enc, compressed, nbCompressedBytes);
1030       enc = &_enc;
1031    }
1032
1033    if (vbr_rate>0)
1034    {
1035       /* Computes the max bit-rate allowed in VBR mode to avoid violating the
1036           target rate and buffering.
1037          We must do this up front so that bust-prevention logic triggers
1038           correctly if we don't have enough bits. */
1039       if (st->constrained_vbr)
1040       {
1041          celt_int32 vbr_bound;
1042          celt_int32 max_allowed;
1043          /* We could use any multiple of vbr_rate as bound (depending on the
1044              delay).
1045             This is clamped to ensure we use at least two bytes if the encoder
1046              was entirely empty, but to allow 0 in hybrid mode. */
1047          vbr_bound = vbr_rate;
1048          max_allowed = IMIN(IMAX(tell==1?2:0,
1049                vbr_rate+vbr_bound-st->vbr_reservoir>>(BITRES+3)),
1050                nbAvailableBytes);
1051          if(max_allowed < nbAvailableBytes)
1052          {
1053             nbCompressedBytes = nbFilledBytes+max_allowed;
1054             nbAvailableBytes = max_allowed;
1055             ec_enc_shrink(enc, nbCompressedBytes);
1056          }
1057       }
1058    }
1059    total_bits = nbCompressedBytes*8;
1060
1061    effEnd = st->end;
1062    if (effEnd > st->mode->effEBands)
1063       effEnd = st->mode->effEBands;
1064
1065    ALLOC(in, CC*(N+st->overlap), celt_sig);
1066
1067    /* Find pitch period and gain */
1068    {
1069       VARDECL(celt_sig, _pre);
1070       celt_sig *pre[2];
1071       SAVE_STACK;
1072       ALLOC(_pre, CC*(N+COMBFILTER_MAXPERIOD), celt_sig);
1073
1074       pre[0] = _pre;
1075       pre[1] = _pre + (N+COMBFILTER_MAXPERIOD);
1076
1077       silence = 1;
1078       c=0; do {
1079          int count = 0;
1080          const celt_word16 * restrict pcmp = pcm+c;
1081          celt_sig * restrict inp = in+c*(N+st->overlap)+st->overlap;
1082
1083          for (i=0;i<N;i++)
1084          {
1085             celt_sig x, tmp;
1086
1087             x = SCALEIN(*pcmp);
1088 #ifndef FIXED_POINT
1089             if (!(x==x))
1090                x = 0;
1091             if (st->clip)
1092                x = MAX32(-65536.f, MIN32(65536.f,x));
1093 #endif
1094             if (++count==st->upsample)
1095             {
1096                count=0;
1097                pcmp+=CC;
1098             } else {
1099                x = 0;
1100             }
1101             /* Apply pre-emphasis */
1102             tmp = MULT16_16(st->mode->preemph[2], x);
1103             *inp = tmp + st->preemph_memE[c];
1104             st->preemph_memE[c] = MULT16_32_Q15(st->mode->preemph[1], *inp)
1105                                    - MULT16_32_Q15(st->mode->preemph[0], tmp);
1106             silence = silence && *inp == 0;
1107             inp++;
1108          }
1109          CELT_COPY(pre[c], prefilter_mem+c*COMBFILTER_MAXPERIOD, COMBFILTER_MAXPERIOD);
1110          CELT_COPY(pre[c]+COMBFILTER_MAXPERIOD, in+c*(N+st->overlap)+st->overlap, N);
1111       } while (++c<CC);
1112
1113       if (tell==1)
1114          ec_enc_bit_logp(enc, silence, 15);
1115       else
1116          silence=0;
1117       if (silence)
1118       {
1119          /*In VBR mode there is no need to send more than the minimum. */
1120          if (vbr_rate>0)
1121          {
1122             effectiveBytes=nbCompressedBytes=IMIN(nbCompressedBytes, nbFilledBytes+2);
1123             total_bits=nbCompressedBytes*8;
1124             nbAvailableBytes=2;
1125             ec_enc_shrink(enc, nbCompressedBytes);
1126          }
1127          /* Pretend we've filled all the remaining bits with zeros
1128             (that's what the initialiser did anyway) */
1129          tell = nbCompressedBytes*8;
1130          enc->nbits_total+=tell-ec_tell(enc);
1131       }
1132 #ifdef ENABLE_POSTFILTER
1133       if (nbAvailableBytes>12*C && st->start==0 && !silence && !st->disable_pf && st->complexity >= 5)
1134       {
1135          VARDECL(celt_word16, pitch_buf);
1136          ALLOC(pitch_buf, (COMBFILTER_MAXPERIOD+N)>>1, celt_word16);
1137
1138          pitch_downsample(pre, pitch_buf, COMBFILTER_MAXPERIOD+N, CC);
1139          pitch_search(pitch_buf+(COMBFILTER_MAXPERIOD>>1), pitch_buf, N,
1140                COMBFILTER_MAXPERIOD-COMBFILTER_MINPERIOD, &pitch_index);
1141          pitch_index = COMBFILTER_MAXPERIOD-pitch_index;
1142
1143          gain1 = remove_doubling(pitch_buf, COMBFILTER_MAXPERIOD, COMBFILTER_MINPERIOD,
1144                N, &pitch_index, st->prefilter_period, st->prefilter_gain);
1145          if (pitch_index > COMBFILTER_MAXPERIOD-2)
1146             pitch_index = COMBFILTER_MAXPERIOD-2;
1147          gain1 = MULT16_16_Q15(QCONST16(.7f,15),gain1);
1148          if (st->loss_rate>2)
1149             gain1 = HALF32(gain1);
1150          if (st->loss_rate>4)
1151             gain1 = HALF32(gain1);
1152          if (st->loss_rate>8)
1153             gain1 = 0;
1154          prefilter_tapset = st->tapset_decision;
1155       } else {
1156          gain1 = 0;
1157       }
1158
1159       /* Gain threshold for enabling the prefilter/postfilter */
1160       pf_threshold = QCONST16(.2f,15);
1161
1162       /* Adjusting the threshold based on rate and continuity */
1163       if (abs(pitch_index-st->prefilter_period)*10>pitch_index)
1164          pf_threshold += QCONST16(.2f,15);
1165       if (nbAvailableBytes<25)
1166          pf_threshold += QCONST16(.1f,15);
1167       if (nbAvailableBytes<35)
1168          pf_threshold += QCONST16(.1f,15);
1169       if (st->prefilter_gain > QCONST16(.4f,15))
1170          pf_threshold -= QCONST16(.1f,15);
1171       if (st->prefilter_gain > QCONST16(.55f,15))
1172          pf_threshold -= QCONST16(.1f,15);
1173
1174       /* Hard threshold at 0.2 */
1175       pf_threshold = MAX16(pf_threshold, QCONST16(.2f,15));
1176       if (gain1<pf_threshold)
1177       {
1178          if(st->start==0 && tell+16<=total_bits)
1179             ec_enc_bit_logp(enc, 0, 1);
1180          gain1 = 0;
1181          pf_on = 0;
1182       } else {
1183          /*This block is not gated by a total bits check only because
1184            of the nbAvailableBytes check above.*/
1185          int qg;
1186          int octave;
1187
1188          if (ABS16(gain1-st->prefilter_gain)<QCONST16(.1f,15))
1189             gain1=st->prefilter_gain;
1190
1191 #ifdef FIXED_POINT
1192          qg = ((gain1+1536)>>10)/3-1;
1193 #else
1194          qg = floor(.5+gain1*32/3)-1;
1195 #endif
1196          qg = IMAX(0, IMIN(7, qg));
1197          ec_enc_bit_logp(enc, 1, 1);
1198          pitch_index += 1;
1199          octave = EC_ILOG(pitch_index)-5;
1200          ec_enc_uint(enc, octave, 6);
1201          ec_enc_bits(enc, pitch_index-(16<<octave), 4+octave);
1202          pitch_index -= 1;
1203          ec_enc_bits(enc, qg, 3);
1204          if (ec_tell(enc)+2<=total_bits)
1205             ec_enc_icdf(enc, prefilter_tapset, tapset_icdf, 2);
1206          else
1207            prefilter_tapset = 0;
1208          gain1 = QCONST16(0.09375f,15)*(qg+1);
1209          pf_on = 1;
1210       }
1211       /*printf("%d %f\n", pitch_index, gain1);*/
1212 #else /* ENABLE_POSTFILTER */
1213       if(st->start==0 && tell+16<=total_bits)
1214          ec_enc_bit_logp(enc, 0, 1);
1215       pf_on = 0;
1216 #endif /* ENABLE_POSTFILTER */
1217
1218       c=0; do {
1219          int offset = st->mode->shortMdctSize-st->mode->overlap;
1220          st->prefilter_period=IMAX(st->prefilter_period, COMBFILTER_MINPERIOD);
1221          CELT_COPY(in+c*(N+st->overlap), st->in_mem+c*(st->overlap), st->overlap);
1222 #ifdef ENABLE_POSTFILTER
1223          if (offset)
1224             comb_filter(in+c*(N+st->overlap)+st->overlap, pre[c]+COMBFILTER_MAXPERIOD,
1225                   st->prefilter_period, st->prefilter_period, offset, -st->prefilter_gain, -st->prefilter_gain,
1226                   st->prefilter_tapset, st->prefilter_tapset, NULL, 0);
1227
1228          comb_filter(in+c*(N+st->overlap)+st->overlap+offset, pre[c]+COMBFILTER_MAXPERIOD+offset,
1229                st->prefilter_period, pitch_index, N-offset, -st->prefilter_gain, -gain1,
1230                st->prefilter_tapset, prefilter_tapset, st->mode->window, st->mode->overlap);
1231 #endif /* ENABLE_POSTFILTER */
1232          CELT_COPY(st->in_mem+c*(st->overlap), in+c*(N+st->overlap)+N, st->overlap);
1233
1234 #ifdef ENABLE_POSTFILTER
1235          if (N>COMBFILTER_MAXPERIOD)
1236          {
1237             CELT_MOVE(prefilter_mem+c*COMBFILTER_MAXPERIOD, pre[c]+N, COMBFILTER_MAXPERIOD);
1238          } else {
1239             CELT_MOVE(prefilter_mem+c*COMBFILTER_MAXPERIOD, prefilter_mem+c*COMBFILTER_MAXPERIOD+N, COMBFILTER_MAXPERIOD-N);
1240             CELT_MOVE(prefilter_mem+c*COMBFILTER_MAXPERIOD+COMBFILTER_MAXPERIOD-N, pre[c]+COMBFILTER_MAXPERIOD, N);
1241          }
1242 #endif /* ENABLE_POSTFILTER */
1243       } while (++c<CC);
1244
1245       RESTORE_STACK;
1246    }
1247
1248 #ifdef RESYNTH
1249    resynth = 1;
1250 #else
1251    resynth = 0;
1252 #endif
1253
1254    isTransient = 0;
1255    shortBlocks = 0;
1256    if (LM>0 && ec_tell(enc)+3<=total_bits)
1257    {
1258       if (st->complexity > 1)
1259       {
1260          isTransient = transient_analysis(in, N+st->overlap, CC,
1261                   st->overlap);
1262          if (isTransient)
1263             shortBlocks = M;
1264       }
1265       ec_enc_bit_logp(enc, isTransient, 3);
1266    }
1267
1268    ALLOC(freq, CC*N, celt_sig); /**< Interleaved signal MDCTs */
1269    ALLOC(bandE,st->mode->nbEBands*CC, celt_ener);
1270    ALLOC(bandLogE,st->mode->nbEBands*CC, celt_word16);
1271    /* Compute MDCTs */
1272    compute_mdcts(st->mode, shortBlocks, in, freq, CC, LM);
1273
1274    if (CC==2&&C==1)
1275    {
1276       for (i=0;i<N;i++)
1277          freq[i] = ADD32(HALF32(freq[i]), HALF32(freq[N+i]));
1278    }
1279    if (st->upsample != 1)
1280    {
1281       c=0; do
1282       {
1283          int bound = N/st->upsample;
1284          for (i=0;i<bound;i++)
1285             freq[c*N+i] *= st->upsample;
1286          for (;i<N;i++)
1287             freq[c*N+i] = 0;
1288       } while (++c<C);
1289    }
1290    ALLOC(X, C*N, celt_norm);         /**< Interleaved normalised MDCTs */
1291
1292    compute_band_energies(st->mode, freq, bandE, effEnd, C, M);
1293
1294    amp2Log2(st->mode, effEnd, st->end, bandE, bandLogE, C);
1295
1296    /* Band normalisation */
1297    normalise_bands(st->mode, freq, X, bandE, effEnd, C, M);
1298
1299    ALLOC(tf_res, st->mode->nbEBands, int);
1300    /* Needs to be before coarse energy quantization because otherwise the energy gets modified */
1301    tf_select = tf_analysis(st->mode, bandLogE, oldBandE, effEnd, C, isTransient, tf_res, effectiveBytes, X, N, LM, &tf_sum);
1302    for (i=effEnd;i<st->end;i++)
1303       tf_res[i] = tf_res[effEnd-1];
1304
1305    ALLOC(error, C*st->mode->nbEBands, celt_word16);
1306    quant_coarse_energy(st->mode, st->start, st->end, effEnd, bandLogE,
1307          oldBandE, total_bits, error, enc,
1308          C, LM, nbAvailableBytes, st->force_intra,
1309          &st->delayedIntra, st->complexity >= 4, st->loss_rate);
1310
1311    tf_encode(st->start, st->end, isTransient, tf_res, LM, tf_select, enc);
1312
1313    st->spread_decision = SPREAD_NORMAL;
1314    if (ec_tell(enc)+4<=total_bits)
1315    {
1316       if (shortBlocks || st->complexity < 3 || nbAvailableBytes < 10*C)
1317       {
1318          if (st->complexity == 0)
1319             st->spread_decision = SPREAD_NONE;
1320       } else {
1321          st->spread_decision = spreading_decision(st->mode, X,
1322                &st->tonal_average, st->spread_decision, &st->hf_average,
1323                &st->tapset_decision, pf_on&&!shortBlocks, effEnd, C, M);
1324       }
1325       ec_enc_icdf(enc, st->spread_decision, spread_icdf, 5);
1326    }
1327
1328    ALLOC(cap, st->mode->nbEBands, int);
1329    ALLOC(offsets, st->mode->nbEBands, int);
1330
1331    init_caps(st->mode,cap,LM,C);
1332    for (i=0;i<st->mode->nbEBands;i++)
1333       offsets[i] = 0;
1334    /* Dynamic allocation code */
1335    /* Make sure that dynamic allocation can't make us bust the budget */
1336    if (effectiveBytes > 50 && LM>=1)
1337    {
1338       int t1, t2;
1339       if (LM <= 1)
1340       {
1341          t1 = 3;
1342          t2 = 5;
1343       } else {
1344          t1 = 2;
1345          t2 = 4;
1346       }
1347       for (i=st->start+1;i<st->end-1;i++)
1348       {
1349          celt_word32 d2;
1350          d2 = 2*bandLogE[i]-bandLogE[i-1]-bandLogE[i+1];
1351          if (C==2)
1352             d2 = HALF32(d2 + 2*bandLogE[i+st->mode->nbEBands]-
1353                   bandLogE[i-1+st->mode->nbEBands]-bandLogE[i+1+st->mode->nbEBands]);
1354          if (d2 > SHL16(t1,DB_SHIFT))
1355             offsets[i] += 1;
1356          if (d2 > SHL16(t2,DB_SHIFT))
1357             offsets[i] += 1;
1358       }
1359    }
1360    dynalloc_logp = 6;
1361    total_bits<<=BITRES;
1362    total_boost = 0;
1363    tell = ec_tell_frac(enc);
1364    for (i=st->start;i<st->end;i++)
1365    {
1366       int width, quanta;
1367       int dynalloc_loop_logp;
1368       int boost;
1369       int j;
1370       width = C*(st->mode->eBands[i+1]-st->mode->eBands[i])<<LM;
1371       /* quanta is 6 bits, but no more than 1 bit/sample
1372          and no less than 1/8 bit/sample */
1373       quanta = IMIN(width<<BITRES, IMAX(6<<BITRES, width));
1374       dynalloc_loop_logp = dynalloc_logp;
1375       boost = 0;
1376       for (j = 0; tell+(dynalloc_loop_logp<<BITRES) < total_bits-total_boost
1377             && boost < cap[i]; j++)
1378       {
1379          int flag;
1380          flag = j<offsets[i];
1381          ec_enc_bit_logp(enc, flag, dynalloc_loop_logp);
1382          tell = ec_tell_frac(enc);
1383          if (!flag)
1384             break;
1385          boost += quanta;
1386          total_boost += quanta;
1387          dynalloc_loop_logp = 1;
1388       }
1389       /* Making dynalloc more likely */
1390       if (j)
1391          dynalloc_logp = IMAX(2, dynalloc_logp-1);
1392       offsets[i] = boost;
1393    }
1394    alloc_trim = 5;
1395    if (tell+(6<<BITRES) <= total_bits - total_boost)
1396    {
1397       alloc_trim = alloc_trim_analysis(st->mode, X, bandLogE,
1398             st->end, LM, C, N);
1399       ec_enc_icdf(enc, alloc_trim, trim_icdf, 7);
1400       tell = ec_tell_frac(enc);
1401    }
1402
1403    /* Variable bitrate */
1404    if (vbr_rate>0)
1405    {
1406      celt_word16 alpha;
1407      celt_int32 delta;
1408      /* The target rate in 8th bits per frame */
1409      celt_int32 target;
1410      celt_int32 min_allowed;
1411
1412      target = vbr_rate + st->vbr_offset - ((40*C+20)<<BITRES);
1413
1414      /* Shortblocks get a large boost in bitrate, but since they
1415         are uncommon long blocks are not greatly affected */
1416      if (shortBlocks || tf_sum < -2*(st->end-st->start))
1417         target = 7*target/4;
1418      else if (tf_sum < -(st->end-st->start))
1419         target = 3*target/2;
1420      else if (M > 1)
1421         target-=(target+14)/28;
1422
1423      /* The current offset is removed from the target and the space used
1424         so far is added*/
1425      target=target+tell;
1426
1427      /* In VBR mode the frame size must not be reduced so much that it would
1428          result in the encoder running out of bits.
1429         The margin of 2 bytes ensures that none of the bust-prevention logic
1430          in the decoder will have triggered so far. */
1431      min_allowed = (tell+total_boost+(1<<BITRES+3)-1>>(BITRES+3)) + 2 - nbFilledBytes;
1432
1433      nbAvailableBytes = target+(1<<(BITRES+2))>>(BITRES+3);
1434      nbAvailableBytes = IMAX(min_allowed,nbAvailableBytes);
1435      nbAvailableBytes = IMIN(nbCompressedBytes,nbAvailableBytes+nbFilledBytes) - nbFilledBytes;
1436
1437      /* By how much did we "miss" the target on that frame */
1438      delta = target - vbr_rate;
1439
1440      target=nbAvailableBytes<<(BITRES+3);
1441
1442      /*If the frame is silent we don't adjust our drift, otherwise
1443        the encoder will shoot to very high rates after hitting a
1444        span of silence, but we do allow the bitres to refill.
1445        This means that we'll undershoot our target in CVBR/VBR modes
1446        on files with lots of silence. */
1447      if(silence)
1448      {
1449        nbAvailableBytes = 2;
1450        target = 2*8<<BITRES;
1451        delta = 0;
1452      }
1453
1454      if (st->vbr_count < 970)
1455      {
1456         st->vbr_count++;
1457         alpha = celt_rcp(SHL32(EXTEND32(st->vbr_count+20),16));
1458      } else
1459         alpha = QCONST16(.001f,15);
1460      /* How many bits have we used in excess of what we're allowed */
1461      if (st->constrained_vbr)
1462         st->vbr_reservoir += target - vbr_rate;
1463      /*printf ("%d\n", st->vbr_reservoir);*/
1464
1465      /* Compute the offset we need to apply in order to reach the target */
1466      st->vbr_drift += (celt_int32)MULT16_32_Q15(alpha,delta-st->vbr_offset-st->vbr_drift);
1467      st->vbr_offset = -st->vbr_drift;
1468      /*printf ("%d\n", st->vbr_drift);*/
1469
1470      if (st->constrained_vbr && st->vbr_reservoir < 0)
1471      {
1472         /* We're under the min value -- increase rate */
1473         int adjust = (-st->vbr_reservoir)/(8<<BITRES);
1474         /* Unless we're just coding silence */
1475         nbAvailableBytes += silence?0:adjust;
1476         st->vbr_reservoir = 0;
1477         /*printf ("+%d\n", adjust);*/
1478      }
1479      nbCompressedBytes = IMIN(nbCompressedBytes,nbAvailableBytes+nbFilledBytes);
1480      /* This moves the raw bits to take into account the new compressed size */
1481      ec_enc_shrink(enc, nbCompressedBytes);
1482    }
1483    if (C==2)
1484    {
1485       int effectiveRate;
1486
1487       /* Always use MS for 2.5 ms frames until we can do a better analysis */
1488       if (LM!=0)
1489          dual_stereo = stereo_analysis(st->mode, X, LM, N);
1490
1491       /* Account for coarse energy */
1492       effectiveRate = (8*effectiveBytes - 80)>>LM;
1493
1494       /* effectiveRate in kb/s */
1495       effectiveRate = 2*effectiveRate/5;
1496       if (effectiveRate<35)
1497          intensity = 8;
1498       else if (effectiveRate<50)
1499          intensity = 12;
1500       else if (effectiveRate<68)
1501          intensity = 16;
1502       else if (effectiveRate<84)
1503          intensity = 18;
1504       else if (effectiveRate<102)
1505          intensity = 19;
1506       else if (effectiveRate<130)
1507          intensity = 20;
1508       else
1509          intensity = 100;
1510       intensity = IMIN(st->end,IMAX(st->start, intensity));
1511    }
1512
1513    /* Bit allocation */
1514    ALLOC(fine_quant, st->mode->nbEBands, int);
1515    ALLOC(pulses, st->mode->nbEBands, int);
1516    ALLOC(fine_priority, st->mode->nbEBands, int);
1517
1518    /* bits =           packet size                    - where we are - safety*/
1519    bits = ((celt_int32)nbCompressedBytes*8<<BITRES) - ec_tell_frac(enc) - 1;
1520    anti_collapse_rsv = isTransient&&LM>=2&&bits>=(LM+2<<BITRES) ? (1<<BITRES) : 0;
1521    bits -= anti_collapse_rsv;
1522    codedBands = compute_allocation(st->mode, st->start, st->end, offsets, cap,
1523          alloc_trim, &intensity, &dual_stereo, bits, &balance, pulses,
1524          fine_quant, fine_priority, C, LM, enc, 1, st->lastCodedBands);
1525    st->lastCodedBands = codedBands;
1526
1527    quant_fine_energy(st->mode, st->start, st->end, oldBandE, error, fine_quant, enc, C);
1528
1529 #ifdef MEASURE_NORM_MSE
1530    float X0[3000];
1531    float bandE0[60];
1532    c=0; do 
1533       for (i=0;i<N;i++)
1534          X0[i+c*N] = X[i+c*N];
1535    while (++c<C);
1536    for (i=0;i<C*st->mode->nbEBands;i++)
1537       bandE0[i] = bandE[i];
1538 #endif
1539
1540    /* Residual quantisation */
1541    ALLOC(collapse_masks, C*st->mode->nbEBands, unsigned char);
1542    quant_all_bands(1, st->mode, st->start, st->end, X, C==2 ? X+N : NULL, collapse_masks,
1543          bandE, pulses, shortBlocks, st->spread_decision, dual_stereo, intensity, tf_res, resynth,
1544          nbCompressedBytes*(8<<BITRES)-anti_collapse_rsv, balance, enc, LM, codedBands, &st->rng);
1545
1546    if (anti_collapse_rsv > 0)
1547    {
1548       anti_collapse_on = st->consec_transient<2;
1549       ec_enc_bits(enc, anti_collapse_on, 1);
1550    }
1551    quant_energy_finalise(st->mode, st->start, st->end, oldBandE, error, fine_quant, fine_priority, nbCompressedBytes*8-ec_tell(enc), enc, C);
1552
1553    if (silence)
1554    {
1555       for (i=0;i<C*st->mode->nbEBands;i++)
1556          oldBandE[i] = -QCONST16(28.f,DB_SHIFT);
1557    }
1558
1559 #ifdef RESYNTH
1560    /* Re-synthesis of the coded audio if required */
1561    if (resynth)
1562    {
1563       celt_sig *out_mem[2];
1564       celt_sig *overlap_mem[2];
1565
1566       log2Amp(st->mode, st->start, st->end, bandE, oldBandE, C);
1567       if (silence)
1568       {
1569          for (i=0;i<C*st->mode->nbEBands;i++)
1570             bandE[i] = 0;
1571       }
1572
1573 #ifdef MEASURE_NORM_MSE
1574       measure_norm_mse(st->mode, X, X0, bandE, bandE0, M, N, C);
1575 #endif
1576       if (anti_collapse_on)
1577       {
1578          anti_collapse(st->mode, X, collapse_masks, LM, C, CC, N,
1579                st->start, st->end, oldBandE, oldLogE, oldLogE2, pulses, st->rng);
1580       }
1581
1582       /* Synthesis */
1583       denormalise_bands(st->mode, X, freq, bandE, effEnd, C, M);
1584
1585       CELT_MOVE(st->syn_mem[0], st->syn_mem[0]+N, MAX_PERIOD);
1586       if (CC==2)
1587          CELT_MOVE(st->syn_mem[1], st->syn_mem[1]+N, MAX_PERIOD);
1588
1589       c=0; do
1590          for (i=0;i<M*st->mode->eBands[st->start];i++)
1591             freq[c*N+i] = 0;
1592       while (++c<C);
1593       c=0; do
1594          for (i=M*st->mode->eBands[st->end];i<N;i++)
1595             freq[c*N+i] = 0;
1596       while (++c<C);
1597
1598       if (CC==2&&C==1)
1599       {
1600          for (i=0;i<N;i++)
1601             freq[N+i] = freq[i];
1602       }
1603
1604       out_mem[0] = st->syn_mem[0]+MAX_PERIOD;
1605       if (CC==2)
1606          out_mem[1] = st->syn_mem[1]+MAX_PERIOD;
1607
1608       c=0; do
1609          overlap_mem[c] = _overlap_mem + c*st->overlap;
1610       while (++c<CC);
1611
1612       compute_inv_mdcts(st->mode, shortBlocks, freq, out_mem, overlap_mem, CC, LM);
1613
1614 #ifdef ENABLE_POSTFILTER
1615       c=0; do {
1616          st->prefilter_period=IMAX(st->prefilter_period, COMBFILTER_MINPERIOD);
1617          st->prefilter_period_old=IMAX(st->prefilter_period_old, COMBFILTER_MINPERIOD);
1618          comb_filter(out_mem[c], out_mem[c], st->prefilter_period_old, st->prefilter_period, st->mode->shortMdctSize,
1619                st->prefilter_gain_old, st->prefilter_gain, st->prefilter_tapset_old, st->prefilter_tapset,
1620                st->mode->window, st->overlap);
1621          if (LM!=0)
1622             comb_filter(out_mem[c]+st->mode->shortMdctSize, out_mem[c]+st->mode->shortMdctSize, st->prefilter_period, pitch_index, N-st->mode->shortMdctSize,
1623                   st->prefilter_gain, gain1, st->prefilter_tapset, prefilter_tapset,
1624                   st->mode->window, st->mode->overlap);
1625       } while (++c<CC);
1626 #endif /* ENABLE_POSTFILTER */
1627
1628       deemphasis(out_mem, (celt_word16*)pcm, N, CC, st->upsample, st->mode->preemph, st->preemph_memD);
1629       st->prefilter_period_old = st->prefilter_period;
1630       st->prefilter_gain_old = st->prefilter_gain;
1631       st->prefilter_tapset_old = st->prefilter_tapset;
1632    }
1633 #endif
1634
1635    st->prefilter_period = pitch_index;
1636    st->prefilter_gain = gain1;
1637    st->prefilter_tapset = prefilter_tapset;
1638 #ifdef RESYNTH
1639    if (LM!=0)
1640    {
1641       st->prefilter_period_old = st->prefilter_period;
1642       st->prefilter_gain_old = st->prefilter_gain;
1643       st->prefilter_tapset_old = st->prefilter_tapset;
1644    }
1645 #endif
1646
1647    if (CC==2&&C==1) {
1648       for (i=0;i<st->mode->nbEBands;i++)
1649          oldBandE[st->mode->nbEBands+i]=oldBandE[i];
1650    }
1651
1652    /* In case start or end were to change */
1653    c=0; do
1654    {
1655       for (i=0;i<st->start;i++)
1656          oldBandE[c*st->mode->nbEBands+i]=0;
1657       for (i=st->end;i<st->mode->nbEBands;i++)
1658          oldBandE[c*st->mode->nbEBands+i]=0;
1659    } while (++c<CC);
1660    if (!isTransient)
1661    {
1662       for (i=0;i<CC*st->mode->nbEBands;i++)
1663          oldLogE2[i] = oldLogE[i];
1664       for (i=0;i<CC*st->mode->nbEBands;i++)
1665          oldLogE[i] = oldBandE[i];
1666    } else {
1667       for (i=0;i<CC*st->mode->nbEBands;i++)
1668          oldLogE[i] = MIN16(oldLogE[i], oldBandE[i]);
1669    }
1670    if (isTransient)
1671       st->consec_transient++;
1672    else
1673       st->consec_transient=0;
1674    st->rng = enc->rng;
1675
1676    /* If there's any room left (can only happen for very high rates),
1677       it's already filled with zeros */
1678    ec_enc_done(enc);
1679    
1680    if (st->signalling)
1681       nbCompressedBytes++;
1682
1683    RESTORE_STACK;
1684    if (ec_get_error(enc))
1685       return CELT_INTERNAL_ERROR;
1686    else
1687       return nbCompressedBytes;
1688 }
1689
1690 #ifdef FIXED_POINT
1691 #ifndef DISABLE_FLOAT_API
1692 CELT_STATIC
1693 int celt_encode_with_ec_float(CELTEncoder * restrict st, const float * pcm, int frame_size, unsigned char *compressed, int nbCompressedBytes, ec_enc *enc)
1694 {
1695    int j, ret, C, N;
1696    VARDECL(celt_int16, in);
1697    ALLOC_STACK;
1698
1699    if (pcm==NULL)
1700       return CELT_BAD_ARG;
1701
1702    C = CHANNELS(st->channels);
1703    N = frame_size;
1704    ALLOC(in, C*N, celt_int16);
1705
1706    for (j=0;j<C*N;j++)
1707      in[j] = FLOAT2INT16(pcm[j]);
1708
1709    ret=celt_encode_with_ec(st,in,frame_size,compressed,nbCompressedBytes, enc);
1710 #ifdef RESYNTH
1711    for (j=0;j<C*N;j++)
1712       ((float*)pcm)[j]=in[j]*(1.f/32768.f);
1713 #endif
1714    RESTORE_STACK;
1715    return ret;
1716
1717 }
1718 #endif /*DISABLE_FLOAT_API*/
1719 #else
1720 CELT_STATIC
1721 int celt_encode_with_ec(CELTEncoder * restrict st, const celt_int16 * pcm, int frame_size, unsigned char *compressed, int nbCompressedBytes, ec_enc *enc)
1722 {
1723    int j, ret, C, N;
1724    VARDECL(celt_sig, in);
1725    ALLOC_STACK;
1726
1727    if (pcm==NULL)
1728       return CELT_BAD_ARG;
1729
1730    C=CHANNELS(st->channels);
1731    N=frame_size;
1732    ALLOC(in, C*N, celt_sig);
1733    for (j=0;j<C*N;j++) {
1734      in[j] = SCALEOUT(pcm[j]);
1735    }
1736
1737    ret = celt_encode_with_ec_float(st,in,frame_size,compressed,nbCompressedBytes, enc);
1738 #ifdef RESYNTH
1739    for (j=0;j<C*N;j++)
1740       ((celt_int16*)pcm)[j] = FLOAT2INT16(in[j]);
1741 #endif
1742    RESTORE_STACK;
1743    return ret;
1744 }
1745 #endif
1746
1747 int celt_encode(CELTEncoder * restrict st, const celt_int16 * pcm, int frame_size, unsigned char *compressed, int nbCompressedBytes)
1748 {
1749    return celt_encode_with_ec(st, pcm, frame_size, compressed, nbCompressedBytes, NULL);
1750 }
1751
1752 #ifndef DISABLE_FLOAT_API
1753 int celt_encode_float(CELTEncoder * restrict st, const float * pcm, int frame_size, unsigned char *compressed, int nbCompressedBytes)
1754 {
1755    return celt_encode_with_ec_float(st, pcm, frame_size, compressed, nbCompressedBytes, NULL);
1756 }
1757 #endif /* DISABLE_FLOAT_API */
1758
1759 int celt_encoder_ctl(CELTEncoder * restrict st, int request, ...)
1760 {
1761    va_list ap;
1762    
1763    va_start(ap, request);
1764    switch (request)
1765    {
1766       case CELT_SET_COMPLEXITY_REQUEST:
1767       {
1768          int value = va_arg(ap, celt_int32);
1769          if (value<0 || value>10)
1770             goto bad_arg;
1771          st->complexity = value;
1772       }
1773       break;
1774       case CELT_SET_START_BAND_REQUEST:
1775       {
1776          celt_int32 value = va_arg(ap, celt_int32);
1777          if (value<0 || value>=st->mode->nbEBands)
1778             goto bad_arg;
1779          st->start = value;
1780       }
1781       break;
1782       case CELT_SET_END_BAND_REQUEST:
1783       {
1784          celt_int32 value = va_arg(ap, celt_int32);
1785          if (value<1 || value>st->mode->nbEBands)
1786             goto bad_arg;
1787          st->end = value;
1788       }
1789       break;
1790       case CELT_SET_PREDICTION_REQUEST:
1791       {
1792          int value = va_arg(ap, celt_int32);
1793          if (value<0 || value>2)
1794             goto bad_arg;
1795          st->disable_pf = value<=1;
1796          st->force_intra = value==0;
1797       }
1798       break;
1799       case CELT_SET_LOSS_PERC_REQUEST:
1800       {
1801          int value = va_arg(ap, celt_int32);
1802          if (value<0 || value>100)
1803             goto bad_arg;
1804          st->loss_rate = value;
1805       }
1806       break;
1807       case CELT_SET_VBR_CONSTRAINT_REQUEST:
1808       {
1809          celt_int32 value = va_arg(ap, celt_int32);
1810          st->constrained_vbr = value;
1811       }
1812       break;
1813       case CELT_SET_VBR_REQUEST:
1814       {
1815          celt_int32 value = va_arg(ap, celt_int32);
1816          st->vbr = value;
1817       }
1818       break;
1819       case CELT_SET_BITRATE_REQUEST:
1820       {
1821          celt_int32 value = va_arg(ap, celt_int32);
1822          if (value<=500)
1823             goto bad_arg;
1824          value = IMIN(value, 260000*st->channels);
1825          st->bitrate = value;
1826       }
1827       break;
1828       case CELT_SET_CHANNELS_REQUEST:
1829       {
1830          celt_int32 value = va_arg(ap, celt_int32);
1831          if (value<1 || value>2)
1832             goto bad_arg;
1833          st->stream_channels = value;
1834       }
1835       break;
1836       case CELT_RESET_STATE:
1837       {
1838          CELT_MEMSET((char*)&st->ENCODER_RESET_START, 0,
1839                celt_encoder_get_size_custom(st->mode, st->channels)-
1840                ((char*)&st->ENCODER_RESET_START - (char*)st));
1841          st->vbr_offset = 0;
1842          st->delayedIntra = 1;
1843          st->spread_decision = SPREAD_NORMAL;
1844          st->tonal_average = QCONST16(1.f,8);
1845       }
1846       break;
1847       case CELT_SET_INPUT_CLIPPING_REQUEST:
1848       {
1849          celt_int32 value = va_arg(ap, celt_int32);
1850          st->clip = value;
1851       }
1852       break;
1853 #ifdef OPUS_BUILD
1854       case CELT_SET_SIGNALLING_REQUEST:
1855       {
1856          celt_int32 value = va_arg(ap, celt_int32);
1857          st->signalling = value;
1858       }
1859       break;
1860       case CELT_GET_MODE_REQUEST:
1861       {
1862          const CELTMode ** value = va_arg(ap, const CELTMode**);
1863          if (value==0)
1864             goto bad_arg;
1865          *value=st->mode;
1866       }
1867       break;
1868 #endif
1869       default:
1870          goto bad_request;
1871    }
1872    va_end(ap);
1873    return CELT_OK;
1874 bad_arg:
1875    va_end(ap);
1876    return CELT_BAD_ARG;
1877 bad_request:
1878    va_end(ap);
1879    return CELT_UNIMPLEMENTED;
1880 }
1881
1882 /**********************************************************************/
1883 /*                                                                    */
1884 /*                             DECODER                                */
1885 /*                                                                    */
1886 /**********************************************************************/
1887 #define DECODE_BUFFER_SIZE 2048
1888
1889 /** Decoder state 
1890  @brief Decoder state
1891  */
1892 struct CELTDecoder {
1893    const CELTMode *mode;
1894    int overlap;
1895    int channels;
1896    int stream_channels;
1897
1898    int downsample;
1899    int start, end;
1900    int signalling;
1901
1902    /* Everything beyond this point gets cleared on a reset */
1903 #define DECODER_RESET_START rng
1904
1905    celt_uint32 rng;
1906    int error;
1907    int last_pitch_index;
1908    int loss_count;
1909    int postfilter_period;
1910    int postfilter_period_old;
1911    celt_word16 postfilter_gain;
1912    celt_word16 postfilter_gain_old;
1913    int postfilter_tapset;
1914    int postfilter_tapset_old;
1915
1916    celt_sig preemph_memD[2];
1917    
1918    celt_sig _decode_mem[1]; /* Size = channels*(DECODE_BUFFER_SIZE+mode->overlap) */
1919    /* celt_word16 lpc[],  Size = channels*LPC_ORDER */
1920    /* celt_word16 oldEBands[], Size = 2*mode->nbEBands */
1921    /* celt_word16 oldLogE[], Size = 2*mode->nbEBands */
1922    /* celt_word16 oldLogE2[], Size = 2*mode->nbEBands */
1923    /* celt_word16 backgroundLogE[], Size = 2*mode->nbEBands */
1924 };
1925
1926 int celt_decoder_get_size(int channels)
1927 {
1928    const CELTMode *mode = celt_mode_create(48000, 960, NULL);
1929    return celt_decoder_get_size_custom(mode, channels);
1930 }
1931
1932 int celt_decoder_get_size_custom(const CELTMode *mode, int channels)
1933 {
1934    int size = sizeof(struct CELTDecoder)
1935             + (channels*(DECODE_BUFFER_SIZE+mode->overlap)-1)*sizeof(celt_sig)
1936             + channels*LPC_ORDER*sizeof(celt_word16)
1937             + 4*2*mode->nbEBands*sizeof(celt_word16);
1938    return size;
1939 }
1940
1941 CELTDecoder *celt_decoder_create(int sampling_rate, int channels, int *error)
1942 {
1943    CELTDecoder *st;
1944    st = (CELTDecoder *)celt_alloc(celt_decoder_get_size(channels));
1945    if (st!=NULL && celt_decoder_init(st, sampling_rate, channels, error)==NULL)
1946    {
1947       celt_decoder_destroy(st);
1948       st = NULL;
1949    }
1950    return st;
1951 }
1952
1953 CELTDecoder *celt_decoder_create_custom(const CELTMode *mode, int channels, int *error)
1954 {
1955    CELTDecoder *st = (CELTDecoder *)celt_alloc(celt_decoder_get_size_custom(mode, channels));
1956    if (st!=NULL && celt_decoder_init_custom(st, mode, channels, error)==NULL)
1957    {
1958       celt_decoder_destroy(st);
1959       st = NULL;
1960    }
1961    return st;
1962 }
1963
1964 CELTDecoder *celt_decoder_init(CELTDecoder *st, int sampling_rate, int channels, int *error)
1965 {
1966    celt_decoder_init_custom(st, celt_mode_create(48000, 960, NULL), channels, error);
1967    st->downsample = resampling_factor(sampling_rate);
1968    if (st->downsample==0)
1969    {
1970       if (error)
1971          *error = CELT_BAD_ARG;
1972       return NULL;
1973    }
1974    return st;
1975 }
1976
1977 CELTDecoder *celt_decoder_init_custom(CELTDecoder *st, const CELTMode *mode, int channels, int *error)
1978 {
1979    if (channels < 0 || channels > 2)
1980    {
1981       if (error)
1982          *error = CELT_BAD_ARG;
1983       return NULL;
1984    }
1985
1986    if (st==NULL)
1987    {
1988       if (error)
1989          *error = CELT_ALLOC_FAIL;
1990       return NULL;
1991    }
1992
1993    CELT_MEMSET((char*)st, 0, celt_decoder_get_size_custom(mode, channels));
1994
1995    st->mode = mode;
1996    st->overlap = mode->overlap;
1997    st->stream_channels = st->channels = channels;
1998
1999    st->downsample = 1;
2000    st->start = 0;
2001    st->end = st->mode->effEBands;
2002    st->signalling = 1;
2003
2004    st->loss_count = 0;
2005
2006    if (error)
2007       *error = CELT_OK;
2008    return st;
2009 }
2010
2011 void celt_decoder_destroy(CELTDecoder *st)
2012 {
2013    celt_free(st);
2014 }
2015
2016 static void celt_decode_lost(CELTDecoder * restrict st, celt_word16 * restrict pcm, int N, int LM)
2017 {
2018    int c;
2019    int pitch_index;
2020    int overlap = st->mode->overlap;
2021    celt_word16 fade = Q15ONE;
2022    int i, len;
2023    const int C = CHANNELS(st->channels);
2024    int offset;
2025    celt_sig *out_mem[2];
2026    celt_sig *decode_mem[2];
2027    celt_sig *overlap_mem[2];
2028    celt_word16 *lpc;
2029    celt_word32 *out_syn[2];
2030    celt_word16 *oldBandE, *oldLogE2, *backgroundLogE;
2031    int plc=1;
2032    SAVE_STACK;
2033    
2034    c=0; do {
2035       decode_mem[c] = st->_decode_mem + c*(DECODE_BUFFER_SIZE+st->overlap);
2036       out_mem[c] = decode_mem[c]+DECODE_BUFFER_SIZE-MAX_PERIOD;
2037       overlap_mem[c] = decode_mem[c]+DECODE_BUFFER_SIZE;
2038    } while (++c<C);
2039    lpc = (celt_word16*)(st->_decode_mem+(DECODE_BUFFER_SIZE+st->overlap)*C);
2040    oldBandE = lpc+C*LPC_ORDER;
2041    oldLogE2 = oldBandE + C*st->mode->nbEBands;
2042    backgroundLogE = oldLogE2  + C*st->mode->nbEBands;
2043
2044    out_syn[0] = out_mem[0]+MAX_PERIOD-N;
2045    if (C==2)
2046       out_syn[1] = out_mem[1]+MAX_PERIOD-N;
2047
2048    len = N+st->mode->overlap;
2049    
2050    if (st->loss_count >= 5)
2051    {
2052       VARDECL(celt_sig, freq);
2053       VARDECL(celt_norm, X);
2054       VARDECL(celt_ener, bandE);
2055       celt_uint32 seed;
2056       int effEnd;
2057
2058       effEnd = st->end;
2059       if (effEnd > st->mode->effEBands)
2060          effEnd = st->mode->effEBands;
2061
2062       ALLOC(freq, C*N, celt_sig); /**< Interleaved signal MDCTs */
2063       ALLOC(X, C*N, celt_norm);   /**< Interleaved normalised MDCTs */
2064       ALLOC(bandE, st->mode->nbEBands*C, celt_ener);
2065
2066       log2Amp(st->mode, st->start, st->end, bandE, backgroundLogE, C);
2067
2068       seed = st->rng;
2069       for (c=0;c<C;c++)
2070       {
2071          for (i=0;i<(st->mode->eBands[st->start]<<LM);i++)
2072             X[c*N+i] = 0;
2073          for (i=0;i<st->mode->effEBands;i++)
2074          {
2075             int j;
2076             int boffs;
2077             int blen;
2078             boffs = N*c+(st->mode->eBands[i]<<LM);
2079             blen = (st->mode->eBands[i+1]-st->mode->eBands[i])<<LM;
2080             for (j=0;j<blen;j++)
2081             {
2082                seed = lcg_rand(seed);
2083                X[boffs+j] = (celt_int32)(seed)>>20;
2084             }
2085             renormalise_vector(X+boffs, blen, Q15ONE);
2086          }
2087          for (i=(st->mode->eBands[st->end]<<LM);i<N;i++)
2088             X[c*N+i] = 0;
2089       }
2090       st->rng = seed;
2091
2092       denormalise_bands(st->mode, X, freq, bandE, st->mode->effEBands, C, 1<<LM);
2093
2094       c=0; do
2095          for (i=0;i<st->mode->eBands[st->start]<<LM;i++)
2096             freq[c*N+i] = 0;
2097       while (++c<C);
2098       c=0; do {
2099          int bound = st->mode->eBands[effEnd]<<LM;
2100          if (st->downsample!=1)
2101             bound = IMIN(bound, N/st->downsample);
2102          for (i=bound;i<N;i++)
2103             freq[c*N+i] = 0;
2104       } while (++c<C);
2105       compute_inv_mdcts(st->mode, 0, freq, out_syn, overlap_mem, C, LM);
2106       plc = 0;
2107    } else if (st->loss_count == 0)
2108    {
2109       celt_word16 pitch_buf[DECODE_BUFFER_SIZE>>1];
2110       /* Corresponds to a min pitch of 67 Hz. It's possible to save CPU in this
2111          search by using only part of the decode buffer */
2112       int poffset = 720;
2113       pitch_downsample(decode_mem, pitch_buf, DECODE_BUFFER_SIZE, C);
2114       /* Max pitch is 100 samples (480 Hz) */
2115       pitch_search(pitch_buf+((poffset)>>1), pitch_buf, DECODE_BUFFER_SIZE-poffset,
2116             poffset-100, &pitch_index);
2117       pitch_index = poffset-pitch_index;
2118       st->last_pitch_index = pitch_index;
2119    } else {
2120       pitch_index = st->last_pitch_index;
2121       fade = QCONST16(.8f,15);
2122    }
2123
2124    if (plc)
2125    {
2126       c=0; do {
2127          VARDECL(celt_word32, e);
2128          celt_word16 exc[MAX_PERIOD];
2129          celt_word32 ac[LPC_ORDER+1];
2130          celt_word16 decay = 1;
2131          celt_word32 S1=0;
2132          celt_word16 mem[LPC_ORDER]={0};
2133
2134          ALLOC(e, MAX_PERIOD+2*st->mode->overlap, celt_word32);
2135
2136          offset = MAX_PERIOD-pitch_index;
2137          for (i=0;i<MAX_PERIOD;i++)
2138             exc[i] = ROUND16(out_mem[c][i], SIG_SHIFT);
2139
2140          if (st->loss_count == 0)
2141          {
2142             _celt_autocorr(exc, ac, st->mode->window, st->mode->overlap,
2143                   LPC_ORDER, MAX_PERIOD);
2144
2145             /* Noise floor -40 dB */
2146 #ifdef FIXED_POINT
2147             ac[0] += SHR32(ac[0],13);
2148 #else
2149             ac[0] *= 1.0001f;
2150 #endif
2151             /* Lag windowing */
2152             for (i=1;i<=LPC_ORDER;i++)
2153             {
2154                /*ac[i] *= exp(-.5*(2*M_PI*.002*i)*(2*M_PI*.002*i));*/
2155 #ifdef FIXED_POINT
2156                ac[i] -= MULT16_32_Q15(2*i*i, ac[i]);
2157 #else
2158                ac[i] -= ac[i]*(.008f*i)*(.008f*i);
2159 #endif
2160             }
2161
2162             _celt_lpc(lpc+c*LPC_ORDER, ac, LPC_ORDER);
2163          }
2164          for (i=0;i<LPC_ORDER;i++)
2165             mem[i] = ROUND16(out_mem[c][MAX_PERIOD-1-i], SIG_SHIFT);
2166          fir(exc, lpc+c*LPC_ORDER, exc, MAX_PERIOD, LPC_ORDER, mem);
2167          /*for (i=0;i<MAX_PERIOD;i++)printf("%d ", exc[i]); printf("\n");*/
2168          /* Check if the waveform is decaying (and if so how fast) */
2169          {
2170             celt_word32 E1=1, E2=1;
2171             int period;
2172             if (pitch_index <= MAX_PERIOD/2)
2173                period = pitch_index;
2174             else
2175                period = MAX_PERIOD/2;
2176             for (i=0;i<period;i++)
2177             {
2178                E1 += SHR32(MULT16_16(exc[MAX_PERIOD-period+i],exc[MAX_PERIOD-period+i]),8);
2179                E2 += SHR32(MULT16_16(exc[MAX_PERIOD-2*period+i],exc[MAX_PERIOD-2*period+i]),8);
2180             }
2181             if (E1 > E2)
2182                E1 = E2;
2183             decay = celt_sqrt(frac_div32(SHR(E1,1),E2));
2184          }
2185
2186          /* Copy excitation, taking decay into account */
2187          for (i=0;i<len+st->mode->overlap;i++)
2188          {
2189             celt_word16 tmp;
2190             if (offset+i >= MAX_PERIOD)
2191             {
2192                offset -= pitch_index;
2193                decay = MULT16_16_Q15(decay, decay);
2194             }
2195             e[i] = SHL32(EXTEND32(MULT16_16_Q15(decay, exc[offset+i])), SIG_SHIFT);
2196             tmp = ROUND16(out_mem[c][offset+i],SIG_SHIFT);
2197             S1 += SHR32(MULT16_16(tmp,tmp),8);
2198          }
2199          for (i=0;i<LPC_ORDER;i++)
2200             mem[i] = ROUND16(out_mem[c][MAX_PERIOD-1-i], SIG_SHIFT);
2201          for (i=0;i<len+st->mode->overlap;i++)
2202             e[i] = MULT16_32_Q15(fade, e[i]);
2203          iir(e, lpc+c*LPC_ORDER, e, len+st->mode->overlap, LPC_ORDER, mem);
2204
2205          {
2206             celt_word32 S2=0;
2207             for (i=0;i<len+overlap;i++)
2208             {
2209                celt_word16 tmp = ROUND16(e[i],SIG_SHIFT);
2210                S2 += SHR32(MULT16_16(tmp,tmp),8);
2211             }
2212             /* This checks for an "explosion" in the synthesis */
2213 #ifdef FIXED_POINT
2214             if (!(S1 > SHR32(S2,2)))
2215 #else
2216                /* Float test is written this way to catch NaNs at the same time */
2217                if (!(S1 > 0.2f*S2))
2218 #endif
2219                {
2220                   for (i=0;i<len+overlap;i++)
2221                      e[i] = 0;
2222                } else if (S1 < S2)
2223                {
2224                   celt_word16 ratio = celt_sqrt(frac_div32(SHR32(S1,1)+1,S2+1));
2225                   for (i=0;i<len+overlap;i++)
2226                      e[i] = MULT16_32_Q15(ratio, e[i]);
2227                }
2228          }
2229
2230 #ifdef ENABLE_POSTFILTER
2231          /* Apply post-filter to the MDCT overlap of the previous frame */
2232          comb_filter(out_mem[c]+MAX_PERIOD, out_mem[c]+MAX_PERIOD, st->postfilter_period, st->postfilter_period, st->overlap,
2233                st->postfilter_gain, st->postfilter_gain, st->postfilter_tapset, st->postfilter_tapset,
2234                NULL, 0);
2235 #endif /* ENABLE_POSTFILTER */
2236
2237          for (i=0;i<MAX_PERIOD+st->mode->overlap-N;i++)
2238             out_mem[c][i] = out_mem[c][N+i];
2239
2240          /* Apply TDAC to the concealed audio so that it blends with the
2241          previous and next frames */
2242          for (i=0;i<overlap/2;i++)
2243          {
2244             celt_word32 tmp;
2245             tmp = MULT16_32_Q15(st->mode->window[i],           e[N+overlap-1-i]) +
2246                   MULT16_32_Q15(st->mode->window[overlap-i-1], e[N+i          ]);
2247             out_mem[c][MAX_PERIOD+i] = MULT16_32_Q15(st->mode->window[overlap-i-1], tmp);
2248             out_mem[c][MAX_PERIOD+overlap-i-1] = MULT16_32_Q15(st->mode->window[i], tmp);
2249          }
2250          for (i=0;i<N;i++)
2251             out_mem[c][MAX_PERIOD-N+i] = e[i];
2252
2253 #ifdef ENABLE_POSTFILTER
2254          /* Apply pre-filter to the MDCT overlap for the next frame (post-filter will be applied then) */
2255          comb_filter(e, out_mem[c]+MAX_PERIOD, st->postfilter_period, st->postfilter_period, st->overlap,
2256                -st->postfilter_gain, -st->postfilter_gain, st->postfilter_tapset, st->postfilter_tapset,
2257                NULL, 0);
2258 #endif /* ENABLE_POSTFILTER */
2259          for (i=0;i<overlap;i++)
2260             out_mem[c][MAX_PERIOD+i] = e[i];
2261       } while (++c<C);
2262    }
2263
2264    deemphasis(out_syn, pcm, N, C, st->downsample, st->mode->preemph, st->preemph_memD);
2265    
2266    st->loss_count++;
2267
2268    RESTORE_STACK;
2269 }
2270
2271 #ifdef FIXED_POINT
2272 CELT_STATIC
2273 int celt_decode_with_ec(CELTDecoder * restrict st, const unsigned char *data, int len, celt_int16 * restrict pcm, int frame_size, ec_dec *dec)
2274 {
2275 #else
2276 CELT_STATIC
2277 int celt_decode_with_ec_float(CELTDecoder * restrict st, const unsigned char *data, int len, celt_sig * restrict pcm, int frame_size, ec_dec *dec)
2278 {
2279 #endif
2280    int c, i, N;
2281    int spread_decision;
2282    celt_int32 bits;
2283    ec_dec _dec;
2284    VARDECL(celt_sig, freq);
2285    VARDECL(celt_norm, X);
2286    VARDECL(celt_ener, bandE);
2287    VARDECL(int, fine_quant);
2288    VARDECL(int, pulses);
2289    VARDECL(int, cap);
2290    VARDECL(int, offsets);
2291    VARDECL(int, fine_priority);
2292    VARDECL(int, tf_res);
2293    VARDECL(unsigned char, collapse_masks);
2294    celt_sig *out_mem[2];
2295    celt_sig *decode_mem[2];
2296    celt_sig *overlap_mem[2];
2297    celt_sig *out_syn[2];
2298    celt_word16 *lpc;
2299    celt_word16 *oldBandE, *oldLogE, *oldLogE2, *backgroundLogE;
2300
2301    int shortBlocks;
2302    int isTransient;
2303    int intra_ener;
2304    const int CC = CHANNELS(st->channels);
2305    int LM, M;
2306    int effEnd;
2307    int codedBands;
2308    int alloc_trim;
2309    int postfilter_pitch;
2310    celt_word16 postfilter_gain;
2311    int intensity=0;
2312    int dual_stereo=0;
2313    celt_int32 total_bits;
2314    celt_int32 balance;
2315    celt_int32 tell;
2316    int dynalloc_logp;
2317    int postfilter_tapset;
2318    int anti_collapse_rsv;
2319    int anti_collapse_on=0;
2320    int silence;
2321    int C = CHANNELS(st->stream_channels);
2322    ALLOC_STACK;
2323
2324    frame_size *= st->downsample;
2325
2326    c=0; do {
2327       decode_mem[c] = st->_decode_mem + c*(DECODE_BUFFER_SIZE+st->overlap);
2328       out_mem[c] = decode_mem[c]+DECODE_BUFFER_SIZE-MAX_PERIOD;
2329       overlap_mem[c] = decode_mem[c]+DECODE_BUFFER_SIZE;
2330    } while (++c<CC);
2331    lpc = (celt_word16*)(st->_decode_mem+(DECODE_BUFFER_SIZE+st->overlap)*CC);
2332    oldBandE = lpc+LPC_ORDER;
2333    oldLogE = oldBandE + 2*st->mode->nbEBands;
2334    oldLogE2 = oldLogE + 2*st->mode->nbEBands;
2335    backgroundLogE = oldLogE2  + 2*st->mode->nbEBands;
2336
2337    if (st->signalling && data!=NULL)
2338    {
2339       int data0=data[0];
2340       /* Convert "standard mode" to Opus header */
2341       if (st->mode->Fs==48000 && st->mode->shortMdctSize==120)
2342       {
2343          data0 = fromOpus(data0);
2344          if (data0<0)
2345             return CELT_CORRUPTED_DATA;
2346       }
2347       st->end = IMAX(1, st->mode->effEBands-2*(data0>>5));
2348       LM = (data0>>3)&0x3;
2349       C = 1 + ((data0>>2)&0x1);
2350       data++;
2351       len--;
2352       if (LM>st->mode->maxLM)
2353          return CELT_CORRUPTED_DATA;
2354       if (frame_size < st->mode->shortMdctSize<<LM)
2355          return CELT_BUFFER_TOO_SMALL;
2356       else
2357          frame_size = st->mode->shortMdctSize<<LM;
2358    } else {
2359       for (LM=0;LM<=st->mode->maxLM;LM++)
2360          if (st->mode->shortMdctSize<<LM==frame_size)
2361             break;
2362       if (LM>st->mode->maxLM)
2363          return CELT_BAD_ARG;
2364    }
2365    M=1<<LM;
2366
2367    if (len<0 || len>1275 || pcm==NULL)
2368       return CELT_BAD_ARG;
2369
2370    N = M*st->mode->shortMdctSize;
2371
2372    effEnd = st->end;
2373    if (effEnd > st->mode->effEBands)
2374       effEnd = st->mode->effEBands;
2375
2376    ALLOC(freq, IMAX(CC,C)*N, celt_sig); /**< Interleaved signal MDCTs */
2377    ALLOC(X, C*N, celt_norm);   /**< Interleaved normalised MDCTs */
2378    ALLOC(bandE, st->mode->nbEBands*C, celt_ener);
2379    c=0; do
2380       for (i=0;i<M*st->mode->eBands[st->start];i++)
2381          X[c*N+i] = 0;
2382    while (++c<C);
2383    c=0; do   
2384       for (i=M*st->mode->eBands[effEnd];i<N;i++)
2385          X[c*N+i] = 0;
2386    while (++c<C);
2387
2388    if (data == NULL || len<=1)
2389    {
2390       celt_decode_lost(st, pcm, N, LM);
2391       RESTORE_STACK;
2392       return frame_size/st->downsample;
2393    }
2394    if (len<0) {
2395      RESTORE_STACK;
2396      return CELT_BAD_ARG;
2397    }
2398
2399    if (dec == NULL)
2400    {
2401       ec_dec_init(&_dec,(unsigned char*)data,len);
2402       dec = &_dec;
2403    }
2404
2405    if (C<CC)
2406    {
2407       for (i=0;i<st->mode->nbEBands;i++)
2408          oldBandE[i]=MAX16(oldBandE[i],oldBandE[st->mode->nbEBands+i]);
2409    }
2410
2411    total_bits = len*8;
2412    tell = ec_tell(dec);
2413
2414    if (tell==1)
2415       silence = ec_dec_bit_logp(dec, 15);
2416    else
2417       silence = 0;
2418    if (silence)
2419    {
2420       /* Pretend we've read all the remaining bits */
2421       tell = len*8;
2422       dec->nbits_total+=tell-ec_tell(dec);
2423    }
2424
2425    postfilter_gain = 0;
2426    postfilter_pitch = 0;
2427    postfilter_tapset = 0;
2428    if (st->start==0 && tell+16 <= total_bits)
2429    {
2430       if(ec_dec_bit_logp(dec, 1))
2431       {
2432 #ifdef ENABLE_POSTFILTER
2433          int qg, octave;
2434          octave = ec_dec_uint(dec, 6);
2435          postfilter_pitch = (16<<octave)+ec_dec_bits(dec, 4+octave)-1;
2436          qg = ec_dec_bits(dec, 3);
2437          if (ec_tell(dec)+2<=total_bits)
2438             postfilter_tapset = ec_dec_icdf(dec, tapset_icdf, 2);
2439          postfilter_gain = QCONST16(.09375f,15)*(qg+1);
2440 #else /* ENABLE_POSTFILTER */
2441          RESTORE_STACK;
2442          return CELT_CORRUPTED_DATA;
2443 #endif /* ENABLE_POSTFILTER */
2444       }
2445       tell = ec_tell(dec);
2446    }
2447
2448    if (LM > 0 && tell+3 <= total_bits)
2449    {
2450       isTransient = ec_dec_bit_logp(dec, 3);
2451       tell = ec_tell(dec);
2452    }
2453    else
2454       isTransient = 0;
2455
2456    if (isTransient)
2457       shortBlocks = M;
2458    else
2459       shortBlocks = 0;
2460
2461    /* Decode the global flags (first symbols in the stream) */
2462    intra_ener = tell+3<=total_bits ? ec_dec_bit_logp(dec, 3) : 0;
2463    /* Get band energies */
2464    unquant_coarse_energy(st->mode, st->start, st->end, oldBandE,
2465          intra_ener, dec, C, LM);
2466
2467    ALLOC(tf_res, st->mode->nbEBands, int);
2468    tf_decode(st->start, st->end, isTransient, tf_res, LM, dec);
2469
2470    tell = ec_tell(dec);
2471    spread_decision = SPREAD_NORMAL;
2472    if (tell+4 <= total_bits)
2473       spread_decision = ec_dec_icdf(dec, spread_icdf, 5);
2474
2475    ALLOC(pulses, st->mode->nbEBands, int);
2476    ALLOC(cap, st->mode->nbEBands, int);
2477    ALLOC(offsets, st->mode->nbEBands, int);
2478    ALLOC(fine_priority, st->mode->nbEBands, int);
2479
2480    init_caps(st->mode,cap,LM,C);
2481
2482    dynalloc_logp = 6;
2483    total_bits<<=BITRES;
2484    tell = ec_tell_frac(dec);
2485    for (i=st->start;i<st->end;i++)
2486    {
2487       int width, quanta;
2488       int dynalloc_loop_logp;
2489       int boost;
2490       width = C*(st->mode->eBands[i+1]-st->mode->eBands[i])<<LM;
2491       /* quanta is 6 bits, but no more than 1 bit/sample
2492          and no less than 1/8 bit/sample */
2493       quanta = IMIN(width<<BITRES, IMAX(6<<BITRES, width));
2494       dynalloc_loop_logp = dynalloc_logp;
2495       boost = 0;
2496       while (tell+(dynalloc_loop_logp<<BITRES) < total_bits && boost < cap[i])
2497       {
2498          int flag;
2499          flag = ec_dec_bit_logp(dec, dynalloc_loop_logp);
2500          tell = ec_tell_frac(dec);
2501          if (!flag)
2502             break;
2503          boost += quanta;
2504          total_bits -= quanta;
2505          dynalloc_loop_logp = 1;
2506       }
2507       offsets[i] = boost;
2508       /* Making dynalloc more likely */
2509       if (boost>0)
2510          dynalloc_logp = IMAX(2, dynalloc_logp-1);
2511    }
2512
2513    ALLOC(fine_quant, st->mode->nbEBands, int);
2514    alloc_trim = tell+(6<<BITRES) <= total_bits ?
2515          ec_dec_icdf(dec, trim_icdf, 7) : 5;
2516
2517    bits = ((celt_int32)len*8<<BITRES) - ec_tell_frac(dec) - 1;
2518    anti_collapse_rsv = isTransient&&LM>=2&&bits>=(LM+2<<BITRES) ? (1<<BITRES) : 0;
2519    bits -= anti_collapse_rsv;
2520    codedBands = compute_allocation(st->mode, st->start, st->end, offsets, cap,
2521          alloc_trim, &intensity, &dual_stereo, bits, &balance, pulses,
2522          fine_quant, fine_priority, C, LM, dec, 0, 0);
2523    
2524    unquant_fine_energy(st->mode, st->start, st->end, oldBandE, fine_quant, dec, C);
2525
2526    /* Decode fixed codebook */
2527    ALLOC(collapse_masks, C*st->mode->nbEBands, unsigned char);
2528    quant_all_bands(0, st->mode, st->start, st->end, X, C==2 ? X+N : NULL, collapse_masks,
2529          NULL, pulses, shortBlocks, spread_decision, dual_stereo, intensity, tf_res, 1,
2530          len*(8<<BITRES)-anti_collapse_rsv, balance, dec, LM, codedBands, &st->rng);
2531
2532    if (anti_collapse_rsv > 0)
2533    {
2534       anti_collapse_on = ec_dec_bits(dec, 1);
2535    }
2536
2537    unquant_energy_finalise(st->mode, st->start, st->end, oldBandE,
2538          fine_quant, fine_priority, len*8-ec_tell(dec), dec, C);
2539
2540    if (anti_collapse_on)
2541       anti_collapse(st->mode, X, collapse_masks, LM, C, C, N,
2542             st->start, st->end, oldBandE, oldLogE, oldLogE2, pulses, st->rng);
2543
2544    log2Amp(st->mode, st->start, st->end, bandE, oldBandE, C);
2545
2546    if (silence)
2547    {
2548       for (i=0;i<C*st->mode->nbEBands;i++)
2549       {
2550          bandE[i] = 0;
2551          oldBandE[i] = -QCONST16(28.f,DB_SHIFT);
2552       }
2553    }
2554    /* Synthesis */
2555    denormalise_bands(st->mode, X, freq, bandE, effEnd, C, M);
2556
2557    CELT_MOVE(decode_mem[0], decode_mem[0]+N, DECODE_BUFFER_SIZE-N);
2558    if (CC==2)
2559       CELT_MOVE(decode_mem[1], decode_mem[1]+N, DECODE_BUFFER_SIZE-N);
2560
2561    c=0; do
2562       for (i=0;i<M*st->mode->eBands[st->start];i++)
2563          freq[c*N+i] = 0;
2564    while (++c<C);
2565    c=0; do {
2566       int bound = M*st->mode->eBands[effEnd];
2567       if (st->downsample!=1)
2568          bound = IMIN(bound, N/st->downsample);
2569       for (i=bound;i<N;i++)
2570          freq[c*N+i] = 0;
2571    } while (++c<C);
2572
2573    out_syn[0] = out_mem[0]+MAX_PERIOD-N;
2574    if (CC==2)
2575       out_syn[1] = out_mem[1]+MAX_PERIOD-N;
2576
2577    if (CC==2&&C==1)
2578    {
2579       for (i=0;i<N;i++)
2580          freq[N+i] = freq[i];
2581    }
2582    if (CC==1&&C==2)
2583    {
2584       for (i=0;i<N;i++)
2585          freq[i] = HALF32(ADD32(freq[i],freq[N+i]));
2586    }
2587
2588    /* Compute inverse MDCTs */
2589    compute_inv_mdcts(st->mode, shortBlocks, freq, out_syn, overlap_mem, CC, LM);
2590
2591 #ifdef ENABLE_POSTFILTER
2592    c=0; do {
2593       st->postfilter_period=IMAX(st->postfilter_period, COMBFILTER_MINPERIOD);
2594       st->postfilter_period_old=IMAX(st->postfilter_period_old, COMBFILTER_MINPERIOD);
2595       comb_filter(out_syn[c], out_syn[c], st->postfilter_period_old, st->postfilter_period, st->mode->shortMdctSize,
2596             st->postfilter_gain_old, st->postfilter_gain, st->postfilter_tapset_old, st->postfilter_tapset,
2597             st->mode->window, st->overlap);
2598       if (LM!=0)
2599          comb_filter(out_syn[c]+st->mode->shortMdctSize, out_syn[c]+st->mode->shortMdctSize, st->postfilter_period, postfilter_pitch, N-st->mode->shortMdctSize,
2600                st->postfilter_gain, postfilter_gain, st->postfilter_tapset, postfilter_tapset,
2601                st->mode->window, st->mode->overlap);
2602
2603    } while (++c<CC);
2604    st->postfilter_period_old = st->postfilter_period;
2605    st->postfilter_gain_old = st->postfilter_gain;
2606    st->postfilter_tapset_old = st->postfilter_tapset;
2607    st->postfilter_period = postfilter_pitch;
2608    st->postfilter_gain = postfilter_gain;
2609    st->postfilter_tapset = postfilter_tapset;
2610    if (LM!=0)
2611    {
2612       st->postfilter_period_old = st->postfilter_period;
2613       st->postfilter_gain_old = st->postfilter_gain;
2614       st->postfilter_tapset_old = st->postfilter_tapset;
2615    }
2616 #endif /* ENABLE_POSTFILTER */
2617
2618    if (C==1) {
2619       for (i=0;i<st->mode->nbEBands;i++)
2620          oldBandE[st->mode->nbEBands+i]=oldBandE[i];
2621    }
2622
2623    /* In case start or end were to change */
2624    c=0; do
2625    {
2626       for (i=0;i<st->start;i++)
2627          oldBandE[c*st->mode->nbEBands+i]=0;
2628       for (i=st->end;i<st->mode->nbEBands;i++)
2629          oldBandE[c*st->mode->nbEBands+i]=0;
2630    } while (++c<2);
2631    if (!isTransient)
2632    {
2633       for (i=0;i<2*st->mode->nbEBands;i++)
2634          oldLogE2[i] = oldLogE[i];
2635       for (i=0;i<2*st->mode->nbEBands;i++)
2636          oldLogE[i] = oldBandE[i];
2637       for (i=0;i<2*st->mode->nbEBands;i++)
2638          backgroundLogE[i] = MIN16(backgroundLogE[i] + M*QCONST16(0.001f,DB_SHIFT), oldBandE[i]);
2639    } else {
2640       for (i=0;i<2*st->mode->nbEBands;i++)
2641          oldLogE[i] = MIN16(oldLogE[i], oldBandE[i]);
2642    }
2643    st->rng = dec->rng;
2644
2645    deemphasis(out_syn, pcm, N, CC, st->downsample, st->mode->preemph, st->preemph_memD);
2646    st->loss_count = 0;
2647    RESTORE_STACK;
2648    if (ec_tell(dec) > 8*len)
2649       return CELT_INTERNAL_ERROR;
2650    if(ec_get_error(dec))
2651       st->error = 1;
2652    return frame_size/st->downsample;
2653 }
2654
2655 #ifdef FIXED_POINT
2656 #ifndef DISABLE_FLOAT_API
2657 CELT_STATIC
2658 int celt_decode_with_ec_float(CELTDecoder * restrict st, const unsigned char *data, int len, float * restrict pcm, int frame_size, ec_dec *dec)
2659 {
2660    int j, ret, C, N;
2661    VARDECL(celt_int16, out);
2662    ALLOC_STACK;
2663
2664    if (pcm==NULL)
2665       return CELT_BAD_ARG;
2666
2667    C = CHANNELS(st->channels);
2668    N = frame_size;
2669    
2670    ALLOC(out, C*N, celt_int16);
2671    ret=celt_decode_with_ec(st, data, len, out, frame_size, dec);
2672    if (ret>0)
2673       for (j=0;j<C*ret;j++)
2674          pcm[j]=out[j]*(1.f/32768.f);
2675      
2676    RESTORE_STACK;
2677    return ret;
2678 }
2679 #endif /*DISABLE_FLOAT_API*/
2680 #else
2681 CELT_STATIC
2682 int celt_decode_with_ec(CELTDecoder * restrict st, const unsigned char *data, int len, celt_int16 * restrict pcm, int frame_size, ec_dec *dec)
2683 {
2684    int j, ret, C, N;
2685    VARDECL(celt_sig, out);
2686    ALLOC_STACK;
2687
2688    if (pcm==NULL)
2689       return CELT_BAD_ARG;
2690
2691    C = CHANNELS(st->channels);
2692    N = frame_size;
2693    ALLOC(out, C*N, celt_sig);
2694
2695    ret=celt_decode_with_ec_float(st, data, len, out, frame_size, dec);
2696
2697    if (ret>0)
2698       for (j=0;j<C*ret;j++)
2699          pcm[j] = FLOAT2INT16 (out[j]);
2700    
2701    RESTORE_STACK;
2702    return ret;
2703 }
2704 #endif
2705
2706 int celt_decode(CELTDecoder * restrict st, const unsigned char *data, int len, celt_int16 * restrict pcm, int frame_size)
2707 {
2708    return celt_decode_with_ec(st, data, len, pcm, frame_size, NULL);
2709 }
2710
2711 #ifndef DISABLE_FLOAT_API
2712 int celt_decode_float(CELTDecoder * restrict st, const unsigned char *data, int len, float * restrict pcm, int frame_size)
2713 {
2714    return celt_decode_with_ec_float(st, data, len, pcm, frame_size, NULL);
2715 }
2716 #endif /* DISABLE_FLOAT_API */
2717
2718 int celt_decoder_ctl(CELTDecoder * restrict st, int request, ...)
2719 {
2720    va_list ap;
2721
2722    va_start(ap, request);
2723    switch (request)
2724    {
2725       case CELT_SET_START_BAND_REQUEST:
2726       {
2727          celt_int32 value = va_arg(ap, celt_int32);
2728          if (value<0 || value>=st->mode->nbEBands)
2729             goto bad_arg;
2730          st->start = value;
2731       }
2732       break;
2733       case CELT_SET_END_BAND_REQUEST:
2734       {
2735          celt_int32 value = va_arg(ap, celt_int32);
2736          if (value<1 || value>st->mode->nbEBands)
2737             goto bad_arg;
2738          st->end = value;
2739       }
2740       break;
2741       case CELT_SET_CHANNELS_REQUEST:
2742       {
2743          celt_int32 value = va_arg(ap, celt_int32);
2744          if (value<1 || value>2)
2745             goto bad_arg;
2746          st->stream_channels = value;
2747       }
2748       break;
2749       case CELT_GET_AND_CLEAR_ERROR_REQUEST:
2750       {
2751          int *value = va_arg(ap, int*);
2752          if (value==NULL)
2753             goto bad_arg;
2754          *value=st->error;
2755          st->error = 0;
2756       }
2757       break;
2758       case CELT_GET_LOOKAHEAD_REQUEST:
2759       {
2760          int *value = va_arg(ap, int*);
2761          if (value==NULL)
2762             goto bad_arg;
2763          *value = st->overlap/st->downsample;
2764       }
2765       break;
2766       case CELT_RESET_STATE:
2767       {
2768          CELT_MEMSET((char*)&st->DECODER_RESET_START, 0,
2769                celt_decoder_get_size_custom(st->mode, st->channels)-
2770                ((char*)&st->DECODER_RESET_START - (char*)st));
2771       }
2772       break;
2773 #ifdef OPUS_BUILD
2774       case CELT_GET_MODE_REQUEST:
2775       {
2776          const CELTMode ** value = va_arg(ap, const CELTMode**);
2777          if (value==0)
2778             goto bad_arg;
2779          *value=st->mode;
2780       }
2781       break;
2782       case CELT_SET_SIGNALLING_REQUEST:
2783       {
2784          celt_int32 value = va_arg(ap, celt_int32);
2785          st->signalling = value;
2786       }
2787       break;
2788 #endif
2789       default:
2790          goto bad_request;
2791    }
2792    va_end(ap);
2793    return CELT_OK;
2794 bad_arg:
2795    va_end(ap);
2796    return CELT_BAD_ARG;
2797 bad_request:
2798       va_end(ap);
2799   return CELT_UNIMPLEMENTED;
2800 }
2801
2802 const char *celt_strerror(int error)
2803 {
2804    static const char *error_strings[8] = {
2805       "success",
2806       "invalid argument",
2807       "buffer too small",
2808       "internal error",
2809       "corrupted stream",
2810       "request not implemented",
2811       "invalid state",
2812       "memory allocation failed"
2813    };
2814    if (error > 0 || error < -7)
2815       return "unknown error";
2816    else 
2817       return error_strings[-error];
2818 }
2819