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