Forced intra now overrides intra avoidance at low rate. Also, using the number
[opus.git] / libcelt / celt.c
1 /* (C) 2007-2008 Jean-Marc Valin, CSIRO
2    (C) 2008 Gregory Maxwell */
3 /*
4    Redistribution and use in source and binary forms, with or without
5    modification, are permitted provided that the following conditions
6    are met:
7    
8    - Redistributions of source code must retain the above copyright
9    notice, this list of conditions and the following disclaimer.
10    
11    - Redistributions in binary form must reproduce the above copyright
12    notice, this list of conditions and the following disclaimer in the
13    documentation and/or other materials provided with the distribution.
14    
15    - Neither the name of the Xiph.org Foundation nor the names of its
16    contributors may be used to endorse or promote products derived from
17    this software without specific prior written permission.
18    
19    THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
20    ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
21    LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
22    A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR
23    CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
24    EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
25    PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
26    PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
27    LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
28    NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
29    SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
30 */
31
32 #ifdef HAVE_CONFIG_H
33 #include "config.h"
34 #endif
35
36 #define CELT_C
37
38 #include "os_support.h"
39 #include "mdct.h"
40 #include <math.h>
41 #include "celt.h"
42 #include "pitch.h"
43 #include "kiss_fftr.h"
44 #include "bands.h"
45 #include "modes.h"
46 #include "entcode.h"
47 #include "quant_bands.h"
48 #include "psy.h"
49 #include "rate.h"
50 #include "stack_alloc.h"
51 #include "mathops.h"
52 #include "float_cast.h"
53 #include <stdarg.h>
54
55 static const celt_word16_t preemph = QCONST16(0.8f,15);
56
57 #ifdef FIXED_POINT
58 static const celt_word16_t transientWindow[16] = {
59      279,  1106,  2454,  4276,  6510,  9081, 11900, 14872,
60    17896, 20868, 23687, 26258, 28492, 30314, 31662, 32489};
61 #else
62 static const float transientWindow[16] = {
63    0.0085135, 0.0337639, 0.0748914, 0.1304955, 
64    0.1986827, 0.2771308, 0.3631685, 0.4538658,
65    0.5461342, 0.6368315, 0.7228692, 0.8013173, 
66    0.8695045, 0.9251086, 0.9662361, 0.9914865};
67 #endif
68
69 #define ENCODERVALID   0x4c434554
70 #define ENCODERPARTIAL 0x5445434c
71 #define ENCODERFREED   0x4c004500
72    
73 /** Encoder state 
74  @brief Encoder state
75  */
76 struct CELTEncoder {
77    celt_uint32_t marker;
78    const CELTMode *mode;     /**< Mode used by the encoder */
79    int frame_size;
80    int block_size;
81    int overlap;
82    int channels;
83    
84    int pitch_enabled;       /* Complexity level is allowed to use pitch */
85    int pitch_permitted;     /*  Use of the LTP is permitted by the user */
86    int pitch_available;     /*  Amount of pitch buffer available */
87    int force_intra;
88    int delayedIntra;
89    celt_word16_t tonal_average;
90    int fold_decision;
91
92    int VBR_rate; /* Target number of 16th bits per frame */
93    celt_word16_t * restrict preemph_memE; 
94    celt_sig_t    * restrict preemph_memD;
95
96    celt_sig_t *in_mem;
97    celt_sig_t *out_mem;
98
99    celt_word16_t *oldBandE;
100 #ifdef EXP_PSY
101    celt_word16_t *psy_mem;
102    struct PsyDecay psy;
103 #endif
104 };
105
106 int check_encoder(const CELTEncoder *st) 
107 {
108    if (st==NULL)
109    {
110       celt_warning("NULL passed as an encoder structure");  
111       return CELT_INVALID_STATE;
112    }
113    if (st->marker == ENCODERVALID)
114       return CELT_OK;
115    if (st->marker == ENCODERFREED)
116       celt_warning("Referencing an encoder that has already been freed");
117    else
118       celt_warning("This is not a valid CELT encoder structure");
119    return CELT_INVALID_STATE;
120 }
121
122 CELTEncoder *celt_encoder_create(const CELTMode *mode)
123 {
124    int N, C;
125    CELTEncoder *st;
126
127    if (check_mode(mode) != CELT_OK)
128       return NULL;
129
130    N = mode->mdctSize;
131    C = mode->nbChannels;
132    st = celt_alloc(sizeof(CELTEncoder));
133    
134    if (st==NULL) 
135       return NULL;   
136    st->marker = ENCODERPARTIAL;
137    st->mode = mode;
138    st->frame_size = N;
139    st->block_size = N;
140    st->overlap = mode->overlap;
141
142    st->VBR_rate = 0;
143    st->pitch_enabled = 1;
144    st->pitch_permitted = 1;
145    st->pitch_available = 1;
146    st->force_intra  = 0;
147    st->delayedIntra = 1;
148    st->tonal_average = QCONST16(1.,8);
149    st->fold_decision = 1;
150
151    st->in_mem = celt_alloc(st->overlap*C*sizeof(celt_sig_t));
152    st->out_mem = celt_alloc((MAX_PERIOD+st->overlap)*C*sizeof(celt_sig_t));
153
154    st->oldBandE = (celt_word16_t*)celt_alloc(C*mode->nbEBands*sizeof(celt_word16_t));
155
156    st->preemph_memE = (celt_word16_t*)celt_alloc(C*sizeof(celt_word16_t));
157    st->preemph_memD = (celt_sig_t*)celt_alloc(C*sizeof(celt_sig_t));
158
159 #ifdef EXP_PSY
160    st->psy_mem = celt_alloc(MAX_PERIOD*sizeof(celt_word16_t));
161    psydecay_init(&st->psy, MAX_PERIOD/2, st->mode->Fs);
162 #endif
163
164    if ((st->in_mem!=NULL) && (st->out_mem!=NULL) && (st->oldBandE!=NULL) 
165 #ifdef EXP_PSY
166        && (st->psy_mem!=NULL) 
167 #endif   
168        && (st->preemph_memE!=NULL) && (st->preemph_memD!=NULL))
169    {
170       st->marker   = ENCODERVALID;
171       return st;
172    }
173    /* If the setup fails for some reason deallocate it. */
174    celt_encoder_destroy(st);  
175    return NULL;
176 }
177
178 void celt_encoder_destroy(CELTEncoder *st)
179 {
180    if (st == NULL)
181    {
182       celt_warning("NULL passed to celt_encoder_destroy");
183       return;
184    }
185
186    if (st->marker == ENCODERFREED)
187    {
188       celt_warning("Freeing an encoder which has already been freed"); 
189       return;
190    }
191
192    if (st->marker != ENCODERVALID && st->marker != ENCODERPARTIAL)
193    {
194       celt_warning("This is not a valid CELT encoder structure");
195       return;
196    }
197    /*Check_mode is non-fatal here because we can still free
198     the encoder memory even if the mode is bad, although calling
199     the free functions in this order is a violation of the API.*/
200    check_mode(st->mode);
201    
202    celt_free(st->in_mem);
203    celt_free(st->out_mem);
204    
205    celt_free(st->oldBandE);
206    
207    celt_free(st->preemph_memE);
208    celt_free(st->preemph_memD);
209    
210 #ifdef EXP_PSY
211    celt_free (st->psy_mem);
212    psydecay_clear(&st->psy);
213 #endif
214    st->marker = ENCODERFREED;
215    
216    celt_free(st);
217 }
218
219 static inline celt_int16_t FLOAT2INT16(float x)
220 {
221    x = x*CELT_SIG_SCALE;
222    x = MAX32(x, -32768);
223    x = MIN32(x, 32767);
224    return (celt_int16_t)float2int(x);
225 }
226
227 static inline celt_word16_t SIG2WORD16(celt_sig_t x)
228 {
229 #ifdef FIXED_POINT
230    x = PSHR32(x, SIG_SHIFT);
231    x = MAX32(x, -32768);
232    x = MIN32(x, 32767);
233    return EXTRACT16(x);
234 #else
235    return (celt_word16_t)x;
236 #endif
237 }
238
239 static int transient_analysis(celt_word32_t *in, int len, int C, int *transient_time, int *transient_shift)
240 {
241    int c, i, n;
242    celt_word32_t ratio;
243    /* FIXME: Remove the floats here */
244    VARDECL(celt_word32_t, begin);
245    SAVE_STACK;
246    ALLOC(begin, len, celt_word32_t);
247    for (i=0;i<len;i++)
248       begin[i] = ABS32(SHR32(in[C*i],SIG_SHIFT));
249    for (c=1;c<C;c++)
250    {
251       for (i=0;i<len;i++)
252          begin[i] = MAX32(begin[i], ABS32(SHR32(in[C*i+c],SIG_SHIFT)));
253    }
254    for (i=1;i<len;i++)
255       begin[i] = MAX32(begin[i-1],begin[i]);
256    n = -1;
257    for (i=8;i<len-8;i++)
258    {
259       if (begin[i] < MULT16_32_Q15(QCONST16(.2f,15),begin[len-1]))
260          n=i;
261    }
262    if (n<32)
263    {
264       n = -1;
265       ratio = 0;
266    } else {
267       ratio = DIV32(begin[len-1],1+begin[n-16]);
268    }
269    /*printf ("%d %f\n", n, ratio*ratio);*/
270    if (ratio < 0)
271       ratio = 0;
272    if (ratio > 1000)
273       ratio = 1000;
274    ratio *= ratio;
275    
276    if (ratio > 2048)
277       *transient_shift = 3;
278    else
279       *transient_shift = 0;
280    
281    *transient_time = n;
282    
283    RESTORE_STACK;
284    return ratio > 20;
285 }
286
287 /** Apply window and compute the MDCT for all sub-frames and 
288     all channels in a frame */
289 static void compute_mdcts(const CELTMode *mode, int shortBlocks, celt_sig_t * restrict in, celt_sig_t * restrict out)
290 {
291    const int C = CHANNELS(mode);
292    if (C==1 && !shortBlocks)
293    {
294       const mdct_lookup *lookup = MDCT(mode);
295       const int overlap = OVERLAP(mode);
296       mdct_forward(lookup, in, out, mode->window, overlap);
297    } else if (!shortBlocks) {
298       const mdct_lookup *lookup = MDCT(mode);
299       const int overlap = OVERLAP(mode);
300       const int N = FRAMESIZE(mode);
301       int c;
302       VARDECL(celt_word32_t, x);
303       VARDECL(celt_word32_t, tmp);
304       SAVE_STACK;
305       ALLOC(x, N+overlap, celt_word32_t);
306       ALLOC(tmp, N, celt_word32_t);
307       for (c=0;c<C;c++)
308       {
309          int j;
310          for (j=0;j<N+overlap;j++)
311             x[j] = in[C*j+c];
312          mdct_forward(lookup, x, tmp, mode->window, overlap);
313          /* Interleaving the sub-frames */
314          for (j=0;j<N;j++)
315             out[j+c*N] = tmp[j];
316       }
317       RESTORE_STACK;
318    } else {
319       const mdct_lookup *lookup = &mode->shortMdct;
320       const int overlap = mode->overlap;
321       const int N = mode->shortMdctSize;
322       int b, c;
323       VARDECL(celt_word32_t, x);
324       VARDECL(celt_word32_t, tmp);
325       SAVE_STACK;
326       ALLOC(x, N+overlap, celt_word32_t);
327       ALLOC(tmp, N, celt_word32_t);
328       for (c=0;c<C;c++)
329       {
330          int B = mode->nbShortMdcts;
331          for (b=0;b<B;b++)
332          {
333             int j;
334             for (j=0;j<N+overlap;j++)
335                x[j] = in[C*(b*N+j)+c];
336             mdct_forward(lookup, x, tmp, mode->window, overlap);
337             /* Interleaving the sub-frames */
338             for (j=0;j<N;j++)
339                out[(j*B+b)+c*N*B] = tmp[j];
340          }
341       }
342       RESTORE_STACK;
343    }
344 }
345
346 /** Compute the IMDCT and apply window for all sub-frames and 
347     all channels in a frame */
348 static void compute_inv_mdcts(const CELTMode *mode, int shortBlocks, celt_sig_t *X, int transient_time, int transient_shift, celt_sig_t * restrict out_mem)
349 {
350    int c, N4;
351    const int C = CHANNELS(mode);
352    const int N = FRAMESIZE(mode);
353    const int overlap = OVERLAP(mode);
354    N4 = (N-overlap)>>1;
355    for (c=0;c<C;c++)
356    {
357       int j;
358       if (transient_shift==0 && C==1 && !shortBlocks) {
359          const mdct_lookup *lookup = MDCT(mode);
360          mdct_backward(lookup, X, out_mem+C*(MAX_PERIOD-N-N4), mode->window, overlap);
361       } else if (!shortBlocks) {
362          const mdct_lookup *lookup = MDCT(mode);
363          VARDECL(celt_word32_t, x);
364          VARDECL(celt_word32_t, tmp);
365          SAVE_STACK;
366          ALLOC(x, 2*N, celt_word32_t);
367          ALLOC(tmp, N, celt_word32_t);
368          /* De-interleaving the sub-frames */
369          for (j=0;j<N;j++)
370             tmp[j] = X[j+c*N];
371          /* Prevents problems from the imdct doing the overlap-add */
372          CELT_MEMSET(x+N4, 0, N);
373          mdct_backward(lookup, tmp, x, mode->window, overlap);
374          celt_assert(transient_shift == 0);
375          /* The first and last part would need to be set to zero if we actually
376             wanted to use them. */
377          for (j=0;j<overlap;j++)
378             out_mem[C*(MAX_PERIOD-N)+C*j+c] += x[j+N4];
379          for (j=0;j<overlap;j++)
380             out_mem[C*(MAX_PERIOD)+C*(overlap-j-1)+c] = x[2*N-j-N4-1];
381          for (j=0;j<2*N4;j++)
382             out_mem[C*(MAX_PERIOD-N)+C*(j+overlap)+c] = x[j+N4+overlap];
383          RESTORE_STACK;
384       } else {
385          int b;
386          const int N2 = mode->shortMdctSize;
387          const int B = mode->nbShortMdcts;
388          const mdct_lookup *lookup = &mode->shortMdct;
389          VARDECL(celt_word32_t, x);
390          VARDECL(celt_word32_t, tmp);
391          SAVE_STACK;
392          ALLOC(x, 2*N, celt_word32_t);
393          ALLOC(tmp, N, celt_word32_t);
394          /* Prevents problems from the imdct doing the overlap-add */
395          CELT_MEMSET(x+N4, 0, N2);
396          for (b=0;b<B;b++)
397          {
398             /* De-interleaving the sub-frames */
399             for (j=0;j<N2;j++)
400                tmp[j] = X[(j*B+b)+c*N2*B];
401             mdct_backward(lookup, tmp, x+N4+N2*b, mode->window, overlap);
402          }
403          if (transient_shift > 0)
404          {
405 #ifdef FIXED_POINT
406             for (j=0;j<16;j++)
407                x[N4+transient_time+j-16] = MULT16_32_Q15(SHR16(Q15_ONE-transientWindow[j],transient_shift)+transientWindow[j], SHL32(x[N4+transient_time+j-16],transient_shift));
408             for (j=transient_time;j<N+overlap;j++)
409                x[N4+j] = SHL32(x[N4+j], transient_shift);
410 #else
411             for (j=0;j<16;j++)
412                x[N4+transient_time+j-16] *= 1+transientWindow[j]*((1<<transient_shift)-1);
413             for (j=transient_time;j<N+overlap;j++)
414                x[N4+j] *= 1<<transient_shift;
415 #endif
416          }
417          /* The first and last part would need to be set to zero 
418             if we actually wanted to use them. */
419          for (j=0;j<overlap;j++)
420             out_mem[C*(MAX_PERIOD-N)+C*j+c] += x[j+N4];
421          for (j=0;j<overlap;j++)
422             out_mem[C*(MAX_PERIOD)+C*(overlap-j-1)+c] = x[2*N-j-N4-1];
423          for (j=0;j<2*N4;j++)
424             out_mem[C*(MAX_PERIOD-N)+C*(j+overlap)+c] = x[j+N4+overlap];
425          RESTORE_STACK;
426       }
427    }
428 }
429
430 #define FLAG_NONE        0
431 #define FLAG_INTRA       1U<<16
432 #define FLAG_PITCH       1U<<15
433 #define FLAG_SHORT       1U<<14
434 #define FLAG_FOLD        1U<<13
435 #define FLAG_MASK        (FLAG_INTRA|FLAG_PITCH|FLAG_SHORT|FLAG_FOLD)
436
437 celt_int32_t flaglist[8] = {
438       0 /*00  */ | FLAG_FOLD,
439       1 /*01  */ | FLAG_PITCH|FLAG_FOLD,
440       8 /*1000*/ | FLAG_NONE,
441       9 /*1001*/ | FLAG_SHORT|FLAG_FOLD,
442      10 /*1010*/ | FLAG_PITCH,
443      11 /*1011*/ | FLAG_INTRA,
444       6 /*110 */ | FLAG_INTRA|FLAG_FOLD,
445       7 /*111 */ | FLAG_INTRA|FLAG_SHORT|FLAG_FOLD
446 };
447
448 void encode_flags(ec_enc *enc, int intra_ener, int has_pitch, int shortBlocks, int has_fold)
449 {
450    int i;
451    int flags=FLAG_NONE;
452    int flag_bits;
453    flags |= intra_ener   ? FLAG_INTRA : 0;
454    flags |= has_pitch    ? FLAG_PITCH : 0;
455    flags |= shortBlocks  ? FLAG_SHORT : 0;
456    flags |= has_fold     ? FLAG_FOLD  : 0;
457    for (i=0;i<8;i++)
458       if (flags == (flaglist[i]&FLAG_MASK))
459          break;
460    celt_assert(i<8);
461    flag_bits = flaglist[i]&0xf;
462    /*printf ("enc %d: %d %d %d %d\n", flag_bits, intra_ener, has_pitch, shortBlocks, has_fold);*/
463    if (i<2)
464       ec_enc_bits(enc, flag_bits, 2);
465    else if (i<6)
466       ec_enc_bits(enc, flag_bits, 4);
467    else
468       ec_enc_bits(enc, flag_bits, 3);
469 }
470
471 void decode_flags(ec_dec *dec, int *intra_ener, int *has_pitch, int *shortBlocks, int *has_fold)
472 {
473    int i;
474    int flag_bits;
475    flag_bits = ec_dec_bits(dec, 2);
476    /*printf ("(%d) ", flag_bits);*/
477    if (flag_bits==2)
478       flag_bits = (flag_bits<<2) | ec_dec_bits(dec, 2);
479    else if (flag_bits==3)
480       flag_bits = (flag_bits<<1) | ec_dec_bits(dec, 1);
481    for (i=0;i<8;i++)
482       if (flag_bits == (flaglist[i]&0xf))
483          break;
484    celt_assert(i<8);
485    *intra_ener  = (flaglist[i]&FLAG_INTRA) != 0;
486    *has_pitch   = (flaglist[i]&FLAG_PITCH) != 0;
487    *shortBlocks = (flaglist[i]&FLAG_SHORT) != 0;
488    *has_fold    = (flaglist[i]&FLAG_FOLD ) != 0;
489    /*printf ("dec %d: %d %d %d %d\n", flag_bits, *intra_ener, *has_pitch, *shortBlocks, *has_fold);*/
490 }
491
492 #ifdef FIXED_POINT
493 int celt_encode(CELTEncoder * restrict st, const celt_int16_t * pcm, celt_int16_t * optional_synthesis, unsigned char *compressed, int nbCompressedBytes)
494 {
495 #else
496 int celt_encode_float(CELTEncoder * restrict st, const celt_sig_t * pcm, celt_sig_t * optional_synthesis, unsigned char *compressed, int nbCompressedBytes)
497 {
498 #endif
499    int i, c, N, N4;
500    int has_pitch;
501    int pitch_index;
502    int bits;
503    int has_fold=1;
504    unsigned coarse_needed;
505    ec_byte_buffer buf;
506    ec_enc         enc;
507    VARDECL(celt_sig_t, in);
508    VARDECL(celt_sig_t, freq);
509    VARDECL(celt_norm_t, X);
510    VARDECL(celt_norm_t, P);
511    VARDECL(celt_ener_t, bandE);
512    VARDECL(celt_word16_t, bandLogE);
513    VARDECL(celt_pgain_t, gains);
514    VARDECL(int, fine_quant);
515    VARDECL(celt_word16_t, error);
516    VARDECL(int, pulses);
517    VARDECL(int, offsets);
518    VARDECL(int, fine_priority);
519 #ifdef EXP_PSY
520    VARDECL(celt_word32_t, mask);
521    VARDECL(celt_word32_t, tonality);
522    VARDECL(celt_word32_t, bandM);
523    VARDECL(celt_ener_t, bandN);
524 #endif
525    int intra_ener = 0;
526    int shortBlocks=0;
527    int transient_time;
528    int transient_shift;
529    const int C = CHANNELS(st->mode);
530    int mdct_weight_shift = 0;
531    int mdct_weight_pos=0;
532    SAVE_STACK;
533
534    if (check_encoder(st) != CELT_OK)
535       return CELT_INVALID_STATE;
536
537    if (check_mode(st->mode) != CELT_OK)
538       return CELT_INVALID_MODE;
539
540    if (nbCompressedBytes<0)
541      return CELT_BAD_ARG; 
542
543    /* The memset is important for now in case the encoder doesn't 
544       fill up all the bytes */
545    CELT_MEMSET(compressed, 0, nbCompressedBytes);
546    ec_byte_writeinit_buffer(&buf, compressed, nbCompressedBytes);
547    ec_enc_init(&enc,&buf);
548
549    N = st->block_size;
550    N4 = (N-st->overlap)>>1;
551    ALLOC(in, 2*C*N-2*C*N4, celt_sig_t);
552
553    CELT_COPY(in, st->in_mem, C*st->overlap);
554    for (c=0;c<C;c++)
555    {
556       const celt_word16_t * restrict pcmp = pcm+c;
557       celt_sig_t * restrict inp = in+C*st->overlap+c;
558       for (i=0;i<N;i++)
559       {
560          /* Apply pre-emphasis */
561          celt_sig_t tmp = SCALEIN(SHL32(EXTEND32(*pcmp), SIG_SHIFT));
562          *inp = SUB32(tmp, SHR32(MULT16_16(preemph,st->preemph_memE[c]),3));
563          st->preemph_memE[c] = SCALEIN(*pcmp);
564          inp += C;
565          pcmp += C;
566       }
567    }
568    CELT_COPY(st->in_mem, in+C*(2*N-2*N4-st->overlap), C*st->overlap);
569    
570    /* Transient handling */
571    if (st->mode->nbShortMdcts > 1)
572    {
573       if (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       } else {
601          transient_time = -1;
602          transient_shift = 0;
603          shortBlocks = 0;
604       }
605    } else {
606       transient_time = -1;
607       transient_shift = 0;
608       shortBlocks = 0;
609    }
610
611    ALLOC(freq, C*N, celt_sig_t); /**< Interleaved signal MDCTs */
612    ALLOC(bandE,st->mode->nbEBands*C, celt_ener_t);
613    ALLOC(bandLogE,st->mode->nbEBands*C, celt_word16_t);
614    /* Compute MDCTs */
615    compute_mdcts(st->mode, shortBlocks, in, freq);
616
617    if (shortBlocks && !transient_shift) 
618    {
619       celt_word32_t sum[4]={1,1,1,1};
620       int m;
621       for (c=0;c<C;c++)
622       {
623          m=0;
624          do {
625             celt_word32_t tmp=0;
626             for (i=m+c*N;i<(c+1)*N;i+=st->mode->nbShortMdcts)
627                tmp += ABS32(freq[i]);
628             sum[m++] += tmp;
629          } while (m<st->mode->nbShortMdcts);
630       }
631       m=0;
632 #ifdef FIXED_POINT
633       do {
634          if (SHR32(sum[m+1],3) > sum[m])
635          {
636             mdct_weight_shift=2;
637             mdct_weight_pos = m;
638          } else if (SHR32(sum[m+1],1) > sum[m] && mdct_weight_shift < 2)
639          {
640             mdct_weight_shift=1;
641             mdct_weight_pos = m;
642          }
643          m++;
644       } while (m<st->mode->nbShortMdcts-1);
645       if (mdct_weight_shift)
646       {
647          for (c=0;c<C;c++)
648             for (m=mdct_weight_pos+1;m<st->mode->nbShortMdcts;m++)
649                for (i=m+c*N;i<(c+1)*N;i+=st->mode->nbShortMdcts)
650                   freq[i] = SHR32(freq[i],mdct_weight_shift);
651       }
652 #else
653       do {
654          if (sum[m+1] > 8*sum[m])
655          {
656             mdct_weight_shift=2;
657             mdct_weight_pos = m;
658          } else if (sum[m+1] > 2*sum[m] && mdct_weight_shift < 2)
659          {
660             mdct_weight_shift=1;
661             mdct_weight_pos = m;
662          }
663          m++;
664       } while (m<st->mode->nbShortMdcts-1);
665       if (mdct_weight_shift)
666       {
667          for (c=0;c<C;c++)
668             for (m=mdct_weight_pos+1;m<st->mode->nbShortMdcts;m++)
669                for (i=m+c*N;i<(c+1)*N;i+=st->mode->nbShortMdcts)
670                   freq[i] = (1./(1<<mdct_weight_shift))*freq[i];
671       }
672 #endif
673    }
674
675    compute_band_energies(st->mode, freq, bandE);
676    for (i=0;i<st->mode->nbEBands*C;i++)
677       bandLogE[i] = amp2Log(bandE[i]);
678
679    /* Don't use intra energy when we're operating at low bit-rate */
680    intra_ener = st->force_intra || (st->delayedIntra && nbCompressedBytes > st->mode->nbEBands);
681    if (shortBlocks || intra_decision(bandLogE, st->oldBandE, st->mode->nbEBands))
682       st->delayedIntra = 1;
683    else
684       st->delayedIntra = 0;
685
686    /* Pitch analysis: we do it early to save on the peak stack space */
687    /* Don't use pitch if there isn't enough data available yet, 
688       or if we're using shortBlocks */
689    has_pitch = st->pitch_enabled && st->pitch_permitted && (st->pitch_available >= MAX_PERIOD) && (!shortBlocks) && !intra_ener;
690 #ifdef EXP_PSY
691    ALLOC(tonality, MAX_PERIOD/4, celt_word16_t);
692    {
693       VARDECL(celt_word16_t, X);
694       ALLOC(X, MAX_PERIOD/2, celt_word16_t);
695       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);
696       compute_tonality(st->mode, X, st->psy_mem, MAX_PERIOD, tonality, MAX_PERIOD/4);
697    }
698 #else
699    if (has_pitch)
700    {
701       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);
702    }
703 #endif
704
705 #ifdef EXP_PSY
706    ALLOC(mask, N, celt_sig_t);
707    compute_mdct_masking(&st->psy, freq, tonality, st->psy_mem, mask, C*N);
708    /*for (i=0;i<256;i++)
709       printf ("%f %f %f ", freq[i], tonality[i], mask[i]);
710    printf ("\n");*/
711 #endif
712
713    /* Deferred allocation after find_spectral_pitch() to reduce 
714       the peak memory usage */
715    ALLOC(X, C*N, celt_norm_t);         /**< Interleaved normalised MDCTs */
716    ALLOC(P, C*N, celt_norm_t);         /**< Interleaved normalised pitch MDCTs*/
717    ALLOC(gains,st->mode->nbPBands, celt_pgain_t);
718
719
720    /* Band normalisation */
721    normalise_bands(st->mode, freq, X, bandE);
722    if (!shortBlocks && !folding_decision(st->mode, X, &st->tonal_average, &st->fold_decision))
723       has_fold = 0;
724 #ifdef EXP_PSY
725    ALLOC(bandN,C*st->mode->nbEBands, celt_ener_t);
726    ALLOC(bandM,st->mode->nbEBands, celt_ener_t);
727    compute_noise_energies(st->mode, freq, tonality, bandN);
728
729    /*for (i=0;i<st->mode->nbEBands;i++)
730       printf ("%f ", (.1+bandN[i])/(.1+bandE[i]));
731    printf ("\n");*/
732    has_fold = 0;
733    for (i=st->mode->nbPBands;i<st->mode->nbEBands;i++)
734       if (bandN[i] < .4*bandE[i])
735          has_fold++;
736    /*printf ("%d\n", has_fold);*/
737    if (has_fold>=2)
738       has_fold = 0;
739    else
740       has_fold = 1;
741    for (i=0;i<N;i++)
742       mask[i] = sqrt(mask[i]);
743    compute_band_energies(st->mode, mask, bandM);
744    /*for (i=0;i<st->mode->nbEBands;i++)
745       printf ("%f %f ", bandE[i], bandM[i]);
746    printf ("\n");*/
747 #endif
748
749    /* Compute MDCTs of the pitch part */
750    if (has_pitch)
751    {
752       celt_word32_t curr_power, pitch_power=0;
753       /* Normalise the pitch vector as well (discard the energies) */
754       VARDECL(celt_ener_t, bandEp);
755       
756       compute_mdcts(st->mode, 0, st->out_mem+pitch_index*C, freq);
757       ALLOC(bandEp, st->mode->nbEBands*st->mode->nbChannels, celt_ener_t);
758       compute_band_energies(st->mode, freq, bandEp);
759       normalise_bands(st->mode, freq, P, bandEp);
760       pitch_power = bandEp[0]+bandEp[1]+bandEp[2];
761       curr_power = bandE[0]+bandE[1]+bandE[2];
762       if (C>1)
763       {
764          pitch_power += bandEp[0+st->mode->nbEBands]+bandEp[1+st->mode->nbEBands]+bandEp[2+st->mode->nbEBands];
765          curr_power += bandE[0+st->mode->nbEBands]+bandE[1+st->mode->nbEBands]+bandE[2+st->mode->nbEBands];
766       }
767       /* Check if we can safely use the pitch (i.e. effective gain 
768       isn't too high) */
769       if ((MULT16_32_Q15(QCONST16(.1f, 15),curr_power) + QCONST32(10.f,ENER_SHIFT) < pitch_power))
770       {
771          /* Pitch prediction */
772          has_pitch = compute_pitch_gain(st->mode, X, P, gains);
773       } else {
774          has_pitch = 0;
775       }
776    }
777    
778    encode_flags(&enc, intra_ener, has_pitch, shortBlocks, has_fold);
779    if (has_pitch)
780    {
781       ec_enc_uint(&enc, pitch_index, MAX_PERIOD-(2*N-2*N4));
782    } else {
783       for (i=0;i<st->mode->nbPBands;i++)
784          gains[i] = 0;
785       for (i=0;i<C*N;i++)
786          P[i] = 0;
787    }
788    if (shortBlocks)
789    {
790       if (transient_shift)
791       {
792          ec_enc_bits(&enc, transient_shift, 2);
793          ec_enc_uint(&enc, transient_time, N+st->overlap);
794       } else {
795          ec_enc_bits(&enc, mdct_weight_shift, 2);
796          if (mdct_weight_shift && st->mode->nbShortMdcts!=2)
797             ec_enc_uint(&enc, mdct_weight_pos, st->mode->nbShortMdcts-1);
798       }
799    }
800
801 #ifdef STDIN_TUNING2
802    static int fine_quant[30];
803    static int pulses[30];
804    static int init=0;
805    if (!init)
806    {
807       for (i=0;i<st->mode->nbEBands;i++)
808          scanf("%d ", &fine_quant[i]);
809       for (i=0;i<st->mode->nbEBands;i++)
810          scanf("%d ", &pulses[i]);
811       init = 1;
812    }
813 #else
814    ALLOC(fine_quant, st->mode->nbEBands, int);
815    ALLOC(pulses, st->mode->nbEBands, int);
816 #endif
817
818    /* Bit allocation */
819    ALLOC(error, C*st->mode->nbEBands, celt_word16_t);
820    coarse_needed = quant_coarse_energy(st->mode, bandLogE, st->oldBandE, nbCompressedBytes*8/3, intra_ener, st->mode->prob, error, &enc);
821    coarse_needed = ((coarse_needed*3-1)>>3)+1;
822
823    /* Variable bitrate */
824    if (st->VBR_rate>0)
825    {
826      /* The target rate in 16th bits per frame */
827      int target=st->VBR_rate;
828    
829      /* Shortblocks get a large boost in bitrate, but since they 
830         are uncommon long blocks are not greatly effected */
831      if (shortBlocks)
832        target*=2;
833      else if (st->mode->nbShortMdcts > 1)
834        target-=(target+14)/28;     
835
836      /* The average energy is removed from the target and the actual 
837         energy added*/
838      target=target-588+ec_enc_tell(&enc, 4);
839
840      /* In VBR mode the frame size must not be reduced so much that it would result in the coarse energy busting its budget */
841      target=IMAX(coarse_needed,(target+64)/128);
842      nbCompressedBytes=IMIN(nbCompressedBytes,target);
843    }
844
845    ALLOC(offsets, st->mode->nbEBands, int);
846    ALLOC(fine_priority, st->mode->nbEBands, int);
847
848    for (i=0;i<st->mode->nbEBands;i++)
849       offsets[i] = 0;
850    bits = nbCompressedBytes*8 - ec_enc_tell(&enc, 0) - 1;
851    if (has_pitch)
852       bits -= st->mode->nbPBands;
853 #ifndef STDIN_TUNING
854    compute_allocation(st->mode, offsets, bits, pulses, fine_quant, fine_priority);
855 #endif
856
857    quant_fine_energy(st->mode, bandE, st->oldBandE, error, fine_quant, &enc);
858
859    /* Residual quantisation */
860    if (C==1)
861       quant_bands(st->mode, X, P, NULL, has_pitch, gains, bandE, pulses, shortBlocks, has_fold, nbCompressedBytes*8, &enc);
862 #ifndef DISABLE_STEREO
863    else
864       quant_bands_stereo(st->mode, X, P, NULL, has_pitch, gains, bandE, pulses, shortBlocks, has_fold, nbCompressedBytes*8, &enc);
865 #endif
866
867    quant_energy_finalise(st->mode, bandE, st->oldBandE, error, fine_quant, fine_priority, nbCompressedBytes*8-ec_enc_tell(&enc, 0), &enc);
868
869    /* Re-synthesis of the coded audio if required */
870    if (st->pitch_available>0 || optional_synthesis!=NULL)
871    {
872       if (st->pitch_available>0 && st->pitch_available<MAX_PERIOD)
873         st->pitch_available+=st->frame_size;
874
875       /* Synthesis */
876       denormalise_bands(st->mode, X, freq, bandE);
877       
878       
879       CELT_MOVE(st->out_mem, st->out_mem+C*N, C*(MAX_PERIOD+st->overlap-N));
880       
881       if (mdct_weight_shift)
882       {
883          int m;
884          for (c=0;c<C;c++)
885             for (m=mdct_weight_pos+1;m<st->mode->nbShortMdcts;m++)
886                for (i=m+c*N;i<(c+1)*N;i+=st->mode->nbShortMdcts)
887 #ifdef FIXED_POINT
888                   freq[i] = SHL32(freq[i], mdct_weight_shift);
889 #else
890                   freq[i] = (1<<mdct_weight_shift)*freq[i];
891 #endif
892       }
893       compute_inv_mdcts(st->mode, shortBlocks, freq, transient_time, transient_shift, st->out_mem);
894       /* De-emphasis and put everything back at the right place 
895          in the synthesis history */
896       if (optional_synthesis != NULL) {
897          for (c=0;c<C;c++)
898          {
899             int j;
900             for (j=0;j<N;j++)
901             {
902                celt_sig_t tmp = MAC16_32_Q15(st->out_mem[C*(MAX_PERIOD-N)+C*j+c],
903                                    preemph,st->preemph_memD[c]);
904                st->preemph_memD[c] = tmp;
905                optional_synthesis[C*j+c] = SCALEOUT(SIG2WORD16(tmp));
906             }
907          }
908       }
909    }
910
911    ec_enc_done(&enc);
912    
913    RESTORE_STACK;
914    return nbCompressedBytes;
915 }
916
917 #ifdef FIXED_POINT
918 #ifndef DISABLE_FLOAT_API
919 int celt_encode_float(CELTEncoder * restrict st, const float * pcm, float * optional_synthesis, unsigned char *compressed, int nbCompressedBytes)
920 {
921    int j, ret, C, N;
922    VARDECL(celt_int16_t, in);
923
924    if (check_encoder(st) != CELT_OK)
925       return CELT_INVALID_STATE;
926
927    if (check_mode(st->mode) != CELT_OK)
928       return CELT_INVALID_MODE;
929
930    SAVE_STACK;
931    C = CHANNELS(st->mode);
932    N = st->block_size;
933    ALLOC(in, C*N, celt_int16_t);
934
935    for (j=0;j<C*N;j++)
936      in[j] = FLOAT2INT16(pcm[j]);
937
938    if (optional_synthesis != NULL) {
939      ret=celt_encode(st,in,in,compressed,nbCompressedBytes);
940       for (j=0;j<C*N;j++)
941          optional_synthesis[j]=in[j]*(1/32768.);
942    } else {
943      ret=celt_encode(st,in,NULL,compressed,nbCompressedBytes);
944    }
945    RESTORE_STACK;
946    return ret;
947
948 }
949 #endif /*DISABLE_FLOAT_API*/
950 #else
951 int celt_encode(CELTEncoder * restrict st, const celt_int16_t * pcm, celt_int16_t * optional_synthesis, unsigned char *compressed, int nbCompressedBytes)
952 {
953    int j, ret, C, N;
954    VARDECL(celt_sig_t, in);
955
956    if (check_encoder(st) != CELT_OK)
957       return CELT_INVALID_STATE;
958
959    if (check_mode(st->mode) != CELT_OK)
960       return CELT_INVALID_MODE;
961
962    SAVE_STACK;
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          int 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    N = st->block_size;
1304    N4 = (N-st->overlap)>>1;
1305
1306    ALLOC(freq, C*N, celt_sig_t); /**< Interleaved signal MDCTs */
1307    ALLOC(X, C*N, celt_norm_t);   /**< Interleaved normalised MDCTs */
1308    ALLOC(P, C*N, celt_norm_t);   /**< Interleaved normalised pitch MDCTs*/
1309    ALLOC(bandE, st->mode->nbEBands*C, celt_ener_t);
1310    ALLOC(gains, st->mode->nbPBands, celt_pgain_t);
1311    
1312    if (data == NULL)
1313    {
1314       celt_decode_lost(st, pcm);
1315       RESTORE_STACK;
1316       return 0;
1317    }
1318    if (len<0) {
1319      RESTORE_STACK;
1320      return CELT_BAD_ARG;
1321    }
1322    
1323    ec_byte_readinit(&buf,(unsigned char*)data,len);
1324    ec_dec_init(&dec,&buf);
1325    
1326    decode_flags(&dec, &intra_ener, &has_pitch, &shortBlocks, &has_fold);
1327    if (shortBlocks)
1328    {
1329       transient_shift = ec_dec_bits(&dec, 2);
1330       if (transient_shift == 3)
1331       {
1332          transient_time = ec_dec_uint(&dec, N+st->mode->overlap);
1333       } else {
1334          mdct_weight_shift = transient_shift;
1335          if (mdct_weight_shift && st->mode->nbShortMdcts>2)
1336             mdct_weight_pos = ec_dec_uint(&dec, st->mode->nbShortMdcts-1);
1337          transient_shift = 0;
1338          transient_time = 0;
1339       }
1340    } else {
1341       transient_time = -1;
1342       transient_shift = 0;
1343    }
1344    
1345    if (has_pitch)
1346    {
1347       pitch_index = ec_dec_uint(&dec, MAX_PERIOD-(2*N-2*N4));
1348       st->last_pitch_index = pitch_index;
1349    } else {
1350       pitch_index = 0;
1351       for (i=0;i<st->mode->nbPBands;i++)
1352          gains[i] = 0;
1353    }
1354
1355    ALLOC(fine_quant, st->mode->nbEBands, int);
1356    /* Get band energies */
1357    unquant_coarse_energy(st->mode, bandE, st->oldBandE, len*8/3, intra_ener, st->mode->prob, &dec);
1358    
1359    ALLOC(pulses, st->mode->nbEBands, int);
1360    ALLOC(offsets, st->mode->nbEBands, int);
1361    ALLOC(fine_priority, st->mode->nbEBands, int);
1362
1363    for (i=0;i<st->mode->nbEBands;i++)
1364       offsets[i] = 0;
1365
1366    bits = len*8 - ec_dec_tell(&dec, 0) - 1;
1367    if (has_pitch)
1368       bits -= st->mode->nbPBands;
1369    compute_allocation(st->mode, offsets, bits, pulses, fine_quant, fine_priority);
1370    /*bits = ec_dec_tell(&dec, 0);
1371    compute_fine_allocation(st->mode, fine_quant, (20*C+len*8/5-(ec_dec_tell(&dec, 0)-bits))/C);*/
1372    
1373    unquant_fine_energy(st->mode, bandE, st->oldBandE, fine_quant, &dec);
1374
1375
1376    if (has_pitch) 
1377    {
1378       VARDECL(celt_ener_t, bandEp);
1379       
1380       /* Pitch MDCT */
1381       compute_mdcts(st->mode, 0, st->out_mem+pitch_index*C, freq);
1382       ALLOC(bandEp, st->mode->nbEBands*C, celt_ener_t);
1383       compute_band_energies(st->mode, freq, bandEp);
1384       normalise_bands(st->mode, freq, P, bandEp);
1385       /* Apply pitch gains */
1386    } else {
1387       for (i=0;i<C*N;i++)
1388          P[i] = 0;
1389    }
1390
1391    /* Decode fixed codebook and merge with pitch */
1392    if (C==1)
1393       unquant_bands(st->mode, X, P, has_pitch, gains, bandE, pulses, shortBlocks, has_fold, len*8, &dec);
1394 #ifndef DISABLE_STEREO
1395    else
1396       unquant_bands_stereo(st->mode, X, P, has_pitch, gains, bandE, pulses, shortBlocks, has_fold, len*8, &dec);
1397 #endif
1398    unquant_energy_finalise(st->mode, bandE, st->oldBandE, fine_quant, fine_priority, len*8-ec_dec_tell(&dec, 0), &dec);
1399    
1400    /* Synthesis */
1401    denormalise_bands(st->mode, X, freq, bandE);
1402
1403
1404    CELT_MOVE(st->decode_mem, st->decode_mem+C*N, C*(DECODE_BUFFER_SIZE+st->overlap-N));
1405    if (mdct_weight_shift)
1406    {
1407       int m;
1408       for (c=0;c<C;c++)
1409          for (m=mdct_weight_pos+1;m<st->mode->nbShortMdcts;m++)
1410             for (i=m+c*N;i<(c+1)*N;i+=st->mode->nbShortMdcts)
1411 #ifdef FIXED_POINT
1412                freq[i] = SHL32(freq[i], mdct_weight_shift);
1413 #else
1414                freq[i] = (1<<mdct_weight_shift)*freq[i];
1415 #endif
1416    }
1417    /* Compute inverse MDCTs */
1418    compute_inv_mdcts(st->mode, shortBlocks, freq, transient_time, transient_shift, st->out_mem);
1419
1420    for (c=0;c<C;c++)
1421    {
1422       int j;
1423       for (j=0;j<N;j++)
1424       {
1425          celt_sig_t tmp = MAC16_32_Q15(st->out_mem[C*(MAX_PERIOD-N)+C*j+c],
1426                                 preemph,st->preemph_memD[c]);
1427          st->preemph_memD[c] = tmp;
1428          pcm[C*j+c] = SCALEOUT(SIG2WORD16(tmp));
1429       }
1430    }
1431
1432    RESTORE_STACK;
1433    return 0;
1434    /*printf ("\n");*/
1435 }
1436
1437 #ifdef FIXED_POINT
1438 #ifndef DISABLE_FLOAT_API
1439 int celt_decode_float(CELTDecoder * restrict st, const unsigned char *data, int len, float * restrict pcm)
1440 {
1441    int j, ret, C, N;
1442    VARDECL(celt_int16_t, out);
1443
1444    if (check_decoder(st) != CELT_OK)
1445       return CELT_INVALID_STATE;
1446
1447    if (check_mode(st->mode) != CELT_OK)
1448       return CELT_INVALID_MODE;
1449
1450    SAVE_STACK;
1451    C = CHANNELS(st->mode);
1452    N = st->block_size;
1453    ALLOC(out, C*N, celt_int16_t);
1454
1455    ret=celt_decode(st, data, len, out);
1456
1457    for (j=0;j<C*N;j++)
1458      pcm[j]=out[j]*(1/32768.);
1459    RESTORE_STACK;
1460    return ret;
1461 }
1462 #endif /*DISABLE_FLOAT_API*/
1463 #else
1464 int celt_decode(CELTDecoder * restrict st, const unsigned char *data, int len, celt_int16_t * restrict pcm)
1465 {
1466    int j, ret, C, N;
1467    VARDECL(celt_sig_t, out);
1468
1469    if (check_decoder(st) != CELT_OK)
1470       return CELT_INVALID_STATE;
1471
1472    if (check_mode(st->mode) != CELT_OK)
1473       return CELT_INVALID_MODE;
1474
1475    SAVE_STACK;
1476    C = CHANNELS(st->mode);
1477    N = st->block_size;
1478    ALLOC(out, C*N, celt_sig_t);
1479
1480    ret=celt_decode_float(st, data, len, out);
1481
1482    for (j=0;j<C*N;j++)
1483      pcm[j] = FLOAT2INT16 (out[j]);
1484
1485    RESTORE_STACK;
1486    return ret;
1487 }
1488 #endif
1489
1490 int celt_decoder_ctl(CELTDecoder * restrict st, int request, ...)
1491 {
1492    va_list ap;
1493
1494    if (check_decoder(st) != CELT_OK)
1495       return CELT_INVALID_STATE;
1496
1497    va_start(ap, request);
1498    if ((request!=CELT_GET_MODE_REQUEST) && (check_mode(st->mode) != CELT_OK))
1499      goto bad_mode;
1500    switch (request)
1501    {
1502       case CELT_GET_MODE_REQUEST:
1503       {
1504          const CELTMode ** value = va_arg(ap, const CELTMode**);
1505          if (value==0)
1506             goto bad_arg;
1507          *value=st->mode;
1508       }
1509       break;
1510       case CELT_RESET_STATE:
1511       {
1512          const CELTMode *mode = st->mode;
1513          int C = mode->nbChannels;
1514
1515          CELT_MEMSET(st->decode_mem, 0, (DECODE_BUFFER_SIZE+st->overlap)*C);
1516          CELT_MEMSET(st->oldBandE, 0, C*mode->nbEBands);
1517
1518          CELT_MEMSET(st->preemph_memD, 0, C);
1519
1520          st->last_pitch_index = 0;
1521       }
1522       break;
1523       default:
1524          goto bad_request;
1525    }
1526    va_end(ap);
1527    return CELT_OK;
1528 bad_mode:
1529   va_end(ap);
1530   return CELT_INVALID_MODE;
1531 bad_arg:
1532    va_end(ap);
1533    return CELT_BAD_ARG;
1534 bad_request:
1535       va_end(ap);
1536   return CELT_UNIMPLEMENTED;
1537 }