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