Making sure the VBR controller never busts the number of bytes allowed
[opus.git] / libcelt / celt.c
1 /* Copyright (c) 2007-2008 CSIRO
2    Copyright (c) 2007-2009 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 "kiss_fftr.h"
46 #include "bands.h"
47 #include "modes.h"
48 #include "entcode.h"
49 #include "quant_bands.h"
50 #include "psy.h"
51 #include "rate.h"
52 #include "stack_alloc.h"
53 #include "mathops.h"
54 #include "float_cast.h"
55 #include <stdarg.h>
56
57 static const celt_word16 preemph = QCONST16(0.8f,15);
58
59 #ifdef FIXED_POINT
60 static const celt_word16 transientWindow[16] = {
61      279,  1106,  2454,  4276,  6510,  9081, 11900, 14872,
62    17896, 20868, 23687, 26258, 28492, 30314, 31662, 32489};
63 #else
64 static const float transientWindow[16] = {
65    0.0085135, 0.0337639, 0.0748914, 0.1304955, 
66    0.1986827, 0.2771308, 0.3631685, 0.4538658,
67    0.5461342, 0.6368315, 0.7228692, 0.8013173, 
68    0.8695045, 0.9251086, 0.9662361, 0.9914865};
69 #endif
70
71 #define ENCODERVALID   0x4c434554
72 #define ENCODERPARTIAL 0x5445434c
73 #define ENCODERFREED   0x4c004500
74    
75 /** Encoder state 
76  @brief Encoder state
77  */
78 struct CELTEncoder {
79    celt_uint32 marker;
80    const CELTMode *mode;     /**< Mode used by the encoder */
81    int frame_size;
82    int block_size;
83    int overlap;
84    int channels;
85    
86    int pitch_enabled;       /* Complexity level is allowed to use pitch */
87    int pitch_permitted;     /*  Use of the LTP is permitted by the user */
88    int pitch_available;     /*  Amount of pitch buffer available */
89    int force_intra;
90    int delayedIntra;
91    celt_word16 tonal_average;
92    int fold_decision;
93    celt_word16 gain_prod;
94
95    /* VBR-related parameters */
96    celt_int32 vbr_reservoir;
97    celt_int32 vbr_drift;
98    celt_int32 vbr_offset;
99    celt_int32 vbr_count;
100
101    celt_int32 vbr_rate; /* Target number of 16th bits per frame */
102    celt_word16 * restrict preemph_memE; 
103    celt_sig    * restrict preemph_memD;
104
105    celt_sig *in_mem;
106    celt_sig *out_mem;
107
108    celt_word16 *oldBandE;
109 #ifdef EXP_PSY
110    celt_word16 *psy_mem;
111    struct PsyDecay psy;
112 #endif
113 };
114
115 static int check_encoder(const CELTEncoder *st) 
116 {
117    if (st==NULL)
118    {
119       celt_warning("NULL passed as an encoder structure");  
120       return CELT_INVALID_STATE;
121    }
122    if (st->marker == ENCODERVALID)
123       return CELT_OK;
124    if (st->marker == ENCODERFREED)
125       celt_warning("Referencing an encoder that has already been freed");
126    else
127       celt_warning("This is not a valid CELT encoder structure");
128    return CELT_INVALID_STATE;
129 }
130
131 CELTEncoder *celt_encoder_create(const CELTMode *mode, int channels, int *error)
132 {
133    int N, C;
134    CELTEncoder *st;
135
136    if (check_mode(mode) != CELT_OK)
137    {
138       if (error)
139          *error = CELT_INVALID_MODE;
140       return NULL;
141    }
142 #ifdef DISABLE_STEREO
143    if (channels > 1)
144    {
145       celt_warning("Stereo support was disable from this build");
146       if (error)
147          *error = CELT_BAD_ARG;
148       return NULL;
149    }
150 #endif
151
152    if (channels < 0 || channels > 2)
153    {
154       celt_warning("Only mono and stereo supported");
155       if (error)
156          *error = CELT_BAD_ARG;
157       return NULL;
158    }
159
160    N = mode->mdctSize;
161    C = channels;
162    st = celt_alloc(sizeof(CELTEncoder));
163    
164    if (st==NULL)
165    {
166       if (error)
167          *error = CELT_ALLOC_FAIL;
168       return NULL;
169    }
170    st->marker = ENCODERPARTIAL;
171    st->mode = mode;
172    st->frame_size = N;
173    st->block_size = N;
174    st->overlap = mode->overlap;
175    st->channels = channels;
176
177    st->vbr_rate = 0;
178    st->pitch_enabled = 1;
179    st->pitch_permitted = 1;
180    st->pitch_available = 1;
181    st->force_intra  = 0;
182    st->delayedIntra = 1;
183    st->tonal_average = QCONST16(1.,8);
184    st->fold_decision = 1;
185
186    st->in_mem = celt_alloc(st->overlap*C*sizeof(celt_sig));
187    st->out_mem = celt_alloc((MAX_PERIOD+st->overlap)*C*sizeof(celt_sig));
188
189    st->oldBandE = (celt_word16*)celt_alloc(C*mode->nbEBands*sizeof(celt_word16));
190
191    st->preemph_memE = (celt_word16*)celt_alloc(C*sizeof(celt_word16));
192    st->preemph_memD = (celt_sig*)celt_alloc(C*sizeof(celt_sig));
193
194 #ifdef EXP_PSY
195    st->psy_mem = celt_alloc(MAX_PERIOD*sizeof(celt_word16));
196    psydecay_init(&st->psy, MAX_PERIOD/2, st->mode->Fs);
197 #endif
198
199    if ((st->in_mem!=NULL) && (st->out_mem!=NULL) && (st->oldBandE!=NULL) 
200 #ifdef EXP_PSY
201        && (st->psy_mem!=NULL) 
202 #endif   
203        && (st->preemph_memE!=NULL) && (st->preemph_memD!=NULL))
204    {
205       if (error)
206          *error = CELT_OK;
207       st->marker   = ENCODERVALID;
208       return st;
209    }
210    /* If the setup fails for some reason deallocate it. */
211    celt_encoder_destroy(st);  
212    if (error)
213       *error = CELT_ALLOC_FAIL;
214    return NULL;
215 }
216
217 void celt_encoder_destroy(CELTEncoder *st)
218 {
219    if (st == NULL)
220    {
221       celt_warning("NULL passed to celt_encoder_destroy");
222       return;
223    }
224
225    if (st->marker == ENCODERFREED)
226    {
227       celt_warning("Freeing an encoder which has already been freed"); 
228       return;
229    }
230
231    if (st->marker != ENCODERVALID && st->marker != ENCODERPARTIAL)
232    {
233       celt_warning("This is not a valid CELT encoder structure");
234       return;
235    }
236    /*Check_mode is non-fatal here because we can still free
237     the encoder memory even if the mode is bad, although calling
238     the free functions in this order is a violation of the API.*/
239    check_mode(st->mode);
240    
241    celt_free(st->in_mem);
242    celt_free(st->out_mem);
243    
244    celt_free(st->oldBandE);
245    
246    celt_free(st->preemph_memE);
247    celt_free(st->preemph_memD);
248    
249 #ifdef EXP_PSY
250    celt_free (st->psy_mem);
251    psydecay_clear(&st->psy);
252 #endif
253    st->marker = ENCODERFREED;
254    
255    celt_free(st);
256 }
257
258 static inline celt_int16 FLOAT2INT16(float x)
259 {
260    x = x*CELT_SIG_SCALE;
261    x = MAX32(x, -32768);
262    x = MIN32(x, 32767);
263    return (celt_int16)float2int(x);
264 }
265
266 static inline celt_word16 SIG2WORD16(celt_sig x)
267 {
268 #ifdef FIXED_POINT
269    x = PSHR32(x, SIG_SHIFT);
270    x = MAX32(x, -32768);
271    x = MIN32(x, 32767);
272    return EXTRACT16(x);
273 #else
274    return (celt_word16)x;
275 #endif
276 }
277
278 static int transient_analysis(celt_word32 *in, int len, int C, int *transient_time, int *transient_shift)
279 {
280    int c, i, n;
281    celt_word32 ratio;
282    VARDECL(celt_word32, begin);
283    SAVE_STACK;
284    ALLOC(begin, len, celt_word32);
285    for (i=0;i<len;i++)
286       begin[i] = ABS32(SHR32(in[C*i],SIG_SHIFT));
287    for (c=1;c<C;c++)
288    {
289       for (i=0;i<len;i++)
290          begin[i] = MAX32(begin[i], ABS32(SHR32(in[C*i+c],SIG_SHIFT)));
291    }
292    for (i=1;i<len;i++)
293       begin[i] = MAX32(begin[i-1],begin[i]);
294    n = -1;
295    for (i=8;i<len-8;i++)
296    {
297       if (begin[i] < MULT16_32_Q15(QCONST16(.2f,15),begin[len-1]))
298          n=i;
299    }
300    if (n<32)
301    {
302       n = -1;
303       ratio = 0;
304    } else {
305       ratio = DIV32(begin[len-1],1+begin[n-16]);
306    }
307    if (ratio < 0)
308       ratio = 0;
309    if (ratio > 1000)
310       ratio = 1000;
311    ratio *= ratio;
312    
313    if (ratio > 2048)
314       *transient_shift = 3;
315    else
316       *transient_shift = 0;
317    
318    *transient_time = n;
319    
320    RESTORE_STACK;
321    return ratio > 20;
322 }
323
324 /** Apply window and compute the MDCT for all sub-frames and 
325     all channels in a frame */
326 static void compute_mdcts(const CELTMode *mode, int shortBlocks, celt_sig * restrict in, celt_sig * restrict out, int _C)
327 {
328    const int C = CHANNELS(_C);
329    if (C==1 && !shortBlocks)
330    {
331       const mdct_lookup *lookup = MDCT(mode);
332       const int overlap = OVERLAP(mode);
333       mdct_forward(lookup, in, out, mode->window, overlap);
334    } else {
335       const mdct_lookup *lookup = MDCT(mode);
336       const int overlap = OVERLAP(mode);
337       int N = FRAMESIZE(mode);
338       int B = 1;
339       int b, c;
340       VARDECL(celt_word32, x);
341       VARDECL(celt_word32, tmp);
342       SAVE_STACK;
343       if (shortBlocks)
344       {
345          lookup = &mode->shortMdct;
346          N = mode->shortMdctSize;
347          B = mode->nbShortMdcts;
348       }
349       ALLOC(x, N+overlap, celt_word32);
350       ALLOC(tmp, N, celt_word32);
351       for (c=0;c<C;c++)
352       {
353          for (b=0;b<B;b++)
354          {
355             int j;
356             for (j=0;j<N+overlap;j++)
357                x[j] = in[C*(b*N+j)+c];
358             mdct_forward(lookup, x, tmp, mode->window, overlap);
359             /* Interleaving the sub-frames */
360             for (j=0;j<N;j++)
361                out[(j*B+b)+c*N*B] = tmp[j];
362          }
363       }
364       RESTORE_STACK;
365    }
366 }
367
368 /** Compute the IMDCT and apply window for all sub-frames and 
369     all channels in a frame */
370 static void compute_inv_mdcts(const CELTMode *mode, int shortBlocks, celt_sig *X, int transient_time, int transient_shift, celt_sig * restrict out_mem, int _C)
371 {
372    int c, N4;
373    const int C = CHANNELS(_C);
374    const int N = FRAMESIZE(mode);
375    const int overlap = OVERLAP(mode);
376    N4 = (N-overlap)>>1;
377    for (c=0;c<C;c++)
378    {
379       int j;
380       if (transient_shift==0 && C==1 && !shortBlocks) {
381          const mdct_lookup *lookup = MDCT(mode);
382          mdct_backward(lookup, X, out_mem+C*(MAX_PERIOD-N-N4), mode->window, overlap);
383       } else {
384          VARDECL(celt_word32, x);
385          VARDECL(celt_word32, tmp);
386          int b;
387          int N2 = N;
388          int B = 1;
389          int n4offset=0;
390          const mdct_lookup *lookup = MDCT(mode);
391          SAVE_STACK;
392          
393          ALLOC(x, 2*N, celt_word32);
394          ALLOC(tmp, N, celt_word32);
395
396          if (shortBlocks)
397          {
398             lookup = &mode->shortMdct;
399             N2 = mode->shortMdctSize;
400             B = mode->nbShortMdcts;
401             n4offset = N4;
402          }
403          /* Prevents problems from the imdct doing the overlap-add */
404          CELT_MEMSET(x+N4, 0, N2);
405
406          for (b=0;b<B;b++)
407          {
408             /* De-interleaving the sub-frames */
409             for (j=0;j<N2;j++)
410                tmp[j] = X[(j*B+b)+c*N2*B];
411             mdct_backward(lookup, tmp, x+n4offset+N2*b, mode->window, overlap);
412          }
413
414          if (transient_shift > 0)
415          {
416 #ifdef FIXED_POINT
417             for (j=0;j<16;j++)
418                x[N4+transient_time+j-16] = MULT16_32_Q15(SHR16(Q15_ONE-transientWindow[j],transient_shift)+transientWindow[j], SHL32(x[N4+transient_time+j-16],transient_shift));
419             for (j=transient_time;j<N+overlap;j++)
420                x[N4+j] = SHL32(x[N4+j], transient_shift);
421 #else
422             for (j=0;j<16;j++)
423                x[N4+transient_time+j-16] *= 1+transientWindow[j]*((1<<transient_shift)-1);
424             for (j=transient_time;j<N+overlap;j++)
425                x[N4+j] *= 1<<transient_shift;
426 #endif
427          }
428          /* The first and last part would need to be set to zero 
429             if we actually wanted to use them. */
430          for (j=0;j<overlap;j++)
431             out_mem[C*(MAX_PERIOD-N)+C*j+c] += x[j+N4];
432          for (j=0;j<overlap;j++)
433             out_mem[C*(MAX_PERIOD)+C*(overlap-j-1)+c] = x[2*N-j-N4-1];
434          for (j=0;j<2*N4;j++)
435             out_mem[C*(MAX_PERIOD-N)+C*(j+overlap)+c] = x[j+N4+overlap];
436          RESTORE_STACK;
437       }
438    }
439 }
440
441 #define FLAG_NONE        0
442 #define FLAG_INTRA       (1U<<13)
443 #define FLAG_PITCH       (1U<<12)
444 #define FLAG_SHORT       (1U<<11)
445 #define FLAG_FOLD        (1U<<10)
446 #define FLAG_MASK        (FLAG_INTRA|FLAG_PITCH|FLAG_SHORT|FLAG_FOLD)
447
448 static const int flaglist[8] = {
449       0 /*00  */ | FLAG_FOLD,
450       1 /*01  */ | FLAG_PITCH|FLAG_FOLD,
451       8 /*1000*/ | FLAG_NONE,
452       9 /*1001*/ | FLAG_SHORT|FLAG_FOLD,
453      10 /*1010*/ | FLAG_PITCH,
454      11 /*1011*/ | FLAG_INTRA,
455       6 /*110 */ | FLAG_INTRA|FLAG_FOLD,
456       7 /*111 */ | FLAG_INTRA|FLAG_SHORT|FLAG_FOLD
457 };
458
459 static void encode_flags(ec_enc *enc, int intra_ener, int has_pitch, int shortBlocks, int has_fold)
460 {
461    int i;
462    int flags=FLAG_NONE;
463    int flag_bits;
464    flags |= intra_ener   ? FLAG_INTRA : 0;
465    flags |= has_pitch    ? FLAG_PITCH : 0;
466    flags |= shortBlocks  ? FLAG_SHORT : 0;
467    flags |= has_fold     ? FLAG_FOLD  : 0;
468    for (i=0;i<8;i++)
469       if (flags == (flaglist[i]&FLAG_MASK))
470          break;
471    celt_assert(i<8);
472    flag_bits = flaglist[i]&0xf;
473    /*printf ("enc %d: %d %d %d %d\n", flag_bits, intra_ener, has_pitch, shortBlocks, has_fold);*/
474    if (i<2)
475       ec_enc_uint(enc, flag_bits, 4);
476    else if (i<6)
477       ec_enc_uint(enc, flag_bits, 16);
478    else
479       ec_enc_uint(enc, flag_bits, 8);
480 }
481
482 static void decode_flags(ec_dec *dec, int *intra_ener, int *has_pitch, int *shortBlocks, int *has_fold)
483 {
484    int i;
485    int flag_bits;
486    flag_bits = ec_dec_uint(dec, 4);
487    /*printf ("(%d) ", flag_bits);*/
488    if (flag_bits==2)
489       flag_bits = (flag_bits<<2) | ec_dec_uint(dec, 4);
490    else if (flag_bits==3)
491       flag_bits = (flag_bits<<1) | ec_dec_uint(dec, 2);
492    for (i=0;i<8;i++)
493       if (flag_bits == (flaglist[i]&0xf))
494          break;
495    celt_assert(i<8);
496    *intra_ener  = (flaglist[i]&FLAG_INTRA) != 0;
497    *has_pitch   = (flaglist[i]&FLAG_PITCH) != 0;
498    *shortBlocks = (flaglist[i]&FLAG_SHORT) != 0;
499    *has_fold    = (flaglist[i]&FLAG_FOLD ) != 0;
500    /*printf ("dec %d: %d %d %d %d\n", flag_bits, *intra_ener, *has_pitch, *shortBlocks, *has_fold);*/
501 }
502
503 static void deemphasis(celt_sig *in, celt_word16 *pcm, int N, int _C, celt_word16 coef, celt_sig *mem)
504 {
505    const int C = CHANNELS(_C);
506    int c;
507    for (c=0;c<C;c++)
508    {
509       int j;
510       for (j=0;j<N;j++)
511       {
512          celt_sig tmp = MAC16_32_Q15(in[C*(MAX_PERIOD-N)+C*j+c],
513                                        coef,mem[c]);
514          mem[c] = tmp;
515          pcm[C*j+c] = SCALEOUT(SIG2WORD16(tmp));
516       }
517    }
518
519 }
520
521 static void mdct_shape(const CELTMode *mode, celt_norm *X, int start, int end, int N, int nbShortMdcts, int mdct_weight_shift, int _C)
522 {
523    int m, i, c;
524    const int C = CHANNELS(_C);
525    for (c=0;c<C;c++)
526       for (m=start;m<end;m++)
527          for (i=m+c*N;i<(c+1)*N;i+=nbShortMdcts)
528 #ifdef FIXED_POINT
529             X[i] = SHR16(X[i], mdct_weight_shift);
530 #else
531             X[i] = (1.f/(1<<mdct_weight_shift))*X[i];
532 #endif
533    renormalise_bands(mode, X, C);
534 }
535
536
537 #ifdef FIXED_POINT
538 int celt_encode(CELTEncoder * restrict st, const celt_int16 * pcm, celt_int16 * optional_synthesis, unsigned char *compressed, int nbCompressedBytes)
539 {
540 #else
541 int celt_encode_float(CELTEncoder * restrict st, const celt_sig * pcm, celt_sig * optional_synthesis, unsigned char *compressed, int nbCompressedBytes)
542 {
543 #endif
544    int i, c, N, NN, N4;
545    int has_pitch;
546    int pitch_index;
547    int bits;
548    int has_fold=1;
549    int coarse_needed;
550    ec_byte_buffer buf;
551    ec_enc         enc;
552    VARDECL(celt_sig, in);
553    VARDECL(celt_sig, freq);
554    VARDECL(celt_sig, pitch_freq);
555    VARDECL(celt_norm, X);
556    VARDECL(celt_ener, bandE);
557    VARDECL(celt_word16, bandLogE);
558    VARDECL(int, fine_quant);
559    VARDECL(celt_word16, error);
560    VARDECL(int, pulses);
561    VARDECL(int, offsets);
562    VARDECL(int, fine_priority);
563    int intra_ener = 0;
564    int shortBlocks=0;
565    int transient_time;
566    int transient_shift;
567    const int C = CHANNELS(st->channels);
568    int mdct_weight_shift = 0;
569    int mdct_weight_pos=0;
570    int gain_id=0;
571    int norm_rate;
572    SAVE_STACK;
573
574    if (check_encoder(st) != CELT_OK)
575       return CELT_INVALID_STATE;
576
577    if (check_mode(st->mode) != CELT_OK)
578       return CELT_INVALID_MODE;
579
580    if (nbCompressedBytes<0 || pcm==NULL)
581      return CELT_BAD_ARG; 
582
583    /* The memset is important for now in case the encoder doesn't 
584       fill up all the bytes */
585    CELT_MEMSET(compressed, 0, nbCompressedBytes);
586    ec_byte_writeinit_buffer(&buf, compressed, nbCompressedBytes);
587    ec_enc_init(&enc,&buf);
588
589    N = st->block_size;
590    N4 = (N-st->overlap)>>1;
591    ALLOC(in, 2*C*N-2*C*N4, celt_sig);
592
593    CELT_COPY(in, st->in_mem, C*st->overlap);
594    for (c=0;c<C;c++)
595    {
596       const celt_word16 * restrict pcmp = pcm+c;
597       celt_sig * restrict inp = in+C*st->overlap+c;
598       for (i=0;i<N;i++)
599       {
600          /* Apply pre-emphasis */
601          celt_sig tmp = SCALEIN(SHL32(EXTEND32(*pcmp), SIG_SHIFT));
602          *inp = SUB32(tmp, SHR32(MULT16_16(preemph,st->preemph_memE[c]),3));
603          st->preemph_memE[c] = SCALEIN(*pcmp);
604          inp += C;
605          pcmp += C;
606       }
607    }
608    CELT_COPY(st->in_mem, in+C*(2*N-2*N4-st->overlap), C*st->overlap);
609
610    /* Transient handling */
611    transient_time = -1;
612    transient_shift = 0;
613    shortBlocks = 0;
614
615    if (st->mode->nbShortMdcts > 1 && transient_analysis(in, N+st->overlap, C, &transient_time, &transient_shift))
616    {
617 #ifndef FIXED_POINT
618       float gain_1;
619 #endif
620       /* Apply the inverse shaping window */
621       if (transient_shift)
622       {
623 #ifdef FIXED_POINT
624          for (c=0;c<C;c++)
625             for (i=0;i<16;i++)
626                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]);
627          for (c=0;c<C;c++)
628             for (i=transient_time;i<N+st->overlap;i++)
629                in[C*i+c] = SHR32(in[C*i+c], transient_shift);
630 #else
631          for (c=0;c<C;c++)
632             for (i=0;i<16;i++)
633                in[C*(transient_time+i-16)+c] /= 1+transientWindow[i]*((1<<transient_shift)-1);
634          gain_1 = 1./(1<<transient_shift);
635          for (c=0;c<C;c++)
636             for (i=transient_time;i<N+st->overlap;i++)
637                in[C*i+c] *= gain_1;
638 #endif
639       }
640       shortBlocks = 1;
641       has_fold = 1;
642    }
643
644    ALLOC(freq, C*N, celt_sig); /**< Interleaved signal MDCTs */
645    ALLOC(bandE,st->mode->nbEBands*C, celt_ener);
646    ALLOC(bandLogE,st->mode->nbEBands*C, celt_word16);
647    /* Compute MDCTs */
648    compute_mdcts(st->mode, shortBlocks, in, freq, C);
649
650
651    norm_rate = (nbCompressedBytes-5)*8*(celt_uint32)st->mode->Fs/(C*N)>>10;
652    /* Pitch analysis: we do it early to save on the peak stack space */
653    /* Don't use pitch if there isn't enough data available yet, 
654       or if we're using shortBlocks */
655    has_pitch = st->pitch_enabled && st->pitch_permitted && (N <= 512) 
656             && (st->pitch_available >= MAX_PERIOD) && (!shortBlocks)
657             && norm_rate < 50;
658    if (has_pitch)
659    {
660       find_spectral_pitch(st->mode, st->mode->fft, &st->mode->psy, in, st->out_mem, st->mode->window, NULL, 2*N-2*N4, MAX_PERIOD-(2*N-2*N4), &pitch_index, C);
661    }
662
663    /* Deferred allocation after find_spectral_pitch() to reduce 
664       the peak memory usage */
665    ALLOC(X, C*N, celt_norm);         /**< Interleaved normalised MDCTs */
666
667    ALLOC(pitch_freq, C*N, celt_sig); /**< Interleaved signal MDCTs */
668    if (has_pitch)
669    {
670       
671       compute_mdcts(st->mode, 0, st->out_mem+pitch_index*C, pitch_freq, C);
672       has_pitch = compute_pitch_gain(st->mode, freq, pitch_freq, norm_rate, &gain_id, C, &st->gain_prod);
673    }
674    
675    if (has_pitch)
676       apply_pitch(st->mode, freq, pitch_freq, gain_id, 1, C);
677
678    compute_band_energies(st->mode, freq, bandE, C);
679    for (i=0;i<st->mode->nbEBands*C;i++)
680       bandLogE[i] = amp2Log(bandE[i]);
681
682    /* Band normalisation */
683    normalise_bands(st->mode, freq, X, bandE, C);
684    if (!shortBlocks && !folding_decision(st->mode, X, &st->tonal_average, &st->fold_decision, C))
685       has_fold = 0;
686
687    /* Don't use intra energy when we're operating at low bit-rate */
688    intra_ener = st->force_intra || (!has_pitch && st->delayedIntra && nbCompressedBytes > st->mode->nbEBands);
689    if (shortBlocks || intra_decision(bandLogE, st->oldBandE, st->mode->nbEBands))
690       st->delayedIntra = 1;
691    else
692       st->delayedIntra = 0;
693
694    NN = st->mode->eBands[st->mode->nbEBands];
695    if (shortBlocks && !transient_shift) 
696    {
697       celt_word32 sum[8]={1,1,1,1,1,1,1,1};
698       int m;
699       for (c=0;c<C;c++)
700       {
701          m=0;
702          do {
703             celt_word32 tmp=0;
704             for (i=m+c*N;i<c*N+NN;i+=st->mode->nbShortMdcts)
705                tmp += ABS32(X[i]);
706             sum[m++] += tmp;
707          } while (m<st->mode->nbShortMdcts);
708       }
709       m=0;
710 #ifdef FIXED_POINT
711       do {
712          if (SHR32(sum[m+1],3) > sum[m])
713          {
714             mdct_weight_shift=2;
715             mdct_weight_pos = m;
716          } else if (SHR32(sum[m+1],1) > sum[m] && mdct_weight_shift < 2)
717          {
718             mdct_weight_shift=1;
719             mdct_weight_pos = m;
720          }
721          m++;
722       } while (m<st->mode->nbShortMdcts-1);
723 #else
724       do {
725          if (sum[m+1] > 8*sum[m])
726          {
727             mdct_weight_shift=2;
728             mdct_weight_pos = m;
729          } else if (sum[m+1] > 2*sum[m] && mdct_weight_shift < 2)
730          {
731             mdct_weight_shift=1;
732             mdct_weight_pos = m;
733          }
734          m++;
735       } while (m<st->mode->nbShortMdcts-1);
736 #endif
737       if (mdct_weight_shift)
738       {
739          mdct_shape(st->mode, X, mdct_weight_pos+1, st->mode->nbShortMdcts, N, st->mode->nbShortMdcts, mdct_weight_shift, C);
740          renormalise_bands(st->mode, X, C);
741       }
742    }
743
744
745    encode_flags(&enc, intra_ener, has_pitch, shortBlocks, has_fold);
746    if (has_pitch)
747    {
748       ec_enc_uint(&enc, pitch_index, MAX_PERIOD-(2*N-2*N4));
749       ec_enc_uint(&enc, gain_id, 16);
750    }
751    if (shortBlocks)
752    {
753       if (transient_shift)
754       {
755          ec_enc_uint(&enc, transient_shift, 4);
756          ec_enc_uint(&enc, transient_time, N+st->overlap);
757       } else {
758          ec_enc_uint(&enc, mdct_weight_shift, 4);
759          if (mdct_weight_shift && st->mode->nbShortMdcts!=2)
760             ec_enc_uint(&enc, mdct_weight_pos, st->mode->nbShortMdcts-1);
761       }
762    }
763
764    ALLOC(fine_quant, st->mode->nbEBands, int);
765    ALLOC(pulses, st->mode->nbEBands, int);
766
767    /* Computes the max bit-rate allowed in VBR more to avoid busting the budget */
768    if (st->vbr_rate>0)
769    {
770       celt_int32 vbr_bound, max_allowed;
771
772       vbr_bound = st->vbr_rate;
773       max_allowed = (st->vbr_rate + vbr_bound - st->vbr_reservoir)>>(BITRES+3); 
774       if (max_allowed < nbCompressedBytes)
775          nbCompressedBytes = max_allowed;
776    }
777
778    /* Bit allocation */
779    ALLOC(error, C*st->mode->nbEBands, celt_word16);
780    coarse_needed = quant_coarse_energy(st->mode, bandLogE, st->oldBandE, nbCompressedBytes*4-8, intra_ener, st->mode->prob, error, &enc, C);
781    coarse_needed = ((coarse_needed*3-1)>>3)+1;
782    if (coarse_needed > nbCompressedBytes)
783       coarse_needed = nbCompressedBytes;
784    /* Variable bitrate */
785    if (st->vbr_rate>0)
786    {
787      celt_word16 alpha;
788      celt_int32 delta;
789      /* The target rate in 16th bits per frame */
790      celt_int32 target=st->vbr_rate;
791    
792      /* Shortblocks get a large boost in bitrate, but since they 
793         are uncommon long blocks are not greatly effected */
794      if (shortBlocks)
795        target*=2;
796      else if (st->mode->nbShortMdcts > 1)
797        target-=(target+14)/28;
798
799      /* The average energy is removed from the target and the actual 
800         energy added*/
801      target=target+st->vbr_offset-588+ec_enc_tell(&enc, BITRES);
802
803      /* In VBR mode the frame size must not be reduced so much that it would result in the coarse energy busting its budget */
804      target=IMAX(coarse_needed,(target+64)/128);
805      target=IMIN(nbCompressedBytes,target);
806      /* Make the adaptation coef (alpha) higher at the beginning */
807      if (st->vbr_count < 990)
808      {
809         st->vbr_count++;
810         alpha = celt_rcp(SHL32(EXTEND32(st->vbr_count+10),16));
811         /*printf ("%d %d\n", st->vbr_count+10, alpha);*/
812      } else
813         alpha = QCONST16(.001f,15);
814
815      /* By how much did we "miss" the target on that frame */
816      delta = (8<<BITRES)*(celt_int32)target - st->vbr_rate;
817      /* How many bits have we used in excess of what we're allowed */
818      st->vbr_reservoir += delta;
819      /*printf ("%d\n", st->vbr_reservoir);*/
820
821      /* Compute the offset we need to apply in order to reach the target */
822      st->vbr_drift += MULT16_32_Q15(alpha,delta-st->vbr_offset-st->vbr_drift);
823      st->vbr_offset = -st->vbr_drift;
824      /*printf ("%d\n", st->vbr_drift);*/
825
826      /* We could use any multiple of vbr_rate as bound (depending on the delay) */
827      if (st->vbr_reservoir < 0)
828      {
829         /* We're under the min value -- increase rate */
830         int adjust = 1-(st->vbr_reservoir-1)/(8<<BITRES);
831         st->vbr_reservoir += adjust*(8<<BITRES);
832         target += adjust;
833         /*printf ("+%d\n", adjust);*/
834      }
835      if (target < nbCompressedBytes)
836         nbCompressedBytes = target;
837      /* This moves the raw bits to take into account the new compressed size */
838      ec_byte_shrink(&buf, nbCompressedBytes);
839    }
840
841    ALLOC(offsets, st->mode->nbEBands, int);
842    ALLOC(fine_priority, st->mode->nbEBands, int);
843
844    for (i=0;i<st->mode->nbEBands;i++)
845       offsets[i] = 0;
846    bits = nbCompressedBytes*8 - ec_enc_tell(&enc, 0) - 1;
847    compute_allocation(st->mode, offsets, bits, pulses, fine_quant, fine_priority, C);
848
849    quant_fine_energy(st->mode, bandE, st->oldBandE, error, fine_quant, &enc, C);
850
851    /* Residual quantisation */
852    if (C==1)
853       quant_bands(st->mode, X, bandE, pulses, shortBlocks, has_fold, nbCompressedBytes*8, 1, &enc);
854 #ifndef DISABLE_STEREO
855    else
856       quant_bands_stereo(st->mode, X, bandE, pulses, shortBlocks, has_fold, nbCompressedBytes*8, &enc);
857 #endif
858
859    quant_energy_finalise(st->mode, bandE, st->oldBandE, error, fine_quant, fine_priority, nbCompressedBytes*8-ec_enc_tell(&enc, 0), &enc, C);
860
861    /* Re-synthesis of the coded audio if required */
862    if (st->pitch_available>0 || optional_synthesis!=NULL)
863    {
864       if (st->pitch_available>0 && st->pitch_available<MAX_PERIOD)
865         st->pitch_available+=st->frame_size;
866
867       if (mdct_weight_shift)
868       {
869          mdct_shape(st->mode, X, 0, mdct_weight_pos+1, N, st->mode->nbShortMdcts, mdct_weight_shift, C);
870       }
871
872       /* Synthesis */
873       denormalise_bands(st->mode, X, freq, bandE, C);
874
875       CELT_MOVE(st->out_mem, st->out_mem+C*N, C*(MAX_PERIOD+st->overlap-N));
876
877       if (has_pitch)
878          apply_pitch(st->mode, freq, pitch_freq, gain_id, 0, C);
879       
880       compute_inv_mdcts(st->mode, shortBlocks, freq, transient_time, transient_shift, st->out_mem, C);
881
882       /* De-emphasis and put everything back at the right place 
883          in the synthesis history */
884       if (optional_synthesis != NULL) {
885          deemphasis(st->out_mem, optional_synthesis, N, C, preemph, st->preemph_memD);
886
887       }
888    }
889
890    ec_enc_done(&enc);
891    
892    RESTORE_STACK;
893    return nbCompressedBytes;
894 }
895
896 #ifdef FIXED_POINT
897 #ifndef DISABLE_FLOAT_API
898 int celt_encode_float(CELTEncoder * restrict st, const float * pcm, float * optional_synthesis, unsigned char *compressed, int nbCompressedBytes)
899 {
900    int j, ret, C, N;
901    VARDECL(celt_int16, in);
902    SAVE_STACK;
903
904    if (check_encoder(st) != CELT_OK)
905       return CELT_INVALID_STATE;
906
907    if (check_mode(st->mode) != CELT_OK)
908       return CELT_INVALID_MODE;
909
910    if (pcm==NULL)
911       return CELT_BAD_ARG;
912
913    C = CHANNELS(st->channels);
914    N = st->block_size;
915    ALLOC(in, C*N, celt_int16);
916
917    for (j=0;j<C*N;j++)
918      in[j] = FLOAT2INT16(pcm[j]);
919
920    if (optional_synthesis != NULL) {
921      ret=celt_encode(st,in,in,compressed,nbCompressedBytes);
922       for (j=0;j<C*N;j++)
923          optional_synthesis[j]=in[j]*(1/32768.);
924    } else {
925      ret=celt_encode(st,in,NULL,compressed,nbCompressedBytes);
926    }
927    RESTORE_STACK;
928    return ret;
929
930 }
931 #endif /*DISABLE_FLOAT_API*/
932 #else
933 int celt_encode(CELTEncoder * restrict st, const celt_int16 * pcm, celt_int16 * optional_synthesis, unsigned char *compressed, int nbCompressedBytes)
934 {
935    int j, ret, C, N;
936    VARDECL(celt_sig, in);
937    SAVE_STACK;
938
939    if (check_encoder(st) != CELT_OK)
940       return CELT_INVALID_STATE;
941
942    if (check_mode(st->mode) != CELT_OK)
943       return CELT_INVALID_MODE;
944
945    if (pcm==NULL)
946       return CELT_BAD_ARG;
947
948    C=CHANNELS(st->channels);
949    N=st->block_size;
950    ALLOC(in, C*N, celt_sig);
951    for (j=0;j<C*N;j++) {
952      in[j] = SCALEOUT(pcm[j]);
953    }
954
955    if (optional_synthesis != NULL) {
956       ret = celt_encode_float(st,in,in,compressed,nbCompressedBytes);
957       for (j=0;j<C*N;j++)
958          optional_synthesis[j] = FLOAT2INT16(in[j]);
959    } else {
960       ret = celt_encode_float(st,in,NULL,compressed,nbCompressedBytes);
961    }
962    RESTORE_STACK;
963    return ret;
964 }
965 #endif
966
967 int celt_encoder_ctl(CELTEncoder * restrict st, int request, ...)
968 {
969    va_list ap;
970    
971    if (check_encoder(st) != CELT_OK)
972       return CELT_INVALID_STATE;
973
974    va_start(ap, request);
975    if ((request!=CELT_GET_MODE_REQUEST) && (check_mode(st->mode) != CELT_OK))
976      goto bad_mode;
977    switch (request)
978    {
979       case CELT_GET_MODE_REQUEST:
980       {
981          const CELTMode ** value = va_arg(ap, const CELTMode**);
982          if (value==0)
983             goto bad_arg;
984          *value=st->mode;
985       }
986       break;
987       case CELT_SET_COMPLEXITY_REQUEST:
988       {
989          int value = va_arg(ap, celt_int32);
990          if (value<0 || value>10)
991             goto bad_arg;
992          if (value<=2) {
993             st->pitch_enabled = 0; 
994             st->pitch_available = 0;
995          } else {
996               st->pitch_enabled = 1;
997               if (st->pitch_available<1)
998                 st->pitch_available = 1;
999          }   
1000       }
1001       break;
1002       case CELT_SET_PREDICTION_REQUEST:
1003       {
1004          int value = va_arg(ap, celt_int32);
1005          if (value<0 || value>2)
1006             goto bad_arg;
1007          if (value==0)
1008          {
1009             st->force_intra   = 1;
1010             st->pitch_permitted = 0;
1011          } else if (value==1) {
1012             st->force_intra   = 0;
1013             st->pitch_permitted = 0;
1014          } else {
1015             st->force_intra   = 0;
1016             st->pitch_permitted = 1;
1017          }   
1018       }
1019       break;
1020       case CELT_SET_VBR_RATE_REQUEST:
1021       {
1022          celt_int32 value = va_arg(ap, celt_int32);
1023          if (value<0)
1024             goto bad_arg;
1025          if (value>3072000)
1026             value = 3072000;
1027          st->vbr_rate = ((st->mode->Fs<<3)+(st->block_size>>1))/st->block_size;
1028          st->vbr_rate = ((value<<7)+(st->vbr_rate>>1))/st->vbr_rate;
1029       }
1030       break;
1031       case CELT_RESET_STATE:
1032       {
1033          const CELTMode *mode = st->mode;
1034          int C = st->channels;
1035
1036          if (st->pitch_available > 0) st->pitch_available = 1;
1037
1038          CELT_MEMSET(st->in_mem, 0, st->overlap*C);
1039          CELT_MEMSET(st->out_mem, 0, (MAX_PERIOD+st->overlap)*C);
1040
1041          CELT_MEMSET(st->oldBandE, 0, C*mode->nbEBands);
1042
1043          CELT_MEMSET(st->preemph_memE, 0, C);
1044          CELT_MEMSET(st->preemph_memD, 0, C);
1045          st->delayedIntra = 1;
1046       }
1047       break;
1048       default:
1049          goto bad_request;
1050    }
1051    va_end(ap);
1052    return CELT_OK;
1053 bad_mode:
1054   va_end(ap);
1055   return CELT_INVALID_MODE;
1056 bad_arg:
1057    va_end(ap);
1058    return CELT_BAD_ARG;
1059 bad_request:
1060    va_end(ap);
1061    return CELT_UNIMPLEMENTED;
1062 }
1063
1064 /**********************************************************************/
1065 /*                                                                    */
1066 /*                             DECODER                                */
1067 /*                                                                    */
1068 /**********************************************************************/
1069 #ifdef NEW_PLC
1070 #define DECODE_BUFFER_SIZE 2048
1071 #else
1072 #define DECODE_BUFFER_SIZE MAX_PERIOD
1073 #endif
1074
1075 #define DECODERVALID   0x4c434454
1076 #define DECODERPARTIAL 0x5444434c
1077 #define DECODERFREED   0x4c004400
1078
1079 /** Decoder state 
1080  @brief Decoder state
1081  */
1082 struct CELTDecoder {
1083    celt_uint32 marker;
1084    const CELTMode *mode;
1085    int frame_size;
1086    int block_size;
1087    int overlap;
1088    int channels;
1089
1090    ec_byte_buffer buf;
1091    ec_enc         enc;
1092
1093    celt_sig * restrict preemph_memD;
1094
1095    celt_sig *out_mem;
1096    celt_sig *decode_mem;
1097
1098    celt_word16 *oldBandE;
1099    
1100    int last_pitch_index;
1101    int loss_count;
1102 };
1103
1104 int check_decoder(const CELTDecoder *st) 
1105 {
1106    if (st==NULL)
1107    {
1108       celt_warning("NULL passed a decoder structure");  
1109       return CELT_INVALID_STATE;
1110    }
1111    if (st->marker == DECODERVALID)
1112       return CELT_OK;
1113    if (st->marker == DECODERFREED)
1114       celt_warning("Referencing a decoder that has already been freed");
1115    else
1116       celt_warning("This is not a valid CELT decoder structure");
1117    return CELT_INVALID_STATE;
1118 }
1119
1120 CELTDecoder *celt_decoder_create(const CELTMode *mode, int channels, int *error)
1121 {
1122    int N, C;
1123    CELTDecoder *st;
1124
1125    if (check_mode(mode) != CELT_OK)
1126    {
1127       if (error)
1128          *error = CELT_INVALID_MODE;
1129       return NULL;
1130    }
1131 #ifdef DISABLE_STEREO
1132    if (channels > 1)
1133    {
1134       celt_warning("Stereo support was disable from this build");
1135       if (error)
1136          *error = CELT_BAD_ARG;
1137       return NULL;
1138    }
1139 #endif
1140
1141    if (channels < 0 || channels > 2)
1142    {
1143       celt_warning("Only mono and stereo supported");
1144       if (error)
1145          *error = CELT_BAD_ARG;
1146       return NULL;
1147    }
1148
1149    N = mode->mdctSize;
1150    C = CHANNELS(channels);
1151    st = celt_alloc(sizeof(CELTDecoder));
1152
1153    if (st==NULL)
1154    {
1155       if (error)
1156          *error = CELT_ALLOC_FAIL;
1157       return NULL;
1158    }
1159
1160    st->marker = DECODERPARTIAL;
1161    st->mode = mode;
1162    st->frame_size = N;
1163    st->block_size = N;
1164    st->overlap = mode->overlap;
1165    st->channels = channels;
1166
1167    st->decode_mem = celt_alloc((DECODE_BUFFER_SIZE+st->overlap)*C*sizeof(celt_sig));
1168    st->out_mem = st->decode_mem+DECODE_BUFFER_SIZE-MAX_PERIOD;
1169    
1170    st->oldBandE = (celt_word16*)celt_alloc(C*mode->nbEBands*sizeof(celt_word16));
1171    
1172    st->preemph_memD = (celt_sig*)celt_alloc(C*sizeof(celt_sig));
1173
1174    st->loss_count = 0;
1175
1176    if ((st->decode_mem!=NULL) && (st->out_mem!=NULL) && (st->oldBandE!=NULL) &&
1177        (st->preemph_memD!=NULL))
1178    {
1179       if (error)
1180          *error = CELT_OK;
1181       st->marker = DECODERVALID;
1182       return st;
1183    }
1184    /* If the setup fails for some reason deallocate it. */
1185    celt_decoder_destroy(st);
1186    if (error)
1187       *error = CELT_ALLOC_FAIL;
1188    return NULL;
1189 }
1190
1191 void celt_decoder_destroy(CELTDecoder *st)
1192 {
1193    if (st == NULL)
1194    {
1195       celt_warning("NULL passed to celt_decoder_destroy");
1196       return;
1197    }
1198
1199    if (st->marker == DECODERFREED) 
1200    {
1201       celt_warning("Freeing a decoder which has already been freed"); 
1202       return;
1203    }
1204    
1205    if (st->marker != DECODERVALID && st->marker != DECODERPARTIAL)
1206    {
1207       celt_warning("This is not a valid CELT decoder structure");
1208       return;
1209    }
1210    
1211    /*Check_mode is non-fatal here because we can still free
1212      the encoder memory even if the mode is bad, although calling
1213      the free functions in this order is a violation of the API.*/
1214    check_mode(st->mode);
1215    
1216    celt_free(st->decode_mem);
1217    celt_free(st->oldBandE);
1218    celt_free(st->preemph_memD);
1219    
1220    st->marker = DECODERFREED;
1221    
1222    celt_free(st);
1223 }
1224
1225 /** Handles lost packets by just copying past data with the same
1226     offset as the last
1227     pitch period */
1228 #ifdef NEW_PLC
1229 #include "plc.c"
1230 #else
1231 static void celt_decode_lost(CELTDecoder * restrict st, celt_word16 * restrict pcm)
1232 {
1233    int c, N;
1234    int pitch_index;
1235    celt_word16 fade = Q15ONE;
1236    int i, len;
1237    VARDECL(celt_sig, freq);
1238    const int C = CHANNELS(st->channels);
1239    int offset;
1240    SAVE_STACK;
1241    N = st->block_size;
1242    ALLOC(freq,C*N, celt_sig); /**< Interleaved signal MDCTs */
1243    
1244    len = N+st->mode->overlap;
1245    
1246    if (st->loss_count == 0)
1247    {
1248       find_spectral_pitch(st->mode, st->mode->fft, &st->mode->psy, st->out_mem+MAX_PERIOD-len, st->out_mem, st->mode->window, NULL, len, MAX_PERIOD-len-100, &pitch_index, C);
1249       pitch_index = MAX_PERIOD-len-pitch_index;
1250       st->last_pitch_index = pitch_index;
1251    } else {
1252       pitch_index = st->last_pitch_index;
1253       if (st->loss_count < 5)
1254          fade = QCONST16(.8f,15);
1255       else
1256          fade = 0;
1257    }
1258
1259    offset = MAX_PERIOD-pitch_index;
1260    while (offset+len >= MAX_PERIOD)
1261       offset -= pitch_index;
1262    compute_mdcts(st->mode, 0, st->out_mem+offset*C, freq, C);
1263    for (i=0;i<C*N;i++)
1264       freq[i] = ADD32(VERY_SMALL, MULT16_32_Q15(fade,freq[i]));
1265
1266    CELT_MOVE(st->out_mem, st->out_mem+C*N, C*(MAX_PERIOD+st->mode->overlap-N));
1267    /* Compute inverse MDCTs */
1268    compute_inv_mdcts(st->mode, 0, freq, -1, 0, st->out_mem, C);
1269
1270    for (c=0;c<C;c++)
1271    {
1272       int j;
1273       for (j=0;j<N;j++)
1274       {
1275          celt_sig tmp = MAC16_32_Q15(st->out_mem[C*(MAX_PERIOD-N)+C*j+c],
1276                                 preemph,st->preemph_memD[c]);
1277          st->preemph_memD[c] = tmp;
1278          pcm[C*j+c] = SCALEOUT(SIG2WORD16(tmp));
1279       }
1280    }
1281    
1282    st->loss_count++;
1283
1284    RESTORE_STACK;
1285 }
1286 #endif
1287
1288 #ifdef FIXED_POINT
1289 int celt_decode(CELTDecoder * restrict st, const unsigned char *data, int len, celt_int16 * restrict pcm)
1290 {
1291 #else
1292 int celt_decode_float(CELTDecoder * restrict st, const unsigned char *data, int len, celt_sig * restrict pcm)
1293 {
1294 #endif
1295    int i, N, N4;
1296    int has_pitch, has_fold;
1297    int pitch_index;
1298    int bits;
1299    ec_dec dec;
1300    ec_byte_buffer buf;
1301    VARDECL(celt_sig, freq);
1302    VARDECL(celt_sig, pitch_freq);
1303    VARDECL(celt_norm, X);
1304    VARDECL(celt_ener, bandE);
1305    VARDECL(int, fine_quant);
1306    VARDECL(int, pulses);
1307    VARDECL(int, offsets);
1308    VARDECL(int, fine_priority);
1309
1310    int shortBlocks;
1311    int intra_ener;
1312    int transient_time;
1313    int transient_shift;
1314    int mdct_weight_shift=0;
1315    const int C = CHANNELS(st->channels);
1316    int mdct_weight_pos=0;
1317    int gain_id=0;
1318    SAVE_STACK;
1319
1320    if (check_decoder(st) != CELT_OK)
1321       return CELT_INVALID_STATE;
1322
1323    if (check_mode(st->mode) != CELT_OK)
1324       return CELT_INVALID_MODE;
1325
1326    if (pcm==NULL)
1327       return CELT_BAD_ARG;
1328
1329    N = st->block_size;
1330    N4 = (N-st->overlap)>>1;
1331
1332    ALLOC(freq, C*N, celt_sig); /**< Interleaved signal MDCTs */
1333    ALLOC(X, C*N, celt_norm);   /**< Interleaved normalised MDCTs */
1334    ALLOC(bandE, st->mode->nbEBands*C, celt_ener);
1335    
1336    if (data == NULL)
1337    {
1338       celt_decode_lost(st, pcm);
1339       RESTORE_STACK;
1340       return 0;
1341    } else {
1342       st->loss_count = 0;
1343    }
1344    if (len<0) {
1345      RESTORE_STACK;
1346      return CELT_BAD_ARG;
1347    }
1348    
1349    ec_byte_readinit(&buf,(unsigned char*)data,len);
1350    ec_dec_init(&dec,&buf);
1351    
1352    decode_flags(&dec, &intra_ener, &has_pitch, &shortBlocks, &has_fold);
1353    if (shortBlocks)
1354    {
1355       transient_shift = ec_dec_uint(&dec, 4);
1356       if (transient_shift == 3)
1357       {
1358          transient_time = ec_dec_uint(&dec, N+st->mode->overlap);
1359       } else {
1360          mdct_weight_shift = transient_shift;
1361          if (mdct_weight_shift && st->mode->nbShortMdcts>2)
1362             mdct_weight_pos = ec_dec_uint(&dec, st->mode->nbShortMdcts-1);
1363          transient_shift = 0;
1364          transient_time = 0;
1365       }
1366    } else {
1367       transient_time = -1;
1368       transient_shift = 0;
1369    }
1370    
1371    if (has_pitch)
1372    {
1373       pitch_index = ec_dec_uint(&dec, MAX_PERIOD-(2*N-2*N4));
1374       gain_id = ec_dec_uint(&dec, 16);
1375    } else {
1376       pitch_index = 0;
1377    }
1378
1379    ALLOC(fine_quant, st->mode->nbEBands, int);
1380    /* Get band energies */
1381    unquant_coarse_energy(st->mode, bandE, st->oldBandE, len*4-8, intra_ener, st->mode->prob, &dec, C);
1382    
1383    ALLOC(pulses, st->mode->nbEBands, int);
1384    ALLOC(offsets, st->mode->nbEBands, int);
1385    ALLOC(fine_priority, st->mode->nbEBands, int);
1386
1387    for (i=0;i<st->mode->nbEBands;i++)
1388       offsets[i] = 0;
1389
1390    bits = len*8 - ec_dec_tell(&dec, 0) - 1;
1391    compute_allocation(st->mode, offsets, bits, pulses, fine_quant, fine_priority, C);
1392    /*bits = ec_dec_tell(&dec, 0);
1393    compute_fine_allocation(st->mode, fine_quant, (20*C+len*8/5-(ec_dec_tell(&dec, 0)-bits))/C);*/
1394    
1395    unquant_fine_energy(st->mode, bandE, st->oldBandE, fine_quant, &dec, C);
1396
1397    ALLOC(pitch_freq, C*N, celt_sig); /**< Interleaved signal MDCTs */
1398    if (has_pitch) 
1399    {
1400       /* Pitch MDCT */
1401       compute_mdcts(st->mode, 0, st->out_mem+pitch_index*C, pitch_freq, C);
1402    }
1403
1404    /* Decode fixed codebook and merge with pitch */
1405    if (C==1)
1406       quant_bands(st->mode, X, bandE, pulses, shortBlocks, has_fold, len*8, 0, &dec);
1407 #ifndef DISABLE_STEREO
1408    else
1409       unquant_bands_stereo(st->mode, X, bandE, pulses, shortBlocks, has_fold, len*8, &dec);
1410 #endif
1411    unquant_energy_finalise(st->mode, bandE, st->oldBandE, fine_quant, fine_priority, len*8-ec_dec_tell(&dec, 0), &dec, C);
1412    
1413    if (mdct_weight_shift)
1414    {
1415       mdct_shape(st->mode, X, 0, mdct_weight_pos+1, N, st->mode->nbShortMdcts, mdct_weight_shift, C);
1416    }
1417
1418    /* Synthesis */
1419    denormalise_bands(st->mode, X, freq, bandE, C);
1420
1421
1422    CELT_MOVE(st->decode_mem, st->decode_mem+C*N, C*(DECODE_BUFFER_SIZE+st->overlap-N));
1423
1424    if (has_pitch)
1425       apply_pitch(st->mode, freq, pitch_freq, gain_id, 0, C);
1426
1427    /* Compute inverse MDCTs */
1428    compute_inv_mdcts(st->mode, shortBlocks, freq, transient_time, transient_shift, st->out_mem, C);
1429
1430    deemphasis(st->out_mem, pcm, N, C, preemph, st->preemph_memD);
1431
1432    RESTORE_STACK;
1433    return 0;
1434 }
1435
1436 #ifdef FIXED_POINT
1437 #ifndef DISABLE_FLOAT_API
1438 int celt_decode_float(CELTDecoder * restrict st, const unsigned char *data, int len, float * restrict pcm)
1439 {
1440    int j, ret, C, N;
1441    VARDECL(celt_int16, out);
1442    SAVE_STACK;
1443
1444    if (check_decoder(st) != CELT_OK)
1445       return CELT_INVALID_STATE;
1446
1447    if (check_mode(st->mode) != CELT_OK)
1448       return CELT_INVALID_MODE;
1449
1450    if (pcm==NULL)
1451       return CELT_BAD_ARG;
1452
1453    C = CHANNELS(st->channels);
1454    N = st->block_size;
1455    
1456    ALLOC(out, C*N, celt_int16);
1457    ret=celt_decode(st, data, len, out);
1458    for (j=0;j<C*N;j++)
1459       pcm[j]=out[j]*(1/32768.);
1460      
1461    RESTORE_STACK;
1462    return ret;
1463 }
1464 #endif /*DISABLE_FLOAT_API*/
1465 #else
1466 int celt_decode(CELTDecoder * restrict st, const unsigned char *data, int len, celt_int16 * restrict pcm)
1467 {
1468    int j, ret, C, N;
1469    VARDECL(celt_sig, out);
1470    SAVE_STACK;
1471
1472    if (check_decoder(st) != CELT_OK)
1473       return CELT_INVALID_STATE;
1474
1475    if (check_mode(st->mode) != CELT_OK)
1476       return CELT_INVALID_MODE;
1477
1478    if (pcm==NULL)
1479       return CELT_BAD_ARG;
1480
1481    C = CHANNELS(st->channels);
1482    N = st->block_size;
1483    ALLOC(out, C*N, celt_sig);
1484
1485    ret=celt_decode_float(st, data, len, out);
1486
1487    for (j=0;j<C*N;j++)
1488       pcm[j] = FLOAT2INT16 (out[j]);
1489    
1490    RESTORE_STACK;
1491    return ret;
1492 }
1493 #endif
1494
1495 int celt_decoder_ctl(CELTDecoder * restrict st, int request, ...)
1496 {
1497    va_list ap;
1498
1499    if (check_decoder(st) != CELT_OK)
1500       return CELT_INVALID_STATE;
1501
1502    va_start(ap, request);
1503    if ((request!=CELT_GET_MODE_REQUEST) && (check_mode(st->mode) != CELT_OK))
1504      goto bad_mode;
1505    switch (request)
1506    {
1507       case CELT_GET_MODE_REQUEST:
1508       {
1509          const CELTMode ** value = va_arg(ap, const CELTMode**);
1510          if (value==0)
1511             goto bad_arg;
1512          *value=st->mode;
1513       }
1514       break;
1515       case CELT_RESET_STATE:
1516       {
1517          const CELTMode *mode = st->mode;
1518          int C = st->channels;
1519
1520          CELT_MEMSET(st->decode_mem, 0, (DECODE_BUFFER_SIZE+st->overlap)*C);
1521          CELT_MEMSET(st->oldBandE, 0, C*mode->nbEBands);
1522
1523          CELT_MEMSET(st->preemph_memD, 0, C);
1524
1525          st->loss_count = 0;
1526       }
1527       break;
1528       default:
1529          goto bad_request;
1530    }
1531    va_end(ap);
1532    return CELT_OK;
1533 bad_mode:
1534   va_end(ap);
1535   return CELT_INVALID_MODE;
1536 bad_arg:
1537    va_end(ap);
1538    return CELT_BAD_ARG;
1539 bad_request:
1540       va_end(ap);
1541   return CELT_UNIMPLEMENTED;
1542 }
1543
1544 const char *celt_strerror(int error)
1545 {
1546    static const char *error_strings[8] = {
1547       "success",
1548       "invalid argument",
1549       "invalid mode",
1550       "internal error",
1551       "corrupted stream",
1552       "request not implemented",
1553       "invalid state",
1554       "memory allocation failed"
1555    };
1556    if (error > 0 || error < -7)
1557       return "unknown error";
1558    else 
1559       return error_strings[-error];
1560 }
1561