More de-interleaving: denormalised MDCT no longer stored with interleaved
[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       /*printf ("%f\n", short_ratio);*/
674       /*if (short_ratio < 1)
675          short_ratio = 1;
676       short_ratio = 1<<(int)floor(.5+log2(short_ratio));
677       if (short_ratio>4)
678          short_ratio = 4;*/
679    }/* else if (transient_shift)
680       printf ("8\n");
681       else printf ("1\n");*/
682
683    compute_band_energies(st->mode, freq, bandE);
684    for (i=0;i<st->mode->nbEBands*C;i++)
685       bandLogE[i] = amp2Log(bandE[i]);
686
687    intra_ener = (st->force_intra || st->delayedIntra);
688    if (shortBlocks || intra_decision(bandLogE, st->oldBandE, st->mode->nbEBands))
689       st->delayedIntra = 1;
690    else
691       st->delayedIntra = 0;
692    /* Pitch analysis: we do it early to save on the peak stack space */
693    /* Don't use pitch if there isn't enough data available yet, 
694       or if we're using shortBlocks */
695    has_pitch = st->pitch_enabled && st->pitch_permitted && (st->pitch_available >= MAX_PERIOD) && (!shortBlocks) && !intra_ener;
696 #ifdef EXP_PSY
697    ALLOC(tonality, MAX_PERIOD/4, celt_word16_t);
698    {
699       VARDECL(celt_word16_t, X);
700       ALLOC(X, MAX_PERIOD/2, celt_word16_t);
701       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);
702       compute_tonality(st->mode, X, st->psy_mem, MAX_PERIOD, tonality, MAX_PERIOD/4);
703    }
704 #else
705    if (has_pitch)
706    {
707       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);
708    }
709 #endif
710
711 #ifdef EXP_PSY
712    ALLOC(mask, N, celt_sig_t);
713    compute_mdct_masking(&st->psy, freq, tonality, st->psy_mem, mask, C*N);
714    /*for (i=0;i<256;i++)
715       printf ("%f %f %f ", freq[i], tonality[i], mask[i]);
716    printf ("\n");*/
717 #endif
718
719    /* Deferred allocation after find_spectral_pitch() to reduce 
720       the peak memory usage */
721    ALLOC(X, C*N, celt_norm_t);         /**< Interleaved normalised MDCTs */
722    ALLOC(P, C*N, celt_norm_t);         /**< Interleaved normalised pitch MDCTs*/
723    ALLOC(gains,st->mode->nbPBands, celt_pgain_t);
724
725
726    /* Band normalisation */
727    normalise_bands(st->mode, freq, X, bandE);
728    if (!shortBlocks && !folding_decision(st->mode, X, &st->tonal_average, &st->fold_decision))
729       has_fold = 0;
730 #ifdef EXP_PSY
731    ALLOC(bandN,C*st->mode->nbEBands, celt_ener_t);
732    ALLOC(bandM,st->mode->nbEBands, celt_ener_t);
733    compute_noise_energies(st->mode, freq, tonality, bandN);
734
735    /*for (i=0;i<st->mode->nbEBands;i++)
736       printf ("%f ", (.1+bandN[i])/(.1+bandE[i]));
737    printf ("\n");*/
738    has_fold = 0;
739    for (i=st->mode->nbPBands;i<st->mode->nbEBands;i++)
740       if (bandN[i] < .4*bandE[i])
741          has_fold++;
742    /*printf ("%d\n", has_fold);*/
743    if (has_fold>=2)
744       has_fold = 0;
745    else
746       has_fold = 1;
747    for (i=0;i<N;i++)
748       mask[i] = sqrt(mask[i]);
749    compute_band_energies(st->mode, mask, bandM);
750    /*for (i=0;i<st->mode->nbEBands;i++)
751       printf ("%f %f ", bandE[i], bandM[i]);
752    printf ("\n");*/
753 #endif
754
755    /* Compute MDCTs of the pitch part */
756    if (has_pitch)
757    {
758       celt_word32_t curr_power, pitch_power=0;
759       /* Normalise the pitch vector as well (discard the energies) */
760       VARDECL(celt_ener_t, bandEp);
761       
762       compute_mdcts(st->mode, 0, st->out_mem+pitch_index*C, freq);
763       ALLOC(bandEp, st->mode->nbEBands*st->mode->nbChannels, celt_ener_t);
764       compute_band_energies(st->mode, freq, bandEp);
765       normalise_bands(st->mode, freq, P, bandEp);
766       pitch_power = bandEp[0]+bandEp[1]+bandEp[2];
767       curr_power = bandE[0]+bandE[1]+bandE[2];
768       if (C>1)
769       {
770          pitch_power += bandEp[0+st->mode->nbEBands]+bandEp[1+st->mode->nbEBands]+bandEp[2+st->mode->nbEBands];
771          curr_power += bandE[0+st->mode->nbEBands]+bandE[1+st->mode->nbEBands]+bandE[2+st->mode->nbEBands];
772       }
773       /* Check if we can safely use the pitch (i.e. effective gain 
774       isn't too high) */
775       if ((MULT16_32_Q15(QCONST16(.1f, 15),curr_power) + QCONST32(10.f,ENER_SHIFT) < pitch_power))
776       {
777          /* Pitch prediction */
778          has_pitch = compute_pitch_gain(st->mode, X, P, gains);
779       } else {
780          has_pitch = 0;
781       }
782    }
783    
784    encode_flags(&enc, intra_ener, has_pitch, shortBlocks, has_fold);
785    if (has_pitch)
786    {
787       ec_enc_uint(&enc, pitch_index, MAX_PERIOD-(2*N-2*N4));
788    } else {
789       for (i=0;i<st->mode->nbPBands;i++)
790          gains[i] = 0;
791       for (i=0;i<C*N;i++)
792          P[i] = 0;
793    }
794    if (shortBlocks)
795    {
796       if (transient_shift)
797       {
798          ec_enc_bits(&enc, transient_shift, 2);
799          ec_enc_uint(&enc, transient_time, N+st->overlap);
800       } else {
801          ec_enc_bits(&enc, mdct_weight_shift, 2);
802          if (mdct_weight_shift && st->mode->nbShortMdcts!=2)
803             ec_enc_uint(&enc, mdct_weight_pos, st->mode->nbShortMdcts-1);
804       }
805    }
806
807 #ifdef STDIN_TUNING2
808    static int fine_quant[30];
809    static int pulses[30];
810    static int init=0;
811    if (!init)
812    {
813       for (i=0;i<st->mode->nbEBands;i++)
814          scanf("%d ", &fine_quant[i]);
815       for (i=0;i<st->mode->nbEBands;i++)
816          scanf("%d ", &pulses[i]);
817       init = 1;
818    }
819 #else
820    ALLOC(fine_quant, st->mode->nbEBands, int);
821    ALLOC(pulses, st->mode->nbEBands, int);
822 #endif
823
824    /* Bit allocation */
825    ALLOC(error, C*st->mode->nbEBands, celt_word16_t);
826    coarse_needed = quant_coarse_energy(st->mode, bandLogE, st->oldBandE, nbCompressedBytes*8/3, intra_ener, st->mode->prob, error, &enc);
827    coarse_needed = ((coarse_needed*3-1)>>3)+1;
828
829    /* Variable bitrate */
830    if (st->VBR_rate>0)
831    {
832      /* The target rate in 16th bits per frame */
833      int target=st->VBR_rate;
834    
835      /* Shortblocks get a large boost in bitrate, but since they 
836         are uncommon long blocks are not greatly effected */
837      if (shortBlocks)
838        target*=2;
839      else if (st->mode->nbShortMdcts > 1)
840        target-=(target+14)/28;     
841
842      /* The average energy is removed from the target and the actual 
843         energy added*/
844      target=target-588+ec_enc_tell(&enc, 4);
845
846      /* In VBR mode the frame size must not be reduced so much that it would result in the coarse energy busting its budget */
847      target=IMAX(coarse_needed,(target+64)/128);
848      nbCompressedBytes=IMIN(nbCompressedBytes,target);
849    }
850
851    ALLOC(offsets, st->mode->nbEBands, int);
852    ALLOC(fine_priority, st->mode->nbEBands, int);
853
854    for (i=0;i<st->mode->nbEBands;i++)
855       offsets[i] = 0;
856    bits = nbCompressedBytes*8 - ec_enc_tell(&enc, 0) - 1;
857    if (has_pitch)
858       bits -= st->mode->nbPBands;
859 #ifndef STDIN_TUNING
860    compute_allocation(st->mode, offsets, bits, pulses, fine_quant, fine_priority);
861 #endif
862
863    quant_fine_energy(st->mode, bandE, st->oldBandE, error, fine_quant, &enc);
864
865    /* Residual quantisation */
866    if (C==1)
867       quant_bands(st->mode, X, P, NULL, has_pitch, gains, bandE, pulses, shortBlocks, has_fold, nbCompressedBytes*8, &enc);
868 #ifndef DISABLE_STEREO
869    else
870       quant_bands_stereo(st->mode, X, P, NULL, has_pitch, gains, bandE, pulses, shortBlocks, has_fold, nbCompressedBytes*8, &enc);
871 #endif
872
873    quant_energy_finalise(st->mode, bandE, st->oldBandE, error, fine_quant, fine_priority, nbCompressedBytes*8-ec_enc_tell(&enc, 0), &enc);
874
875    /* Re-synthesis of the coded audio if required */
876    if (st->pitch_available>0 || optional_synthesis!=NULL)
877    {
878       if (st->pitch_available>0 && st->pitch_available<MAX_PERIOD)
879         st->pitch_available+=st->frame_size;
880
881       /* Synthesis */
882       denormalise_bands(st->mode, X, freq, bandE);
883       
884       
885       CELT_MOVE(st->out_mem, st->out_mem+C*N, C*(MAX_PERIOD+st->overlap-N));
886       
887       if (mdct_weight_shift)
888       {
889          int m;
890          for (c=0;c<C;c++)
891             for (m=mdct_weight_pos+1;m<st->mode->nbShortMdcts;m++)
892                for (i=m+c*N;i<(c+1)*N;i+=st->mode->nbShortMdcts)
893 #ifdef FIXED_POINT
894                   freq[i] = SHL32(freq[i], mdct_weight_shift);
895 #else
896                   freq[i] = (1<<mdct_weight_shift)*freq[i];
897 #endif
898       }
899       compute_inv_mdcts(st->mode, shortBlocks, freq, transient_time, transient_shift, st->out_mem);
900       /* De-emphasis and put everything back at the right place 
901          in the synthesis history */
902       if (optional_synthesis != NULL) {
903          for (c=0;c<C;c++)
904          {
905             int j;
906             for (j=0;j<N;j++)
907             {
908                celt_sig_t tmp = MAC16_32_Q15(st->out_mem[C*(MAX_PERIOD-N)+C*j+c],
909                                    preemph,st->preemph_memD[c]);
910                st->preemph_memD[c] = tmp;
911                optional_synthesis[C*j+c] = SCALEOUT(SIG2WORD16(tmp));
912             }
913          }
914       }
915    }
916
917    ec_enc_done(&enc);
918    
919    RESTORE_STACK;
920    return nbCompressedBytes;
921 }
922
923 #ifdef FIXED_POINT
924 #ifndef DISABLE_FLOAT_API
925 int celt_encode_float(CELTEncoder * restrict st, const float * pcm, float * optional_synthesis, unsigned char *compressed, int nbCompressedBytes)
926 {
927    int j, ret, C, N;
928    VARDECL(celt_int16_t, in);
929
930    if (check_encoder(st) != CELT_OK)
931       return CELT_INVALID_STATE;
932
933    if (check_mode(st->mode) != CELT_OK)
934       return CELT_INVALID_MODE;
935
936    SAVE_STACK;
937    C = CHANNELS(st->mode);
938    N = st->block_size;
939    ALLOC(in, C*N, celt_int16_t);
940
941    for (j=0;j<C*N;j++)
942      in[j] = FLOAT2INT16(pcm[j]);
943
944    if (optional_synthesis != NULL) {
945      ret=celt_encode(st,in,in,compressed,nbCompressedBytes);
946       for (j=0;j<C*N;j++)
947          optional_synthesis[j]=in[j]*(1/32768.);
948    } else {
949      ret=celt_encode(st,in,NULL,compressed,nbCompressedBytes);
950    }
951    RESTORE_STACK;
952    return ret;
953
954 }
955 #endif /*DISABLE_FLOAT_API*/
956 #else
957 int celt_encode(CELTEncoder * restrict st, const celt_int16_t * pcm, celt_int16_t * optional_synthesis, unsigned char *compressed, int nbCompressedBytes)
958 {
959    int j, ret, C, N;
960    VARDECL(celt_sig_t, in);
961
962    if (check_encoder(st) != CELT_OK)
963       return CELT_INVALID_STATE;
964
965    if (check_mode(st->mode) != CELT_OK)
966       return CELT_INVALID_MODE;
967
968    SAVE_STACK;
969    C=CHANNELS(st->mode);
970    N=st->block_size;
971    ALLOC(in, C*N, celt_sig_t);
972    for (j=0;j<C*N;j++) {
973      in[j] = SCALEOUT(pcm[j]);
974    }
975
976    if (optional_synthesis != NULL) {
977       ret = celt_encode_float(st,in,in,compressed,nbCompressedBytes);
978       for (j=0;j<C*N;j++)
979          optional_synthesis[j] = FLOAT2INT16(in[j]);
980    } else {
981       ret = celt_encode_float(st,in,NULL,compressed,nbCompressedBytes);
982    }
983    RESTORE_STACK;
984    return ret;
985 }
986 #endif
987
988 int celt_encoder_ctl(CELTEncoder * restrict st, int request, ...)
989 {
990    va_list ap;
991    
992    if (check_encoder(st) != CELT_OK)
993       return CELT_INVALID_STATE;
994
995    va_start(ap, request);
996    if ((request!=CELT_GET_MODE_REQUEST) && (check_mode(st->mode) != CELT_OK))
997      goto bad_mode;
998    switch (request)
999    {
1000       case CELT_GET_MODE_REQUEST:
1001       {
1002          const CELTMode ** value = va_arg(ap, const CELTMode**);
1003          if (value==0)
1004             goto bad_arg;
1005          *value=st->mode;
1006       }
1007       break;
1008       case CELT_SET_COMPLEXITY_REQUEST:
1009       {
1010          int value = va_arg(ap, celt_int32_t);
1011          if (value<0 || value>10)
1012             goto bad_arg;
1013          if (value<=2) {
1014             st->pitch_enabled = 0; 
1015             st->pitch_available = 0;
1016          } else {
1017               st->pitch_enabled = 1;
1018               if (st->pitch_available<1)
1019                 st->pitch_available = 1;
1020          }   
1021       }
1022       break;
1023       case CELT_SET_PREDICTION_REQUEST:
1024       {
1025          int value = va_arg(ap, celt_int32_t);
1026          if (value<0 || value>2)
1027             goto bad_arg;
1028          if (value==0)
1029          {
1030             st->force_intra   = 1;
1031             st->pitch_permitted = 0;
1032          } else if (value=1) {
1033             st->force_intra   = 0;
1034             st->pitch_permitted = 0;
1035          } else {
1036             st->force_intra   = 0;
1037             st->pitch_permitted = 1;
1038          }   
1039       }
1040       break;
1041       case CELT_SET_VBR_RATE_REQUEST:
1042       {
1043          int value = va_arg(ap, celt_int32_t);
1044          if (value<0)
1045             goto bad_arg;
1046          if (value>3072000)
1047             value = 3072000;
1048          st->VBR_rate = ((st->mode->Fs<<3)+(st->block_size>>1))/st->block_size;
1049          st->VBR_rate = ((value<<7)+(st->VBR_rate>>1))/st->VBR_rate;
1050       }
1051       break;
1052       case CELT_RESET_STATE:
1053       {
1054          const CELTMode *mode = st->mode;
1055          int C = mode->nbChannels;
1056
1057          if (st->pitch_available > 0) st->pitch_available = 1;
1058
1059          CELT_MEMSET(st->in_mem, 0, st->overlap*C);
1060          CELT_MEMSET(st->out_mem, 0, (MAX_PERIOD+st->overlap)*C);
1061
1062          CELT_MEMSET(st->oldBandE, 0, C*mode->nbEBands);
1063
1064          CELT_MEMSET(st->preemph_memE, 0, C);
1065          CELT_MEMSET(st->preemph_memD, 0, C);
1066          st->delayedIntra = 1;
1067       }
1068       break;
1069       default:
1070          goto bad_request;
1071    }
1072    va_end(ap);
1073    return CELT_OK;
1074 bad_mode:
1075   va_end(ap);
1076   return CELT_INVALID_MODE;
1077 bad_arg:
1078    va_end(ap);
1079    return CELT_BAD_ARG;
1080 bad_request:
1081    va_end(ap);
1082    return CELT_UNIMPLEMENTED;
1083 }
1084
1085 /**********************************************************************/
1086 /*                                                                    */
1087 /*                             DECODER                                */
1088 /*                                                                    */
1089 /**********************************************************************/
1090 #ifdef NEW_PLC
1091 #define DECODE_BUFFER_SIZE 2048
1092 #else
1093 #define DECODE_BUFFER_SIZE MAX_PERIOD
1094 #endif
1095
1096 #define DECODERVALID   0x4c434454
1097 #define DECODERPARTIAL 0x5444434c
1098 #define DECODERFREED   0x4c004400
1099
1100 /** Decoder state 
1101  @brief Decoder state
1102  */
1103 struct CELTDecoder {
1104    celt_uint32_t marker;
1105    const CELTMode *mode;
1106    int frame_size;
1107    int block_size;
1108    int overlap;
1109
1110    ec_byte_buffer buf;
1111    ec_enc         enc;
1112
1113    celt_sig_t * restrict preemph_memD;
1114
1115    celt_sig_t *out_mem;
1116    celt_sig_t *decode_mem;
1117
1118    celt_word16_t *oldBandE;
1119    
1120    int last_pitch_index;
1121 };
1122
1123 int check_decoder(const CELTDecoder *st) 
1124 {
1125    if (st==NULL)
1126    {
1127       celt_warning("NULL passed a decoder structure");  
1128       return CELT_INVALID_STATE;
1129    }
1130    if (st->marker == DECODERVALID)
1131       return CELT_OK;
1132    if (st->marker == DECODERFREED)
1133       celt_warning("Referencing a decoder that has already been freed");
1134    else
1135       celt_warning("This is not a valid CELT decoder structure");
1136    return CELT_INVALID_STATE;
1137 }
1138
1139 CELTDecoder *celt_decoder_create(const CELTMode *mode)
1140 {
1141    int N, C;
1142    CELTDecoder *st;
1143
1144    if (check_mode(mode) != CELT_OK)
1145       return NULL;
1146
1147    N = mode->mdctSize;
1148    C = CHANNELS(mode);
1149    st = celt_alloc(sizeof(CELTDecoder));
1150
1151    if (st==NULL)
1152       return NULL;
1153    
1154    st->marker = DECODERPARTIAL;
1155    st->mode = mode;
1156    st->frame_size = N;
1157    st->block_size = N;
1158    st->overlap = mode->overlap;
1159
1160    st->decode_mem = celt_alloc((DECODE_BUFFER_SIZE+st->overlap)*C*sizeof(celt_sig_t));
1161    st->out_mem = st->decode_mem+DECODE_BUFFER_SIZE-MAX_PERIOD;
1162    
1163    st->oldBandE = (celt_word16_t*)celt_alloc(C*mode->nbEBands*sizeof(celt_word16_t));
1164    
1165    st->preemph_memD = (celt_sig_t*)celt_alloc(C*sizeof(celt_sig_t));
1166
1167    st->last_pitch_index = 0;
1168
1169    if ((st->decode_mem!=NULL) && (st->out_mem!=NULL) && (st->oldBandE!=NULL) &&
1170        (st->preemph_memD!=NULL))
1171    {
1172       st->marker = DECODERVALID;
1173       return st;
1174    }
1175    /* If the setup fails for some reason deallocate it. */
1176    celt_decoder_destroy(st);
1177    return NULL;
1178 }
1179
1180 void celt_decoder_destroy(CELTDecoder *st)
1181 {
1182    if (st == NULL)
1183    {
1184       celt_warning("NULL passed to celt_decoder_destroy");
1185       return;
1186    }
1187
1188    if (st->marker == DECODERFREED) 
1189    {
1190       celt_warning("Freeing a decoder which has already been freed"); 
1191       return;
1192    }
1193    
1194    if (st->marker != DECODERVALID && st->marker != DECODERPARTIAL)
1195    {
1196       celt_warning("This is not a valid CELT decoder structure");
1197       return;
1198    }
1199    
1200    /*Check_mode is non-fatal here because we can still free
1201      the encoder memory even if the mode is bad, although calling
1202      the free functions in this order is a violation of the API.*/
1203    check_mode(st->mode);
1204    
1205    celt_free(st->decode_mem);
1206    celt_free(st->oldBandE);
1207    celt_free(st->preemph_memD);
1208    
1209    st->marker = DECODERFREED;
1210    
1211    celt_free(st);
1212 }
1213
1214 /** Handles lost packets by just copying past data with the same
1215     offset as the last
1216     pitch period */
1217 #ifdef NEW_PLC
1218 #include "plc.c"
1219 #else
1220 static void celt_decode_lost(CELTDecoder * restrict st, celt_word16_t * restrict pcm)
1221 {
1222    int c, N;
1223    int pitch_index;
1224    int i, len;
1225    VARDECL(celt_sig_t, freq);
1226    const int C = CHANNELS(st->mode);
1227    int offset;
1228    SAVE_STACK;
1229    N = st->block_size;
1230    ALLOC(freq,C*N, celt_sig_t); /**< Interleaved signal MDCTs */
1231    
1232    len = N+st->mode->overlap;
1233 #if 0
1234    pitch_index = st->last_pitch_index;
1235    
1236    /* Use the pitch MDCT as the "guessed" signal */
1237    compute_mdcts(st->mode, st->mode->window, st->out_mem+pitch_index*C, freq);
1238
1239 #else
1240    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);
1241    pitch_index = MAX_PERIOD-len-pitch_index;
1242    offset = MAX_PERIOD-pitch_index;
1243    while (offset+len >= MAX_PERIOD)
1244       offset -= pitch_index;
1245    compute_mdcts(st->mode, 0, st->out_mem+offset*C, freq);
1246    for (i=0;i<C*N;i++)
1247       freq[i] = ADD32(EPSILON, MULT16_32_Q15(QCONST16(.9f,15),freq[i]));
1248 #endif
1249    
1250    
1251    
1252    CELT_MOVE(st->out_mem, st->out_mem+C*N, C*(MAX_PERIOD+st->mode->overlap-N));
1253    /* Compute inverse MDCTs */
1254    compute_inv_mdcts(st->mode, 0, freq, -1, 0, st->out_mem);
1255
1256    for (c=0;c<C;c++)
1257    {
1258       int j;
1259       for (j=0;j<N;j++)
1260       {
1261          celt_sig_t tmp = MAC16_32_Q15(st->out_mem[C*(MAX_PERIOD-N)+C*j+c],
1262                                 preemph,st->preemph_memD[c]);
1263          st->preemph_memD[c] = tmp;
1264          pcm[C*j+c] = SCALEOUT(SIG2WORD16(tmp));
1265       }
1266    }
1267    RESTORE_STACK;
1268 }
1269 #endif
1270
1271 #ifdef FIXED_POINT
1272 int celt_decode(CELTDecoder * restrict st, const unsigned char *data, int len, celt_int16_t * restrict pcm)
1273 {
1274 #else
1275 int celt_decode_float(CELTDecoder * restrict st, const unsigned char *data, int len, celt_sig_t * restrict pcm)
1276 {
1277 #endif
1278    int i, c, N, N4;
1279    int has_pitch, has_fold;
1280    int pitch_index;
1281    int bits;
1282    ec_dec dec;
1283    ec_byte_buffer buf;
1284    VARDECL(celt_sig_t, freq);
1285    VARDECL(celt_norm_t, X);
1286    VARDECL(celt_norm_t, P);
1287    VARDECL(celt_ener_t, bandE);
1288    VARDECL(celt_pgain_t, gains);
1289    VARDECL(int, fine_quant);
1290    VARDECL(int, pulses);
1291    VARDECL(int, offsets);
1292    VARDECL(int, fine_priority);
1293
1294    int shortBlocks;
1295    int intra_ener;
1296    int transient_time;
1297    int transient_shift;
1298    int mdct_weight_shift=0;
1299    const int C = CHANNELS(st->mode);
1300    int mdct_weight_pos=0;
1301    SAVE_STACK;
1302
1303    if (check_decoder(st) != CELT_OK)
1304       return CELT_INVALID_STATE;
1305
1306    if (check_mode(st->mode) != CELT_OK)
1307       return CELT_INVALID_MODE;
1308
1309    N = st->block_size;
1310    N4 = (N-st->overlap)>>1;
1311
1312    ALLOC(freq, C*N, celt_sig_t); /**< Interleaved signal MDCTs */
1313    ALLOC(X, C*N, celt_norm_t);   /**< Interleaved normalised MDCTs */
1314    ALLOC(P, C*N, celt_norm_t);   /**< Interleaved normalised pitch MDCTs*/
1315    ALLOC(bandE, st->mode->nbEBands*C, celt_ener_t);
1316    ALLOC(gains, st->mode->nbPBands, celt_pgain_t);
1317    
1318    if (data == NULL)
1319    {
1320       celt_decode_lost(st, pcm);
1321       RESTORE_STACK;
1322       return 0;
1323    }
1324    if (len<0) {
1325      RESTORE_STACK;
1326      return CELT_BAD_ARG;
1327    }
1328    
1329    ec_byte_readinit(&buf,(unsigned char*)data,len);
1330    ec_dec_init(&dec,&buf);
1331    
1332    decode_flags(&dec, &intra_ener, &has_pitch, &shortBlocks, &has_fold);
1333    if (shortBlocks)
1334    {
1335       transient_shift = ec_dec_bits(&dec, 2);
1336       if (transient_shift == 3)
1337       {
1338          transient_time = ec_dec_uint(&dec, N+st->mode->overlap);
1339       } else {
1340          mdct_weight_shift = transient_shift;
1341          if (mdct_weight_shift && st->mode->nbShortMdcts>2)
1342             mdct_weight_pos = ec_dec_uint(&dec, st->mode->nbShortMdcts-1);
1343          transient_shift = 0;
1344          transient_time = 0;
1345       }
1346    } else {
1347       transient_time = -1;
1348       transient_shift = 0;
1349    }
1350    
1351    if (has_pitch)
1352    {
1353       pitch_index = ec_dec_uint(&dec, MAX_PERIOD-(2*N-2*N4));
1354       st->last_pitch_index = pitch_index;
1355    } else {
1356       pitch_index = 0;
1357       for (i=0;i<st->mode->nbPBands;i++)
1358          gains[i] = 0;
1359    }
1360
1361    ALLOC(fine_quant, st->mode->nbEBands, int);
1362    /* Get band energies */
1363    unquant_coarse_energy(st->mode, bandE, st->oldBandE, len*8/3, intra_ener, st->mode->prob, &dec);
1364    
1365    ALLOC(pulses, st->mode->nbEBands, int);
1366    ALLOC(offsets, st->mode->nbEBands, int);
1367    ALLOC(fine_priority, st->mode->nbEBands, int);
1368
1369    for (i=0;i<st->mode->nbEBands;i++)
1370       offsets[i] = 0;
1371
1372    bits = len*8 - ec_dec_tell(&dec, 0) - 1;
1373    if (has_pitch)
1374       bits -= st->mode->nbPBands;
1375    compute_allocation(st->mode, offsets, bits, pulses, fine_quant, fine_priority);
1376    /*bits = ec_dec_tell(&dec, 0);
1377    compute_fine_allocation(st->mode, fine_quant, (20*C+len*8/5-(ec_dec_tell(&dec, 0)-bits))/C);*/
1378    
1379    unquant_fine_energy(st->mode, bandE, st->oldBandE, fine_quant, &dec);
1380
1381
1382    if (has_pitch) 
1383    {
1384       VARDECL(celt_ener_t, bandEp);
1385       
1386       /* Pitch MDCT */
1387       compute_mdcts(st->mode, 0, st->out_mem+pitch_index*C, freq);
1388       ALLOC(bandEp, st->mode->nbEBands*C, celt_ener_t);
1389       compute_band_energies(st->mode, freq, bandEp);
1390       normalise_bands(st->mode, freq, P, bandEp);
1391       /* Apply pitch gains */
1392    } else {
1393       for (i=0;i<C*N;i++)
1394          P[i] = 0;
1395    }
1396
1397    /* Decode fixed codebook and merge with pitch */
1398    if (C==1)
1399       unquant_bands(st->mode, X, P, has_pitch, gains, bandE, pulses, shortBlocks, has_fold, len*8, &dec);
1400 #ifndef DISABLE_STEREO
1401    else
1402       unquant_bands_stereo(st->mode, X, P, has_pitch, gains, bandE, pulses, shortBlocks, has_fold, len*8, &dec);
1403 #endif
1404    unquant_energy_finalise(st->mode, bandE, st->oldBandE, fine_quant, fine_priority, len*8-ec_dec_tell(&dec, 0), &dec);
1405    
1406    /* Synthesis */
1407    denormalise_bands(st->mode, X, freq, bandE);
1408
1409
1410    CELT_MOVE(st->decode_mem, st->decode_mem+C*N, C*(DECODE_BUFFER_SIZE+st->overlap-N));
1411    if (mdct_weight_shift)
1412    {
1413       int m;
1414       for (c=0;c<C;c++)
1415          for (m=mdct_weight_pos+1;m<st->mode->nbShortMdcts;m++)
1416             for (i=m+c*N;i<(c+1)*N;i+=st->mode->nbShortMdcts)
1417 #ifdef FIXED_POINT
1418                freq[i] = SHL32(freq[i], mdct_weight_shift);
1419 #else
1420                freq[i] = (1<<mdct_weight_shift)*freq[i];
1421 #endif
1422    }
1423    /* Compute inverse MDCTs */
1424    compute_inv_mdcts(st->mode, shortBlocks, freq, transient_time, transient_shift, st->out_mem);
1425
1426    for (c=0;c<C;c++)
1427    {
1428       int j;
1429       for (j=0;j<N;j++)
1430       {
1431          celt_sig_t tmp = MAC16_32_Q15(st->out_mem[C*(MAX_PERIOD-N)+C*j+c],
1432                                 preemph,st->preemph_memD[c]);
1433          st->preemph_memD[c] = tmp;
1434          pcm[C*j+c] = SCALEOUT(SIG2WORD16(tmp));
1435       }
1436    }
1437
1438    RESTORE_STACK;
1439    return 0;
1440    /*printf ("\n");*/
1441 }
1442
1443 #ifdef FIXED_POINT
1444 #ifndef DISABLE_FLOAT_API
1445 int celt_decode_float(CELTDecoder * restrict st, const unsigned char *data, int len, float * restrict pcm)
1446 {
1447    int j, ret, C, N;
1448    VARDECL(celt_int16_t, out);
1449
1450    if (check_decoder(st) != CELT_OK)
1451       return CELT_INVALID_STATE;
1452
1453    if (check_mode(st->mode) != CELT_OK)
1454       return CELT_INVALID_MODE;
1455
1456    SAVE_STACK;
1457    C = CHANNELS(st->mode);
1458    N = st->block_size;
1459    ALLOC(out, C*N, celt_int16_t);
1460
1461    ret=celt_decode(st, data, len, out);
1462
1463    for (j=0;j<C*N;j++)
1464      pcm[j]=out[j]*(1/32768.);
1465    RESTORE_STACK;
1466    return ret;
1467 }
1468 #endif /*DISABLE_FLOAT_API*/
1469 #else
1470 int celt_decode(CELTDecoder * restrict st, const unsigned char *data, int len, celt_int16_t * restrict pcm)
1471 {
1472    int j, ret, C, N;
1473    VARDECL(celt_sig_t, out);
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    SAVE_STACK;
1482    C = CHANNELS(st->mode);
1483    N = st->block_size;
1484    ALLOC(out, C*N, celt_sig_t);
1485
1486    ret=celt_decode_float(st, data, len, out);
1487
1488    for (j=0;j<C*N;j++)
1489      pcm[j] = FLOAT2INT16 (out[j]);
1490
1491    RESTORE_STACK;
1492    return ret;
1493 }
1494 #endif
1495
1496 int celt_decoder_ctl(CELTDecoder * restrict st, int request, ...)
1497 {
1498    va_list ap;
1499
1500    if (check_decoder(st) != CELT_OK)
1501       return CELT_INVALID_STATE;
1502
1503    va_start(ap, request);
1504    if ((request!=CELT_GET_MODE_REQUEST) && (check_mode(st->mode) != CELT_OK))
1505      goto bad_mode;
1506    switch (request)
1507    {
1508       case CELT_GET_MODE_REQUEST:
1509       {
1510          const CELTMode ** value = va_arg(ap, const CELTMode**);
1511          if (value==0)
1512             goto bad_arg;
1513          *value=st->mode;
1514       }
1515       break;
1516       case CELT_RESET_STATE:
1517       {
1518          const CELTMode *mode = st->mode;
1519          int C = mode->nbChannels;
1520
1521          CELT_MEMSET(st->decode_mem, 0, (DECODE_BUFFER_SIZE+st->overlap)*C);
1522          CELT_MEMSET(st->oldBandE, 0, C*mode->nbEBands);
1523
1524          CELT_MEMSET(st->preemph_memD, 0, C);
1525
1526          st->last_pitch_index = 0;
1527       }
1528       break;
1529       default:
1530          goto bad_request;
1531    }
1532    va_end(ap);
1533    return CELT_OK;
1534 bad_mode:
1535   va_end(ap);
1536   return CELT_INVALID_MODE;
1537 bad_arg:
1538    va_end(ap);
1539    return CELT_BAD_ARG;
1540 bad_request:
1541       va_end(ap);
1542   return CELT_UNIMPLEMENTED;
1543 }