Allow coarse energy to take almost all the bits. Also, fixed a some issues with
[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    /* Bit allocation */
768    ALLOC(error, C*st->mode->nbEBands, celt_word16);
769    coarse_needed = quant_coarse_energy(st->mode, bandLogE, st->oldBandE, nbCompressedBytes*8-16, intra_ener, st->mode->prob, error, &enc, C);
770    coarse_needed = ((coarse_needed*3-1)>>3)+1;
771
772    /* Variable bitrate */
773    if (st->vbr_rate>0)
774    {
775      celt_word16 alpha;
776      celt_int32 delta, vbr_bound;
777      /* The target rate in 16th bits per frame */
778      celt_int32 target=st->vbr_rate;
779    
780      /* Shortblocks get a large boost in bitrate, but since they 
781         are uncommon long blocks are not greatly effected */
782      if (shortBlocks)
783        target*=2;
784      else if (st->mode->nbShortMdcts > 1)
785        target-=(target+14)/28;
786
787      /* The average energy is removed from the target and the actual 
788         energy added*/
789      target=target+st->vbr_offset-588+ec_enc_tell(&enc, BITRES);
790
791      /* In VBR mode the frame size must not be reduced so much that it would result in the coarse energy busting its budget */
792      target=IMAX(coarse_needed,(target+64)/128);
793      nbCompressedBytes=IMIN(nbCompressedBytes,target);
794      /* Make the adaptation coef (alpha) higher at the beginning */
795      if (st->vbr_count < 990)
796      {
797         st->vbr_count++;
798         alpha = celt_rcp(SHL32(EXTEND32(st->vbr_count+10),16));
799         /*printf ("%d %d\n", st->vbr_count+10, alpha);*/
800      } else
801         alpha = QCONST16(.001f,15);
802
803      /* By how much did we "miss" the target on that frame */
804      delta = (8<<BITRES)*(celt_int32)nbCompressedBytes - st->vbr_rate;
805      /* How many bits have we used in excess of what we're allowed */
806      st->vbr_reservoir += delta;
807      /*printf ("%d\n", st->vbr_reservoir);*/
808
809      /* Compute the offset we need to apply in order to reach the target */
810      st->vbr_drift += MULT16_32_Q15(alpha,delta-st->vbr_offset-st->vbr_drift);
811      st->vbr_offset = -st->vbr_drift;
812      /*printf ("%d\n", st->vbr_drift);*/
813
814      /* We could use any multiple of vbr_rate as bound (depending on the delay) */
815      vbr_bound = st->vbr_rate;
816      if (st->vbr_reservoir > vbr_bound)
817      {
818         /* Busted the reservoir -- reduce the rate */
819         int adjust = 1+(st->vbr_reservoir-vbr_bound-1)/(8<<BITRES);
820         nbCompressedBytes -= adjust;
821         st->vbr_reservoir -= adjust*(8<<BITRES);
822         /*printf ("-%d\n", adjust);*/
823      } else if (st->vbr_reservoir < 0)
824      {
825         /* We're under the min value -- increase rate */
826         int adjust = 1-(st->vbr_reservoir-1)/(8<<BITRES);
827         st->vbr_reservoir += adjust*(8<<BITRES);
828         nbCompressedBytes += adjust;
829         /*printf ("+%d\n", adjust);*/
830      }
831
832      /* This moves the raw bits to take into account the new compressed size */
833      ec_byte_shrink(&buf, nbCompressedBytes);
834    }
835
836    ALLOC(offsets, st->mode->nbEBands, int);
837    ALLOC(fine_priority, st->mode->nbEBands, int);
838
839    for (i=0;i<st->mode->nbEBands;i++)
840       offsets[i] = 0;
841    bits = nbCompressedBytes*8 - ec_enc_tell(&enc, 0) - 1;
842    compute_allocation(st->mode, offsets, bits, pulses, fine_quant, fine_priority, C);
843
844    quant_fine_energy(st->mode, bandE, st->oldBandE, error, fine_quant, &enc, C);
845
846    /* Residual quantisation */
847    if (C==1)
848       quant_bands(st->mode, X, bandE, pulses, shortBlocks, has_fold, nbCompressedBytes*8, 1, &enc);
849 #ifndef DISABLE_STEREO
850    else
851       quant_bands_stereo(st->mode, X, bandE, pulses, shortBlocks, has_fold, nbCompressedBytes*8, &enc);
852 #endif
853
854    quant_energy_finalise(st->mode, bandE, st->oldBandE, error, fine_quant, fine_priority, nbCompressedBytes*8-ec_enc_tell(&enc, 0), &enc, C);
855
856    /* Re-synthesis of the coded audio if required */
857    if (st->pitch_available>0 || optional_synthesis!=NULL)
858    {
859       if (st->pitch_available>0 && st->pitch_available<MAX_PERIOD)
860         st->pitch_available+=st->frame_size;
861
862       if (mdct_weight_shift)
863       {
864          mdct_shape(st->mode, X, 0, mdct_weight_pos+1, N, st->mode->nbShortMdcts, mdct_weight_shift, C);
865       }
866
867       /* Synthesis */
868       denormalise_bands(st->mode, X, freq, bandE, C);
869
870       CELT_MOVE(st->out_mem, st->out_mem+C*N, C*(MAX_PERIOD+st->overlap-N));
871
872       if (has_pitch)
873          apply_pitch(st->mode, freq, pitch_freq, gain_id, 0, C);
874       
875       compute_inv_mdcts(st->mode, shortBlocks, freq, transient_time, transient_shift, st->out_mem, C);
876
877       /* De-emphasis and put everything back at the right place 
878          in the synthesis history */
879       if (optional_synthesis != NULL) {
880          deemphasis(st->out_mem, optional_synthesis, N, C, preemph, st->preemph_memD);
881
882       }
883    }
884
885    ec_enc_done(&enc);
886    
887    RESTORE_STACK;
888    return nbCompressedBytes;
889 }
890
891 #ifdef FIXED_POINT
892 #ifndef DISABLE_FLOAT_API
893 int celt_encode_float(CELTEncoder * restrict st, const float * pcm, float * optional_synthesis, unsigned char *compressed, int nbCompressedBytes)
894 {
895    int j, ret, C, N;
896    VARDECL(celt_int16, in);
897    SAVE_STACK;
898
899    if (check_encoder(st) != CELT_OK)
900       return CELT_INVALID_STATE;
901
902    if (check_mode(st->mode) != CELT_OK)
903       return CELT_INVALID_MODE;
904
905    if (pcm==NULL)
906       return CELT_BAD_ARG;
907
908    C = CHANNELS(st->channels);
909    N = st->block_size;
910    ALLOC(in, C*N, celt_int16);
911
912    for (j=0;j<C*N;j++)
913      in[j] = FLOAT2INT16(pcm[j]);
914
915    if (optional_synthesis != NULL) {
916      ret=celt_encode(st,in,in,compressed,nbCompressedBytes);
917       for (j=0;j<C*N;j++)
918          optional_synthesis[j]=in[j]*(1/32768.);
919    } else {
920      ret=celt_encode(st,in,NULL,compressed,nbCompressedBytes);
921    }
922    RESTORE_STACK;
923    return ret;
924
925 }
926 #endif /*DISABLE_FLOAT_API*/
927 #else
928 int celt_encode(CELTEncoder * restrict st, const celt_int16 * pcm, celt_int16 * optional_synthesis, unsigned char *compressed, int nbCompressedBytes)
929 {
930    int j, ret, C, N;
931    VARDECL(celt_sig, in);
932    SAVE_STACK;
933
934    if (check_encoder(st) != CELT_OK)
935       return CELT_INVALID_STATE;
936
937    if (check_mode(st->mode) != CELT_OK)
938       return CELT_INVALID_MODE;
939
940    if (pcm==NULL)
941       return CELT_BAD_ARG;
942
943    C=CHANNELS(st->channels);
944    N=st->block_size;
945    ALLOC(in, C*N, celt_sig);
946    for (j=0;j<C*N;j++) {
947      in[j] = SCALEOUT(pcm[j]);
948    }
949
950    if (optional_synthesis != NULL) {
951       ret = celt_encode_float(st,in,in,compressed,nbCompressedBytes);
952       for (j=0;j<C*N;j++)
953          optional_synthesis[j] = FLOAT2INT16(in[j]);
954    } else {
955       ret = celt_encode_float(st,in,NULL,compressed,nbCompressedBytes);
956    }
957    RESTORE_STACK;
958    return ret;
959 }
960 #endif
961
962 int celt_encoder_ctl(CELTEncoder * restrict st, int request, ...)
963 {
964    va_list ap;
965    
966    if (check_encoder(st) != CELT_OK)
967       return CELT_INVALID_STATE;
968
969    va_start(ap, request);
970    if ((request!=CELT_GET_MODE_REQUEST) && (check_mode(st->mode) != CELT_OK))
971      goto bad_mode;
972    switch (request)
973    {
974       case CELT_GET_MODE_REQUEST:
975       {
976          const CELTMode ** value = va_arg(ap, const CELTMode**);
977          if (value==0)
978             goto bad_arg;
979          *value=st->mode;
980       }
981       break;
982       case CELT_SET_COMPLEXITY_REQUEST:
983       {
984          int value = va_arg(ap, celt_int32);
985          if (value<0 || value>10)
986             goto bad_arg;
987          if (value<=2) {
988             st->pitch_enabled = 0; 
989             st->pitch_available = 0;
990          } else {
991               st->pitch_enabled = 1;
992               if (st->pitch_available<1)
993                 st->pitch_available = 1;
994          }   
995       }
996       break;
997       case CELT_SET_PREDICTION_REQUEST:
998       {
999          int value = va_arg(ap, celt_int32);
1000          if (value<0 || value>2)
1001             goto bad_arg;
1002          if (value==0)
1003          {
1004             st->force_intra   = 1;
1005             st->pitch_permitted = 0;
1006          } else if (value==1) {
1007             st->force_intra   = 0;
1008             st->pitch_permitted = 0;
1009          } else {
1010             st->force_intra   = 0;
1011             st->pitch_permitted = 1;
1012          }   
1013       }
1014       break;
1015       case CELT_SET_VBR_RATE_REQUEST:
1016       {
1017          celt_int32 value = va_arg(ap, celt_int32);
1018          if (value<0)
1019             goto bad_arg;
1020          if (value>3072000)
1021             value = 3072000;
1022          st->vbr_rate = ((st->mode->Fs<<3)+(st->block_size>>1))/st->block_size;
1023          st->vbr_rate = ((value<<7)+(st->vbr_rate>>1))/st->vbr_rate;
1024       }
1025       break;
1026       case CELT_RESET_STATE:
1027       {
1028          const CELTMode *mode = st->mode;
1029          int C = st->channels;
1030
1031          if (st->pitch_available > 0) st->pitch_available = 1;
1032
1033          CELT_MEMSET(st->in_mem, 0, st->overlap*C);
1034          CELT_MEMSET(st->out_mem, 0, (MAX_PERIOD+st->overlap)*C);
1035
1036          CELT_MEMSET(st->oldBandE, 0, C*mode->nbEBands);
1037
1038          CELT_MEMSET(st->preemph_memE, 0, C);
1039          CELT_MEMSET(st->preemph_memD, 0, C);
1040          st->delayedIntra = 1;
1041       }
1042       break;
1043       default:
1044          goto bad_request;
1045    }
1046    va_end(ap);
1047    return CELT_OK;
1048 bad_mode:
1049   va_end(ap);
1050   return CELT_INVALID_MODE;
1051 bad_arg:
1052    va_end(ap);
1053    return CELT_BAD_ARG;
1054 bad_request:
1055    va_end(ap);
1056    return CELT_UNIMPLEMENTED;
1057 }
1058
1059 /**********************************************************************/
1060 /*                                                                    */
1061 /*                             DECODER                                */
1062 /*                                                                    */
1063 /**********************************************************************/
1064 #ifdef NEW_PLC
1065 #define DECODE_BUFFER_SIZE 2048
1066 #else
1067 #define DECODE_BUFFER_SIZE MAX_PERIOD
1068 #endif
1069
1070 #define DECODERVALID   0x4c434454
1071 #define DECODERPARTIAL 0x5444434c
1072 #define DECODERFREED   0x4c004400
1073
1074 /** Decoder state 
1075  @brief Decoder state
1076  */
1077 struct CELTDecoder {
1078    celt_uint32 marker;
1079    const CELTMode *mode;
1080    int frame_size;
1081    int block_size;
1082    int overlap;
1083    int channels;
1084
1085    ec_byte_buffer buf;
1086    ec_enc         enc;
1087
1088    celt_sig * restrict preemph_memD;
1089
1090    celt_sig *out_mem;
1091    celt_sig *decode_mem;
1092
1093    celt_word16 *oldBandE;
1094    
1095    int last_pitch_index;
1096    int loss_count;
1097 };
1098
1099 int check_decoder(const CELTDecoder *st) 
1100 {
1101    if (st==NULL)
1102    {
1103       celt_warning("NULL passed a decoder structure");  
1104       return CELT_INVALID_STATE;
1105    }
1106    if (st->marker == DECODERVALID)
1107       return CELT_OK;
1108    if (st->marker == DECODERFREED)
1109       celt_warning("Referencing a decoder that has already been freed");
1110    else
1111       celt_warning("This is not a valid CELT decoder structure");
1112    return CELT_INVALID_STATE;
1113 }
1114
1115 CELTDecoder *celt_decoder_create(const CELTMode *mode, int channels, int *error)
1116 {
1117    int N, C;
1118    CELTDecoder *st;
1119
1120    if (check_mode(mode) != CELT_OK)
1121    {
1122       if (error)
1123          *error = CELT_INVALID_MODE;
1124       return NULL;
1125    }
1126 #ifdef DISABLE_STEREO
1127    if (channels > 1)
1128    {
1129       celt_warning("Stereo support was disable from this build");
1130       if (error)
1131          *error = CELT_BAD_ARG;
1132       return NULL;
1133    }
1134 #endif
1135
1136    if (channels < 0 || channels > 2)
1137    {
1138       celt_warning("Only mono and stereo supported");
1139       if (error)
1140          *error = CELT_BAD_ARG;
1141       return NULL;
1142    }
1143
1144    N = mode->mdctSize;
1145    C = CHANNELS(channels);
1146    st = celt_alloc(sizeof(CELTDecoder));
1147
1148    if (st==NULL)
1149    {
1150       if (error)
1151          *error = CELT_ALLOC_FAIL;
1152       return NULL;
1153    }
1154
1155    st->marker = DECODERPARTIAL;
1156    st->mode = mode;
1157    st->frame_size = N;
1158    st->block_size = N;
1159    st->overlap = mode->overlap;
1160    st->channels = channels;
1161
1162    st->decode_mem = celt_alloc((DECODE_BUFFER_SIZE+st->overlap)*C*sizeof(celt_sig));
1163    st->out_mem = st->decode_mem+DECODE_BUFFER_SIZE-MAX_PERIOD;
1164    
1165    st->oldBandE = (celt_word16*)celt_alloc(C*mode->nbEBands*sizeof(celt_word16));
1166    
1167    st->preemph_memD = (celt_sig*)celt_alloc(C*sizeof(celt_sig));
1168
1169    st->loss_count = 0;
1170
1171    if ((st->decode_mem!=NULL) && (st->out_mem!=NULL) && (st->oldBandE!=NULL) &&
1172        (st->preemph_memD!=NULL))
1173    {
1174       if (error)
1175          *error = CELT_OK;
1176       st->marker = DECODERVALID;
1177       return st;
1178    }
1179    /* If the setup fails for some reason deallocate it. */
1180    celt_decoder_destroy(st);
1181    if (error)
1182       *error = CELT_ALLOC_FAIL;
1183    return NULL;
1184 }
1185
1186 void celt_decoder_destroy(CELTDecoder *st)
1187 {
1188    if (st == NULL)
1189    {
1190       celt_warning("NULL passed to celt_decoder_destroy");
1191       return;
1192    }
1193
1194    if (st->marker == DECODERFREED) 
1195    {
1196       celt_warning("Freeing a decoder which has already been freed"); 
1197       return;
1198    }
1199    
1200    if (st->marker != DECODERVALID && st->marker != DECODERPARTIAL)
1201    {
1202       celt_warning("This is not a valid CELT decoder structure");
1203       return;
1204    }
1205    
1206    /*Check_mode is non-fatal here because we can still free
1207      the encoder memory even if the mode is bad, although calling
1208      the free functions in this order is a violation of the API.*/
1209    check_mode(st->mode);
1210    
1211    celt_free(st->decode_mem);
1212    celt_free(st->oldBandE);
1213    celt_free(st->preemph_memD);
1214    
1215    st->marker = DECODERFREED;
1216    
1217    celt_free(st);
1218 }
1219
1220 /** Handles lost packets by just copying past data with the same
1221     offset as the last
1222     pitch period */
1223 #ifdef NEW_PLC
1224 #include "plc.c"
1225 #else
1226 static void celt_decode_lost(CELTDecoder * restrict st, celt_word16 * restrict pcm)
1227 {
1228    int c, N;
1229    int pitch_index;
1230    celt_word16 fade = Q15ONE;
1231    int i, len;
1232    VARDECL(celt_sig, freq);
1233    const int C = CHANNELS(st->channels);
1234    int offset;
1235    SAVE_STACK;
1236    N = st->block_size;
1237    ALLOC(freq,C*N, celt_sig); /**< Interleaved signal MDCTs */
1238    
1239    len = N+st->mode->overlap;
1240    
1241    if (st->loss_count == 0)
1242    {
1243       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);
1244       pitch_index = MAX_PERIOD-len-pitch_index;
1245       st->last_pitch_index = pitch_index;
1246    } else {
1247       pitch_index = st->last_pitch_index;
1248       if (st->loss_count < 5)
1249          fade = QCONST16(.8f,15);
1250       else
1251          fade = 0;
1252    }
1253
1254    offset = MAX_PERIOD-pitch_index;
1255    while (offset+len >= MAX_PERIOD)
1256       offset -= pitch_index;
1257    compute_mdcts(st->mode, 0, st->out_mem+offset*C, freq, C);
1258    for (i=0;i<C*N;i++)
1259       freq[i] = ADD32(VERY_SMALL, MULT16_32_Q15(fade,freq[i]));
1260
1261    CELT_MOVE(st->out_mem, st->out_mem+C*N, C*(MAX_PERIOD+st->mode->overlap-N));
1262    /* Compute inverse MDCTs */
1263    compute_inv_mdcts(st->mode, 0, freq, -1, 0, st->out_mem, C);
1264
1265    for (c=0;c<C;c++)
1266    {
1267       int j;
1268       for (j=0;j<N;j++)
1269       {
1270          celt_sig tmp = MAC16_32_Q15(st->out_mem[C*(MAX_PERIOD-N)+C*j+c],
1271                                 preemph,st->preemph_memD[c]);
1272          st->preemph_memD[c] = tmp;
1273          pcm[C*j+c] = SCALEOUT(SIG2WORD16(tmp));
1274       }
1275    }
1276    
1277    st->loss_count++;
1278
1279    RESTORE_STACK;
1280 }
1281 #endif
1282
1283 #ifdef FIXED_POINT
1284 int celt_decode(CELTDecoder * restrict st, const unsigned char *data, int len, celt_int16 * restrict pcm)
1285 {
1286 #else
1287 int celt_decode_float(CELTDecoder * restrict st, const unsigned char *data, int len, celt_sig * restrict pcm)
1288 {
1289 #endif
1290    int i, N, N4;
1291    int has_pitch, has_fold;
1292    int pitch_index;
1293    int bits;
1294    ec_dec dec;
1295    ec_byte_buffer buf;
1296    VARDECL(celt_sig, freq);
1297    VARDECL(celt_sig, pitch_freq);
1298    VARDECL(celt_norm, X);
1299    VARDECL(celt_ener, bandE);
1300    VARDECL(int, fine_quant);
1301    VARDECL(int, pulses);
1302    VARDECL(int, offsets);
1303    VARDECL(int, fine_priority);
1304
1305    int shortBlocks;
1306    int intra_ener;
1307    int transient_time;
1308    int transient_shift;
1309    int mdct_weight_shift=0;
1310    const int C = CHANNELS(st->channels);
1311    int mdct_weight_pos=0;
1312    int gain_id=0;
1313    SAVE_STACK;
1314
1315    if (check_decoder(st) != CELT_OK)
1316       return CELT_INVALID_STATE;
1317
1318    if (check_mode(st->mode) != CELT_OK)
1319       return CELT_INVALID_MODE;
1320
1321    if (pcm==NULL)
1322       return CELT_BAD_ARG;
1323
1324    N = st->block_size;
1325    N4 = (N-st->overlap)>>1;
1326
1327    ALLOC(freq, C*N, celt_sig); /**< Interleaved signal MDCTs */
1328    ALLOC(X, C*N, celt_norm);   /**< Interleaved normalised MDCTs */
1329    ALLOC(bandE, st->mode->nbEBands*C, celt_ener);
1330    
1331    if (data == NULL)
1332    {
1333       celt_decode_lost(st, pcm);
1334       RESTORE_STACK;
1335       return 0;
1336    } else {
1337       st->loss_count = 0;
1338    }
1339    if (len<0) {
1340      RESTORE_STACK;
1341      return CELT_BAD_ARG;
1342    }
1343    
1344    ec_byte_readinit(&buf,(unsigned char*)data,len);
1345    ec_dec_init(&dec,&buf);
1346    
1347    decode_flags(&dec, &intra_ener, &has_pitch, &shortBlocks, &has_fold);
1348    if (shortBlocks)
1349    {
1350       transient_shift = ec_dec_uint(&dec, 4);
1351       if (transient_shift == 3)
1352       {
1353          transient_time = ec_dec_uint(&dec, N+st->mode->overlap);
1354       } else {
1355          mdct_weight_shift = transient_shift;
1356          if (mdct_weight_shift && st->mode->nbShortMdcts>2)
1357             mdct_weight_pos = ec_dec_uint(&dec, st->mode->nbShortMdcts-1);
1358          transient_shift = 0;
1359          transient_time = 0;
1360       }
1361    } else {
1362       transient_time = -1;
1363       transient_shift = 0;
1364    }
1365    
1366    if (has_pitch)
1367    {
1368       pitch_index = ec_dec_uint(&dec, MAX_PERIOD-(2*N-2*N4));
1369       gain_id = ec_dec_uint(&dec, 16);
1370    } else {
1371       pitch_index = 0;
1372    }
1373
1374    ALLOC(fine_quant, st->mode->nbEBands, int);
1375    /* Get band energies */
1376    unquant_coarse_energy(st->mode, bandE, st->oldBandE, len*8-16, intra_ener, st->mode->prob, &dec, C);
1377    
1378    ALLOC(pulses, st->mode->nbEBands, int);
1379    ALLOC(offsets, st->mode->nbEBands, int);
1380    ALLOC(fine_priority, st->mode->nbEBands, int);
1381
1382    for (i=0;i<st->mode->nbEBands;i++)
1383       offsets[i] = 0;
1384
1385    bits = len*8 - ec_dec_tell(&dec, 0) - 1;
1386    compute_allocation(st->mode, offsets, bits, pulses, fine_quant, fine_priority, C);
1387    /*bits = ec_dec_tell(&dec, 0);
1388    compute_fine_allocation(st->mode, fine_quant, (20*C+len*8/5-(ec_dec_tell(&dec, 0)-bits))/C);*/
1389    
1390    unquant_fine_energy(st->mode, bandE, st->oldBandE, fine_quant, &dec, C);
1391
1392    ALLOC(pitch_freq, C*N, celt_sig); /**< Interleaved signal MDCTs */
1393    if (has_pitch) 
1394    {
1395       /* Pitch MDCT */
1396       compute_mdcts(st->mode, 0, st->out_mem+pitch_index*C, pitch_freq, C);
1397    }
1398
1399    /* Decode fixed codebook and merge with pitch */
1400    if (C==1)
1401       quant_bands(st->mode, X, bandE, pulses, shortBlocks, has_fold, len*8, 0, &dec);
1402 #ifndef DISABLE_STEREO
1403    else
1404       unquant_bands_stereo(st->mode, X, bandE, pulses, shortBlocks, has_fold, len*8, &dec);
1405 #endif
1406    unquant_energy_finalise(st->mode, bandE, st->oldBandE, fine_quant, fine_priority, len*8-ec_dec_tell(&dec, 0), &dec, C);
1407    
1408    if (mdct_weight_shift)
1409    {
1410       mdct_shape(st->mode, X, 0, mdct_weight_pos+1, N, st->mode->nbShortMdcts, mdct_weight_shift, C);
1411    }
1412
1413    /* Synthesis */
1414    denormalise_bands(st->mode, X, freq, bandE, C);
1415
1416
1417    CELT_MOVE(st->decode_mem, st->decode_mem+C*N, C*(DECODE_BUFFER_SIZE+st->overlap-N));
1418
1419    if (has_pitch)
1420       apply_pitch(st->mode, freq, pitch_freq, gain_id, 0, C);
1421
1422    /* Compute inverse MDCTs */
1423    compute_inv_mdcts(st->mode, shortBlocks, freq, transient_time, transient_shift, st->out_mem, C);
1424
1425    deemphasis(st->out_mem, pcm, N, C, preemph, st->preemph_memD);
1426
1427    RESTORE_STACK;
1428    return 0;
1429 }
1430
1431 #ifdef FIXED_POINT
1432 #ifndef DISABLE_FLOAT_API
1433 int celt_decode_float(CELTDecoder * restrict st, const unsigned char *data, int len, float * restrict pcm)
1434 {
1435    int j, ret, C, N;
1436    VARDECL(celt_int16, out);
1437    SAVE_STACK;
1438
1439    if (check_decoder(st) != CELT_OK)
1440       return CELT_INVALID_STATE;
1441
1442    if (check_mode(st->mode) != CELT_OK)
1443       return CELT_INVALID_MODE;
1444
1445    if (pcm==NULL)
1446       return CELT_BAD_ARG;
1447
1448    C = CHANNELS(st->channels);
1449    N = st->block_size;
1450    
1451    ALLOC(out, C*N, celt_int16);
1452    ret=celt_decode(st, data, len, out);
1453    for (j=0;j<C*N;j++)
1454       pcm[j]=out[j]*(1/32768.);
1455      
1456    RESTORE_STACK;
1457    return ret;
1458 }
1459 #endif /*DISABLE_FLOAT_API*/
1460 #else
1461 int celt_decode(CELTDecoder * restrict st, const unsigned char *data, int len, celt_int16 * restrict pcm)
1462 {
1463    int j, ret, C, N;
1464    VARDECL(celt_sig, out);
1465    SAVE_STACK;
1466
1467    if (check_decoder(st) != CELT_OK)
1468       return CELT_INVALID_STATE;
1469
1470    if (check_mode(st->mode) != CELT_OK)
1471       return CELT_INVALID_MODE;
1472
1473    if (pcm==NULL)
1474       return CELT_BAD_ARG;
1475
1476    C = CHANNELS(st->channels);
1477    N = st->block_size;
1478    ALLOC(out, C*N, celt_sig);
1479
1480    ret=celt_decode_float(st, data, len, out);
1481
1482    for (j=0;j<C*N;j++)
1483       pcm[j] = FLOAT2INT16 (out[j]);
1484    
1485    RESTORE_STACK;
1486    return ret;
1487 }
1488 #endif
1489
1490 int celt_decoder_ctl(CELTDecoder * restrict st, int request, ...)
1491 {
1492    va_list ap;
1493
1494    if (check_decoder(st) != CELT_OK)
1495       return CELT_INVALID_STATE;
1496
1497    va_start(ap, request);
1498    if ((request!=CELT_GET_MODE_REQUEST) && (check_mode(st->mode) != CELT_OK))
1499      goto bad_mode;
1500    switch (request)
1501    {
1502       case CELT_GET_MODE_REQUEST:
1503       {
1504          const CELTMode ** value = va_arg(ap, const CELTMode**);
1505          if (value==0)
1506             goto bad_arg;
1507          *value=st->mode;
1508       }
1509       break;
1510       case CELT_RESET_STATE:
1511       {
1512          const CELTMode *mode = st->mode;
1513          int C = st->channels;
1514
1515          CELT_MEMSET(st->decode_mem, 0, (DECODE_BUFFER_SIZE+st->overlap)*C);
1516          CELT_MEMSET(st->oldBandE, 0, C*mode->nbEBands);
1517
1518          CELT_MEMSET(st->preemph_memD, 0, C);
1519
1520          st->loss_count = 0;
1521       }
1522       break;
1523       default:
1524          goto bad_request;
1525    }
1526    va_end(ap);
1527    return CELT_OK;
1528 bad_mode:
1529   va_end(ap);
1530   return CELT_INVALID_MODE;
1531 bad_arg:
1532    va_end(ap);
1533    return CELT_BAD_ARG;
1534 bad_request:
1535       va_end(ap);
1536   return CELT_UNIMPLEMENTED;
1537 }
1538
1539 const char *celt_strerror(int error)
1540 {
1541    static const char *error_strings[8] = {
1542       "success",
1543       "invalid argument",
1544       "invalid mode",
1545       "internal error",
1546       "corrupted stream",
1547       "request not implemented",
1548       "invalid state",
1549       "memory allocation failed"
1550    };
1551    if (error > 0 || error < -7)
1552       return "unknown error";
1553    else 
1554       return error_strings[-error];
1555 }
1556