fcd4293b0cc09aeb738b6621c87f111bf7a62083
[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
708    resynth = optional_resynthesis!=NULL;
709
710    if (st->complexity > 1 && LM>0)
711    {
712       isTransient = M > 1 &&
713          transient_analysis(in, N+st->overlap, C, &transient_time,
714                             &transient_shift, &st->frame_max, st->overlap);
715    } else {
716       isTransient = 0;
717    }
718    if (isTransient)
719    {
720 #ifndef FIXED_POINT
721       float gain_1;
722 #endif
723       /* Apply the inverse shaping window */
724       if (transient_shift)
725       {
726          transient_time_quant = transient_time*(celt_int32)8000/st->mode->Fs;
727          transient_time = transient_time_quant*(celt_int32)st->mode->Fs/8000;
728 #ifdef FIXED_POINT
729          for (c=0;c<C;c++)
730             for (i=0;i<16;i++)
731                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]);
732          for (c=0;c<C;c++)
733             for (i=transient_time;i<N+st->overlap;i++)
734                in[C*i+c] = SHR32(in[C*i+c], transient_shift);
735 #else
736          for (c=0;c<C;c++)
737             for (i=0;i<16;i++)
738                in[C*(transient_time+i-16)+c] /= 1+transientWindow[i]*((1<<transient_shift)-1);
739          gain_1 = 1.f/(1<<transient_shift);
740          for (c=0;c<C;c++)
741             for (i=transient_time;i<N+st->overlap;i++)
742                in[C*i+c] *= gain_1;
743 #endif
744       }
745    }
746
747    if (isTransient)
748       shortBlocks = M;
749    else
750       shortBlocks = 0;
751
752    ALLOC(freq, C*N, celt_sig); /**< Interleaved signal MDCTs */
753    ALLOC(bandE,st->mode->nbEBands*C, celt_ener);
754    ALLOC(bandLogE,st->mode->nbEBands*C, celt_word16);
755    /* Compute MDCTs */
756    compute_mdcts(st->mode, shortBlocks, in, freq, C, LM);
757
758    ALLOC(X, C*N, celt_norm);         /**< Interleaved normalised MDCTs */
759
760    compute_band_energies(st->mode, freq, bandE, effEnd, C, M);
761
762    amp2Log2(st->mode, effEnd, st->end, bandE, bandLogE, C);
763
764    /* Band normalisation */
765    normalise_bands(st->mode, freq, X, bandE, effEnd, C, M);
766
767    ALLOC(tf_res, st->mode->nbEBands, int);
768    /* Needs to be before coarse energy quantization because otherwise the energy gets modified */
769    tf_select = tf_analysis(st->mode, bandLogE, oldBandE, effEnd, C, isTransient, tf_res, nbAvailableBytes, X, N, LM, &tf_sum);
770    for (i=effEnd;i<st->end;i++)
771       tf_res[i] = tf_res[effEnd-1];
772
773    NN = M*st->mode->eBands[effEnd];
774    if (shortBlocks && !transient_shift)
775    {
776       celt_word32 sum[8]={1,1,1,1,1,1,1,1};
777       int m;
778       for (c=0;c<C;c++)
779       {
780          m=0;
781          do {
782             celt_word32 tmp=0;
783             for (i=m+c*N;i<c*N+NN;i+=M)
784                tmp += ABS32(X[i]);
785             sum[m++] += tmp;
786          } while (m<M);
787       }
788       m=0;
789 #ifdef FIXED_POINT
790       do {
791          if (SHR32(sum[m+1],3) > sum[m])
792          {
793             mdct_weight_shift=2;
794             mdct_weight_pos = m;
795          } else if (SHR32(sum[m+1],1) > sum[m] && mdct_weight_shift < 2)
796          {
797             mdct_weight_shift=1;
798             mdct_weight_pos = m;
799          }
800          m++;
801       } while (m<M-1);
802 #else
803       do {
804          if (sum[m+1] > 8*sum[m])
805          {
806             mdct_weight_shift=2;
807             mdct_weight_pos = m;
808          } else if (sum[m+1] > 2*sum[m] && mdct_weight_shift < 2)
809          {
810             mdct_weight_shift=1;
811             mdct_weight_pos = m;
812          }
813          m++;
814       } while (m<M-1);
815 #endif
816       if (mdct_weight_shift)
817          mdct_shape(st->mode, X, mdct_weight_pos+1, M, N, mdct_weight_shift, effEnd, C, 0, M);
818    }
819
820    ALLOC(error, C*st->mode->nbEBands, celt_word16);
821    quant_coarse_energy(st->mode, st->start, st->end, effEnd, bandLogE,
822          oldBandE, nbCompressedBytes*8, st->mode->prob,
823          error, enc, C, LM, nbAvailableBytes, st->force_intra,
824          &st->delayedIntra, st->complexity >= 4);
825
826    if (LM > 0)
827       ec_enc_bit_prob(enc, shortBlocks!=0, 8192);
828
829    if (shortBlocks)
830    {
831       if (transient_shift)
832       {
833          int max_time = (N+st->mode->overlap)*(celt_int32)8000/st->mode->Fs;
834          ec_enc_uint(enc, transient_shift, 4);
835          ec_enc_uint(enc, transient_time_quant, max_time);
836       } else {
837          ec_enc_uint(enc, mdct_weight_shift, 4);
838          if (mdct_weight_shift && M!=2)
839             ec_enc_uint(enc, mdct_weight_pos, M-1);
840       }
841    }
842
843    tf_encode(st->start, st->end, isTransient, tf_res, nbAvailableBytes, LM, tf_select, enc);
844
845    if (shortBlocks || st->complexity < 3)
846    {
847       if (st->complexity == 0)
848       {
849          has_fold = 0;
850          st->fold_decision = 3;
851       } else {
852          has_fold = 1;
853          st->fold_decision = 1;
854       }
855    } else {
856       has_fold = folding_decision(st->mode, X, &st->tonal_average, &st->fold_decision, effEnd, C, M);
857    }
858    ec_enc_bit_prob(enc, has_fold>>1, 8192);
859    ec_enc_bit_prob(enc, has_fold&1, (has_fold>>1) ? 32768 : 49152);
860
861    ALLOC(offsets, st->mode->nbEBands, int);
862
863    for (i=0;i<st->mode->nbEBands;i++)
864       offsets[i] = 0;
865    /* Dynamic allocation code */
866    /* Make sure that dynamic allocation can't make us bust the budget */
867    if (nbCompressedBytes > 30)
868    {
869       int t1, t2;
870       if (LM <= 1)
871       {
872          t1 = 3;
873          t2 = 5;
874       } else {
875          t1 = 2;
876          t2 = 4;
877       }
878       for (i=1;i<st->mode->nbEBands-1;i++)
879       {
880          if (2*bandLogE[i]-bandLogE[i-1]-bandLogE[i+1] > SHL16(t1,DB_SHIFT))
881             offsets[i] += 1;
882          if (2*bandLogE[i]-bandLogE[i-1]-bandLogE[i+1] > SHL16(t2,DB_SHIFT))
883             offsets[i] += 1;
884       }
885    }
886    for (i=0;i<st->mode->nbEBands;i++)
887    {
888       int j;
889       ec_enc_bit_prob(enc, offsets[i]!=0, 1024);
890       if (offsets[i]!=0)
891       {
892          for (j=0;j<offsets[i]-1;j++)
893             ec_enc_bit_prob(enc, 1, 32768);
894          ec_enc_bit_prob(enc, 0, 32768);
895       }
896       offsets[i] *= (6<<BITRES);
897    }
898    {
899       int trim_index = 3;
900
901       /*if (isTransient)
902          trim_index--;
903       if (has_fold==0)
904          trim_index--;
905       if (C==2)
906          trim_index--;*/
907       alloc_trim = trim_coef[trim_index];
908       ec_encode_bin(enc, trim_cdf[trim_index], trim_cdf[trim_index+1], 7);
909    }
910
911    /* Variable bitrate */
912    if (st->vbr_rate_norm>0)
913    {
914      celt_word16 alpha;
915      celt_int32 delta;
916      /* The target rate in 16th bits per frame */
917      celt_int32 vbr_rate;
918      celt_int32 target;
919      celt_int32 vbr_bound, max_allowed;
920
921      vbr_rate = M*st->vbr_rate_norm;
922
923      /* Computes the max bit-rate allowed in VBR more to avoid busting the budget */
924      vbr_bound = vbr_rate;
925      max_allowed = (vbr_rate + vbr_bound - st->vbr_reservoir)>>(BITRES+3);
926      if (max_allowed < 4)
927         max_allowed = 4;
928      if (max_allowed < nbAvailableBytes)
929         nbAvailableBytes = max_allowed;
930      target=vbr_rate;
931
932      /* Shortblocks get a large boost in bitrate, but since they 
933         are uncommon long blocks are not greatly affected */
934      if (shortBlocks || tf_sum < -2*(st->end-st->start))
935         target*=2;
936      else if (tf_sum < -(st->end-st->start))
937         target = 3*target/2;
938      else if (M > 1)
939         target-=(target+14)/28;
940
941      /* The average energy is removed from the target and the actual 
942         energy added*/
943      target=target+st->vbr_offset-(50<<BITRES)+ec_enc_tell(enc, BITRES);
944
945      /* In VBR mode the frame size must not be reduced so much that it would result in the coarse energy busting its budget */
946      target=IMIN(nbAvailableBytes<<(BITRES+3),target);
947      /* Make the adaptation coef (alpha) higher at the beginning */
948      if (st->vbr_count < 990)
949      {
950         st->vbr_count++;
951         alpha = celt_rcp(SHL32(EXTEND32(st->vbr_count+10),16));
952         /*printf ("%d %d\n", st->vbr_count+10, alpha);*/
953      } else
954         alpha = QCONST16(.001f,15);
955
956      /* By how much did we "miss" the target on that frame */
957      delta = (celt_int32)target - vbr_rate;
958      /* How many bits have we used in excess of what we're allowed */
959      st->vbr_reservoir += delta;
960      /*printf ("%d\n", st->vbr_reservoir);*/
961
962      /* Compute the offset we need to apply in order to reach the target */
963      st->vbr_drift += (celt_int32)MULT16_32_Q15(alpha,delta-st->vbr_offset-st->vbr_drift);
964      st->vbr_offset = -st->vbr_drift;
965      /*printf ("%d\n", st->vbr_drift);*/
966
967      /* We could use any multiple of vbr_rate as bound (depending on the delay) */
968      if (st->vbr_reservoir < 0)
969      {
970         /* We're under the min value -- increase rate */
971         int adjust = 1-(st->vbr_reservoir-1)/(8<<BITRES);
972         st->vbr_reservoir += adjust*(8<<BITRES);
973         target += adjust;
974         /*printf ("+%d\n", adjust);*/
975      }
976      if (nbAvailableBytes > target>>(BITRES+3))
977         nbAvailableBytes = target>>(BITRES+3);
978      nbCompressedBytes = nbAvailableBytes + nbFilledBytes;
979
980      /* This moves the raw bits to take into account the new compressed size */
981      ec_byte_shrink(&buf, nbCompressedBytes);
982    }
983
984    /* Bit allocation */
985    ALLOC(fine_quant, st->mode->nbEBands, int);
986    ALLOC(pulses, st->mode->nbEBands, int);
987    ALLOC(fine_priority, st->mode->nbEBands, int);
988
989    bits = nbCompressedBytes*8 - ec_enc_tell(enc, 0) - 1;
990    codedBands = compute_allocation(st->mode, st->start, st->end, offsets, alloc_trim, bits, pulses, fine_quant, fine_priority, C, LM);
991
992    quant_fine_energy(st->mode, st->start, st->end, bandE, oldBandE, error, fine_quant, enc, C);
993
994 #ifdef MEASURE_NORM_MSE
995    float X0[3000];
996    float bandE0[60];
997    for (c=0;c<C;c++)
998       for (i=0;i<N;i++)
999          X0[i+c*N] = X[i+c*N];
1000    for (i=0;i<C*st->mode->nbEBands;i++)
1001       bandE0[i] = bandE[i];
1002 #endif
1003
1004    /* Residual quantisation */
1005    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);
1006
1007    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);
1008
1009    /* Re-synthesis of the coded audio if required */
1010    if (resynth)
1011    {
1012       VARDECL(celt_sig, _out_mem);
1013       celt_sig *out_mem[2];
1014       celt_sig *overlap_mem[2];
1015
1016       log2Amp(st->mode, st->start, st->end, bandE, oldBandE, C);
1017
1018 #ifdef MEASURE_NORM_MSE
1019       measure_norm_mse(st->mode, X, X0, bandE, bandE0, M, N, C);
1020 #endif
1021
1022       if (mdct_weight_shift)
1023       {
1024          mdct_shape(st->mode, X, 0, mdct_weight_pos+1, N, mdct_weight_shift, effEnd, C, 1, M);
1025       }
1026
1027       /* Synthesis */
1028       denormalise_bands(st->mode, X, freq, bandE, effEnd, C, M);
1029
1030       for (c=0;c<C;c++)
1031          for (i=0;i<M*st->mode->eBands[st->start];i++)
1032             freq[c*N+i] = 0;
1033       for (c=0;c<C;c++)
1034          for (i=M*st->mode->eBands[st->end];i<N;i++)
1035             freq[c*N+i] = 0;
1036
1037       ALLOC(_out_mem, C*N, celt_sig);
1038
1039       for (c=0;c<C;c++)
1040       {
1041          overlap_mem[c] = _overlap_mem + c*st->overlap;
1042          out_mem[c] = _out_mem+c*N;
1043       }
1044
1045       compute_inv_mdcts(st->mode, shortBlocks, freq, transient_time,
1046             transient_shift, out_mem, overlap_mem, C, LM);
1047
1048       /* De-emphasis and put everything back at the right place 
1049          in the synthesis history */
1050       if (optional_resynthesis != NULL) {
1051          deemphasis(out_mem, optional_resynthesis, N, C, st->mode->preemph, st->preemph_memD);
1052
1053       }
1054    }
1055
1056    /* If there's any room left (can only happen for very high rates),
1057       fill it with zeros */
1058    while (ec_enc_tell(enc,0) + 8 <= nbCompressedBytes*8)
1059       ec_enc_bits(enc, 0, 8);
1060    ec_enc_done(enc);
1061    
1062    RESTORE_STACK;
1063    if (ec_enc_get_error(enc))
1064       return CELT_CORRUPTED_DATA;
1065    else
1066       return nbCompressedBytes;
1067 }
1068
1069 #ifdef FIXED_POINT
1070 #ifndef DISABLE_FLOAT_API
1071 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)
1072 {
1073    int j, ret, C, N, LM, M;
1074    VARDECL(celt_int16, in);
1075    SAVE_STACK;
1076
1077    if (pcm==NULL)
1078       return CELT_BAD_ARG;
1079
1080    for (LM=0;LM<4;LM++)
1081       if (st->mode->shortMdctSize<<LM==frame_size)
1082          break;
1083    if (LM>=MAX_CONFIG_SIZES)
1084       return CELT_BAD_ARG;
1085    M=1<<LM;
1086
1087    C = CHANNELS(st->channels);
1088    N = M*st->mode->shortMdctSize;
1089    ALLOC(in, C*N, celt_int16);
1090
1091    for (j=0;j<C*N;j++)
1092      in[j] = FLOAT2INT16(pcm[j]);
1093
1094    if (optional_resynthesis != NULL) {
1095      ret=celt_encode_with_ec(st,in,in,frame_size,compressed,nbCompressedBytes, enc);
1096       for (j=0;j<C*N;j++)
1097          optional_resynthesis[j]=in[j]*(1.f/32768.f);
1098    } else {
1099      ret=celt_encode_with_ec(st,in,NULL,frame_size,compressed,nbCompressedBytes, enc);
1100    }
1101    RESTORE_STACK;
1102    return ret;
1103
1104 }
1105 #endif /*DISABLE_FLOAT_API*/
1106 #else
1107 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)
1108 {
1109    int j, ret, C, N, LM, M;
1110    VARDECL(celt_sig, in);
1111    SAVE_STACK;
1112
1113    if (pcm==NULL)
1114       return CELT_BAD_ARG;
1115
1116    for (LM=0;LM<4;LM++)
1117       if (st->mode->shortMdctSize<<LM==frame_size)
1118          break;
1119    if (LM>=MAX_CONFIG_SIZES)
1120       return CELT_BAD_ARG;
1121    M=1<<LM;
1122
1123    C=CHANNELS(st->channels);
1124    N=M*st->mode->shortMdctSize;
1125    ALLOC(in, C*N, celt_sig);
1126    for (j=0;j<C*N;j++) {
1127      in[j] = SCALEOUT(pcm[j]);
1128    }
1129
1130    if (optional_resynthesis != NULL) {
1131       ret = celt_encode_with_ec_float(st,in,in,frame_size,compressed,nbCompressedBytes, enc);
1132       for (j=0;j<C*N;j++)
1133          optional_resynthesis[j] = FLOAT2INT16(in[j]);
1134    } else {
1135       ret = celt_encode_with_ec_float(st,in,NULL,frame_size,compressed,nbCompressedBytes, enc);
1136    }
1137    RESTORE_STACK;
1138    return ret;
1139 }
1140 #endif
1141
1142 int celt_encode(CELTEncoder * restrict st, const celt_int16 * pcm, int frame_size, unsigned char *compressed, int nbCompressedBytes)
1143 {
1144    return celt_encode_with_ec(st, pcm, NULL, frame_size, compressed, nbCompressedBytes, NULL);
1145 }
1146
1147 #ifndef DISABLE_FLOAT_API
1148 int celt_encode_float(CELTEncoder * restrict st, const float * pcm, int frame_size, unsigned char *compressed, int nbCompressedBytes)
1149 {
1150    return celt_encode_with_ec_float(st, pcm, NULL, frame_size, compressed, nbCompressedBytes, NULL);
1151 }
1152 #endif /* DISABLE_FLOAT_API */
1153
1154 int celt_encode_resynthesis(CELTEncoder * restrict st, const celt_int16 * pcm, celt_int16 * optional_resynthesis, int frame_size, unsigned char *compressed, int nbCompressedBytes)
1155 {
1156    return celt_encode_with_ec(st, pcm, optional_resynthesis, frame_size, compressed, nbCompressedBytes, NULL);
1157 }
1158
1159 #ifndef DISABLE_FLOAT_API
1160 int celt_encode_resynthesis_float(CELTEncoder * restrict st, const float * pcm, float * optional_resynthesis, int frame_size, unsigned char *compressed, int nbCompressedBytes)
1161 {
1162    return celt_encode_with_ec_float(st, pcm, optional_resynthesis, frame_size, compressed, nbCompressedBytes, NULL);
1163 }
1164 #endif /* DISABLE_FLOAT_API */
1165
1166
1167 int celt_encoder_ctl(CELTEncoder * restrict st, int request, ...)
1168 {
1169    va_list ap;
1170    
1171    va_start(ap, request);
1172    switch (request)
1173    {
1174       case CELT_GET_MODE_REQUEST:
1175       {
1176          const CELTMode ** value = va_arg(ap, const CELTMode**);
1177          if (value==0)
1178             goto bad_arg;
1179          *value=st->mode;
1180       }
1181       break;
1182       case CELT_SET_COMPLEXITY_REQUEST:
1183       {
1184          int value = va_arg(ap, celt_int32);
1185          if (value<0 || value>10)
1186             goto bad_arg;
1187          st->complexity = value;
1188       }
1189       break;
1190       case CELT_SET_START_BAND_REQUEST:
1191       {
1192          celt_int32 value = va_arg(ap, celt_int32);
1193          if (value<0 || value>=st->mode->nbEBands)
1194             goto bad_arg;
1195          st->start = value;
1196       }
1197       break;
1198       case CELT_SET_END_BAND_REQUEST:
1199       {
1200          celt_int32 value = va_arg(ap, celt_int32);
1201          if (value<0 || value>=st->mode->nbEBands)
1202             goto bad_arg;
1203          st->end = value;
1204       }
1205       break;
1206       case CELT_SET_PREDICTION_REQUEST:
1207       {
1208          int value = va_arg(ap, celt_int32);
1209          if (value<0 || value>2)
1210             goto bad_arg;
1211          if (value==0)
1212          {
1213             st->force_intra   = 1;
1214          } else if (value==1) {
1215             st->force_intra   = 0;
1216          } else {
1217             st->force_intra   = 0;
1218          }   
1219       }
1220       break;
1221       case CELT_SET_VBR_RATE_REQUEST:
1222       {
1223          celt_int32 value = va_arg(ap, celt_int32);
1224          int frame_rate;
1225          int N = st->mode->shortMdctSize;
1226          if (value<0)
1227             goto bad_arg;
1228          if (value>3072000)
1229             value = 3072000;
1230          frame_rate = ((st->mode->Fs<<3)+(N>>1))/N;
1231          st->vbr_rate_norm = ((value<<(BITRES+3))+(frame_rate>>1))/frame_rate;
1232       }
1233       break;
1234       case CELT_RESET_STATE:
1235       {
1236          CELT_MEMSET((char*)&st->ENCODER_RESET_START, 0,
1237                celt_encoder_get_size(st->mode, st->channels)-
1238                ((char*)&st->ENCODER_RESET_START - (char*)st));
1239          st->delayedIntra = 1;
1240          st->fold_decision = 1;
1241          st->tonal_average = QCONST16(1.f,8);
1242       }
1243       break;
1244       default:
1245          goto bad_request;
1246    }
1247    va_end(ap);
1248    return CELT_OK;
1249 bad_arg:
1250    va_end(ap);
1251    return CELT_BAD_ARG;
1252 bad_request:
1253    va_end(ap);
1254    return CELT_UNIMPLEMENTED;
1255 }
1256
1257 /**********************************************************************/
1258 /*                                                                    */
1259 /*                             DECODER                                */
1260 /*                                                                    */
1261 /**********************************************************************/
1262 #define DECODE_BUFFER_SIZE 2048
1263
1264 /** Decoder state 
1265  @brief Decoder state
1266  */
1267 struct CELTDecoder {
1268    const CELTMode *mode;
1269    int overlap;
1270    int channels;
1271
1272    int start, end;
1273
1274    /* Everything beyond this point gets cleared on a reset */
1275 #define DECODER_RESET_START last_pitch_index
1276
1277    int last_pitch_index;
1278    int loss_count;
1279
1280    celt_sig preemph_memD[2];
1281    
1282    celt_sig _decode_mem[1]; /* Size = channels*(DECODE_BUFFER_SIZE+mode->overlap) */
1283    /* celt_word16 lpc[],  Size = channels*LPC_ORDER */
1284    /* celt_word16 oldEBands[], Size = channels*mode->nbEBands */
1285 };
1286
1287 int celt_decoder_get_size(const CELTMode *mode, int channels)
1288 {
1289    int size = sizeof(struct CELTDecoder)
1290             + (channels*(DECODE_BUFFER_SIZE+mode->overlap)-1)*sizeof(celt_sig)
1291             + channels*LPC_ORDER*sizeof(celt_word16)
1292             + channels*mode->nbEBands*sizeof(celt_word16);
1293    return size;
1294 }
1295
1296 CELTDecoder *celt_decoder_create(const CELTMode *mode, int channels, int *error)
1297 {
1298    return celt_decoder_init(
1299          (CELTDecoder *)celt_alloc(celt_decoder_get_size(mode, channels)),
1300          mode, channels, error);
1301 }
1302
1303 CELTDecoder *celt_decoder_init(CELTDecoder *st, const CELTMode *mode, int channels, int *error)
1304 {
1305    if (channels < 0 || channels > 2)
1306    {
1307       if (error)
1308          *error = CELT_BAD_ARG;
1309       return NULL;
1310    }
1311
1312    if (st==NULL)
1313    {
1314       if (error)
1315          *error = CELT_ALLOC_FAIL;
1316       return NULL;
1317    }
1318
1319    CELT_MEMSET((char*)st, 0, celt_decoder_get_size(mode, channels));
1320
1321    st->mode = mode;
1322    st->overlap = mode->overlap;
1323    st->channels = channels;
1324
1325    st->start = 0;
1326    st->end = st->mode->effEBands;
1327
1328    st->loss_count = 0;
1329
1330    if (error)
1331       *error = CELT_OK;
1332    return st;
1333 }
1334
1335 void celt_decoder_destroy(CELTDecoder *st)
1336 {
1337    celt_free(st);
1338 }
1339
1340 static void celt_decode_lost(CELTDecoder * restrict st, celt_word16 * restrict pcm, int N, int LM)
1341 {
1342    int c;
1343    int pitch_index;
1344    int overlap = st->mode->overlap;
1345    celt_word16 fade = Q15ONE;
1346    int i, len;
1347    const int C = CHANNELS(st->channels);
1348    int offset;
1349    celt_sig *out_mem[2];
1350    celt_sig *decode_mem[2];
1351    celt_sig *overlap_mem[2];
1352    celt_word16 *lpc;
1353    SAVE_STACK;
1354    
1355    for (c=0;c<C;c++)
1356    {
1357       decode_mem[c] = st->_decode_mem + c*(DECODE_BUFFER_SIZE+st->overlap);
1358       out_mem[c] = decode_mem[c]+DECODE_BUFFER_SIZE-MAX_PERIOD;
1359       overlap_mem[c] = decode_mem[c]+DECODE_BUFFER_SIZE;
1360    }
1361    lpc = (celt_word16*)(st->_decode_mem+(DECODE_BUFFER_SIZE+st->overlap)*C);
1362
1363    len = N+st->mode->overlap;
1364    
1365    if (st->loss_count == 0)
1366    {
1367       celt_word16 pitch_buf[MAX_PERIOD>>1];
1368       celt_word32 tmp=0;
1369       celt_word32 mem0[2]={0,0};
1370       celt_word16 mem1[2]={0,0};
1371       int len2 = len;
1372       /* FIXME: This is a kludge */
1373       if (len2>MAX_PERIOD>>1)
1374          len2 = MAX_PERIOD>>1;
1375       pitch_downsample(out_mem, pitch_buf, MAX_PERIOD, MAX_PERIOD,
1376                        C, mem0, mem1);
1377       pitch_search(st->mode, pitch_buf+((MAX_PERIOD-len2)>>1), pitch_buf, len2,
1378                    MAX_PERIOD-len2-100, &pitch_index, &tmp, 1<<LM);
1379       pitch_index = MAX_PERIOD-len2-pitch_index;
1380       st->last_pitch_index = pitch_index;
1381    } else {
1382       pitch_index = st->last_pitch_index;
1383       if (st->loss_count < 5)
1384          fade = QCONST16(.8f,15);
1385       else
1386          fade = 0;
1387    }
1388
1389    for (c=0;c<C;c++)
1390    {
1391       /* FIXME: This is more memory than necessary */
1392       celt_word32 e[2*MAX_PERIOD];
1393       celt_word16 exc[2*MAX_PERIOD];
1394       celt_word32 ac[LPC_ORDER+1];
1395       celt_word16 decay = 1;
1396       celt_word32 S1=0;
1397       celt_word16 mem[LPC_ORDER]={0};
1398
1399       offset = MAX_PERIOD-pitch_index;
1400       for (i=0;i<MAX_PERIOD;i++)
1401          exc[i] = ROUND16(out_mem[c][i], SIG_SHIFT);
1402
1403       if (st->loss_count == 0)
1404       {
1405          _celt_autocorr(exc, ac, st->mode->window, st->mode->overlap,
1406                         LPC_ORDER, MAX_PERIOD);
1407
1408          /* Noise floor -40 dB */
1409 #ifdef FIXED_POINT
1410          ac[0] += SHR32(ac[0],13);
1411 #else
1412          ac[0] *= 1.0001f;
1413 #endif
1414          /* Lag windowing */
1415          for (i=1;i<=LPC_ORDER;i++)
1416          {
1417             /*ac[i] *= exp(-.5*(2*M_PI*.002*i)*(2*M_PI*.002*i));*/
1418 #ifdef FIXED_POINT
1419             ac[i] -= MULT16_32_Q15(2*i*i, ac[i]);
1420 #else
1421             ac[i] -= ac[i]*(.008f*i)*(.008f*i);
1422 #endif
1423          }
1424
1425          _celt_lpc(lpc+c*LPC_ORDER, ac, LPC_ORDER);
1426       }
1427       fir(exc, lpc+c*LPC_ORDER, exc, MAX_PERIOD, LPC_ORDER, mem);
1428       /*for (i=0;i<MAX_PERIOD;i++)printf("%d ", exc[i]); printf("\n");*/
1429       /* Check if the waveform is decaying (and if so how fast) */
1430       {
1431          celt_word32 E1=1, E2=1;
1432          int period;
1433          if (pitch_index <= MAX_PERIOD/2)
1434             period = pitch_index;
1435          else
1436             period = MAX_PERIOD/2;
1437          for (i=0;i<period;i++)
1438          {
1439             E1 += SHR32(MULT16_16(exc[MAX_PERIOD-period+i],exc[MAX_PERIOD-period+i]),8);
1440             E2 += SHR32(MULT16_16(exc[MAX_PERIOD-2*period+i],exc[MAX_PERIOD-2*period+i]),8);
1441          }
1442          if (E1 > E2)
1443             E1 = E2;
1444          decay = celt_sqrt(frac_div32(SHR(E1,1),E2));
1445       }
1446
1447       /* Copy excitation, taking decay into account */
1448       for (i=0;i<len+st->mode->overlap;i++)
1449       {
1450          if (offset+i >= MAX_PERIOD)
1451          {
1452             offset -= pitch_index;
1453             decay = MULT16_16_Q15(decay, decay);
1454          }
1455          e[i] = SHL32(EXTEND32(MULT16_16_Q15(decay, exc[offset+i])), SIG_SHIFT);
1456          S1 += SHR32(MULT16_16(out_mem[c][offset+i],out_mem[c][offset+i]),8);
1457       }
1458
1459       iir(e, lpc+c*LPC_ORDER, e, len+st->mode->overlap, LPC_ORDER, mem);
1460
1461       {
1462          celt_word32 S2=0;
1463          for (i=0;i<len+overlap;i++)
1464             S2 += SHR32(MULT16_16(e[i],e[i]),8);
1465          /* This checks for an "explosion" in the synthesis */
1466 #ifdef FIXED_POINT
1467          if (!(S1 > SHR32(S2,2)))
1468 #else
1469          /* Float test is written this way to catch NaNs at the same time */
1470          if (!(S1 > 0.2f*S2))
1471 #endif
1472          {
1473             for (i=0;i<len+overlap;i++)
1474                e[i] = 0;
1475          } else if (S1 < S2)
1476          {
1477             celt_word16 ratio = celt_sqrt(frac_div32(SHR32(S1,1)+1,S2+1));
1478             for (i=0;i<len+overlap;i++)
1479                e[i] = MULT16_16_Q15(ratio, e[i]);
1480          }
1481       }
1482
1483       for (i=0;i<MAX_PERIOD+st->mode->overlap-N;i++)
1484          out_mem[c][i] = out_mem[c][N+i];
1485
1486       /* Apply TDAC to the concealed audio so that it blends with the
1487          previous and next frames */
1488       for (i=0;i<overlap/2;i++)
1489       {
1490          celt_word32 tmp1, tmp2;
1491          tmp1 = MULT16_32_Q15(st->mode->window[i          ], e[i          ]) -
1492                 MULT16_32_Q15(st->mode->window[overlap-i-1], e[overlap-i-1]);
1493          tmp2 = MULT16_32_Q15(st->mode->window[i],           e[N+overlap-1-i]) +
1494                 MULT16_32_Q15(st->mode->window[overlap-i-1], e[N+i          ]);
1495          tmp1 = MULT16_32_Q15(fade, tmp1);
1496          tmp2 = MULT16_32_Q15(fade, tmp2);
1497          out_mem[c][MAX_PERIOD+i] = MULT16_32_Q15(st->mode->window[overlap-i-1], tmp2);
1498          out_mem[c][MAX_PERIOD+overlap-i-1] = MULT16_32_Q15(st->mode->window[i], tmp2);
1499          out_mem[c][MAX_PERIOD-N+i] += MULT16_32_Q15(st->mode->window[i], tmp1);
1500          out_mem[c][MAX_PERIOD-N+overlap-i-1] -= MULT16_32_Q15(st->mode->window[overlap-i-1], tmp1);
1501       }
1502       for (i=0;i<N-overlap;i++)
1503          out_mem[c][MAX_PERIOD-N+overlap+i] = MULT16_32_Q15(fade, e[overlap+i]);
1504    }
1505
1506    deemphasis(out_mem, pcm, N, C, st->mode->preemph, st->preemph_memD);
1507    
1508    st->loss_count++;
1509
1510    RESTORE_STACK;
1511 }
1512
1513 #ifdef FIXED_POINT
1514 int celt_decode_with_ec(CELTDecoder * restrict st, const unsigned char *data, int len, celt_int16 * restrict pcm, int frame_size, ec_dec *dec)
1515 {
1516 #else
1517 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)
1518 {
1519 #endif
1520    int c, i, N;
1521    int has_fold;
1522    int bits;
1523    ec_dec _dec;
1524    ec_byte_buffer buf;
1525    VARDECL(celt_sig, freq);
1526    VARDECL(celt_norm, X);
1527    VARDECL(celt_ener, bandE);
1528    VARDECL(int, fine_quant);
1529    VARDECL(int, pulses);
1530    VARDECL(int, offsets);
1531    VARDECL(int, fine_priority);
1532    VARDECL(int, tf_res);
1533    celt_sig *out_mem[2];
1534    celt_sig *decode_mem[2];
1535    celt_sig *overlap_mem[2];
1536    celt_sig *out_syn[2];
1537    celt_word16 *lpc;
1538    celt_word16 *oldBandE;
1539
1540    int shortBlocks;
1541    int isTransient;
1542    int intra_ener;
1543    int transient_time;
1544    int transient_shift;
1545    int mdct_weight_shift=0;
1546    const int C = CHANNELS(st->channels);
1547    int mdct_weight_pos=0;
1548    int LM, M;
1549    int nbFilledBytes, nbAvailableBytes;
1550    int effEnd;
1551    int codedBands;
1552    int alloc_trim;
1553    SAVE_STACK;
1554
1555    if (pcm==NULL)
1556       return CELT_BAD_ARG;
1557
1558    for (LM=0;LM<4;LM++)
1559       if (st->mode->shortMdctSize<<LM==frame_size)
1560          break;
1561    if (LM>=MAX_CONFIG_SIZES)
1562       return CELT_BAD_ARG;
1563    M=1<<LM;
1564
1565    for (c=0;c<C;c++)
1566    {
1567       decode_mem[c] = st->_decode_mem + c*(DECODE_BUFFER_SIZE+st->overlap);
1568       out_mem[c] = decode_mem[c]+DECODE_BUFFER_SIZE-MAX_PERIOD;
1569       overlap_mem[c] = decode_mem[c]+DECODE_BUFFER_SIZE;
1570    }
1571    lpc = (celt_word16*)(st->_decode_mem+(DECODE_BUFFER_SIZE+st->overlap)*C);
1572    oldBandE = lpc+C*LPC_ORDER;
1573
1574    N = M*st->mode->shortMdctSize;
1575
1576    effEnd = st->end;
1577    if (effEnd > st->mode->effEBands)
1578       effEnd = st->mode->effEBands;
1579
1580    ALLOC(freq, C*N, celt_sig); /**< Interleaved signal MDCTs */
1581    ALLOC(X, C*N, celt_norm);   /**< Interleaved normalised MDCTs */
1582    ALLOC(bandE, st->mode->nbEBands*C, celt_ener);
1583    for (c=0;c<C;c++)
1584       for (i=0;i<M*st->mode->eBands[st->start];i++)
1585          X[c*N+i] = 0;
1586    for (c=0;c<C;c++)
1587       for (i=M*st->mode->eBands[effEnd];i<N;i++)
1588          X[c*N+i] = 0;
1589
1590    if (data == NULL)
1591    {
1592       celt_decode_lost(st, pcm, N, LM);
1593       RESTORE_STACK;
1594       return CELT_OK;
1595    }
1596    if (len<0) {
1597      RESTORE_STACK;
1598      return CELT_BAD_ARG;
1599    }
1600    
1601    if (dec == NULL)
1602    {
1603       ec_byte_readinit(&buf,(unsigned char*)data,len);
1604       ec_dec_init(&_dec,&buf);
1605       dec = &_dec;
1606       nbFilledBytes = 0;
1607    } else {
1608       nbFilledBytes = (ec_dec_tell(dec, 0)+4)>>3;
1609    }
1610    nbAvailableBytes = len-nbFilledBytes;
1611
1612    /* Decode the global flags (first symbols in the stream) */
1613    intra_ener = ec_dec_bit_prob(dec, 8192);
1614    /* Get band energies */
1615    unquant_coarse_energy(st->mode, st->start, st->end, bandE, oldBandE,
1616          intra_ener, st->mode->prob, dec, C, LM);
1617
1618    if (LM > 0)
1619       isTransient = ec_dec_bit_prob(dec, 8192);
1620    else
1621       isTransient = 0;
1622
1623    if (isTransient)
1624       shortBlocks = M;
1625    else
1626       shortBlocks = 0;
1627
1628    if (isTransient)
1629    {
1630       transient_shift = ec_dec_uint(dec, 4);
1631       if (transient_shift == 3)
1632       {
1633          int transient_time_quant;
1634          int max_time = (N+st->mode->overlap)*(celt_int32)8000/st->mode->Fs;
1635          transient_time_quant = ec_dec_uint(dec, max_time);
1636          transient_time = transient_time_quant*(celt_int32)st->mode->Fs/8000;
1637       } else {
1638          mdct_weight_shift = transient_shift;
1639          if (mdct_weight_shift && M>2)
1640             mdct_weight_pos = ec_dec_uint(dec, M-1);
1641          transient_shift = 0;
1642          transient_time = 0;
1643       }
1644    } else {
1645       transient_time = -1;
1646       transient_shift = 0;
1647    }
1648
1649    ALLOC(tf_res, st->mode->nbEBands, int);
1650    tf_decode(st->start, st->end, C, isTransient, tf_res, nbAvailableBytes, LM, dec);
1651
1652    has_fold = ec_dec_bit_prob(dec, 8192)<<1;
1653    has_fold |= ec_dec_bit_prob(dec, (has_fold>>1) ? 32768 : 49152);
1654
1655    ALLOC(pulses, st->mode->nbEBands, int);
1656    ALLOC(offsets, st->mode->nbEBands, int);
1657    ALLOC(fine_priority, st->mode->nbEBands, int);
1658
1659    for (i=0;i<st->mode->nbEBands;i++)
1660       offsets[i] = 0;
1661    for (i=0;i<st->mode->nbEBands;i++)
1662    {
1663       if (ec_dec_bit_prob(dec, 1024))
1664       {
1665          while (ec_dec_bit_prob(dec, 32768))
1666             offsets[i]++;
1667          offsets[i]++;
1668          offsets[i] *= (6<<BITRES);
1669       }
1670    }
1671
1672    ALLOC(fine_quant, st->mode->nbEBands, int);
1673    {
1674       int fl;
1675       int trim_index=0;
1676       fl = ec_decode_bin(dec, 7);
1677       while (trim_cdf[trim_index+1] <= fl)
1678          trim_index++;
1679       ec_dec_update(dec, trim_cdf[trim_index], trim_cdf[trim_index+1], 128);
1680       alloc_trim = trim_coef[trim_index];
1681    }
1682
1683    bits = len*8 - ec_dec_tell(dec, 0) - 1;
1684    codedBands = compute_allocation(st->mode, st->start, st->end, offsets, alloc_trim, bits, pulses, fine_quant, fine_priority, C, LM);
1685    
1686    unquant_fine_energy(st->mode, st->start, st->end, bandE, oldBandE, fine_quant, dec, C);
1687
1688    /* Decode fixed codebook */
1689    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);
1690
1691    unquant_energy_finalise(st->mode, st->start, st->end, bandE, oldBandE,
1692          fine_quant, fine_priority, len*8-ec_dec_tell(dec, 0), dec, C);
1693
1694    log2Amp(st->mode, st->start, st->end, bandE, oldBandE, C);
1695
1696    if (mdct_weight_shift)
1697    {
1698       mdct_shape(st->mode, X, 0, mdct_weight_pos+1, N, mdct_weight_shift, effEnd, C, 1, M);
1699    }
1700
1701    /* Synthesis */
1702    denormalise_bands(st->mode, X, freq, bandE, effEnd, C, M);
1703
1704    CELT_MOVE(decode_mem[0], decode_mem[0]+N, DECODE_BUFFER_SIZE-N);
1705    if (C==2)
1706       CELT_MOVE(decode_mem[1], decode_mem[1]+N, DECODE_BUFFER_SIZE-N);
1707
1708    for (c=0;c<C;c++)
1709       for (i=0;i<M*st->mode->eBands[st->start];i++)
1710          freq[c*N+i] = 0;
1711    for (c=0;c<C;c++)
1712       for (i=M*st->mode->eBands[effEnd];i<N;i++)
1713          freq[c*N+i] = 0;
1714
1715    out_syn[0] = out_mem[0]+MAX_PERIOD-N;
1716    if (C==2)
1717       out_syn[1] = out_mem[1]+MAX_PERIOD-N;
1718
1719    /* Compute inverse MDCTs */
1720    compute_inv_mdcts(st->mode, shortBlocks, freq, transient_time,
1721          transient_shift, out_syn, overlap_mem, C, LM);
1722
1723    deemphasis(out_syn, pcm, N, C, st->mode->preemph, st->preemph_memD);
1724    st->loss_count = 0;
1725    RESTORE_STACK;
1726    if (ec_dec_get_error(dec))
1727       return CELT_CORRUPTED_DATA;
1728    else
1729       return CELT_OK;
1730 }
1731
1732 #ifdef FIXED_POINT
1733 #ifndef DISABLE_FLOAT_API
1734 int celt_decode_with_ec_float(CELTDecoder * restrict st, const unsigned char *data, int len, float * restrict pcm, int frame_size, ec_dec *dec)
1735 {
1736    int j, ret, C, N, LM, M;
1737    VARDECL(celt_int16, out);
1738    SAVE_STACK;
1739
1740    if (pcm==NULL)
1741       return CELT_BAD_ARG;
1742
1743    for (LM=0;LM<4;LM++)
1744       if (st->mode->shortMdctSize<<LM==frame_size)
1745          break;
1746    if (LM>=MAX_CONFIG_SIZES)
1747       return CELT_BAD_ARG;
1748    M=1<<LM;
1749
1750    C = CHANNELS(st->channels);
1751    N = M*st->mode->shortMdctSize;
1752    
1753    ALLOC(out, C*N, celt_int16);
1754    ret=celt_decode_with_ec(st, data, len, out, frame_size, dec);
1755    if (ret==0)
1756       for (j=0;j<C*N;j++)
1757          pcm[j]=out[j]*(1.f/32768.f);
1758      
1759    RESTORE_STACK;
1760    return ret;
1761 }
1762 #endif /*DISABLE_FLOAT_API*/
1763 #else
1764 int celt_decode_with_ec(CELTDecoder * restrict st, const unsigned char *data, int len, celt_int16 * restrict pcm, int frame_size, ec_dec *dec)
1765 {
1766    int j, ret, C, N, LM, M;
1767    VARDECL(celt_sig, out);
1768    SAVE_STACK;
1769
1770    if (pcm==NULL)
1771       return CELT_BAD_ARG;
1772
1773    for (LM=0;LM<4;LM++)
1774       if (st->mode->shortMdctSize<<LM==frame_size)
1775          break;
1776    if (LM>=MAX_CONFIG_SIZES)
1777       return CELT_BAD_ARG;
1778    M=1<<LM;
1779
1780    C = CHANNELS(st->channels);
1781    N = M*st->mode->shortMdctSize;
1782    ALLOC(out, C*N, celt_sig);
1783
1784    ret=celt_decode_with_ec_float(st, data, len, out, frame_size, dec);
1785
1786    if (ret==0)
1787       for (j=0;j<C*N;j++)
1788          pcm[j] = FLOAT2INT16 (out[j]);
1789    
1790    RESTORE_STACK;
1791    return ret;
1792 }
1793 #endif
1794
1795 int celt_decode(CELTDecoder * restrict st, const unsigned char *data, int len, celt_int16 * restrict pcm, int frame_size)
1796 {
1797    return celt_decode_with_ec(st, data, len, pcm, frame_size, NULL);
1798 }
1799
1800 #ifndef DISABLE_FLOAT_API
1801 int celt_decode_float(CELTDecoder * restrict st, const unsigned char *data, int len, float * restrict pcm, int frame_size)
1802 {
1803    return celt_decode_with_ec_float(st, data, len, pcm, frame_size, NULL);
1804 }
1805 #endif /* DISABLE_FLOAT_API */
1806
1807 int celt_decoder_ctl(CELTDecoder * restrict st, int request, ...)
1808 {
1809    va_list ap;
1810
1811    va_start(ap, request);
1812    switch (request)
1813    {
1814       case CELT_GET_MODE_REQUEST:
1815       {
1816          const CELTMode ** value = va_arg(ap, const CELTMode**);
1817          if (value==0)
1818             goto bad_arg;
1819          *value=st->mode;
1820       }
1821       break;
1822       case CELT_SET_START_BAND_REQUEST:
1823       {
1824          celt_int32 value = va_arg(ap, celt_int32);
1825          if (value<0 || value>=st->mode->nbEBands)
1826             goto bad_arg;
1827          st->start = value;
1828       }
1829       break;
1830       case CELT_SET_END_BAND_REQUEST:
1831       {
1832          celt_int32 value = va_arg(ap, celt_int32);
1833          if (value<0 || value>=st->mode->nbEBands)
1834             goto bad_arg;
1835          st->end = value;
1836       }
1837       break;
1838       case CELT_RESET_STATE:
1839       {
1840          CELT_MEMSET((char*)&st->DECODER_RESET_START, 0,
1841                celt_decoder_get_size(st->mode, st->channels)-
1842                ((char*)&st->DECODER_RESET_START - (char*)st));
1843       }
1844       break;
1845       default:
1846          goto bad_request;
1847    }
1848    va_end(ap);
1849    return CELT_OK;
1850 bad_arg:
1851    va_end(ap);
1852    return CELT_BAD_ARG;
1853 bad_request:
1854       va_end(ap);
1855   return CELT_UNIMPLEMENTED;
1856 }
1857
1858 const char *celt_strerror(int error)
1859 {
1860    static const char *error_strings[8] = {
1861       "success",
1862       "invalid argument",
1863       "invalid mode",
1864       "internal error",
1865       "corrupted stream",
1866       "request not implemented",
1867       "invalid state",
1868       "memory allocation failed"
1869    };
1870    if (error > 0 || error < -7)
1871       return "unknown error";
1872    else 
1873       return error_strings[-error];
1874 }
1875