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