Keeping the allocation of the intensity-codec bands
[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    - Neither the name of the Xiph.org Foundation nor the names of its
18    contributors may be used to endorse or promote products derived from
19    this software without specific prior written permission.
20    
21    THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
22    ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
23    LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
24    A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR
25    CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
26    EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
27    PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
28    PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
29    LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
30    NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
31    SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
32 */
33
34 #ifdef HAVE_CONFIG_H
35 #include "config.h"
36 #endif
37
38 #define CELT_C
39
40 #include "os_support.h"
41 #include "mdct.h"
42 #include <math.h>
43 #include "celt.h"
44 #include "pitch.h"
45 #include "bands.h"
46 #include "modes.h"
47 #include "entcode.h"
48 #include "quant_bands.h"
49 #include "rate.h"
50 #include "stack_alloc.h"
51 #include "mathops.h"
52 #include "float_cast.h"
53 #include <stdarg.h>
54 #include "plc.h"
55
56 static const int trim_cdf[12] = {0, 2, 4, 9, 19, 41, 87, 109, 119, 124, 126, 128};
57
58 #define COMBFILTER_MAXPERIOD 1024
59 #define COMBFILTER_MINPERIOD 16
60
61 /** Encoder state 
62  @brief Encoder state
63  */
64 struct CELTEncoder {
65    const CELTMode *mode;     /**< Mode used by the encoder */
66    int overlap;
67    int channels;
68    
69    int force_intra;
70    int complexity;
71    int start, end;
72
73    celt_int32 vbr_rate_norm; /* Target number of 8th bits per frame */
74    int constrained_vbr;      /* If zero, VBR can do whatever it likes with the rate */
75
76    /* Everything beyond this point gets cleared on a reset */
77 #define ENCODER_RESET_START frame_max
78
79    celt_word32 frame_max;
80    int fold_decision;
81    int delayedIntra;
82    int tonal_average;
83
84    int prefilter_period;
85    celt_word16 prefilter_gain;
86
87    /* VBR-related parameters */
88    celt_int32 vbr_reservoir;
89    celt_int32 vbr_drift;
90    celt_int32 vbr_offset;
91    celt_int32 vbr_count;
92
93    celt_word32 preemph_memE[2];
94    celt_word32 preemph_memD[2];
95
96 #ifdef RESYNTH
97    celt_sig syn_mem[2][2*MAX_PERIOD];
98 #endif
99
100    celt_sig in_mem[1]; /* Size = channels*mode->overlap */
101    /* celt_sig prefilter_mem[],  Size = channels*COMBFILTER_PERIOD */
102    /* celt_sig overlap_mem[],  Size = channels*mode->overlap */
103    /* celt_word16 oldEBands[], Size = channels*mode->nbEBands */
104 };
105
106 int celt_encoder_get_size(const CELTMode *mode, int channels)
107 {
108    int size = sizeof(struct CELTEncoder)
109          + (2*channels*mode->overlap-1)*sizeof(celt_sig)
110          + channels*COMBFILTER_MAXPERIOD*sizeof(celt_sig)
111          + channels*mode->nbEBands*sizeof(celt_word16);
112    return size;
113 }
114
115 CELTEncoder *celt_encoder_create(const CELTMode *mode, int channels, int *error)
116 {
117    return celt_encoder_init(
118          (CELTEncoder *)celt_alloc(celt_encoder_get_size(mode, channels)),
119          mode, channels, error);
120 }
121
122 CELTEncoder *celt_encoder_init(CELTEncoder *st, const CELTMode *mode, int channels, int *error)
123 {
124    if (channels < 0 || channels > 2)
125    {
126       if (error)
127          *error = CELT_BAD_ARG;
128       return NULL;
129    }
130
131    if (st==NULL)
132    {
133       if (error)
134          *error = CELT_ALLOC_FAIL;
135       return NULL;
136    }
137
138    CELT_MEMSET((char*)st, 0, celt_encoder_get_size(mode, channels));
139    
140    st->mode = mode;
141    st->overlap = mode->overlap;
142    st->channels = channels;
143
144    st->start = 0;
145    st->end = st->mode->effEBands;
146    st->constrained_vbr = 1;
147
148    st->vbr_rate_norm = 0;
149    st->vbr_offset = 0;
150    st->force_intra  = 0;
151    st->delayedIntra = 1;
152    st->tonal_average = 256;
153    st->fold_decision = 1;
154    st->complexity = 5;
155
156    if (error)
157       *error = CELT_OK;
158    return st;
159 }
160
161 void celt_encoder_destroy(CELTEncoder *st)
162 {
163    celt_free(st);
164 }
165
166 static inline celt_int16 FLOAT2INT16(float x)
167 {
168    x = x*CELT_SIG_SCALE;
169    x = MAX32(x, -32768);
170    x = MIN32(x, 32767);
171    return (celt_int16)float2int(x);
172 }
173
174 static inline celt_word16 SIG2WORD16(celt_sig x)
175 {
176 #ifdef FIXED_POINT
177    x = PSHR32(x, SIG_SHIFT);
178    x = MAX32(x, -32768);
179    x = MIN32(x, 32767);
180    return EXTRACT16(x);
181 #else
182    return (celt_word16)x;
183 #endif
184 }
185
186 static int transient_analysis(const celt_word32 * restrict in, int len, int C,
187                               celt_word32 *frame_max, int overlap)
188 {
189    int i, n;
190    celt_word32 threshold;
191    VARDECL(celt_word32, begin);
192    VARDECL(celt_word16, tmp);
193    celt_word32 mem0=0,mem1=0;
194    SAVE_STACK;
195    ALLOC(tmp, len, celt_word16);
196    ALLOC(begin, len+1, celt_word32);
197
198    if (C==1)
199    {
200       for (i=0;i<len;i++)
201          tmp[i] = SHR32(in[i],SIG_SHIFT);
202    } else {
203       for (i=0;i<len;i++)
204          tmp[i] = SHR32(ADD32(in[i],in[i+len]), SIG_SHIFT+1);
205    }
206
207    /* High-pass filter: (1 - 2*z^-1 + z^-2) / (1 - z^-1 + .5*z^-2) */
208    for (i=0;i<len;i++)
209    {
210       celt_word32 x,y;
211       x = tmp[i];
212       y = ADD32(mem0, x);
213 #ifdef FIXED_POINT
214       mem0 = mem1 + y - SHL32(x,1);
215       mem1 = x - SHR32(y,1);
216 #else
217       mem0 = mem1 + y - 2*x;
218       mem1 = x - .5f*y;
219 #endif
220       tmp[i] = EXTRACT16(SHR(y,2));
221    }
222    /* First few samples are bad because we don't propagate the memory */
223    for (i=0;i<24;i++)
224       tmp[i] = 0;
225
226    begin[0] = 0;
227    for (i=0;i<len;i++)
228       begin[i+1] = MAX32(begin[i], ABS32(tmp[i]));
229
230    n = -1;
231
232    threshold = MULT16_32_Q15(QCONST16(.4f,15),begin[len]);
233    /* If the following condition isn't met, there's just no way
234       we'll have a transient*/
235    if (*frame_max < threshold)
236    {
237       /* It's likely we have a transient, now find it */
238       for (i=8;i<len-8;i++)
239       {
240          if (begin[i+1] < threshold)
241             n=i;
242       }
243    }
244
245    *frame_max = begin[len-overlap];
246    /* Only consider the last 7.5 ms for the next transient */
247    if (len>360+overlap)
248    {
249       *frame_max = 0;
250       for (i=len-360-overlap;i<len-overlap;i++)
251          *frame_max = MAX32(*frame_max, ABS32(tmp[i]));
252    }
253    RESTORE_STACK;
254    return n>=32;
255 }
256
257 /** Apply window and compute the MDCT for all sub-frames and 
258     all channels in a frame */
259 static void compute_mdcts(const CELTMode *mode, int shortBlocks, celt_sig * restrict in, celt_sig * restrict out, int _C, int LM)
260 {
261    const int C = CHANNELS(_C);
262    if (C==1 && !shortBlocks)
263    {
264       const int overlap = OVERLAP(mode);
265       clt_mdct_forward(&mode->mdct, in, out, mode->window, overlap, mode->maxLM-LM);
266    } else {
267       const int overlap = OVERLAP(mode);
268       int N = mode->shortMdctSize<<LM;
269       int B = 1;
270       int b, c;
271       VARDECL(celt_word32, tmp);
272       SAVE_STACK;
273       if (shortBlocks)
274       {
275          /*lookup = &mode->mdct[0];*/
276          N = mode->shortMdctSize;
277          B = shortBlocks;
278       }
279       ALLOC(tmp, N, celt_word32);
280       c=0; do {
281          for (b=0;b<B;b++)
282          {
283             int j;
284             clt_mdct_forward(&mode->mdct, in+c*(B*N+overlap)+b*N, tmp, mode->window, overlap, shortBlocks ? mode->maxLM : mode->maxLM-LM);
285             /* Interleaving the sub-frames */
286             for (j=0;j<N;j++)
287                out[(j*B+b)+c*N*B] = tmp[j];
288          }
289       } while (++c<C);
290       RESTORE_STACK;
291    }
292 }
293
294 /** Compute the IMDCT and apply window for all sub-frames and 
295     all channels in a frame */
296 static void compute_inv_mdcts(const CELTMode *mode, int shortBlocks, celt_sig *X,
297       celt_sig * restrict out_mem[],
298       celt_sig * restrict overlap_mem[], int _C, int LM)
299 {
300    int c;
301    const int C = CHANNELS(_C);
302    const int N = mode->shortMdctSize<<LM;
303    const int overlap = OVERLAP(mode);
304    c=0; do {
305       int j;
306          VARDECL(celt_word32, x);
307          VARDECL(celt_word32, tmp);
308          int b;
309          int N2 = N;
310          int B = 1;
311          SAVE_STACK;
312          
313          ALLOC(x, N+overlap, celt_word32);
314          ALLOC(tmp, N, celt_word32);
315
316          if (shortBlocks)
317          {
318             N2 = mode->shortMdctSize;
319             B = shortBlocks;
320          }
321          /* Prevents problems from the imdct doing the overlap-add */
322          CELT_MEMSET(x, 0, overlap);
323
324          for (b=0;b<B;b++)
325          {
326             /* De-interleaving the sub-frames */
327             for (j=0;j<N2;j++)
328                tmp[j] = X[(j*B+b)+c*N2*B];
329             clt_mdct_backward(&mode->mdct, tmp, x+N2*b, mode->window, overlap, shortBlocks ? mode->maxLM : mode->maxLM-LM);
330          }
331
332          for (j=0;j<overlap;j++)
333             out_mem[c][j] = x[j] + overlap_mem[c][j];
334          for (;j<N;j++)
335             out_mem[c][j] = x[j];
336          for (j=0;j<overlap;j++)
337             overlap_mem[c][j] = x[N+j];
338          RESTORE_STACK;
339    } while (++c<C);
340 }
341
342 static void deemphasis(celt_sig *in[], celt_word16 *pcm, int N, int _C, const celt_word16 *coef, celt_sig *mem)
343 {
344    const int C = CHANNELS(_C);
345    int c;
346    c=0; do {
347       int j;
348       celt_sig * restrict x;
349       celt_word16  * restrict y;
350       celt_sig m = mem[c];
351       x =in[c];
352       y = pcm+c;
353       for (j=0;j<N;j++)
354       {
355          celt_sig tmp = *x + m;
356          m = MULT16_32_Q15(coef[0], tmp)
357            - MULT16_32_Q15(coef[1], *x);
358          tmp = SHL32(MULT16_32_Q15(coef[3], tmp), 2);
359          *y = SCALEOUT(SIG2WORD16(tmp));
360          x++;
361          y+=C;
362       }
363       mem[c] = m;
364    } while (++c<C);
365 }
366
367 #ifdef ENABLE_POSTFILTER
368 /* FIXME: Handle the case where T = maxperiod */
369 static void comb_filter(celt_word32 *y, celt_word32 *x, int T0, int T1, int N,
370       int C, celt_word16 g0, celt_word16 g1, const celt_word16 *window, int overlap)
371 {
372    int i;
373    /* printf ("%d %d %f %f\n", T0, T1, g0, g1); */
374    celt_word16 g00, g01, g02, g10, g11, g12;
375    celt_word16 t0, t1, t2;
376    /* zeros at theta = +/- 5*pi/6 */
377    t0 = QCONST16(.26795f, 15);
378    t1 = QCONST16(.46410f, 15);
379    t2 = QCONST16(.26795f, 15);
380    g00 = MULT16_16_Q15(g0, t0);
381    g01 = MULT16_16_Q15(g0, t1);
382    g02 = MULT16_16_Q15(g0, t2);
383    g10 = MULT16_16_Q15(g1, t0);
384    g11 = MULT16_16_Q15(g1, t1);
385    g12 = MULT16_16_Q15(g1, t2);
386    for (i=0;i<overlap;i++)
387    {
388       celt_word16 f;
389       f = MULT16_16_Q15(window[i],window[i]);
390       y[i] = x[i]
391                + MULT16_32_Q15(MULT16_16_Q15((Q15ONE-f),g01),x[i-T0])
392                + MULT16_32_Q15(MULT16_16_Q15((Q15ONE-f),g00),x[i-T0-1])
393                + MULT16_32_Q15(MULT16_16_Q15((Q15ONE-f),g02),x[i-T0+1])
394                + MULT16_32_Q15(MULT16_16_Q15(f,g11),x[i-T1])
395                + MULT16_32_Q15(MULT16_16_Q15(f,g10),x[i-T1-1])
396                + MULT16_32_Q15(MULT16_16_Q15(f,g12),x[i-T1+1]);
397
398    }
399    for (i=overlap;i<N;i++)
400       y[i] = x[i]
401                + MULT16_32_Q15(g11,x[i-T1])
402                + MULT16_32_Q15(g10,x[i-T1-1])
403                + MULT16_32_Q15(g12,x[i-T1+1]);
404 }
405 #endif /* ENABLE_POSTFILTER */
406
407 static const signed char tf_select_table[4][8] = {
408       {0, -1, 0, -1,    0,-1, 0,-1},
409       {0, -1, 0, -2,    1, 0, 1 -1},
410       {0, -2, 0, -3,    2, 0, 1 -1},
411       {0, -2, 0, -3,    2, 0, 1 -1},
412 };
413
414 static celt_word32 l1_metric(const celt_norm *tmp, int N, int LM, int width)
415 {
416    int i, j;
417    static const celt_word16 sqrtM_1[4] = {Q15ONE, QCONST16(0.70711f,15), QCONST16(0.5f,15), QCONST16(0.35355f,15)};
418    celt_word32 L1;
419    celt_word16 bias;
420    L1=0;
421    for (i=0;i<1<<LM;i++)
422    {
423       celt_word32 L2 = 0;
424       for (j=0;j<N>>LM;j++)
425          L2 = MAC16_16(L2, tmp[(j<<LM)+i], tmp[(j<<LM)+i]);
426       L1 += celt_sqrt(L2);
427    }
428    L1 = MULT16_32_Q15(sqrtM_1[LM], L1);
429    if (width==1)
430       bias = QCONST16(.12f,15)*LM;
431    else if (width==2)
432       bias = QCONST16(.05f,15)*LM;
433    else
434       bias = QCONST16(.02f,15)*LM;
435    L1 = MAC16_32_Q15(L1, bias, L1);
436    return L1;
437 }
438
439 static int tf_analysis(const CELTMode *m, celt_word16 *bandLogE, celt_word16 *oldBandE,
440       int len, int C, int isTransient, int *tf_res, int nbCompressedBytes, celt_norm *X,
441       int N0, int LM, int *tf_sum)
442 {
443    int i;
444    VARDECL(int, metric);
445    int cost0;
446    int cost1;
447    VARDECL(int, path0);
448    VARDECL(int, path1);
449    VARDECL(celt_norm, tmp);
450    int lambda;
451    int tf_select=0;
452    SAVE_STACK;
453
454    /* FIXME: Should check number of bytes *left* */
455    if (nbCompressedBytes<15*C)
456    {
457       *tf_sum = 0;
458       for (i=0;i<len;i++)
459          tf_res[i] = isTransient;
460       return 0;
461    }
462    if (nbCompressedBytes<40)
463       lambda = 12;
464    else if (nbCompressedBytes<60)
465       lambda = 6;
466    else if (nbCompressedBytes<100)
467       lambda = 4;
468    else
469       lambda = 3;
470
471    ALLOC(metric, len, int);
472    ALLOC(tmp, (m->eBands[len]-m->eBands[len-1])<<LM, celt_norm);
473    ALLOC(path0, len, int);
474    ALLOC(path1, len, int);
475
476    *tf_sum = 0;
477    for (i=0;i<len;i++)
478    {
479       int j, k, N;
480       celt_word32 L1, best_L1;
481       int best_level=0;
482       N = (m->eBands[i+1]-m->eBands[i])<<LM;
483       for (j=0;j<N;j++)
484          tmp[j] = X[j+(m->eBands[i]<<LM)];
485       /* FIXME: Do something with the right channel */
486       if (C==2)
487          for (j=0;j<N;j++)
488             tmp[j] = ADD16(tmp[j],X[N0+j+(m->eBands[i]<<LM)]);
489       L1 = l1_metric(tmp, N, isTransient ? LM : 0, N>>LM);
490       best_L1 = L1;
491       /*printf ("%f ", L1);*/
492       for (k=0;k<LM;k++)
493       {
494          int B;
495
496          if (isTransient)
497             B = (LM-k-1);
498          else
499             B = k+1;
500
501          if (isTransient)
502             haar1(tmp, N>>(LM-k), 1<<(LM-k));
503          else
504             haar1(tmp, N>>k, 1<<k);
505
506          L1 = l1_metric(tmp, N, B, N>>LM);
507
508          if (L1 < best_L1)
509          {
510             best_L1 = L1;
511             best_level = k+1;
512          }
513       }
514       /*printf ("%d ", isTransient ? LM-best_level : best_level);*/
515       if (isTransient)
516          metric[i] = best_level;
517       else
518          metric[i] = -best_level;
519       *tf_sum += metric[i];
520    }
521    /*printf("\n");*/
522    /* FIXME: Figure out how to set this */
523    tf_select = 0;
524
525    cost0 = 0;
526    cost1 = isTransient ? 0 : lambda;
527    /* Viterbi forward pass */
528    for (i=1;i<len;i++)
529    {
530       int curr0, curr1;
531       int from0, from1;
532
533       from0 = cost0;
534       from1 = cost1 + lambda;
535       if (from0 < from1)
536       {
537          curr0 = from0;
538          path0[i]= 0;
539       } else {
540          curr0 = from1;
541          path0[i]= 1;
542       }
543
544       from0 = cost0 + lambda;
545       from1 = cost1;
546       if (from0 < from1)
547       {
548          curr1 = from0;
549          path1[i]= 0;
550       } else {
551          curr1 = from1;
552          path1[i]= 1;
553       }
554       cost0 = curr0 + abs(metric[i]-tf_select_table[LM][4*isTransient+2*tf_select+0]);
555       cost1 = curr1 + abs(metric[i]-tf_select_table[LM][4*isTransient+2*tf_select+1]);
556    }
557    tf_res[len-1] = cost0 < cost1 ? 0 : 1;
558    /* Viterbi backward pass to check the decisions */
559    for (i=len-2;i>=0;i--)
560    {
561       if (tf_res[i+1] == 1)
562          tf_res[i] = path1[i+1];
563       else
564          tf_res[i] = path0[i+1];
565    }
566    RESTORE_STACK;
567    return tf_select;
568 }
569
570 static void tf_encode(int start, int end, int isTransient, int *tf_res, int LM, int tf_select, ec_enc *enc)
571 {
572    int curr, i;
573    ec_enc_bit_prob(enc, tf_res[start], isTransient ? 16384 : 4096);
574    curr = tf_res[start];
575    for (i=start+1;i<end;i++)
576    {
577       ec_enc_bit_prob(enc, tf_res[i] ^ curr, isTransient ? 4096 : 2048);
578       curr = tf_res[i];
579    }
580    ec_enc_bits(enc, tf_select, 1);
581    for (i=start;i<end;i++)
582       tf_res[i] = tf_select_table[LM][4*isTransient+2*tf_select+tf_res[i]];
583    /*printf("%d %d ", isTransient, tf_select); for(i=0;i<end;i++)printf("%d ", tf_res[i]);printf("\n");*/
584 }
585
586 static void tf_decode(int start, int end, int C, int isTransient, int *tf_res, int LM, ec_dec *dec)
587 {
588    int i, curr, tf_select;
589    tf_res[start] = ec_dec_bit_prob(dec, isTransient ? 16384 : 4096);
590    curr = tf_res[start];
591    for (i=start+1;i<end;i++)
592    {
593       tf_res[i] = ec_dec_bit_prob(dec, isTransient ? 4096 : 2048) ^ curr;
594       curr = tf_res[i];
595    }
596    tf_select = ec_dec_bits(dec, 1);
597    for (i=start;i<end;i++)
598       tf_res[i] = tf_select_table[LM][4*isTransient+2*tf_select+tf_res[i]];
599 }
600
601 static int alloc_trim_analysis(const CELTMode *m, const celt_norm *X,
602       const celt_word16 *bandLogE, int nbEBands, int LM, int C, int N0)
603 {
604    int i;
605    int trim_index = 5;
606    if (C==2)
607    {
608       celt_word16 sum = 0; /* Q10 */
609       /* Compute inter-channel correlation for low frequencies */
610       for (i=0;i<8;i++)
611       {
612          int j;
613          celt_word32 partial = 0;
614          for (j=m->eBands[i]<<LM;j<m->eBands[i+1]<<LM;j++)
615             partial = MAC16_16(partial, X[j], X[N0+j]);
616          sum = ADD16(sum, EXTRACT16(SHR32(partial, 18)));
617       }
618       sum = MULT16_16_Q15(QCONST16(1.f/8, 15), sum);
619       /*printf ("%f\n", sum);*/
620       if (sum > QCONST16(.995f,10))
621          trim_index-=4;
622       else if (sum > QCONST16(.92f,10))
623          trim_index-=3;
624       else if (sum > QCONST16(.85f,10))
625          trim_index-=2;
626       else if (sum > QCONST16(.8f,10))
627          trim_index-=1;
628    }
629 #if 0
630    float diff=0;
631    int c;
632    c=0; do {
633       for (i=0;i<nbEBands-1;i++)
634       {
635          diff += bandLogE[i+c*nbEBands]*(i-.5*nbEBands);
636       }
637    } while (++c<0);
638    diff /= C*(nbEBands-1);
639    /*printf("%f\n", diff);*/
640    if (diff > 4)
641       trim_index--;
642    if (diff > 8)
643       trim_index--;
644    if (diff < -4)
645       trim_index++;
646 #endif
647    if (trim_index<0)
648       trim_index = 0;
649    if (trim_index>5)
650       trim_index = 5;
651    return trim_index;
652 }
653
654 static int stereo_analysis(const CELTMode *m, const celt_norm *X,
655       int nbEBands, int LM, int C, int N0)
656 {
657    int i;
658    int thetas;
659    celt_word32 sumLR = EPSILON, sumMS = EPSILON;
660
661    /* Use the L1 norm to model the entropy of the L/R signal vs the M/S signal */
662    for (i=0;i<13;i++)
663    {
664       int j;
665       for (j=m->eBands[i]<<LM;j<m->eBands[i+1]<<LM;j++)
666       {
667          celt_word16 L, R, M, S;
668          L = X[j];
669          R = X[N0+j];
670          M = L+R;
671          S = L-R;
672          sumLR += EXTEND32(ABS16(L)) + EXTEND32(ABS16(R));
673          sumMS += EXTEND32(ABS16(M)) + EXTEND32(ABS16(S));
674       }
675    }
676    sumMS = MULT16_32_Q15(QCONST16(0.707107f, 15), sumMS);
677    thetas = 13;
678    /* We don't need thetas for lower bands with LM<=1 */
679    if (LM<=1)
680       thetas -= 8;
681    return MULT16_32_Q15((m->eBands[13]<<(LM+1))+thetas, sumMS)
682          > MULT16_32_Q15(m->eBands[13]<<(LM+1), sumLR);
683 }
684
685 #ifdef FIXED_POINT
686 int celt_encode_with_ec(CELTEncoder * restrict st, const celt_int16 * pcm, int frame_size, unsigned char *compressed, int nbCompressedBytes, ec_enc *enc)
687 {
688 #else
689 int celt_encode_with_ec_float(CELTEncoder * restrict st, const celt_sig * pcm, int frame_size, unsigned char *compressed, int nbCompressedBytes, ec_enc *enc)
690 {
691 #endif
692    int i, c, N;
693    int bits;
694    int has_fold=1;
695    ec_byte_buffer buf;
696    ec_enc         _enc;
697    VARDECL(celt_sig, in);
698    VARDECL(celt_sig, freq);
699    VARDECL(celt_norm, X);
700    VARDECL(celt_ener, bandE);
701    VARDECL(celt_word16, bandLogE);
702    VARDECL(int, fine_quant);
703    VARDECL(celt_word16, error);
704    VARDECL(int, pulses);
705    VARDECL(int, offsets);
706    VARDECL(int, fine_priority);
707    VARDECL(int, tf_res);
708    celt_sig *_overlap_mem;
709    celt_sig *prefilter_mem;
710    celt_word16 *oldBandE;
711    int shortBlocks=0;
712    int isTransient=0;
713    int resynth;
714    const int C = CHANNELS(st->channels);
715    int LM, M;
716    int tf_select;
717    int nbFilledBytes, nbAvailableBytes;
718    int effEnd;
719    int codedBands;
720    int tf_sum;
721    int alloc_trim;
722    int pitch_index=0;
723    celt_word16 gain1 = 0;
724    int intensity=0;
725    int dual_stereo=0;
726    int effectiveBytes;
727    SAVE_STACK;
728
729    if (nbCompressedBytes<0 || pcm==NULL)
730      return CELT_BAD_ARG;
731
732    for (LM=0;LM<4;LM++)
733       if (st->mode->shortMdctSize<<LM==frame_size)
734          break;
735    if (LM>=MAX_CONFIG_SIZES)
736       return CELT_BAD_ARG;
737    M=1<<LM;
738
739    prefilter_mem = st->in_mem+C*(st->overlap);
740    _overlap_mem = prefilter_mem+C*COMBFILTER_MAXPERIOD;
741    /*_overlap_mem = st->in_mem+C*(st->overlap);*/
742    oldBandE = (celt_word16*)(st->in_mem+C*(2*st->overlap+COMBFILTER_MAXPERIOD));
743
744    if (enc==NULL)
745    {
746       ec_byte_writeinit_buffer(&buf, compressed, nbCompressedBytes);
747       ec_enc_init(&_enc,&buf);
748       enc = &_enc;
749       nbFilledBytes=0;
750    } else {
751       nbFilledBytes=(ec_enc_tell(enc, 0)+4)>>3;
752    }
753    nbAvailableBytes = nbCompressedBytes - nbFilledBytes;
754
755    if (st->vbr_rate_norm>0)
756       effectiveBytes = st->vbr_rate_norm>>BITRES<<LM>>3;
757    else
758       effectiveBytes = nbCompressedBytes;
759
760    effEnd = st->end;
761    if (effEnd > st->mode->effEBands)
762       effEnd = st->mode->effEBands;
763
764    N = M*st->mode->shortMdctSize;
765    ALLOC(in, C*(N+st->overlap), celt_sig);
766
767    /* Find pitch period and gain */
768    {
769       VARDECL(celt_sig, _pre);
770       celt_sig *pre[2];
771       SAVE_STACK;
772       c = 0;
773       ALLOC(_pre, C*(N+COMBFILTER_MAXPERIOD), celt_sig);
774
775       pre[0] = _pre;
776       pre[1] = _pre + (N+COMBFILTER_MAXPERIOD);
777
778       c=0; do {
779          const celt_word16 * restrict pcmp = pcm+c;
780          celt_sig * restrict inp = in+c*(N+st->overlap)+st->overlap;
781
782          for (i=0;i<N;i++)
783          {
784             /* Apply pre-emphasis */
785             celt_sig tmp = MULT16_16(st->mode->preemph[2], SCALEIN(*pcmp));
786             *inp = tmp + st->preemph_memE[c];
787             st->preemph_memE[c] = MULT16_32_Q15(st->mode->preemph[1], *inp)
788                                    - MULT16_32_Q15(st->mode->preemph[0], tmp);
789             inp++;
790             pcmp+=C;
791          }
792          CELT_COPY(pre[c], prefilter_mem+c*COMBFILTER_MAXPERIOD, COMBFILTER_MAXPERIOD);
793          CELT_COPY(pre[c]+COMBFILTER_MAXPERIOD, in+c*(N+st->overlap)+st->overlap, N);
794       } while (++c<C);
795
796 #ifdef ENABLE_POSTFILTER
797       {
798          VARDECL(celt_word16, pitch_buf);
799          ALLOC(pitch_buf, (COMBFILTER_MAXPERIOD+N)>>1, celt_word16);
800          celt_word32 tmp=0;
801          celt_word32 mem0[2]={0,0};
802          celt_word16 mem1[2]={0,0};
803
804          pitch_downsample(pre, pitch_buf, COMBFILTER_MAXPERIOD+N, COMBFILTER_MAXPERIOD+N,
805                           C, mem0, mem1);
806          pitch_search(st->mode, pitch_buf+(COMBFILTER_MAXPERIOD>>1), pitch_buf, N,
807                COMBFILTER_MAXPERIOD-COMBFILTER_MINPERIOD, &pitch_index, &tmp, 1<<LM);
808          pitch_index = COMBFILTER_MAXPERIOD-pitch_index;
809
810          gain1 = remove_doubling(pitch_buf, COMBFILTER_MAXPERIOD, COMBFILTER_MINPERIOD,
811                N, &pitch_index, st->prefilter_period, st->prefilter_gain);
812       }
813       if (pitch_index > COMBFILTER_MAXPERIOD)
814          pitch_index = COMBFILTER_MAXPERIOD;
815       gain1 = MULT16_16_Q15(QCONST16(.7f,15),gain1);
816       if (gain1 > QCONST16(.6f,15))
817          gain1 = QCONST16(.6f,15);
818       if (ABS16(gain1-st->prefilter_gain)<QCONST16(.1,15))
819          gain1=st->prefilter_gain;
820       if (gain1<QCONST16(.2f,15))
821       {
822          ec_enc_bit_prob(enc, 0, 32768);
823          gain1 = 0;
824       } else {
825          int qg;
826          int octave;
827 #ifdef FIXED_POINT
828          qg = ((gain1+2048)>>12)-2;
829 #else
830          qg = floor(.5+gain1*8)-2;
831 #endif
832          ec_enc_bit_prob(enc, 1, 32768);
833          octave = EC_ILOG(pitch_index)-5;
834          ec_enc_uint(enc, octave, 6);
835          ec_enc_bits(enc, pitch_index-(16<<octave), 4+octave);
836          ec_enc_bits(enc, qg, 2);
837          gain1 = QCONST16(.125f,15)*(qg+2);
838       }
839       /*printf("%d %f\n", pitch_index, gain1);*/
840 #else /* ENABLE_POSTFILTER */
841       ec_enc_bit_prob(enc, 0, 32768);
842 #endif /* ENABLE_POSTFILTER */
843
844       c=0; do {
845          CELT_COPY(in+c*(N+st->overlap), st->in_mem+c*(st->overlap), st->overlap);
846 #ifdef ENABLE_POSTFILTER
847          comb_filter(in+c*(N+st->overlap)+st->overlap, pre[c]+COMBFILTER_MAXPERIOD,
848                st->prefilter_period, pitch_index, N, C, -st->prefilter_gain, -gain1, st->mode->window, st->mode->overlap);
849 #endif /* ENABLE_POSTFILTER */
850          CELT_COPY(st->in_mem+c*(st->overlap), in+c*(N+st->overlap)+N, st->overlap);
851
852 #ifdef ENABLE_POSTFILTER
853          if (N>COMBFILTER_MAXPERIOD)
854          {
855             CELT_MOVE(prefilter_mem+c*COMBFILTER_MAXPERIOD, pre[c]+N, COMBFILTER_MAXPERIOD);
856          } else {
857             CELT_MOVE(prefilter_mem+c*COMBFILTER_MAXPERIOD, prefilter_mem+c*COMBFILTER_MAXPERIOD+N, COMBFILTER_MAXPERIOD-N);
858             CELT_MOVE(prefilter_mem+c*COMBFILTER_MAXPERIOD+COMBFILTER_MAXPERIOD-N, pre[c]+COMBFILTER_MAXPERIOD, N);
859          }
860 #endif /* ENABLE_POSTFILTER */
861       } while (++c<C);
862
863       RESTORE_STACK;
864    }
865
866 #ifdef RESYNTH
867    resynth = 1;
868 #else
869    resynth = 0;
870 #endif
871
872    if (st->complexity > 1 && LM>0)
873    {
874       isTransient = M > 1 &&
875          transient_analysis(in, N+st->overlap, C, &st->frame_max, st->overlap);
876    } else {
877       isTransient = 0;
878    }
879
880    if (isTransient)
881       shortBlocks = M;
882    else
883       shortBlocks = 0;
884
885    ALLOC(freq, C*N, celt_sig); /**< Interleaved signal MDCTs */
886    ALLOC(bandE,st->mode->nbEBands*C, celt_ener);
887    ALLOC(bandLogE,st->mode->nbEBands*C, celt_word16);
888    /* Compute MDCTs */
889    compute_mdcts(st->mode, shortBlocks, in, freq, C, LM);
890
891    ALLOC(X, C*N, celt_norm);         /**< Interleaved normalised MDCTs */
892
893    compute_band_energies(st->mode, freq, bandE, effEnd, C, M);
894
895    amp2Log2(st->mode, effEnd, st->end, bandE, bandLogE, C);
896
897    /* Band normalisation */
898    normalise_bands(st->mode, freq, X, bandE, effEnd, C, M);
899
900    ALLOC(tf_res, st->mode->nbEBands, int);
901    /* Needs to be before coarse energy quantization because otherwise the energy gets modified */
902    tf_select = tf_analysis(st->mode, bandLogE, oldBandE, effEnd, C, isTransient, tf_res, effectiveBytes, X, N, LM, &tf_sum);
903    for (i=effEnd;i<st->end;i++)
904       tf_res[i] = tf_res[effEnd-1];
905
906    ALLOC(error, C*st->mode->nbEBands, celt_word16);
907    quant_coarse_energy(st->mode, st->start, st->end, effEnd, bandLogE,
908          oldBandE, nbCompressedBytes*8, error, enc,
909          C, LM, nbAvailableBytes, st->force_intra,
910          &st->delayedIntra, st->complexity >= 4);
911
912    if (LM > 0)
913       ec_enc_bit_prob(enc, shortBlocks!=0, 8192);
914
915    tf_encode(st->start, st->end, isTransient, tf_res, LM, tf_select, enc);
916
917    if (shortBlocks || st->complexity < 3)
918    {
919       if (st->complexity == 0)
920       {
921          has_fold = 0;
922          st->fold_decision = 3;
923       } else {
924          has_fold = 1;
925          st->fold_decision = 1;
926       }
927    } else {
928       has_fold = folding_decision(st->mode, X, &st->tonal_average, &st->fold_decision, effEnd, C, M);
929    }
930    ec_enc_bit_prob(enc, has_fold>>1, 8192);
931    ec_enc_bit_prob(enc, has_fold&1, (has_fold>>1) ? 32768 : 49152);
932
933    ALLOC(offsets, st->mode->nbEBands, int);
934
935    for (i=0;i<st->mode->nbEBands;i++)
936       offsets[i] = 0;
937    /* Dynamic allocation code */
938    /* Make sure that dynamic allocation can't make us bust the budget */
939    if (effectiveBytes > 50 && LM>=1)
940    {
941       int t1, t2;
942       if (LM <= 1)
943       {
944          t1 = 3;
945          t2 = 5;
946       } else {
947          t1 = 2;
948          t2 = 4;
949       }
950       for (i=1;i<st->mode->nbEBands-1;i++)
951       {
952          celt_word32 d2;
953          d2 = 2*bandLogE[i]-bandLogE[i-1]-bandLogE[i+1];
954          if (C==2)
955             d2 = HALF32(d2 + 2*bandLogE[i+st->mode->nbEBands]-
956                   bandLogE[i-1+st->mode->nbEBands]-bandLogE[i+1+st->mode->nbEBands]);
957          if (d2 > SHL16(t1,DB_SHIFT))
958             offsets[i] += 1;
959          if (d2 > SHL16(t2,DB_SHIFT))
960             offsets[i] += 1;
961       }
962    }
963    for (i=0;i<st->mode->nbEBands;i++)
964    {
965       int j;
966       ec_enc_bit_prob(enc, offsets[i]!=0, 1024);
967       if (offsets[i]!=0)
968       {
969          for (j=0;j<offsets[i]-1;j++)
970             ec_enc_bit_prob(enc, 1, 32768);
971          ec_enc_bit_prob(enc, 0, 32768);
972       }
973       offsets[i] *= (6<<BITRES);
974    }
975    alloc_trim = alloc_trim_analysis(st->mode, X, bandLogE, st->mode->nbEBands, LM, C, N);
976    ec_encode_bin(enc, trim_cdf[alloc_trim], trim_cdf[alloc_trim+1], 7);
977
978    /* Variable bitrate */
979    if (st->vbr_rate_norm>0)
980    {
981      celt_word16 alpha;
982      celt_int32 delta, tell;
983      /* The target rate in 8th bits per frame */
984      celt_int32 vbr_rate;
985      celt_int32 target;
986      celt_int32 vbr_bound, max_allowed, min_allowed;
987
988      target = vbr_rate = M*st->vbr_rate_norm;
989
990      target = target + st->vbr_offset - ((40*C+20)<<BITRES);
991
992      /* Shortblocks get a large boost in bitrate, but since they
993         are uncommon long blocks are not greatly affected */
994      if (shortBlocks || tf_sum < -2*(st->end-st->start))
995         target = 7*target/4;
996      else if (tf_sum < -(st->end-st->start))
997         target = 3*target/2;
998      else if (M > 1)
999         target-=(target+14)/28;
1000
1001      tell = ec_enc_tell(enc, BITRES);
1002
1003      /* The current offset is removed from the target and the space used
1004         so far is added*/
1005      target=target+tell;
1006      /* By how much did we "miss" the target on that frame */
1007      delta = target - vbr_rate;
1008
1009      /* Computes the max bit-rate allowed in VBR more to avoid violating the target rate and buffering */
1010      vbr_bound = vbr_rate;
1011      if (st->constrained_vbr)
1012         max_allowed = IMIN(vbr_rate+vbr_bound-st->vbr_reservoir>>(BITRES+3),nbAvailableBytes);
1013      else
1014         max_allowed = nbAvailableBytes;
1015      min_allowed = (tell>>(BITRES+3)) + 2 - nbFilledBytes;
1016
1017      /* In VBR mode the frame size must not be reduced so much that it would result in the encoder running out of bits */
1018      nbAvailableBytes = target+(1<<(BITRES+2))>>(BITRES+3);
1019      nbAvailableBytes=IMAX(min_allowed,IMIN(max_allowed,nbAvailableBytes));
1020      target=nbAvailableBytes<<(BITRES+3);
1021
1022      if (st->vbr_count < 970)
1023      {
1024         st->vbr_count++;
1025         alpha = celt_rcp(SHL32(EXTEND32(st->vbr_count+20),16));
1026      } else
1027         alpha = QCONST16(.001f,15);
1028      /* How many bits have we used in excess of what we're allowed */
1029      if (st->constrained_vbr)
1030         st->vbr_reservoir += target - vbr_rate;
1031      /*printf ("%d\n", st->vbr_reservoir);*/
1032
1033      /* Compute the offset we need to apply in order to reach the target */
1034      st->vbr_drift += (celt_int32)MULT16_32_Q15(alpha,delta-st->vbr_offset-st->vbr_drift);
1035      st->vbr_offset = -st->vbr_drift;
1036      /*printf ("%d\n", st->vbr_drift);*/
1037
1038      /* We could use any multiple of vbr_rate as bound (depending on the delay) */
1039      if (st->constrained_vbr && st->vbr_reservoir < 0)
1040      {
1041         /* We're under the min value -- increase rate */
1042         int adjust = (-st->vbr_reservoir)/(8<<BITRES);
1043         nbAvailableBytes += adjust;
1044         st->vbr_reservoir = 0;
1045         /*printf ("+%d\n", adjust);*/
1046      }
1047      nbCompressedBytes = IMIN(nbCompressedBytes,nbAvailableBytes+nbFilledBytes);
1048
1049      /* This moves the raw bits to take into account the new compressed size */
1050      ec_byte_shrink(&buf, nbCompressedBytes);
1051    }
1052
1053    if (C==2)
1054    {
1055       dual_stereo = stereo_analysis(st->mode, X, st->mode->nbEBands, LM, C, N);
1056       ec_enc_bit_prob(enc, dual_stereo, 32768);
1057    }
1058    if (C==2)
1059    {
1060       int effectiveRate;
1061
1062       /* Account for coarse energy */
1063       effectiveRate = (8*effectiveBytes - 80)>>LM;
1064
1065       /* effectiveRate in kb/s */
1066       effectiveRate = 2*effectiveRate/5;
1067       if (effectiveRate<35)
1068          intensity = 6;
1069       else if (effectiveRate<50)
1070          intensity = 12;
1071       else if (effectiveRate<68)
1072          intensity = 16;
1073       else if (effectiveRate<84)
1074          intensity = 18;
1075       else if (effectiveRate<102)
1076          intensity = 19;
1077       else if (effectiveRate<130)
1078          intensity = 20;
1079       else
1080          intensity = 100;
1081       intensity = IMIN(st->end,IMAX(st->start, intensity));
1082       ec_enc_uint(enc, intensity, 1+st->end-st->start);
1083    }
1084
1085    /* Bit allocation */
1086    ALLOC(fine_quant, st->mode->nbEBands, int);
1087    ALLOC(pulses, st->mode->nbEBands, int);
1088    ALLOC(fine_priority, st->mode->nbEBands, int);
1089
1090    bits = nbCompressedBytes*8 - ec_enc_tell(enc, 0) - 1;
1091    codedBands = compute_allocation(st->mode, st->start, st->end, offsets, alloc_trim, bits, pulses, fine_quant, fine_priority, C, LM);
1092
1093    quant_fine_energy(st->mode, st->start, st->end, bandE, oldBandE, error, fine_quant, enc, C);
1094
1095 #ifdef MEASURE_NORM_MSE
1096    float X0[3000];
1097    float bandE0[60];
1098    c=0; do 
1099       for (i=0;i<N;i++)
1100          X0[i+c*N] = X[i+c*N];
1101    while (++c<C);
1102    for (i=0;i<C*st->mode->nbEBands;i++)
1103       bandE0[i] = bandE[i];
1104 #endif
1105
1106    /* Residual quantisation */
1107    quant_all_bands(1, st->mode, st->start, st->end, X, C==2 ? X+N : NULL,
1108          bandE, pulses, shortBlocks, has_fold, dual_stereo, intensity, tf_res, resynth,
1109          nbCompressedBytes*8, enc, LM, codedBands);
1110
1111    quant_energy_finalise(st->mode, st->start, st->end, bandE, oldBandE, error, fine_quant, fine_priority, nbCompressedBytes*8-ec_enc_tell(enc, 0), enc, C);
1112
1113 #ifdef RESYNTH
1114    /* Re-synthesis of the coded audio if required */
1115    if (resynth)
1116    {
1117       celt_sig *out_mem[2];
1118       celt_sig *overlap_mem[2];
1119
1120       log2Amp(st->mode, st->start, st->end, bandE, oldBandE, C);
1121
1122 #ifdef MEASURE_NORM_MSE
1123       measure_norm_mse(st->mode, X, X0, bandE, bandE0, M, N, C);
1124 #endif
1125
1126       /* Synthesis */
1127       denormalise_bands(st->mode, X, freq, bandE, effEnd, C, M);
1128
1129       CELT_MOVE(st->syn_mem[0], st->syn_mem[0]+N, MAX_PERIOD);
1130       if (C==2)
1131          CELT_MOVE(st->syn_mem[1], st->syn_mem[1]+N, MAX_PERIOD);
1132
1133       c=0; do
1134          for (i=0;i<M*st->mode->eBands[st->start];i++)
1135             freq[c*N+i] = 0;
1136       while (++c<C);
1137       c=0; do
1138          for (i=M*st->mode->eBands[st->end];i<N;i++)
1139             freq[c*N+i] = 0;
1140       while (++c<C);
1141
1142       out_mem[0] = st->syn_mem[0]+MAX_PERIOD;
1143       if (C==2)
1144          out_mem[1] = st->syn_mem[1]+MAX_PERIOD;
1145
1146       c=0; do
1147          overlap_mem[c] = _overlap_mem + c*st->overlap;
1148       while (++c<C);
1149
1150       compute_inv_mdcts(st->mode, shortBlocks, freq, out_mem, overlap_mem, C, LM);
1151
1152 #ifdef ENABLE_POSTFILTER
1153       c=0; do {
1154          comb_filter(out_mem[c], out_mem[c], st->prefilter_period, st->prefilter_period, st->overlap, C,
1155                st->prefilter_gain, st->prefilter_gain, NULL, 0);
1156          comb_filter(out_mem[c]+st->overlap, out_mem[c]+st->overlap, st->prefilter_period, pitch_index, N-st->overlap, C,
1157                st->prefilter_gain, gain1, st->mode->window, st->mode->overlap);
1158       } while (++c<C);
1159 #endif /* ENABLE_POSTFILTER */
1160
1161       deemphasis(out_mem, (celt_word16*)pcm, N, C, st->mode->preemph, st->preemph_memD);
1162    }
1163 #endif
1164
1165    st->prefilter_period = pitch_index;
1166    st->prefilter_gain = gain1;
1167
1168    /* If there's any room left (can only happen for very high rates),
1169       fill it with zeros */
1170    while (ec_enc_tell(enc,0) + 8 <= nbCompressedBytes*8)
1171       ec_enc_bits(enc, 0, 8);
1172    ec_enc_done(enc);
1173    
1174    RESTORE_STACK;
1175    if (ec_enc_get_error(enc))
1176       return CELT_CORRUPTED_DATA;
1177    else
1178       return nbCompressedBytes;
1179 }
1180
1181 #ifdef FIXED_POINT
1182 #ifndef DISABLE_FLOAT_API
1183 int celt_encode_with_ec_float(CELTEncoder * restrict st, const float * pcm, int frame_size, unsigned char *compressed, int nbCompressedBytes, ec_enc *enc)
1184 {
1185    int j, ret, C, N, LM, M;
1186    VARDECL(celt_int16, in);
1187    SAVE_STACK;
1188
1189    if (pcm==NULL)
1190       return CELT_BAD_ARG;
1191
1192    for (LM=0;LM<4;LM++)
1193       if (st->mode->shortMdctSize<<LM==frame_size)
1194          break;
1195    if (LM>=MAX_CONFIG_SIZES)
1196       return CELT_BAD_ARG;
1197    M=1<<LM;
1198
1199    C = CHANNELS(st->channels);
1200    N = M*st->mode->shortMdctSize;
1201    ALLOC(in, C*N, celt_int16);
1202
1203    for (j=0;j<C*N;j++)
1204      in[j] = FLOAT2INT16(pcm[j]);
1205
1206    ret=celt_encode_with_ec(st,in,frame_size,compressed,nbCompressedBytes, enc);
1207 #ifdef RESYNTH
1208    for (j=0;j<C*N;j++)
1209       ((float*)pcm)[j]=in[j]*(1.f/32768.f);
1210 #endif
1211    RESTORE_STACK;
1212    return ret;
1213
1214 }
1215 #endif /*DISABLE_FLOAT_API*/
1216 #else
1217 int celt_encode_with_ec(CELTEncoder * restrict st, const celt_int16 * pcm, int frame_size, unsigned char *compressed, int nbCompressedBytes, ec_enc *enc)
1218 {
1219    int j, ret, C, N, LM, M;
1220    VARDECL(celt_sig, in);
1221    SAVE_STACK;
1222
1223    if (pcm==NULL)
1224       return CELT_BAD_ARG;
1225
1226    for (LM=0;LM<4;LM++)
1227       if (st->mode->shortMdctSize<<LM==frame_size)
1228          break;
1229    if (LM>=MAX_CONFIG_SIZES)
1230       return CELT_BAD_ARG;
1231    M=1<<LM;
1232
1233    C=CHANNELS(st->channels);
1234    N=M*st->mode->shortMdctSize;
1235    ALLOC(in, C*N, celt_sig);
1236    for (j=0;j<C*N;j++) {
1237      in[j] = SCALEOUT(pcm[j]);
1238    }
1239
1240    ret = celt_encode_with_ec_float(st,in,frame_size,compressed,nbCompressedBytes, enc);
1241 #ifdef RESYNTH
1242    for (j=0;j<C*N;j++)
1243       ((celt_int16*)pcm)[j] = FLOAT2INT16(in[j]);
1244 #endif
1245    RESTORE_STACK;
1246    return ret;
1247 }
1248 #endif
1249
1250 int celt_encode(CELTEncoder * restrict st, const celt_int16 * pcm, int frame_size, unsigned char *compressed, int nbCompressedBytes)
1251 {
1252    return celt_encode_with_ec(st, pcm, frame_size, compressed, nbCompressedBytes, NULL);
1253 }
1254
1255 #ifndef DISABLE_FLOAT_API
1256 int celt_encode_float(CELTEncoder * restrict st, const float * pcm, int frame_size, unsigned char *compressed, int nbCompressedBytes)
1257 {
1258    return celt_encode_with_ec_float(st, pcm, frame_size, compressed, nbCompressedBytes, NULL);
1259 }
1260 #endif /* DISABLE_FLOAT_API */
1261
1262 int celt_encoder_ctl(CELTEncoder * restrict st, int request, ...)
1263 {
1264    va_list ap;
1265    
1266    va_start(ap, request);
1267    switch (request)
1268    {
1269       case CELT_GET_MODE_REQUEST:
1270       {
1271          const CELTMode ** value = va_arg(ap, const CELTMode**);
1272          if (value==0)
1273             goto bad_arg;
1274          *value=st->mode;
1275       }
1276       break;
1277       case CELT_SET_COMPLEXITY_REQUEST:
1278       {
1279          int value = va_arg(ap, celt_int32);
1280          if (value<0 || value>10)
1281             goto bad_arg;
1282          st->complexity = value;
1283       }
1284       break;
1285       case CELT_SET_START_BAND_REQUEST:
1286       {
1287          celt_int32 value = va_arg(ap, celt_int32);
1288          if (value<0 || value>=st->mode->nbEBands)
1289             goto bad_arg;
1290          st->start = value;
1291       }
1292       break;
1293       case CELT_SET_END_BAND_REQUEST:
1294       {
1295          celt_int32 value = va_arg(ap, celt_int32);
1296          if (value<0 || value>=st->mode->nbEBands)
1297             goto bad_arg;
1298          st->end = value;
1299       }
1300       break;
1301       case CELT_SET_PREDICTION_REQUEST:
1302       {
1303          int value = va_arg(ap, celt_int32);
1304          if (value<0 || value>2)
1305             goto bad_arg;
1306          if (value==0)
1307          {
1308             st->force_intra   = 1;
1309          } else if (value==1) {
1310             st->force_intra   = 0;
1311          } else {
1312             st->force_intra   = 0;
1313          }   
1314       }
1315       break;
1316       case CELT_SET_VBR_RATE_REQUEST:
1317       {
1318          celt_int32 value = va_arg(ap, celt_int32);
1319          int frame_rate;
1320          int N = st->mode->shortMdctSize;
1321          if (value<0)
1322             goto bad_arg;
1323          if (value>3072000)
1324             value = 3072000;
1325          frame_rate = ((st->mode->Fs<<3)+(N>>1))/N;
1326          st->vbr_rate_norm = ((value<<(BITRES+3))+(frame_rate>>1))/frame_rate;
1327       }
1328       break;
1329       case CELT_RESET_STATE:
1330       {
1331          CELT_MEMSET((char*)&st->ENCODER_RESET_START, 0,
1332                celt_encoder_get_size(st->mode, st->channels)-
1333                ((char*)&st->ENCODER_RESET_START - (char*)st));
1334          st->vbr_offset = 0;
1335          st->delayedIntra = 1;
1336          st->fold_decision = 1;
1337          st->tonal_average = QCONST16(1.f,8);
1338       }
1339       break;
1340       default:
1341          goto bad_request;
1342    }
1343    va_end(ap);
1344    return CELT_OK;
1345 bad_arg:
1346    va_end(ap);
1347    return CELT_BAD_ARG;
1348 bad_request:
1349    va_end(ap);
1350    return CELT_UNIMPLEMENTED;
1351 }
1352
1353 /**********************************************************************/
1354 /*                                                                    */
1355 /*                             DECODER                                */
1356 /*                                                                    */
1357 /**********************************************************************/
1358 #define DECODE_BUFFER_SIZE 2048
1359
1360 /** Decoder state 
1361  @brief Decoder state
1362  */
1363 struct CELTDecoder {
1364    const CELTMode *mode;
1365    int overlap;
1366    int channels;
1367
1368    int start, end;
1369
1370    /* Everything beyond this point gets cleared on a reset */
1371 #define DECODER_RESET_START last_pitch_index
1372
1373    int last_pitch_index;
1374    int loss_count;
1375    int postfilter_period;
1376    celt_word16 postfilter_gain;
1377
1378    celt_sig preemph_memD[2];
1379    
1380    celt_sig _decode_mem[1]; /* Size = channels*(DECODE_BUFFER_SIZE+mode->overlap) */
1381    /* celt_word16 lpc[],  Size = channels*LPC_ORDER */
1382    /* celt_word16 oldEBands[], Size = channels*mode->nbEBands */
1383 };
1384
1385 int celt_decoder_get_size(const CELTMode *mode, int channels)
1386 {
1387    int size = sizeof(struct CELTDecoder)
1388             + (channels*(DECODE_BUFFER_SIZE+mode->overlap)-1)*sizeof(celt_sig)
1389             + channels*LPC_ORDER*sizeof(celt_word16)
1390             + channels*mode->nbEBands*sizeof(celt_word16);
1391    return size;
1392 }
1393
1394 CELTDecoder *celt_decoder_create(const CELTMode *mode, int channels, int *error)
1395 {
1396    return celt_decoder_init(
1397          (CELTDecoder *)celt_alloc(celt_decoder_get_size(mode, channels)),
1398          mode, channels, error);
1399 }
1400
1401 CELTDecoder *celt_decoder_init(CELTDecoder *st, const CELTMode *mode, int channels, int *error)
1402 {
1403    if (channels < 0 || channels > 2)
1404    {
1405       if (error)
1406          *error = CELT_BAD_ARG;
1407       return NULL;
1408    }
1409
1410    if (st==NULL)
1411    {
1412       if (error)
1413          *error = CELT_ALLOC_FAIL;
1414       return NULL;
1415    }
1416
1417    CELT_MEMSET((char*)st, 0, celt_decoder_get_size(mode, channels));
1418
1419    st->mode = mode;
1420    st->overlap = mode->overlap;
1421    st->channels = channels;
1422
1423    st->start = 0;
1424    st->end = st->mode->effEBands;
1425
1426    st->loss_count = 0;
1427
1428    if (error)
1429       *error = CELT_OK;
1430    return st;
1431 }
1432
1433 void celt_decoder_destroy(CELTDecoder *st)
1434 {
1435    celt_free(st);
1436 }
1437
1438 static void celt_decode_lost(CELTDecoder * restrict st, celt_word16 * restrict pcm, int N, int LM)
1439 {
1440    int c;
1441    int pitch_index;
1442    int overlap = st->mode->overlap;
1443    celt_word16 fade = Q15ONE;
1444    int i, len;
1445    const int C = CHANNELS(st->channels);
1446    int offset;
1447    celt_sig *out_mem[2];
1448    celt_sig *decode_mem[2];
1449    celt_sig *overlap_mem[2];
1450    celt_word16 *lpc;
1451    SAVE_STACK;
1452    
1453    c=0; do {
1454       decode_mem[c] = st->_decode_mem + c*(DECODE_BUFFER_SIZE+st->overlap);
1455       out_mem[c] = decode_mem[c]+DECODE_BUFFER_SIZE-MAX_PERIOD;
1456       overlap_mem[c] = decode_mem[c]+DECODE_BUFFER_SIZE;
1457    } while (++c<C);
1458    lpc = (celt_word16*)(st->_decode_mem+(DECODE_BUFFER_SIZE+st->overlap)*C);
1459
1460    len = N+st->mode->overlap;
1461    
1462    if (st->loss_count == 0)
1463    {
1464       celt_word16 pitch_buf[MAX_PERIOD>>1];
1465       celt_word32 tmp=0;
1466       celt_word32 mem0[2]={0,0};
1467       celt_word16 mem1[2]={0,0};
1468       int len2 = len;
1469       /* FIXME: This is a kludge */
1470       if (len2>MAX_PERIOD>>1)
1471          len2 = MAX_PERIOD>>1;
1472       pitch_downsample(out_mem, pitch_buf, MAX_PERIOD, MAX_PERIOD,
1473                        C, mem0, mem1);
1474       pitch_search(st->mode, pitch_buf+((MAX_PERIOD-len2)>>1), pitch_buf, len2,
1475                    MAX_PERIOD-len2-100, &pitch_index, &tmp, 1<<LM);
1476       pitch_index = MAX_PERIOD-len2-pitch_index;
1477       st->last_pitch_index = pitch_index;
1478    } else {
1479       pitch_index = st->last_pitch_index;
1480       if (st->loss_count < 5)
1481          fade = QCONST16(.8f,15);
1482       else
1483          fade = 0;
1484    }
1485
1486    c=0; do {
1487       /* FIXME: This is more memory than necessary */
1488       celt_word32 e[2*MAX_PERIOD];
1489       celt_word16 exc[2*MAX_PERIOD];
1490       celt_word32 ac[LPC_ORDER+1];
1491       celt_word16 decay = 1;
1492       celt_word32 S1=0;
1493       celt_word16 mem[LPC_ORDER]={0};
1494
1495       offset = MAX_PERIOD-pitch_index;
1496       for (i=0;i<MAX_PERIOD;i++)
1497          exc[i] = ROUND16(out_mem[c][i], SIG_SHIFT);
1498
1499       if (st->loss_count == 0)
1500       {
1501          _celt_autocorr(exc, ac, st->mode->window, st->mode->overlap,
1502                         LPC_ORDER, MAX_PERIOD);
1503
1504          /* Noise floor -40 dB */
1505 #ifdef FIXED_POINT
1506          ac[0] += SHR32(ac[0],13);
1507 #else
1508          ac[0] *= 1.0001f;
1509 #endif
1510          /* Lag windowing */
1511          for (i=1;i<=LPC_ORDER;i++)
1512          {
1513             /*ac[i] *= exp(-.5*(2*M_PI*.002*i)*(2*M_PI*.002*i));*/
1514 #ifdef FIXED_POINT
1515             ac[i] -= MULT16_32_Q15(2*i*i, ac[i]);
1516 #else
1517             ac[i] -= ac[i]*(.008f*i)*(.008f*i);
1518 #endif
1519          }
1520
1521          _celt_lpc(lpc+c*LPC_ORDER, ac, LPC_ORDER);
1522       }
1523       for (i=0;i<LPC_ORDER;i++)
1524          mem[i] = ROUND16(out_mem[c][MAX_PERIOD-1-i], SIG_SHIFT);
1525       fir(exc, lpc+c*LPC_ORDER, exc, MAX_PERIOD, LPC_ORDER, mem);
1526       /*for (i=0;i<MAX_PERIOD;i++)printf("%d ", exc[i]); printf("\n");*/
1527       /* Check if the waveform is decaying (and if so how fast) */
1528       {
1529          celt_word32 E1=1, E2=1;
1530          int period;
1531          if (pitch_index <= MAX_PERIOD/2)
1532             period = pitch_index;
1533          else
1534             period = MAX_PERIOD/2;
1535          for (i=0;i<period;i++)
1536          {
1537             E1 += SHR32(MULT16_16(exc[MAX_PERIOD-period+i],exc[MAX_PERIOD-period+i]),8);
1538             E2 += SHR32(MULT16_16(exc[MAX_PERIOD-2*period+i],exc[MAX_PERIOD-2*period+i]),8);
1539          }
1540          if (E1 > E2)
1541             E1 = E2;
1542          decay = celt_sqrt(frac_div32(SHR(E1,1),E2));
1543       }
1544
1545       /* Copy excitation, taking decay into account */
1546       for (i=0;i<len+st->mode->overlap;i++)
1547       {
1548          celt_word16 tmp;
1549          if (offset+i >= MAX_PERIOD)
1550          {
1551             offset -= pitch_index;
1552             decay = MULT16_16_Q15(decay, decay);
1553          }
1554          e[i] = SHL32(EXTEND32(MULT16_16_Q15(decay, exc[offset+i])), SIG_SHIFT);
1555          tmp = ROUND16(out_mem[c][offset+i],SIG_SHIFT);
1556          S1 += SHR32(MULT16_16(tmp,tmp),8);
1557       }
1558       for (i=0;i<LPC_ORDER;i++)
1559          mem[i] = ROUND16(out_mem[c][MAX_PERIOD-1-i], SIG_SHIFT);
1560       for (i=0;i<len+st->mode->overlap;i++)
1561          e[i] = MULT16_32_Q15(fade, e[i]);
1562       iir(e, lpc+c*LPC_ORDER, e, len+st->mode->overlap, LPC_ORDER, mem);
1563
1564       {
1565          celt_word32 S2=0;
1566          for (i=0;i<len+overlap;i++)
1567          {
1568             celt_word16 tmp = ROUND16(e[i],SIG_SHIFT);
1569             S2 += SHR32(MULT16_16(tmp,tmp),8);
1570          }
1571          /* This checks for an "explosion" in the synthesis */
1572 #ifdef FIXED_POINT
1573          if (!(S1 > SHR32(S2,2)))
1574 #else
1575          /* Float test is written this way to catch NaNs at the same time */
1576          if (!(S1 > 0.2f*S2))
1577 #endif
1578          {
1579             for (i=0;i<len+overlap;i++)
1580                e[i] = 0;
1581          } else if (S1 < S2)
1582          {
1583             celt_word16 ratio = celt_sqrt(frac_div32(SHR32(S1,1)+1,S2+1));
1584             for (i=0;i<len+overlap;i++)
1585                e[i] = MULT16_32_Q15(ratio, e[i]);
1586          }
1587       }
1588
1589 #ifdef ENABLE_POSTFILTER
1590       /* Apply post-filter to the MDCT overlap of the previous frame */
1591       comb_filter(out_mem[c]+MAX_PERIOD, out_mem[c]+MAX_PERIOD, st->postfilter_period, st->postfilter_period, st->overlap, C,
1592                   st->postfilter_gain, st->postfilter_gain, NULL, 0);
1593 #endif /* ENABLE_POSTFILTER */
1594
1595       for (i=0;i<MAX_PERIOD+st->mode->overlap-N;i++)
1596          out_mem[c][i] = out_mem[c][N+i];
1597
1598       /* Apply TDAC to the concealed audio so that it blends with the
1599          previous and next frames */
1600       for (i=0;i<overlap/2;i++)
1601       {
1602          celt_word32 tmp;
1603          tmp = MULT16_32_Q15(st->mode->window[i],           e[N+overlap-1-i]) +
1604                MULT16_32_Q15(st->mode->window[overlap-i-1], e[N+i          ]);
1605          out_mem[c][MAX_PERIOD+i] = MULT16_32_Q15(st->mode->window[overlap-i-1], tmp);
1606          out_mem[c][MAX_PERIOD+overlap-i-1] = MULT16_32_Q15(st->mode->window[i], tmp);
1607       }
1608       for (i=0;i<N;i++)
1609          out_mem[c][MAX_PERIOD-N+i] = e[i];
1610
1611 #ifdef ENABLE_POSTFILTER
1612       /* Apply pre-filter to the MDCT overlap for the next frame (post-filter will be applied then) */
1613       comb_filter(e, out_mem[c]+MAX_PERIOD, st->postfilter_period, st->postfilter_period, st->overlap, C,
1614                   -st->postfilter_gain, -st->postfilter_gain, NULL, 0);
1615 #endif /* ENABLE_POSTFILTER */
1616       for (i=0;i<overlap;i++)
1617          out_mem[c][MAX_PERIOD+i] = e[i];
1618    } while (++c<C);
1619
1620    {
1621       celt_word32 *out_syn[2];
1622       out_syn[0] = out_mem[0]+MAX_PERIOD-N;
1623       if (C==2)
1624          out_syn[1] = out_mem[1]+MAX_PERIOD-N;
1625       deemphasis(out_syn, pcm, N, C, st->mode->preemph, st->preemph_memD);
1626    }
1627    
1628    st->loss_count++;
1629
1630    RESTORE_STACK;
1631 }
1632
1633 #ifdef FIXED_POINT
1634 int celt_decode_with_ec(CELTDecoder * restrict st, const unsigned char *data, int len, celt_int16 * restrict pcm, int frame_size, ec_dec *dec)
1635 {
1636 #else
1637 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)
1638 {
1639 #endif
1640    int c, i, N;
1641    int has_fold;
1642    int bits;
1643    ec_dec _dec;
1644    ec_byte_buffer buf;
1645    VARDECL(celt_sig, freq);
1646    VARDECL(celt_norm, X);
1647    VARDECL(celt_ener, bandE);
1648    VARDECL(int, fine_quant);
1649    VARDECL(int, pulses);
1650    VARDECL(int, offsets);
1651    VARDECL(int, fine_priority);
1652    VARDECL(int, tf_res);
1653    celt_sig *out_mem[2];
1654    celt_sig *decode_mem[2];
1655    celt_sig *overlap_mem[2];
1656    celt_sig *out_syn[2];
1657    celt_word16 *lpc;
1658    celt_word16 *oldBandE;
1659
1660    int shortBlocks;
1661    int isTransient;
1662    int intra_ener;
1663    const int C = CHANNELS(st->channels);
1664    int LM, M;
1665    int nbFilledBytes, nbAvailableBytes;
1666    int effEnd;
1667    int codedBands;
1668    int alloc_trim;
1669    int postfilter_pitch;
1670    celt_word16 postfilter_gain;
1671    int intensity=0;
1672    int dual_stereo=0;
1673    SAVE_STACK;
1674
1675    if (pcm==NULL)
1676       return CELT_BAD_ARG;
1677
1678    for (LM=0;LM<4;LM++)
1679       if (st->mode->shortMdctSize<<LM==frame_size)
1680          break;
1681    if (LM>=MAX_CONFIG_SIZES)
1682       return CELT_BAD_ARG;
1683    M=1<<LM;
1684
1685    c=0; do {
1686       decode_mem[c] = st->_decode_mem + c*(DECODE_BUFFER_SIZE+st->overlap);
1687       out_mem[c] = decode_mem[c]+DECODE_BUFFER_SIZE-MAX_PERIOD;
1688       overlap_mem[c] = decode_mem[c]+DECODE_BUFFER_SIZE;
1689    } while (++c<C);
1690    lpc = (celt_word16*)(st->_decode_mem+(DECODE_BUFFER_SIZE+st->overlap)*C);
1691    oldBandE = lpc+C*LPC_ORDER;
1692
1693    N = M*st->mode->shortMdctSize;
1694
1695    effEnd = st->end;
1696    if (effEnd > st->mode->effEBands)
1697       effEnd = st->mode->effEBands;
1698
1699    ALLOC(freq, C*N, celt_sig); /**< Interleaved signal MDCTs */
1700    ALLOC(X, C*N, celt_norm);   /**< Interleaved normalised MDCTs */
1701    ALLOC(bandE, st->mode->nbEBands*C, celt_ener);
1702    c=0; do
1703       for (i=0;i<M*st->mode->eBands[st->start];i++)
1704          X[c*N+i] = 0;
1705    while (++c<C);
1706    c=0; do   
1707       for (i=M*st->mode->eBands[effEnd];i<N;i++)
1708          X[c*N+i] = 0;
1709    while (++c<C);
1710
1711    if (data == NULL)
1712    {
1713       celt_decode_lost(st, pcm, N, LM);
1714       RESTORE_STACK;
1715       return CELT_OK;
1716    }
1717    if (len<0) {
1718      RESTORE_STACK;
1719      return CELT_BAD_ARG;
1720    }
1721    
1722    if (dec == NULL)
1723    {
1724       ec_byte_readinit(&buf,(unsigned char*)data,len);
1725       ec_dec_init(&_dec,&buf);
1726       dec = &_dec;
1727       nbFilledBytes = 0;
1728    } else {
1729       nbFilledBytes = (ec_dec_tell(dec, 0)+4)>>3;
1730    }
1731    nbAvailableBytes = len-nbFilledBytes;
1732
1733    if (ec_dec_bit_prob(dec, 32768))
1734    {
1735 #ifdef ENABLE_POSTFILTER
1736       int qg, octave;
1737       octave = ec_dec_uint(dec, 6);
1738       postfilter_pitch = (16<<octave)+ec_dec_bits(dec, 4+octave);
1739       qg = ec_dec_bits(dec, 2);
1740       postfilter_gain = QCONST16(.125f,15)*(qg+2);
1741 #else /* ENABLE_POSTFILTER */
1742       RESTORE_STACK;
1743       return CELT_CORRUPTED_DATA;
1744 #endif /* ENABLE_POSTFILTER */
1745
1746    } else {
1747       postfilter_gain = 0;
1748       postfilter_pitch = 0;
1749    }
1750
1751    /* Decode the global flags (first symbols in the stream) */
1752    intra_ener = ec_dec_bit_prob(dec, 8192);
1753    /* Get band energies */
1754    unquant_coarse_energy(st->mode, st->start, st->end, bandE, oldBandE,
1755          intra_ener, dec, C, LM);
1756
1757    if (LM > 0)
1758       isTransient = ec_dec_bit_prob(dec, 8192);
1759    else
1760       isTransient = 0;
1761
1762    if (isTransient)
1763       shortBlocks = M;
1764    else
1765       shortBlocks = 0;
1766
1767    ALLOC(tf_res, st->mode->nbEBands, int);
1768    tf_decode(st->start, st->end, C, isTransient, tf_res, LM, dec);
1769
1770    has_fold = ec_dec_bit_prob(dec, 8192)<<1;
1771    has_fold |= ec_dec_bit_prob(dec, (has_fold>>1) ? 32768 : 49152);
1772
1773    ALLOC(pulses, st->mode->nbEBands, int);
1774    ALLOC(offsets, st->mode->nbEBands, int);
1775    ALLOC(fine_priority, st->mode->nbEBands, int);
1776
1777    for (i=0;i<st->mode->nbEBands;i++)
1778       offsets[i] = 0;
1779    for (i=0;i<st->mode->nbEBands;i++)
1780    {
1781       if (ec_dec_bit_prob(dec, 1024))
1782       {
1783          while (ec_dec_bit_prob(dec, 32768))
1784             offsets[i]++;
1785          offsets[i]++;
1786          offsets[i] *= (6<<BITRES);
1787       }
1788    }
1789
1790    ALLOC(fine_quant, st->mode->nbEBands, int);
1791    {
1792       int fl;
1793       alloc_trim = 0;
1794       fl = ec_decode_bin(dec, 7);
1795       while (trim_cdf[alloc_trim+1] <= fl)
1796          alloc_trim++;
1797       ec_dec_update(dec, trim_cdf[alloc_trim], trim_cdf[alloc_trim+1], 128);
1798    }
1799
1800    if (C==2)
1801    {
1802       dual_stereo = ec_dec_bit_prob(dec, 32768);
1803       intensity = ec_dec_uint(dec, 1+st->end-st->start);
1804    }
1805
1806    bits = len*8 - ec_dec_tell(dec, 0) - 1;
1807    codedBands = compute_allocation(st->mode, st->start, st->end, offsets, alloc_trim, bits, pulses, fine_quant, fine_priority, C, LM);
1808    
1809    unquant_fine_energy(st->mode, st->start, st->end, bandE, oldBandE, fine_quant, dec, C);
1810
1811    /* Decode fixed codebook */
1812    quant_all_bands(0, st->mode, st->start, st->end, X, C==2 ? X+N : NULL,
1813          NULL, pulses, shortBlocks, has_fold, dual_stereo, intensity, tf_res, 1,
1814          len*8, dec, LM, codedBands);
1815
1816    unquant_energy_finalise(st->mode, st->start, st->end, bandE, oldBandE,
1817          fine_quant, fine_priority, len*8-ec_dec_tell(dec, 0), dec, C);
1818
1819    log2Amp(st->mode, st->start, st->end, bandE, oldBandE, C);
1820
1821    /* Synthesis */
1822    denormalise_bands(st->mode, X, freq, bandE, effEnd, C, M);
1823
1824    CELT_MOVE(decode_mem[0], decode_mem[0]+N, DECODE_BUFFER_SIZE-N);
1825    if (C==2)
1826       CELT_MOVE(decode_mem[1], decode_mem[1]+N, DECODE_BUFFER_SIZE-N);
1827
1828    c=0; do
1829       for (i=0;i<M*st->mode->eBands[st->start];i++)
1830          freq[c*N+i] = 0;
1831    while (++c<C);
1832    c=0; do
1833       for (i=M*st->mode->eBands[effEnd];i<N;i++)
1834          freq[c*N+i] = 0;
1835    while (++c<C);
1836
1837    out_syn[0] = out_mem[0]+MAX_PERIOD-N;
1838    if (C==2)
1839       out_syn[1] = out_mem[1]+MAX_PERIOD-N;
1840
1841    /* Compute inverse MDCTs */
1842    compute_inv_mdcts(st->mode, shortBlocks, freq, out_syn, overlap_mem, C, LM);
1843
1844 #ifdef ENABLE_POSTFILTER
1845    c=0; do {
1846       comb_filter(out_syn[c], out_syn[c], st->postfilter_period, st->postfilter_period, st->overlap, C,
1847             st->postfilter_gain, st->postfilter_gain, NULL, 0);
1848       comb_filter(out_syn[c]+st->overlap, out_syn[c]+st->overlap, st->postfilter_period, postfilter_pitch, N-st->overlap, C,
1849             st->postfilter_gain, postfilter_gain, st->mode->window, st->mode->overlap);
1850    } while (++c<C);
1851    st->postfilter_period = postfilter_pitch;
1852    st->postfilter_gain = postfilter_gain;
1853 #endif /* ENABLE_POSTFILTER */
1854
1855    deemphasis(out_syn, pcm, N, C, st->mode->preemph, st->preemph_memD);
1856    st->loss_count = 0;
1857    RESTORE_STACK;
1858    if (ec_dec_get_error(dec))
1859       return CELT_CORRUPTED_DATA;
1860    else
1861       return CELT_OK;
1862 }
1863
1864 #ifdef FIXED_POINT
1865 #ifndef DISABLE_FLOAT_API
1866 int celt_decode_with_ec_float(CELTDecoder * restrict st, const unsigned char *data, int len, float * restrict pcm, int frame_size, ec_dec *dec)
1867 {
1868    int j, ret, C, N, LM, M;
1869    VARDECL(celt_int16, out);
1870    SAVE_STACK;
1871
1872    if (pcm==NULL)
1873       return CELT_BAD_ARG;
1874
1875    for (LM=0;LM<4;LM++)
1876       if (st->mode->shortMdctSize<<LM==frame_size)
1877          break;
1878    if (LM>=MAX_CONFIG_SIZES)
1879       return CELT_BAD_ARG;
1880    M=1<<LM;
1881
1882    C = CHANNELS(st->channels);
1883    N = M*st->mode->shortMdctSize;
1884    
1885    ALLOC(out, C*N, celt_int16);
1886    ret=celt_decode_with_ec(st, data, len, out, frame_size, dec);
1887    if (ret==0)
1888       for (j=0;j<C*N;j++)
1889          pcm[j]=out[j]*(1.f/32768.f);
1890      
1891    RESTORE_STACK;
1892    return ret;
1893 }
1894 #endif /*DISABLE_FLOAT_API*/
1895 #else
1896 int celt_decode_with_ec(CELTDecoder * restrict st, const unsigned char *data, int len, celt_int16 * restrict pcm, int frame_size, ec_dec *dec)
1897 {
1898    int j, ret, C, N, LM, M;
1899    VARDECL(celt_sig, out);
1900    SAVE_STACK;
1901
1902    if (pcm==NULL)
1903       return CELT_BAD_ARG;
1904
1905    for (LM=0;LM<4;LM++)
1906       if (st->mode->shortMdctSize<<LM==frame_size)
1907          break;
1908    if (LM>=MAX_CONFIG_SIZES)
1909       return CELT_BAD_ARG;
1910    M=1<<LM;
1911
1912    C = CHANNELS(st->channels);
1913    N = M*st->mode->shortMdctSize;
1914    ALLOC(out, C*N, celt_sig);
1915
1916    ret=celt_decode_with_ec_float(st, data, len, out, frame_size, dec);
1917
1918    if (ret==0)
1919       for (j=0;j<C*N;j++)
1920          pcm[j] = FLOAT2INT16 (out[j]);
1921    
1922    RESTORE_STACK;
1923    return ret;
1924 }
1925 #endif
1926
1927 int celt_decode(CELTDecoder * restrict st, const unsigned char *data, int len, celt_int16 * restrict pcm, int frame_size)
1928 {
1929    return celt_decode_with_ec(st, data, len, pcm, frame_size, NULL);
1930 }
1931
1932 #ifndef DISABLE_FLOAT_API
1933 int celt_decode_float(CELTDecoder * restrict st, const unsigned char *data, int len, float * restrict pcm, int frame_size)
1934 {
1935    return celt_decode_with_ec_float(st, data, len, pcm, frame_size, NULL);
1936 }
1937 #endif /* DISABLE_FLOAT_API */
1938
1939 int celt_decoder_ctl(CELTDecoder * restrict st, int request, ...)
1940 {
1941    va_list ap;
1942
1943    va_start(ap, request);
1944    switch (request)
1945    {
1946       case CELT_GET_MODE_REQUEST:
1947       {
1948          const CELTMode ** value = va_arg(ap, const CELTMode**);
1949          if (value==0)
1950             goto bad_arg;
1951          *value=st->mode;
1952       }
1953       break;
1954       case CELT_SET_START_BAND_REQUEST:
1955       {
1956          celt_int32 value = va_arg(ap, celt_int32);
1957          if (value<0 || value>=st->mode->nbEBands)
1958             goto bad_arg;
1959          st->start = value;
1960       }
1961       break;
1962       case CELT_SET_END_BAND_REQUEST:
1963       {
1964          celt_int32 value = va_arg(ap, celt_int32);
1965          if (value<0 || value>=st->mode->nbEBands)
1966             goto bad_arg;
1967          st->end = value;
1968       }
1969       break;
1970       case CELT_RESET_STATE:
1971       {
1972          CELT_MEMSET((char*)&st->DECODER_RESET_START, 0,
1973                celt_decoder_get_size(st->mode, st->channels)-
1974                ((char*)&st->DECODER_RESET_START - (char*)st));
1975       }
1976       break;
1977       default:
1978          goto bad_request;
1979    }
1980    va_end(ap);
1981    return CELT_OK;
1982 bad_arg:
1983    va_end(ap);
1984    return CELT_BAD_ARG;
1985 bad_request:
1986       va_end(ap);
1987   return CELT_UNIMPLEMENTED;
1988 }
1989
1990 const char *celt_strerror(int error)
1991 {
1992    static const char *error_strings[8] = {
1993       "success",
1994       "invalid argument",
1995       "invalid mode",
1996       "internal error",
1997       "corrupted stream",
1998       "request not implemented",
1999       "invalid state",
2000       "memory allocation failed"
2001    };
2002    if (error > 0 || error < -7)
2003       return "unknown error";
2004    else 
2005       return error_strings[-error];
2006 }
2007