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