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