Implemented "raw bits"
[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_uint(enc, flag_bits, 4);
463    else if (i<6)
464       ec_enc_uint(enc, flag_bits, 16);
465    else
466       ec_enc_uint(enc, flag_bits, 8);
467 }
468
469 void decode_flags(ec_dec *dec, int *intra_ener, int *has_pitch, int *shortBlocks, int *has_fold)
470 {
471    int i;
472    int flag_bits;
473    flag_bits = ec_dec_uint(dec, 4);
474    /*printf ("(%d) ", flag_bits);*/
475    if (flag_bits==2)
476       flag_bits = (flag_bits<<2) | ec_dec_uint(dec, 4);
477    else if (flag_bits==3)
478       flag_bits = (flag_bits<<1) | ec_dec_uint(dec, 2);
479    for (i=0;i<8;i++)
480       if (flag_bits == (flaglist[i]&0xf))
481          break;
482    celt_assert(i<8);
483    *intra_ener  = (flaglist[i]&FLAG_INTRA) != 0;
484    *has_pitch   = (flaglist[i]&FLAG_PITCH) != 0;
485    *shortBlocks = (flaglist[i]&FLAG_SHORT) != 0;
486    *has_fold    = (flaglist[i]&FLAG_FOLD ) != 0;
487    /*printf ("dec %d: %d %d %d %d\n", flag_bits, *intra_ener, *has_pitch, *shortBlocks, *has_fold);*/
488 }
489
490 #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 || pcm==NULL)
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[8]={1,1,1,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 && (N <= 512) 
681             && (st->pitch_available >= MAX_PERIOD) && (!shortBlocks)
682             && !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    SAVE_STACK;
917
918    if (check_encoder(st) != CELT_OK)
919       return CELT_INVALID_STATE;
920
921    if (check_mode(st->mode) != CELT_OK)
922       return CELT_INVALID_MODE;
923
924    if (pcm==NULL)
925       return CELT_BAD_ARG;
926
927    C = CHANNELS(st->mode);
928    N = st->block_size;
929    ALLOC(in, C*N, celt_int16_t);
930
931    for (j=0;j<C*N;j++)
932      in[j] = FLOAT2INT16(pcm[j]);
933
934    if (optional_synthesis != NULL) {
935      ret=celt_encode(st,in,in,compressed,nbCompressedBytes);
936       for (j=0;j<C*N;j++)
937          optional_synthesis[j]=in[j]*(1/32768.);
938    } else {
939      ret=celt_encode(st,in,NULL,compressed,nbCompressedBytes);
940    }
941    RESTORE_STACK;
942    return ret;
943
944 }
945 #endif /*DISABLE_FLOAT_API*/
946 #else
947 int celt_encode(CELTEncoder * restrict st, const celt_int16_t * pcm, celt_int16_t * optional_synthesis, unsigned char *compressed, int nbCompressedBytes)
948 {
949    int j, ret, C, N;
950    VARDECL(celt_sig_t, in);
951    SAVE_STACK;
952
953    if (check_encoder(st) != CELT_OK)
954       return CELT_INVALID_STATE;
955
956    if (check_mode(st->mode) != CELT_OK)
957       return CELT_INVALID_MODE;
958
959    if (pcm==NULL)
960       return CELT_BAD_ARG;
961
962    C=CHANNELS(st->mode);
963    N=st->block_size;
964    ALLOC(in, C*N, celt_sig_t);
965    for (j=0;j<C*N;j++) {
966      in[j] = SCALEOUT(pcm[j]);
967    }
968
969    if (optional_synthesis != NULL) {
970       ret = celt_encode_float(st,in,in,compressed,nbCompressedBytes);
971       for (j=0;j<C*N;j++)
972          optional_synthesis[j] = FLOAT2INT16(in[j]);
973    } else {
974       ret = celt_encode_float(st,in,NULL,compressed,nbCompressedBytes);
975    }
976    RESTORE_STACK;
977    return ret;
978 }
979 #endif
980
981 int celt_encoder_ctl(CELTEncoder * restrict st, int request, ...)
982 {
983    va_list ap;
984    
985    if (check_encoder(st) != CELT_OK)
986       return CELT_INVALID_STATE;
987
988    va_start(ap, request);
989    if ((request!=CELT_GET_MODE_REQUEST) && (check_mode(st->mode) != CELT_OK))
990      goto bad_mode;
991    switch (request)
992    {
993       case CELT_GET_MODE_REQUEST:
994       {
995          const CELTMode ** value = va_arg(ap, const CELTMode**);
996          if (value==0)
997             goto bad_arg;
998          *value=st->mode;
999       }
1000       break;
1001       case CELT_SET_COMPLEXITY_REQUEST:
1002       {
1003          int value = va_arg(ap, celt_int32_t);
1004          if (value<0 || value>10)
1005             goto bad_arg;
1006          if (value<=2) {
1007             st->pitch_enabled = 0; 
1008             st->pitch_available = 0;
1009          } else {
1010               st->pitch_enabled = 1;
1011               if (st->pitch_available<1)
1012                 st->pitch_available = 1;
1013          }   
1014       }
1015       break;
1016       case CELT_SET_PREDICTION_REQUEST:
1017       {
1018          int value = va_arg(ap, celt_int32_t);
1019          if (value<0 || value>2)
1020             goto bad_arg;
1021          if (value==0)
1022          {
1023             st->force_intra   = 1;
1024             st->pitch_permitted = 0;
1025          } else if (value==1) {
1026             st->force_intra   = 0;
1027             st->pitch_permitted = 0;
1028          } else {
1029             st->force_intra   = 0;
1030             st->pitch_permitted = 1;
1031          }   
1032       }
1033       break;
1034       case CELT_SET_VBR_RATE_REQUEST:
1035       {
1036          int value = va_arg(ap, celt_int32_t);
1037          if (value<0)
1038             goto bad_arg;
1039          if (value>3072000)
1040             value = 3072000;
1041          st->VBR_rate = ((st->mode->Fs<<3)+(st->block_size>>1))/st->block_size;
1042          st->VBR_rate = ((value<<7)+(st->VBR_rate>>1))/st->VBR_rate;
1043       }
1044       break;
1045       case CELT_RESET_STATE:
1046       {
1047          const CELTMode *mode = st->mode;
1048          int C = mode->nbChannels;
1049
1050          if (st->pitch_available > 0) st->pitch_available = 1;
1051
1052          CELT_MEMSET(st->in_mem, 0, st->overlap*C);
1053          CELT_MEMSET(st->out_mem, 0, (MAX_PERIOD+st->overlap)*C);
1054
1055          CELT_MEMSET(st->oldBandE, 0, C*mode->nbEBands);
1056
1057          CELT_MEMSET(st->preemph_memE, 0, C);
1058          CELT_MEMSET(st->preemph_memD, 0, C);
1059          st->delayedIntra = 1;
1060       }
1061       break;
1062       default:
1063          goto bad_request;
1064    }
1065    va_end(ap);
1066    return CELT_OK;
1067 bad_mode:
1068   va_end(ap);
1069   return CELT_INVALID_MODE;
1070 bad_arg:
1071    va_end(ap);
1072    return CELT_BAD_ARG;
1073 bad_request:
1074    va_end(ap);
1075    return CELT_UNIMPLEMENTED;
1076 }
1077
1078 /**********************************************************************/
1079 /*                                                                    */
1080 /*                             DECODER                                */
1081 /*                                                                    */
1082 /**********************************************************************/
1083 #ifdef NEW_PLC
1084 #define DECODE_BUFFER_SIZE 2048
1085 #else
1086 #define DECODE_BUFFER_SIZE MAX_PERIOD
1087 #endif
1088
1089 #define DECODERVALID   0x4c434454
1090 #define DECODERPARTIAL 0x5444434c
1091 #define DECODERFREED   0x4c004400
1092
1093 /** Decoder state 
1094  @brief Decoder state
1095  */
1096 struct CELTDecoder {
1097    celt_uint32_t marker;
1098    const CELTMode *mode;
1099    int frame_size;
1100    int block_size;
1101    int overlap;
1102
1103    ec_byte_buffer buf;
1104    ec_enc         enc;
1105
1106    celt_sig_t * restrict preemph_memD;
1107
1108    celt_sig_t *out_mem;
1109    celt_sig_t *decode_mem;
1110
1111    celt_word16_t *oldBandE;
1112    
1113    int last_pitch_index;
1114 };
1115
1116 int check_decoder(const CELTDecoder *st) 
1117 {
1118    if (st==NULL)
1119    {
1120       celt_warning("NULL passed a decoder structure");  
1121       return CELT_INVALID_STATE;
1122    }
1123    if (st->marker == DECODERVALID)
1124       return CELT_OK;
1125    if (st->marker == DECODERFREED)
1126       celt_warning("Referencing a decoder that has already been freed");
1127    else
1128       celt_warning("This is not a valid CELT decoder structure");
1129    return CELT_INVALID_STATE;
1130 }
1131
1132 CELTDecoder *celt_decoder_create(const CELTMode *mode)
1133 {
1134    int N, C;
1135    CELTDecoder *st;
1136
1137    if (check_mode(mode) != CELT_OK)
1138       return NULL;
1139
1140    N = mode->mdctSize;
1141    C = CHANNELS(mode);
1142    st = celt_alloc(sizeof(CELTDecoder));
1143
1144    if (st==NULL)
1145       return NULL;
1146    
1147    st->marker = DECODERPARTIAL;
1148    st->mode = mode;
1149    st->frame_size = N;
1150    st->block_size = N;
1151    st->overlap = mode->overlap;
1152
1153    st->decode_mem = celt_alloc((DECODE_BUFFER_SIZE+st->overlap)*C*sizeof(celt_sig_t));
1154    st->out_mem = st->decode_mem+DECODE_BUFFER_SIZE-MAX_PERIOD;
1155    
1156    st->oldBandE = (celt_word16_t*)celt_alloc(C*mode->nbEBands*sizeof(celt_word16_t));
1157    
1158    st->preemph_memD = (celt_sig_t*)celt_alloc(C*sizeof(celt_sig_t));
1159
1160    st->last_pitch_index = 0;
1161
1162    if ((st->decode_mem!=NULL) && (st->out_mem!=NULL) && (st->oldBandE!=NULL) &&
1163        (st->preemph_memD!=NULL))
1164    {
1165       st->marker = DECODERVALID;
1166       return st;
1167    }
1168    /* If the setup fails for some reason deallocate it. */
1169    celt_decoder_destroy(st);
1170    return NULL;
1171 }
1172
1173 void celt_decoder_destroy(CELTDecoder *st)
1174 {
1175    if (st == NULL)
1176    {
1177       celt_warning("NULL passed to celt_decoder_destroy");
1178       return;
1179    }
1180
1181    if (st->marker == DECODERFREED) 
1182    {
1183       celt_warning("Freeing a decoder which has already been freed"); 
1184       return;
1185    }
1186    
1187    if (st->marker != DECODERVALID && st->marker != DECODERPARTIAL)
1188    {
1189       celt_warning("This is not a valid CELT decoder structure");
1190       return;
1191    }
1192    
1193    /*Check_mode is non-fatal here because we can still free
1194      the encoder memory even if the mode is bad, although calling
1195      the free functions in this order is a violation of the API.*/
1196    check_mode(st->mode);
1197    
1198    celt_free(st->decode_mem);
1199    celt_free(st->oldBandE);
1200    celt_free(st->preemph_memD);
1201    
1202    st->marker = DECODERFREED;
1203    
1204    celt_free(st);
1205 }
1206
1207 /** Handles lost packets by just copying past data with the same
1208     offset as the last
1209     pitch period */
1210 #ifdef NEW_PLC
1211 #include "plc.c"
1212 #else
1213 static void celt_decode_lost(CELTDecoder * restrict st, celt_word16_t * restrict pcm)
1214 {
1215    int c, N;
1216    int pitch_index;
1217    int i, len;
1218    VARDECL(celt_sig_t, freq);
1219    const int C = CHANNELS(st->mode);
1220    int offset;
1221    SAVE_STACK;
1222    N = st->block_size;
1223    ALLOC(freq,C*N, celt_sig_t); /**< Interleaved signal MDCTs */
1224    
1225    len = N+st->mode->overlap;
1226 #if 0
1227    pitch_index = st->last_pitch_index;
1228    
1229    /* Use the pitch MDCT as the "guessed" signal */
1230    compute_mdcts(st->mode, st->mode->window, st->out_mem+pitch_index*C, freq);
1231
1232 #else
1233    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);
1234    pitch_index = MAX_PERIOD-len-pitch_index;
1235    offset = MAX_PERIOD-pitch_index;
1236    while (offset+len >= MAX_PERIOD)
1237       offset -= pitch_index;
1238    compute_mdcts(st->mode, 0, st->out_mem+offset*C, freq);
1239    for (i=0;i<C*N;i++)
1240       freq[i] = ADD32(EPSILON, MULT16_32_Q15(QCONST16(.9f,15),freq[i]));
1241 #endif
1242    
1243    
1244    
1245    CELT_MOVE(st->out_mem, st->out_mem+C*N, C*(MAX_PERIOD+st->mode->overlap-N));
1246    /* Compute inverse MDCTs */
1247    compute_inv_mdcts(st->mode, 0, freq, -1, 0, st->out_mem);
1248
1249    for (c=0;c<C;c++)
1250    {
1251       int j;
1252       for (j=0;j<N;j++)
1253       {
1254          celt_sig_t tmp = MAC16_32_Q15(st->out_mem[C*(MAX_PERIOD-N)+C*j+c],
1255                                 preemph,st->preemph_memD[c]);
1256          st->preemph_memD[c] = tmp;
1257          pcm[C*j+c] = SCALEOUT(SIG2WORD16(tmp));
1258       }
1259    }
1260    RESTORE_STACK;
1261 }
1262 #endif
1263
1264 #ifdef FIXED_POINT
1265 int celt_decode(CELTDecoder * restrict st, const unsigned char *data, int len, celt_int16_t * restrict pcm)
1266 {
1267 #else
1268 int celt_decode_float(CELTDecoder * restrict st, const unsigned char *data, int len, celt_sig_t * restrict pcm)
1269 {
1270 #endif
1271    int i, c, N, N4;
1272    int has_pitch, has_fold;
1273    int pitch_index;
1274    int bits;
1275    ec_dec dec;
1276    ec_byte_buffer buf;
1277    VARDECL(celt_sig_t, freq);
1278    VARDECL(celt_norm_t, X);
1279    VARDECL(celt_norm_t, P);
1280    VARDECL(celt_ener_t, bandE);
1281    VARDECL(celt_pgain_t, gains);
1282    VARDECL(int, fine_quant);
1283    VARDECL(int, pulses);
1284    VARDECL(int, offsets);
1285    VARDECL(int, fine_priority);
1286
1287    int shortBlocks;
1288    int intra_ener;
1289    int transient_time;
1290    int transient_shift;
1291    int mdct_weight_shift=0;
1292    const int C = CHANNELS(st->mode);
1293    int mdct_weight_pos=0;
1294    SAVE_STACK;
1295
1296    if (check_decoder(st) != CELT_OK)
1297       return CELT_INVALID_STATE;
1298
1299    if (check_mode(st->mode) != CELT_OK)
1300       return CELT_INVALID_MODE;
1301
1302    if (pcm==NULL)
1303       return CELT_BAD_ARG;
1304
1305    N = st->block_size;
1306    N4 = (N-st->overlap)>>1;
1307
1308    ALLOC(freq, C*N, celt_sig_t); /**< Interleaved signal MDCTs */
1309    ALLOC(X, C*N, celt_norm_t);   /**< Interleaved normalised MDCTs */
1310    ALLOC(P, C*N, celt_norm_t);   /**< Interleaved normalised pitch MDCTs*/
1311    ALLOC(bandE, st->mode->nbEBands*C, celt_ener_t);
1312    ALLOC(gains, st->mode->nbPBands, celt_pgain_t);
1313    
1314    if (data == NULL)
1315    {
1316       celt_decode_lost(st, pcm);
1317       RESTORE_STACK;
1318       return 0;
1319    }
1320    if (len<0) {
1321      RESTORE_STACK;
1322      return CELT_BAD_ARG;
1323    }
1324    
1325    ec_byte_readinit(&buf,(unsigned char*)data,len);
1326    ec_dec_init(&dec,&buf);
1327    
1328    decode_flags(&dec, &intra_ener, &has_pitch, &shortBlocks, &has_fold);
1329    if (shortBlocks)
1330    {
1331       transient_shift = ec_dec_bits(&dec, 2);
1332       if (transient_shift == 3)
1333       {
1334          transient_time = ec_dec_uint(&dec, N+st->mode->overlap);
1335       } else {
1336          mdct_weight_shift = transient_shift;
1337          if (mdct_weight_shift && st->mode->nbShortMdcts>2)
1338             mdct_weight_pos = ec_dec_uint(&dec, st->mode->nbShortMdcts-1);
1339          transient_shift = 0;
1340          transient_time = 0;
1341       }
1342    } else {
1343       transient_time = -1;
1344       transient_shift = 0;
1345    }
1346    
1347    if (has_pitch)
1348    {
1349       pitch_index = ec_dec_uint(&dec, MAX_PERIOD-(2*N-2*N4));
1350       st->last_pitch_index = pitch_index;
1351    } else {
1352       pitch_index = 0;
1353       for (i=0;i<st->mode->nbPBands;i++)
1354          gains[i] = 0;
1355    }
1356
1357    ALLOC(fine_quant, st->mode->nbEBands, int);
1358    /* Get band energies */
1359    unquant_coarse_energy(st->mode, bandE, st->oldBandE, len*8/3, intra_ener, st->mode->prob, &dec);
1360    
1361    ALLOC(pulses, st->mode->nbEBands, int);
1362    ALLOC(offsets, st->mode->nbEBands, int);
1363    ALLOC(fine_priority, st->mode->nbEBands, int);
1364
1365    for (i=0;i<st->mode->nbEBands;i++)
1366       offsets[i] = 0;
1367
1368    bits = len*8 - ec_dec_tell(&dec, 0) - 1;
1369    if (has_pitch)
1370       bits -= st->mode->nbPBands;
1371    compute_allocation(st->mode, offsets, bits, pulses, fine_quant, fine_priority);
1372    /*bits = ec_dec_tell(&dec, 0);
1373    compute_fine_allocation(st->mode, fine_quant, (20*C+len*8/5-(ec_dec_tell(&dec, 0)-bits))/C);*/
1374    
1375    unquant_fine_energy(st->mode, bandE, st->oldBandE, fine_quant, &dec);
1376
1377
1378    if (has_pitch) 
1379    {
1380       VARDECL(celt_ener_t, bandEp);
1381       
1382       /* Pitch MDCT */
1383       compute_mdcts(st->mode, 0, st->out_mem+pitch_index*C, freq);
1384       ALLOC(bandEp, st->mode->nbEBands*C, celt_ener_t);
1385       compute_band_energies(st->mode, freq, bandEp);
1386       normalise_bands(st->mode, freq, P, bandEp);
1387       /* Apply pitch gains */
1388    } else {
1389       for (i=0;i<C*N;i++)
1390          P[i] = 0;
1391    }
1392
1393    /* Decode fixed codebook and merge with pitch */
1394    if (C==1)
1395       unquant_bands(st->mode, X, P, has_pitch, gains, bandE, pulses, shortBlocks, has_fold, len*8, &dec);
1396 #ifndef DISABLE_STEREO
1397    else
1398       unquant_bands_stereo(st->mode, X, P, has_pitch, gains, bandE, pulses, shortBlocks, has_fold, len*8, &dec);
1399 #endif
1400    unquant_energy_finalise(st->mode, bandE, st->oldBandE, fine_quant, fine_priority, len*8-ec_dec_tell(&dec, 0), &dec);
1401    
1402    /* Synthesis */
1403    denormalise_bands(st->mode, X, freq, bandE);
1404
1405
1406    CELT_MOVE(st->decode_mem, st->decode_mem+C*N, C*(DECODE_BUFFER_SIZE+st->overlap-N));
1407    if (mdct_weight_shift)
1408    {
1409       int m;
1410       for (c=0;c<C;c++)
1411          for (m=mdct_weight_pos+1;m<st->mode->nbShortMdcts;m++)
1412             for (i=m+c*N;i<(c+1)*N;i+=st->mode->nbShortMdcts)
1413 #ifdef FIXED_POINT
1414                freq[i] = SHL32(freq[i], mdct_weight_shift);
1415 #else
1416                freq[i] = (1<<mdct_weight_shift)*freq[i];
1417 #endif
1418    }
1419    /* Compute inverse MDCTs */
1420    compute_inv_mdcts(st->mode, shortBlocks, freq, transient_time, transient_shift, st->out_mem);
1421
1422    for (c=0;c<C;c++)
1423    {
1424       int j;
1425       for (j=0;j<N;j++)
1426       {
1427          celt_sig_t tmp = MAC16_32_Q15(st->out_mem[C*(MAX_PERIOD-N)+C*j+c],
1428                                 preemph,st->preemph_memD[c]);
1429          st->preemph_memD[c] = tmp;
1430          pcm[C*j+c] = SCALEOUT(SIG2WORD16(tmp));
1431       }
1432    }
1433
1434    RESTORE_STACK;
1435    return 0;
1436 }
1437
1438 #ifdef FIXED_POINT
1439 #ifndef DISABLE_FLOAT_API
1440 int celt_decode_float(CELTDecoder * restrict st, const unsigned char *data, int len, float * restrict pcm)
1441 {
1442    int j, ret, C, N;
1443    VARDECL(celt_int16_t, out);
1444    SAVE_STACK;
1445
1446    if (check_decoder(st) != CELT_OK)
1447       return CELT_INVALID_STATE;
1448
1449    if (check_mode(st->mode) != CELT_OK)
1450       return CELT_INVALID_MODE;
1451
1452    if (pcm==NULL)
1453       return CELT_BAD_ARG;
1454
1455    C = CHANNELS(st->mode);
1456    N = st->block_size;
1457    
1458    ALLOC(out, C*N, celt_int16_t);
1459    ret=celt_decode(st, data, len, out);
1460    for (j=0;j<C*N;j++)
1461       pcm[j]=out[j]*(1/32768.);
1462      
1463    RESTORE_STACK;
1464    return ret;
1465 }
1466 #endif /*DISABLE_FLOAT_API*/
1467 #else
1468 int celt_decode(CELTDecoder * restrict st, const unsigned char *data, int len, celt_int16_t * restrict pcm)
1469 {
1470    int j, ret, C, N;
1471    VARDECL(celt_sig_t, out);
1472    SAVE_STACK;
1473
1474    if (check_decoder(st) != CELT_OK)
1475       return CELT_INVALID_STATE;
1476
1477    if (check_mode(st->mode) != CELT_OK)
1478       return CELT_INVALID_MODE;
1479
1480    if (pcm==NULL)
1481       return CELT_BAD_ARG;
1482
1483    C = CHANNELS(st->mode);
1484    N = st->block_size;
1485    ALLOC(out, C*N, celt_sig_t);
1486
1487    ret=celt_decode_float(st, data, len, out);
1488
1489    for (j=0;j<C*N;j++)
1490       pcm[j] = FLOAT2INT16 (out[j]);
1491    
1492    RESTORE_STACK;
1493    return ret;
1494 }
1495 #endif
1496
1497 int celt_decoder_ctl(CELTDecoder * restrict st, int request, ...)
1498 {
1499    va_list ap;
1500
1501    if (check_decoder(st) != CELT_OK)
1502       return CELT_INVALID_STATE;
1503
1504    va_start(ap, request);
1505    if ((request!=CELT_GET_MODE_REQUEST) && (check_mode(st->mode) != CELT_OK))
1506      goto bad_mode;
1507    switch (request)
1508    {
1509       case CELT_GET_MODE_REQUEST:
1510       {
1511          const CELTMode ** value = va_arg(ap, const CELTMode**);
1512          if (value==0)
1513             goto bad_arg;
1514          *value=st->mode;
1515       }
1516       break;
1517       case CELT_RESET_STATE:
1518       {
1519          const CELTMode *mode = st->mode;
1520          int C = mode->nbChannels;
1521
1522          CELT_MEMSET(st->decode_mem, 0, (DECODE_BUFFER_SIZE+st->overlap)*C);
1523          CELT_MEMSET(st->oldBandE, 0, C*mode->nbEBands);
1524
1525          CELT_MEMSET(st->preemph_memD, 0, C);
1526
1527          st->last_pitch_index = 0;
1528       }
1529       break;
1530       default:
1531          goto bad_request;
1532    }
1533    va_end(ap);
1534    return CELT_OK;
1535 bad_mode:
1536   va_end(ap);
1537   return CELT_INVALID_MODE;
1538 bad_arg:
1539    va_end(ap);
1540    return CELT_BAD_ARG;
1541 bad_request:
1542       va_end(ap);
1543   return CELT_UNIMPLEMENTED;
1544 }