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