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