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