More simplifications from denorm pitch
[opus.git] / libcelt / celt.c
1 /* (C) 2007-2008 Jean-Marc Valin, CSIRO
2    (C) 2008 Gregory Maxwell */
3 /*
4    Redistribution and use in source and binary forms, with or without
5    modification, are permitted provided that the following conditions
6    are met:
7    
8    - Redistributions of source code must retain the above copyright
9    notice, this list of conditions and the following disclaimer.
10    
11    - Redistributions in binary form must reproduce the above copyright
12    notice, this list of conditions and the following disclaimer in the
13    documentation and/or other materials provided with the distribution.
14    
15    - Neither the name of the Xiph.org Foundation nor the names of its
16    contributors may be used to endorse or promote products derived from
17    this software without specific prior written permission.
18    
19    THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
20    ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
21    LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
22    A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR
23    CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
24    EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
25    PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
26    PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
27    LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
28    NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
29    SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
30 */
31
32 #ifdef HAVE_CONFIG_H
33 #include "config.h"
34 #endif
35
36 #define CELT_C
37
38 #include "os_support.h"
39 #include "mdct.h"
40 #include <math.h>
41 #include "celt.h"
42 #include "pitch.h"
43 #include "kiss_fftr.h"
44 #include "bands.h"
45 #include "modes.h"
46 #include "entcode.h"
47 #include "quant_bands.h"
48 #include "psy.h"
49 #include "rate.h"
50 #include "stack_alloc.h"
51 #include "mathops.h"
52 #include "float_cast.h"
53 #include <stdarg.h>
54
55 static const celt_word16_t preemph = QCONST16(0.8f,15);
56
57 #ifdef FIXED_POINT
58 static const celt_word16_t transientWindow[16] = {
59      279,  1106,  2454,  4276,  6510,  9081, 11900, 14872,
60    17896, 20868, 23687, 26258, 28492, 30314, 31662, 32489};
61 #else
62 static const float transientWindow[16] = {
63    0.0085135, 0.0337639, 0.0748914, 0.1304955, 
64    0.1986827, 0.2771308, 0.3631685, 0.4538658,
65    0.5461342, 0.6368315, 0.7228692, 0.8013173, 
66    0.8695045, 0.9251086, 0.9662361, 0.9914865};
67 #endif
68
69 #define ENCODERVALID   0x4c434554
70 #define ENCODERPARTIAL 0x5445434c
71 #define ENCODERFREED   0x4c004500
72    
73 /** Encoder state 
74  @brief Encoder state
75  */
76 struct CELTEncoder {
77    celt_uint32_t marker;
78    const CELTMode *mode;     /**< Mode used by the encoder */
79    int frame_size;
80    int block_size;
81    int overlap;
82    int channels;
83    
84    int pitch_enabled;       /* Complexity level is allowed to use pitch */
85    int pitch_permitted;     /*  Use of the LTP is permitted by the user */
86    int pitch_available;     /*  Amount of pitch buffer available */
87    int force_intra;
88    int delayedIntra;
89    celt_word16_t tonal_average;
90    int fold_decision;
91
92    int VBR_rate; /* Target number of 16th bits per frame */
93    celt_word16_t * restrict preemph_memE; 
94    celt_sig_t    * restrict preemph_memD;
95
96    celt_sig_t *in_mem;
97    celt_sig_t *out_mem;
98
99    celt_word16_t *oldBandE;
100 #ifdef EXP_PSY
101    celt_word16_t *psy_mem;
102    struct PsyDecay psy;
103 #endif
104 };
105
106 int check_encoder(const CELTEncoder *st) 
107 {
108    if (st==NULL)
109    {
110       celt_warning("NULL passed as an encoder structure");  
111       return CELT_INVALID_STATE;
112    }
113    if (st->marker == ENCODERVALID)
114       return CELT_OK;
115    if (st->marker == ENCODERFREED)
116       celt_warning("Referencing an encoder that has already been freed");
117    else
118       celt_warning("This is not a valid CELT encoder structure");
119    return CELT_INVALID_STATE;
120 }
121
122 CELTEncoder *celt_encoder_create(const CELTMode *mode)
123 {
124    int N, C;
125    CELTEncoder *st;
126
127    if (check_mode(mode) != CELT_OK)
128       return NULL;
129
130    N = mode->mdctSize;
131    C = mode->nbChannels;
132    st = celt_alloc(sizeof(CELTEncoder));
133    
134    if (st==NULL) 
135       return NULL;   
136    st->marker = ENCODERPARTIAL;
137    st->mode = mode;
138    st->frame_size = N;
139    st->block_size = N;
140    st->overlap = mode->overlap;
141
142    st->VBR_rate = 0;
143    st->pitch_enabled = 1;
144    st->pitch_permitted = 1;
145    st->pitch_available = 1;
146    st->force_intra  = 0;
147    st->delayedIntra = 1;
148    st->tonal_average = QCONST16(1.,8);
149    st->fold_decision = 1;
150
151    st->in_mem = celt_alloc(st->overlap*C*sizeof(celt_sig_t));
152    st->out_mem = celt_alloc((MAX_PERIOD+st->overlap)*C*sizeof(celt_sig_t));
153
154    st->oldBandE = (celt_word16_t*)celt_alloc(C*mode->nbEBands*sizeof(celt_word16_t));
155
156    st->preemph_memE = (celt_word16_t*)celt_alloc(C*sizeof(celt_word16_t));
157    st->preemph_memD = (celt_sig_t*)celt_alloc(C*sizeof(celt_sig_t));
158
159 #ifdef EXP_PSY
160    st->psy_mem = celt_alloc(MAX_PERIOD*sizeof(celt_word16_t));
161    psydecay_init(&st->psy, MAX_PERIOD/2, st->mode->Fs);
162 #endif
163
164    if ((st->in_mem!=NULL) && (st->out_mem!=NULL) && (st->oldBandE!=NULL) 
165 #ifdef EXP_PSY
166        && (st->psy_mem!=NULL) 
167 #endif   
168        && (st->preemph_memE!=NULL) && (st->preemph_memD!=NULL))
169    {
170       st->marker   = ENCODERVALID;
171       return st;
172    }
173    /* If the setup fails for some reason deallocate it. */
174    celt_encoder_destroy(st);  
175    return NULL;
176 }
177
178 void celt_encoder_destroy(CELTEncoder *st)
179 {
180    if (st == NULL)
181    {
182       celt_warning("NULL passed to celt_encoder_destroy");
183       return;
184    }
185
186    if (st->marker == ENCODERFREED)
187    {
188       celt_warning("Freeing an encoder which has already been freed"); 
189       return;
190    }
191
192    if (st->marker != ENCODERVALID && st->marker != ENCODERPARTIAL)
193    {
194       celt_warning("This is not a valid CELT encoder structure");
195       return;
196    }
197    /*Check_mode is non-fatal here because we can still free
198     the encoder memory even if the mode is bad, although calling
199     the free functions in this order is a violation of the API.*/
200    check_mode(st->mode);
201    
202    celt_free(st->in_mem);
203    celt_free(st->out_mem);
204    
205    celt_free(st->oldBandE);
206    
207    celt_free(st->preemph_memE);
208    celt_free(st->preemph_memD);
209    
210 #ifdef EXP_PSY
211    celt_free (st->psy_mem);
212    psydecay_clear(&st->psy);
213 #endif
214    st->marker = ENCODERFREED;
215    
216    celt_free(st);
217 }
218
219 static inline celt_int16_t FLOAT2INT16(float x)
220 {
221    x = x*CELT_SIG_SCALE;
222    x = MAX32(x, -32768);
223    x = MIN32(x, 32767);
224    return (celt_int16_t)float2int(x);
225 }
226
227 static inline celt_word16_t SIG2WORD16(celt_sig_t x)
228 {
229 #ifdef FIXED_POINT
230    x = PSHR32(x, SIG_SHIFT);
231    x = MAX32(x, -32768);
232    x = MIN32(x, 32767);
233    return EXTRACT16(x);
234 #else
235    return (celt_word16_t)x;
236 #endif
237 }
238
239 static int transient_analysis(celt_word32_t *in, int len, int C, int *transient_time, int *transient_shift)
240 {
241    int c, i, n;
242    celt_word32_t ratio;
243    VARDECL(celt_word32_t, begin);
244    SAVE_STACK;
245    ALLOC(begin, len, celt_word32_t);
246    for (i=0;i<len;i++)
247       begin[i] = ABS32(SHR32(in[C*i],SIG_SHIFT));
248    for (c=1;c<C;c++)
249    {
250       for (i=0;i<len;i++)
251          begin[i] = MAX32(begin[i], ABS32(SHR32(in[C*i+c],SIG_SHIFT)));
252    }
253    for (i=1;i<len;i++)
254       begin[i] = MAX32(begin[i-1],begin[i]);
255    n = -1;
256    for (i=8;i<len-8;i++)
257    {
258       if (begin[i] < MULT16_32_Q15(QCONST16(.2f,15),begin[len-1]))
259          n=i;
260    }
261    if (n<32)
262    {
263       n = -1;
264       ratio = 0;
265    } else {
266       ratio = DIV32(begin[len-1],1+begin[n-16]);
267    }
268    if (ratio < 0)
269       ratio = 0;
270    if (ratio > 1000)
271       ratio = 1000;
272    ratio *= ratio;
273    
274    if (ratio > 2048)
275       *transient_shift = 3;
276    else
277       *transient_shift = 0;
278    
279    *transient_time = n;
280    
281    RESTORE_STACK;
282    return ratio > 20;
283 }
284
285 /** Apply window and compute the MDCT for all sub-frames and 
286     all channels in a frame */
287 static void compute_mdcts(const CELTMode *mode, int shortBlocks, celt_sig_t * restrict in, celt_sig_t * restrict out)
288 {
289    const int C = CHANNELS(mode);
290    if (C==1 && !shortBlocks)
291    {
292       const mdct_lookup *lookup = MDCT(mode);
293       const int overlap = OVERLAP(mode);
294       mdct_forward(lookup, in, out, mode->window, overlap);
295    } else if (!shortBlocks) {
296       const mdct_lookup *lookup = MDCT(mode);
297       const int overlap = OVERLAP(mode);
298       const int N = FRAMESIZE(mode);
299       int c;
300       VARDECL(celt_word32_t, x);
301       VARDECL(celt_word32_t, tmp);
302       SAVE_STACK;
303       ALLOC(x, N+overlap, celt_word32_t);
304       ALLOC(tmp, N, celt_word32_t);
305       for (c=0;c<C;c++)
306       {
307          int j;
308          for (j=0;j<N+overlap;j++)
309             x[j] = in[C*j+c];
310          mdct_forward(lookup, x, tmp, mode->window, overlap);
311          /* Interleaving the sub-frames */
312          for (j=0;j<N;j++)
313             out[j+c*N] = tmp[j];
314       }
315       RESTORE_STACK;
316    } else {
317       const mdct_lookup *lookup = &mode->shortMdct;
318       const int overlap = mode->overlap;
319       const int N = mode->shortMdctSize;
320       int b, c;
321       VARDECL(celt_word32_t, x);
322       VARDECL(celt_word32_t, tmp);
323       SAVE_STACK;
324       ALLOC(x, N+overlap, celt_word32_t);
325       ALLOC(tmp, N, celt_word32_t);
326       for (c=0;c<C;c++)
327       {
328          int B = mode->nbShortMdcts;
329          for (b=0;b<B;b++)
330          {
331             int j;
332             for (j=0;j<N+overlap;j++)
333                x[j] = in[C*(b*N+j)+c];
334             mdct_forward(lookup, x, tmp, mode->window, overlap);
335             /* Interleaving the sub-frames */
336             for (j=0;j<N;j++)
337                out[(j*B+b)+c*N*B] = tmp[j];
338          }
339       }
340       RESTORE_STACK;
341    }
342 }
343
344 /** Compute the IMDCT and apply window for all sub-frames and 
345     all channels in a frame */
346 static void compute_inv_mdcts(const CELTMode *mode, int shortBlocks, celt_sig_t *X, int transient_time, int transient_shift, celt_sig_t * restrict out_mem)
347 {
348    int c, N4;
349    const int C = CHANNELS(mode);
350    const int N = FRAMESIZE(mode);
351    const int overlap = OVERLAP(mode);
352    N4 = (N-overlap)>>1;
353    for (c=0;c<C;c++)
354    {
355       int j;
356       if (transient_shift==0 && C==1 && !shortBlocks) {
357          const mdct_lookup *lookup = MDCT(mode);
358          mdct_backward(lookup, X, out_mem+C*(MAX_PERIOD-N-N4), mode->window, overlap);
359       } else if (!shortBlocks) {
360          const mdct_lookup *lookup = MDCT(mode);
361          VARDECL(celt_word32_t, x);
362          VARDECL(celt_word32_t, tmp);
363          SAVE_STACK;
364          ALLOC(x, 2*N, celt_word32_t);
365          ALLOC(tmp, N, celt_word32_t);
366          /* De-interleaving the sub-frames */
367          for (j=0;j<N;j++)
368             tmp[j] = X[j+c*N];
369          /* Prevents problems from the imdct doing the overlap-add */
370          CELT_MEMSET(x+N4, 0, N);
371          mdct_backward(lookup, tmp, x, mode->window, overlap);
372          celt_assert(transient_shift == 0);
373          /* The first and last part would need to be set to zero if we actually
374             wanted to use them. */
375          for (j=0;j<overlap;j++)
376             out_mem[C*(MAX_PERIOD-N)+C*j+c] += x[j+N4];
377          for (j=0;j<overlap;j++)
378             out_mem[C*(MAX_PERIOD)+C*(overlap-j-1)+c] = x[2*N-j-N4-1];
379          for (j=0;j<2*N4;j++)
380             out_mem[C*(MAX_PERIOD-N)+C*(j+overlap)+c] = x[j+N4+overlap];
381          RESTORE_STACK;
382       } else {
383          int b;
384          const int N2 = mode->shortMdctSize;
385          const int B = mode->nbShortMdcts;
386          const mdct_lookup *lookup = &mode->shortMdct;
387          VARDECL(celt_word32_t, x);
388          VARDECL(celt_word32_t, tmp);
389          SAVE_STACK;
390          ALLOC(x, 2*N, celt_word32_t);
391          ALLOC(tmp, N, celt_word32_t);
392          /* Prevents problems from the imdct doing the overlap-add */
393          CELT_MEMSET(x+N4, 0, N2);
394          for (b=0;b<B;b++)
395          {
396             /* De-interleaving the sub-frames */
397             for (j=0;j<N2;j++)
398                tmp[j] = X[(j*B+b)+c*N2*B];
399             mdct_backward(lookup, tmp, x+N4+N2*b, mode->window, overlap);
400          }
401          if (transient_shift > 0)
402          {
403 #ifdef FIXED_POINT
404             for (j=0;j<16;j++)
405                x[N4+transient_time+j-16] = MULT16_32_Q15(SHR16(Q15_ONE-transientWindow[j],transient_shift)+transientWindow[j], SHL32(x[N4+transient_time+j-16],transient_shift));
406             for (j=transient_time;j<N+overlap;j++)
407                x[N4+j] = SHL32(x[N4+j], transient_shift);
408 #else
409             for (j=0;j<16;j++)
410                x[N4+transient_time+j-16] *= 1+transientWindow[j]*((1<<transient_shift)-1);
411             for (j=transient_time;j<N+overlap;j++)
412                x[N4+j] *= 1<<transient_shift;
413 #endif
414          }
415          /* The first and last part would need to be set to zero 
416             if we actually wanted to use them. */
417          for (j=0;j<overlap;j++)
418             out_mem[C*(MAX_PERIOD-N)+C*j+c] += x[j+N4];
419          for (j=0;j<overlap;j++)
420             out_mem[C*(MAX_PERIOD)+C*(overlap-j-1)+c] = x[2*N-j-N4-1];
421          for (j=0;j<2*N4;j++)
422             out_mem[C*(MAX_PERIOD-N)+C*(j+overlap)+c] = x[j+N4+overlap];
423          RESTORE_STACK;
424       }
425    }
426 }
427
428 #define FLAG_NONE        0
429 #define FLAG_INTRA       (1U<<13)
430 #define FLAG_PITCH       (1U<<12)
431 #define FLAG_SHORT       (1U<<11)
432 #define FLAG_FOLD        (1U<<10)
433 #define FLAG_MASK        (FLAG_INTRA|FLAG_PITCH|FLAG_SHORT|FLAG_FOLD)
434
435 int flaglist[8] = {
436       0 /*00  */ | FLAG_FOLD,
437       1 /*01  */ | FLAG_PITCH|FLAG_FOLD,
438       8 /*1000*/ | FLAG_NONE,
439       9 /*1001*/ | FLAG_SHORT|FLAG_FOLD,
440      10 /*1010*/ | FLAG_PITCH,
441      11 /*1011*/ | FLAG_INTRA,
442       6 /*110 */ | FLAG_INTRA|FLAG_FOLD,
443       7 /*111 */ | FLAG_INTRA|FLAG_SHORT|FLAG_FOLD
444 };
445
446 void encode_flags(ec_enc *enc, int intra_ener, int has_pitch, int shortBlocks, int has_fold)
447 {
448    int i;
449    int flags=FLAG_NONE;
450    int flag_bits;
451    flags |= intra_ener   ? FLAG_INTRA : 0;
452    flags |= has_pitch    ? FLAG_PITCH : 0;
453    flags |= shortBlocks  ? FLAG_SHORT : 0;
454    flags |= has_fold     ? FLAG_FOLD  : 0;
455    for (i=0;i<8;i++)
456       if (flags == (flaglist[i]&FLAG_MASK))
457          break;
458    celt_assert(i<8);
459    flag_bits = flaglist[i]&0xf;
460    /*printf ("enc %d: %d %d %d %d\n", flag_bits, intra_ener, has_pitch, shortBlocks, has_fold);*/
461    if (i<2)
462       ec_enc_uint(enc, flag_bits, 4);
463    else if (i<6)
464       ec_enc_uint(enc, flag_bits, 16);
465    else
466       ec_enc_uint(enc, flag_bits, 8);
467 }
468
469 void decode_flags(ec_dec *dec, int *intra_ener, int *has_pitch, int *shortBlocks, int *has_fold)
470 {
471    int i;
472    int flag_bits;
473    flag_bits = ec_dec_uint(dec, 4);
474    /*printf ("(%d) ", flag_bits);*/
475    if (flag_bits==2)
476       flag_bits = (flag_bits<<2) | ec_dec_uint(dec, 4);
477    else if (flag_bits==3)
478       flag_bits = (flag_bits<<1) | ec_dec_uint(dec, 2);
479    for (i=0;i<8;i++)
480       if (flag_bits == (flaglist[i]&0xf))
481          break;
482    celt_assert(i<8);
483    *intra_ener  = (flaglist[i]&FLAG_INTRA) != 0;
484    *has_pitch   = (flaglist[i]&FLAG_PITCH) != 0;
485    *shortBlocks = (flaglist[i]&FLAG_SHORT) != 0;
486    *has_fold    = (flaglist[i]&FLAG_FOLD ) != 0;
487    /*printf ("dec %d: %d %d %d %d\n", flag_bits, *intra_ener, *has_pitch, *shortBlocks, *has_fold);*/
488 }
489
490 #ifdef FIXED_POINT
491 int celt_encode(CELTEncoder * restrict st, const celt_int16_t * pcm, celt_int16_t * optional_synthesis, unsigned char *compressed, int nbCompressedBytes)
492 {
493 #else
494 int celt_encode_float(CELTEncoder * restrict st, const celt_sig_t * pcm, celt_sig_t * optional_synthesis, unsigned char *compressed, int nbCompressedBytes)
495 {
496 #endif
497    int i, c, N, N4;
498    int has_pitch;
499    int pitch_index;
500    int bits;
501    int has_fold=1;
502    unsigned coarse_needed;
503    ec_byte_buffer buf;
504    ec_enc         enc;
505    VARDECL(celt_sig_t, in);
506    VARDECL(celt_sig_t, freq);
507    VARDECL(celt_sig_t, pitch_freq);
508    VARDECL(celt_norm_t, X);
509    VARDECL(celt_norm_t, P);
510    VARDECL(celt_ener_t, bandE);
511    VARDECL(celt_word16_t, bandLogE);
512    VARDECL(int, fine_quant);
513    VARDECL(celt_word16_t, error);
514    VARDECL(int, pulses);
515    VARDECL(int, offsets);
516    VARDECL(int, fine_priority);
517    int intra_ener = 0;
518    int shortBlocks=0;
519    int transient_time;
520    int transient_shift;
521    const int C = CHANNELS(st->mode);
522    int mdct_weight_shift = 0;
523    int mdct_weight_pos=0;
524    int gain_id=0;
525    int norm_rate;
526    SAVE_STACK;
527
528    if (check_encoder(st) != CELT_OK)
529       return CELT_INVALID_STATE;
530
531    if (check_mode(st->mode) != CELT_OK)
532       return CELT_INVALID_MODE;
533
534    if (nbCompressedBytes<0 || pcm==NULL)
535      return CELT_BAD_ARG; 
536
537    /* The memset is important for now in case the encoder doesn't 
538       fill up all the bytes */
539    CELT_MEMSET(compressed, 0, nbCompressedBytes);
540    ec_byte_writeinit_buffer(&buf, compressed, nbCompressedBytes);
541    ec_enc_init(&enc,&buf);
542
543    N = st->block_size;
544    N4 = (N-st->overlap)>>1;
545    ALLOC(in, 2*C*N-2*C*N4, celt_sig_t);
546
547    CELT_COPY(in, st->in_mem, C*st->overlap);
548    for (c=0;c<C;c++)
549    {
550       const celt_word16_t * restrict pcmp = pcm+c;
551       celt_sig_t * restrict inp = in+C*st->overlap+c;
552       for (i=0;i<N;i++)
553       {
554          /* Apply pre-emphasis */
555          celt_sig_t tmp = SCALEIN(SHL32(EXTEND32(*pcmp), SIG_SHIFT));
556          *inp = SUB32(tmp, SHR32(MULT16_16(preemph,st->preemph_memE[c]),3));
557          st->preemph_memE[c] = SCALEIN(*pcmp);
558          inp += C;
559          pcmp += C;
560       }
561    }
562    CELT_COPY(st->in_mem, in+C*(2*N-2*N4-st->overlap), C*st->overlap);
563
564    /* Transient handling */
565    transient_time = -1;
566    transient_shift = 0;
567    shortBlocks = 0;
568
569    if (st->mode->nbShortMdcts > 1 && transient_analysis(in, N+st->overlap, C, &transient_time, &transient_shift))
570    {
571 #ifndef FIXED_POINT
572       float gain_1;
573 #endif
574       /* Apply the inverse shaping window */
575       if (transient_shift)
576       {
577 #ifdef FIXED_POINT
578          for (c=0;c<C;c++)
579             for (i=0;i<16;i++)
580                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]);
581          for (c=0;c<C;c++)
582             for (i=transient_time;i<N+st->overlap;i++)
583                in[C*i+c] = SHR32(in[C*i+c], transient_shift);
584 #else
585          for (c=0;c<C;c++)
586             for (i=0;i<16;i++)
587                in[C*(transient_time+i-16)+c] /= 1+transientWindow[i]*((1<<transient_shift)-1);
588          gain_1 = 1./(1<<transient_shift);
589          for (c=0;c<C;c++)
590             for (i=transient_time;i<N+st->overlap;i++)
591                in[C*i+c] *= gain_1;
592 #endif
593       }
594       shortBlocks = 1;
595       has_fold = 1;
596    }
597
598    ALLOC(freq, C*N, celt_sig_t); /**< Interleaved signal MDCTs */
599    ALLOC(bandE,st->mode->nbEBands*C, celt_ener_t);
600    ALLOC(bandLogE,st->mode->nbEBands*C, celt_word16_t);
601    /* Compute MDCTs */
602    compute_mdcts(st->mode, shortBlocks, in, freq);
603
604    if (shortBlocks && !transient_shift) 
605    {
606       celt_word32_t sum[8]={1,1,1,1,1,1,1,1};
607       int m;
608       for (c=0;c<C;c++)
609       {
610          m=0;
611          do {
612             celt_word32_t tmp=0;
613             for (i=m+c*N;i<(c+1)*N;i+=st->mode->nbShortMdcts)
614                tmp += ABS32(freq[i]);
615             sum[m++] += tmp;
616          } while (m<st->mode->nbShortMdcts);
617       }
618       m=0;
619 #ifdef FIXED_POINT
620       do {
621          if (SHR32(sum[m+1],3) > sum[m])
622          {
623             mdct_weight_shift=2;
624             mdct_weight_pos = m;
625          } else if (SHR32(sum[m+1],1) > sum[m] && mdct_weight_shift < 2)
626          {
627             mdct_weight_shift=1;
628             mdct_weight_pos = m;
629          }
630          m++;
631       } while (m<st->mode->nbShortMdcts-1);
632       if (mdct_weight_shift)
633       {
634          for (c=0;c<C;c++)
635             for (m=mdct_weight_pos+1;m<st->mode->nbShortMdcts;m++)
636                for (i=m+c*N;i<(c+1)*N;i+=st->mode->nbShortMdcts)
637                   freq[i] = SHR32(freq[i],mdct_weight_shift);
638       }
639 #else
640       do {
641          if (sum[m+1] > 8*sum[m])
642          {
643             mdct_weight_shift=2;
644             mdct_weight_pos = m;
645          } else if (sum[m+1] > 2*sum[m] && mdct_weight_shift < 2)
646          {
647             mdct_weight_shift=1;
648             mdct_weight_pos = m;
649          }
650          m++;
651       } while (m<st->mode->nbShortMdcts-1);
652       if (mdct_weight_shift)
653       {
654          for (c=0;c<C;c++)
655             for (m=mdct_weight_pos+1;m<st->mode->nbShortMdcts;m++)
656                for (i=m+c*N;i<(c+1)*N;i+=st->mode->nbShortMdcts)
657                   freq[i] = (1./(1<<mdct_weight_shift))*freq[i];
658       }
659 #endif
660    }
661
662    norm_rate = (nbCompressedBytes-5)*8*(celt_uint32_t)st->mode->Fs/(C*N)>>10;
663    /* Pitch analysis: we do it early to save on the peak stack space */
664    /* Don't use pitch if there isn't enough data available yet, 
665       or if we're using shortBlocks */
666    has_pitch = st->pitch_enabled && st->pitch_permitted && (N <= 512) 
667             && (st->pitch_available >= MAX_PERIOD) && (!shortBlocks)
668             && norm_rate < 50;
669    if (has_pitch)
670    {
671       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);
672    }
673
674    /* Deferred allocation after find_spectral_pitch() to reduce 
675       the peak memory usage */
676    ALLOC(X, C*N, celt_norm_t);         /**< Interleaved normalised MDCTs */
677    ALLOC(P, C*N, celt_norm_t);         /**< Interleaved normalised pitch MDCTs*/
678
679    ALLOC(pitch_freq, C*N, celt_sig_t); /**< Interleaved signal MDCTs */
680    if (has_pitch)
681    {
682       
683       compute_mdcts(st->mode, 0, st->out_mem+pitch_index*C, pitch_freq);
684       has_pitch = compute_new_pitch(st->mode, freq, pitch_freq, norm_rate, &gain_id);
685    }
686    
687    if (has_pitch)
688       apply_new_pitch(st->mode, freq, pitch_freq, gain_id, 1);
689
690    compute_band_energies(st->mode, freq, bandE);
691    for (i=0;i<st->mode->nbEBands*C;i++)
692       bandLogE[i] = amp2Log(bandE[i]);
693    
694    /* Band normalisation */
695    normalise_bands(st->mode, freq, X, bandE);
696    if (!shortBlocks && !folding_decision(st->mode, X, &st->tonal_average, &st->fold_decision))
697       has_fold = 0;
698
699    /* Don't use intra energy when we're operating at low bit-rate */
700    intra_ener = st->force_intra || (!has_pitch && st->delayedIntra && nbCompressedBytes > st->mode->nbEBands);
701    if (shortBlocks || intra_decision(bandLogE, st->oldBandE, st->mode->nbEBands))
702       st->delayedIntra = 1;
703    else
704       st->delayedIntra = 0;
705
706
707    encode_flags(&enc, intra_ener, has_pitch, shortBlocks, has_fold);
708    if (has_pitch)
709    {
710       ec_enc_uint(&enc, pitch_index, MAX_PERIOD-(2*N-2*N4));
711       ec_enc_uint(&enc, gain_id, 16);
712    } else {
713       for (i=0;i<C*N;i++)
714          P[i] = 0;
715    }
716    if (shortBlocks)
717    {
718       if (transient_shift)
719       {
720          ec_enc_uint(&enc, transient_shift, 4);
721          ec_enc_uint(&enc, transient_time, N+st->overlap);
722       } else {
723          ec_enc_uint(&enc, mdct_weight_shift, 4);
724          if (mdct_weight_shift && st->mode->nbShortMdcts!=2)
725             ec_enc_uint(&enc, mdct_weight_pos, st->mode->nbShortMdcts-1);
726       }
727    }
728
729    ALLOC(fine_quant, st->mode->nbEBands, int);
730    ALLOC(pulses, st->mode->nbEBands, int);
731
732    /* Bit allocation */
733    ALLOC(error, C*st->mode->nbEBands, celt_word16_t);
734    coarse_needed = quant_coarse_energy(st->mode, bandLogE, st->oldBandE, nbCompressedBytes*8/3, intra_ener, st->mode->prob, error, &enc);
735    coarse_needed = ((coarse_needed*3-1)>>3)+1;
736
737    /* Variable bitrate */
738    if (st->VBR_rate>0)
739    {
740      /* The target rate in 16th bits per frame */
741      int target=st->VBR_rate;
742    
743      /* Shortblocks get a large boost in bitrate, but since they 
744         are uncommon long blocks are not greatly effected */
745      if (shortBlocks)
746        target*=2;
747      else if (st->mode->nbShortMdcts > 1)
748        target-=(target+14)/28;     
749
750      /* The average energy is removed from the target and the actual 
751         energy added*/
752      target=target-588+ec_enc_tell(&enc, BITRES);
753
754      /* In VBR mode the frame size must not be reduced so much that it would result in the coarse energy busting its budget */
755      target=IMAX(coarse_needed,(target+64)/128);
756      nbCompressedBytes=IMIN(nbCompressedBytes,target);
757      ec_byte_shrink(&buf, nbCompressedBytes);
758    }
759
760    ALLOC(offsets, st->mode->nbEBands, int);
761    ALLOC(fine_priority, st->mode->nbEBands, int);
762
763    for (i=0;i<st->mode->nbEBands;i++)
764       offsets[i] = 0;
765    bits = nbCompressedBytes*8 - ec_enc_tell(&enc, 0) - 1;
766    compute_allocation(st->mode, offsets, bits, pulses, fine_quant, fine_priority);
767
768    quant_fine_energy(st->mode, bandE, st->oldBandE, error, fine_quant, &enc);
769
770    /* Residual quantisation */
771    if (C==1)
772       quant_bands(st->mode, X, P, bandE, pulses, shortBlocks, has_fold, nbCompressedBytes*8, &enc);
773 #ifndef DISABLE_STEREO
774    else
775       quant_bands_stereo(st->mode, X, P, bandE, pulses, shortBlocks, has_fold, nbCompressedBytes*8, &enc);
776 #endif
777
778    quant_energy_finalise(st->mode, bandE, st->oldBandE, error, fine_quant, fine_priority, nbCompressedBytes*8-ec_enc_tell(&enc, 0), &enc);
779
780    /* Re-synthesis of the coded audio if required */
781    if (st->pitch_available>0 || optional_synthesis!=NULL)
782    {
783       if (st->pitch_available>0 && st->pitch_available<MAX_PERIOD)
784         st->pitch_available+=st->frame_size;
785
786       /* Synthesis */
787       denormalise_bands(st->mode, X, freq, bandE);
788       
789       
790       CELT_MOVE(st->out_mem, st->out_mem+C*N, C*(MAX_PERIOD+st->overlap-N));
791       
792       if (mdct_weight_shift)
793       {
794          int m;
795          for (c=0;c<C;c++)
796             for (m=mdct_weight_pos+1;m<st->mode->nbShortMdcts;m++)
797                for (i=m+c*N;i<(c+1)*N;i+=st->mode->nbShortMdcts)
798 #ifdef FIXED_POINT
799                   freq[i] = SHL32(freq[i], mdct_weight_shift);
800 #else
801                   freq[i] = (1<<mdct_weight_shift)*freq[i];
802 #endif
803       }
804       if (has_pitch)
805          apply_new_pitch(st->mode, freq, pitch_freq, gain_id, 0);
806       
807       compute_inv_mdcts(st->mode, shortBlocks, freq, transient_time, transient_shift, st->out_mem);
808       /* De-emphasis and put everything back at the right place 
809          in the synthesis history */
810       if (optional_synthesis != NULL) {
811          for (c=0;c<C;c++)
812          {
813             int j;
814             for (j=0;j<N;j++)
815             {
816                celt_sig_t tmp = MAC16_32_Q15(st->out_mem[C*(MAX_PERIOD-N)+C*j+c],
817                                    preemph,st->preemph_memD[c]);
818                st->preemph_memD[c] = tmp;
819                optional_synthesis[C*j+c] = SCALEOUT(SIG2WORD16(tmp));
820             }
821          }
822       }
823    }
824
825    ec_enc_done(&enc);
826    
827    RESTORE_STACK;
828    return nbCompressedBytes;
829 }
830
831 #ifdef FIXED_POINT
832 #ifndef DISABLE_FLOAT_API
833 int celt_encode_float(CELTEncoder * restrict st, const float * pcm, float * optional_synthesis, unsigned char *compressed, int nbCompressedBytes)
834 {
835    int j, ret, C, N;
836    VARDECL(celt_int16_t, in);
837    SAVE_STACK;
838
839    if (check_encoder(st) != CELT_OK)
840       return CELT_INVALID_STATE;
841
842    if (check_mode(st->mode) != CELT_OK)
843       return CELT_INVALID_MODE;
844
845    if (pcm==NULL)
846       return CELT_BAD_ARG;
847
848    C = CHANNELS(st->mode);
849    N = st->block_size;
850    ALLOC(in, C*N, celt_int16_t);
851
852    for (j=0;j<C*N;j++)
853      in[j] = FLOAT2INT16(pcm[j]);
854
855    if (optional_synthesis != NULL) {
856      ret=celt_encode(st,in,in,compressed,nbCompressedBytes);
857       for (j=0;j<C*N;j++)
858          optional_synthesis[j]=in[j]*(1/32768.);
859    } else {
860      ret=celt_encode(st,in,NULL,compressed,nbCompressedBytes);
861    }
862    RESTORE_STACK;
863    return ret;
864
865 }
866 #endif /*DISABLE_FLOAT_API*/
867 #else
868 int celt_encode(CELTEncoder * restrict st, const celt_int16_t * pcm, celt_int16_t * optional_synthesis, unsigned char *compressed, int nbCompressedBytes)
869 {
870    int j, ret, C, N;
871    VARDECL(celt_sig_t, in);
872    SAVE_STACK;
873
874    if (check_encoder(st) != CELT_OK)
875       return CELT_INVALID_STATE;
876
877    if (check_mode(st->mode) != CELT_OK)
878       return CELT_INVALID_MODE;
879
880    if (pcm==NULL)
881       return CELT_BAD_ARG;
882
883    C=CHANNELS(st->mode);
884    N=st->block_size;
885    ALLOC(in, C*N, celt_sig_t);
886    for (j=0;j<C*N;j++) {
887      in[j] = SCALEOUT(pcm[j]);
888    }
889
890    if (optional_synthesis != NULL) {
891       ret = celt_encode_float(st,in,in,compressed,nbCompressedBytes);
892       for (j=0;j<C*N;j++)
893          optional_synthesis[j] = FLOAT2INT16(in[j]);
894    } else {
895       ret = celt_encode_float(st,in,NULL,compressed,nbCompressedBytes);
896    }
897    RESTORE_STACK;
898    return ret;
899 }
900 #endif
901
902 int celt_encoder_ctl(CELTEncoder * restrict st, int request, ...)
903 {
904    va_list ap;
905    
906    if (check_encoder(st) != CELT_OK)
907       return CELT_INVALID_STATE;
908
909    va_start(ap, request);
910    if ((request!=CELT_GET_MODE_REQUEST) && (check_mode(st->mode) != CELT_OK))
911      goto bad_mode;
912    switch (request)
913    {
914       case CELT_GET_MODE_REQUEST:
915       {
916          const CELTMode ** value = va_arg(ap, const CELTMode**);
917          if (value==0)
918             goto bad_arg;
919          *value=st->mode;
920       }
921       break;
922       case CELT_SET_COMPLEXITY_REQUEST:
923       {
924          int value = va_arg(ap, celt_int32_t);
925          if (value<0 || value>10)
926             goto bad_arg;
927          if (value<=2) {
928             st->pitch_enabled = 0; 
929             st->pitch_available = 0;
930          } else {
931               st->pitch_enabled = 1;
932               if (st->pitch_available<1)
933                 st->pitch_available = 1;
934          }   
935       }
936       break;
937       case CELT_SET_PREDICTION_REQUEST:
938       {
939          int value = va_arg(ap, celt_int32_t);
940          if (value<0 || value>2)
941             goto bad_arg;
942          if (value==0)
943          {
944             st->force_intra   = 1;
945             st->pitch_permitted = 0;
946          } else if (value==1) {
947             st->force_intra   = 0;
948             st->pitch_permitted = 0;
949          } else {
950             st->force_intra   = 0;
951             st->pitch_permitted = 1;
952          }   
953       }
954       break;
955       case CELT_SET_VBR_RATE_REQUEST:
956       {
957          celt_int32_t value = va_arg(ap, celt_int32_t);
958          if (value<0)
959             goto bad_arg;
960          if (value>3072000)
961             value = 3072000;
962          st->VBR_rate = ((st->mode->Fs<<3)+(st->block_size>>1))/st->block_size;
963          st->VBR_rate = ((value<<7)+(st->VBR_rate>>1))/st->VBR_rate;
964       }
965       break;
966       case CELT_RESET_STATE:
967       {
968          const CELTMode *mode = st->mode;
969          int C = mode->nbChannels;
970
971          if (st->pitch_available > 0) st->pitch_available = 1;
972
973          CELT_MEMSET(st->in_mem, 0, st->overlap*C);
974          CELT_MEMSET(st->out_mem, 0, (MAX_PERIOD+st->overlap)*C);
975
976          CELT_MEMSET(st->oldBandE, 0, C*mode->nbEBands);
977
978          CELT_MEMSET(st->preemph_memE, 0, C);
979          CELT_MEMSET(st->preemph_memD, 0, C);
980          st->delayedIntra = 1;
981       }
982       break;
983       default:
984          goto bad_request;
985    }
986    va_end(ap);
987    return CELT_OK;
988 bad_mode:
989   va_end(ap);
990   return CELT_INVALID_MODE;
991 bad_arg:
992    va_end(ap);
993    return CELT_BAD_ARG;
994 bad_request:
995    va_end(ap);
996    return CELT_UNIMPLEMENTED;
997 }
998
999 /**********************************************************************/
1000 /*                                                                    */
1001 /*                             DECODER                                */
1002 /*                                                                    */
1003 /**********************************************************************/
1004 #ifdef NEW_PLC
1005 #define DECODE_BUFFER_SIZE 2048
1006 #else
1007 #define DECODE_BUFFER_SIZE MAX_PERIOD
1008 #endif
1009
1010 #define DECODERVALID   0x4c434454
1011 #define DECODERPARTIAL 0x5444434c
1012 #define DECODERFREED   0x4c004400
1013
1014 /** Decoder state 
1015  @brief Decoder state
1016  */
1017 struct CELTDecoder {
1018    celt_uint32_t marker;
1019    const CELTMode *mode;
1020    int frame_size;
1021    int block_size;
1022    int overlap;
1023
1024    ec_byte_buffer buf;
1025    ec_enc         enc;
1026
1027    celt_sig_t * restrict preemph_memD;
1028
1029    celt_sig_t *out_mem;
1030    celt_sig_t *decode_mem;
1031
1032    celt_word16_t *oldBandE;
1033    
1034    int last_pitch_index;
1035    int loss_count;
1036 };
1037
1038 int check_decoder(const CELTDecoder *st) 
1039 {
1040    if (st==NULL)
1041    {
1042       celt_warning("NULL passed a decoder structure");  
1043       return CELT_INVALID_STATE;
1044    }
1045    if (st->marker == DECODERVALID)
1046       return CELT_OK;
1047    if (st->marker == DECODERFREED)
1048       celt_warning("Referencing a decoder that has already been freed");
1049    else
1050       celt_warning("This is not a valid CELT decoder structure");
1051    return CELT_INVALID_STATE;
1052 }
1053
1054 CELTDecoder *celt_decoder_create(const CELTMode *mode)
1055 {
1056    int N, C;
1057    CELTDecoder *st;
1058
1059    if (check_mode(mode) != CELT_OK)
1060       return NULL;
1061
1062    N = mode->mdctSize;
1063    C = CHANNELS(mode);
1064    st = celt_alloc(sizeof(CELTDecoder));
1065
1066    if (st==NULL)
1067       return NULL;
1068    
1069    st->marker = DECODERPARTIAL;
1070    st->mode = mode;
1071    st->frame_size = N;
1072    st->block_size = N;
1073    st->overlap = mode->overlap;
1074
1075    st->decode_mem = celt_alloc((DECODE_BUFFER_SIZE+st->overlap)*C*sizeof(celt_sig_t));
1076    st->out_mem = st->decode_mem+DECODE_BUFFER_SIZE-MAX_PERIOD;
1077    
1078    st->oldBandE = (celt_word16_t*)celt_alloc(C*mode->nbEBands*sizeof(celt_word16_t));
1079    
1080    st->preemph_memD = (celt_sig_t*)celt_alloc(C*sizeof(celt_sig_t));
1081
1082    st->loss_count = 0;
1083
1084    if ((st->decode_mem!=NULL) && (st->out_mem!=NULL) && (st->oldBandE!=NULL) &&
1085        (st->preemph_memD!=NULL))
1086    {
1087       st->marker = DECODERVALID;
1088       return st;
1089    }
1090    /* If the setup fails for some reason deallocate it. */
1091    celt_decoder_destroy(st);
1092    return NULL;
1093 }
1094
1095 void celt_decoder_destroy(CELTDecoder *st)
1096 {
1097    if (st == NULL)
1098    {
1099       celt_warning("NULL passed to celt_decoder_destroy");
1100       return;
1101    }
1102
1103    if (st->marker == DECODERFREED) 
1104    {
1105       celt_warning("Freeing a decoder which has already been freed"); 
1106       return;
1107    }
1108    
1109    if (st->marker != DECODERVALID && st->marker != DECODERPARTIAL)
1110    {
1111       celt_warning("This is not a valid CELT decoder structure");
1112       return;
1113    }
1114    
1115    /*Check_mode is non-fatal here because we can still free
1116      the encoder memory even if the mode is bad, although calling
1117      the free functions in this order is a violation of the API.*/
1118    check_mode(st->mode);
1119    
1120    celt_free(st->decode_mem);
1121    celt_free(st->oldBandE);
1122    celt_free(st->preemph_memD);
1123    
1124    st->marker = DECODERFREED;
1125    
1126    celt_free(st);
1127 }
1128
1129 /** Handles lost packets by just copying past data with the same
1130     offset as the last
1131     pitch period */
1132 #ifdef NEW_PLC
1133 #include "plc.c"
1134 #else
1135 static void celt_decode_lost(CELTDecoder * restrict st, celt_word16_t * restrict pcm)
1136 {
1137    int c, N;
1138    int pitch_index;
1139    celt_word16_t fade = Q15ONE;
1140    int i, len;
1141    VARDECL(celt_sig_t, freq);
1142    const int C = CHANNELS(st->mode);
1143    int offset;
1144    SAVE_STACK;
1145    N = st->block_size;
1146    ALLOC(freq,C*N, celt_sig_t); /**< Interleaved signal MDCTs */
1147    
1148    len = N+st->mode->overlap;
1149    
1150    if (st->loss_count == 0)
1151    {
1152       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);
1153       pitch_index = MAX_PERIOD-len-pitch_index;
1154       st->last_pitch_index = pitch_index;
1155    } else {
1156       pitch_index = st->last_pitch_index;
1157       if (st->loss_count < 5)
1158          fade = QCONST16(.8f,15);
1159       else
1160          fade = 0;
1161    }
1162
1163    offset = MAX_PERIOD-pitch_index;
1164    while (offset+len >= MAX_PERIOD)
1165       offset -= pitch_index;
1166    compute_mdcts(st->mode, 0, st->out_mem+offset*C, freq);
1167    for (i=0;i<C*N;i++)
1168       freq[i] = ADD32(VERY_SMALL, MULT16_32_Q15(fade,freq[i]));
1169
1170    CELT_MOVE(st->out_mem, st->out_mem+C*N, C*(MAX_PERIOD+st->mode->overlap-N));
1171    /* Compute inverse MDCTs */
1172    compute_inv_mdcts(st->mode, 0, freq, -1, 0, st->out_mem);
1173
1174    for (c=0;c<C;c++)
1175    {
1176       int j;
1177       for (j=0;j<N;j++)
1178       {
1179          celt_sig_t tmp = MAC16_32_Q15(st->out_mem[C*(MAX_PERIOD-N)+C*j+c],
1180                                 preemph,st->preemph_memD[c]);
1181          st->preemph_memD[c] = tmp;
1182          pcm[C*j+c] = SCALEOUT(SIG2WORD16(tmp));
1183       }
1184    }
1185    
1186    st->loss_count++;
1187
1188    RESTORE_STACK;
1189 }
1190 #endif
1191
1192 #ifdef FIXED_POINT
1193 int celt_decode(CELTDecoder * restrict st, const unsigned char *data, int len, celt_int16_t * restrict pcm)
1194 {
1195 #else
1196 int celt_decode_float(CELTDecoder * restrict st, const unsigned char *data, int len, celt_sig_t * restrict pcm)
1197 {
1198 #endif
1199    int i, c, N, N4;
1200    int has_pitch, has_fold;
1201    int pitch_index;
1202    int bits;
1203    ec_dec dec;
1204    ec_byte_buffer buf;
1205    VARDECL(celt_sig_t, freq);
1206    VARDECL(celt_sig_t, pitch_freq);
1207    VARDECL(celt_norm_t, X);
1208    VARDECL(celt_norm_t, P);
1209    VARDECL(celt_ener_t, bandE);
1210    VARDECL(int, fine_quant);
1211    VARDECL(int, pulses);
1212    VARDECL(int, offsets);
1213    VARDECL(int, fine_priority);
1214
1215    int shortBlocks;
1216    int intra_ener;
1217    int transient_time;
1218    int transient_shift;
1219    int mdct_weight_shift=0;
1220    const int C = CHANNELS(st->mode);
1221    int mdct_weight_pos=0;
1222    int gain_id=0;
1223    SAVE_STACK;
1224
1225    if (check_decoder(st) != CELT_OK)
1226       return CELT_INVALID_STATE;
1227
1228    if (check_mode(st->mode) != CELT_OK)
1229       return CELT_INVALID_MODE;
1230
1231    if (pcm==NULL)
1232       return CELT_BAD_ARG;
1233
1234    N = st->block_size;
1235    N4 = (N-st->overlap)>>1;
1236
1237    ALLOC(freq, C*N, celt_sig_t); /**< Interleaved signal MDCTs */
1238    ALLOC(X, C*N, celt_norm_t);   /**< Interleaved normalised MDCTs */
1239    ALLOC(P, C*N, celt_norm_t);   /**< Interleaved normalised pitch MDCTs*/
1240    ALLOC(bandE, st->mode->nbEBands*C, celt_ener_t);
1241    
1242    if (data == NULL)
1243    {
1244       celt_decode_lost(st, pcm);
1245       RESTORE_STACK;
1246       return 0;
1247    } else {
1248       st->loss_count = 0;
1249    }
1250    if (len<0) {
1251      RESTORE_STACK;
1252      return CELT_BAD_ARG;
1253    }
1254    
1255    ec_byte_readinit(&buf,(unsigned char*)data,len);
1256    ec_dec_init(&dec,&buf);
1257    
1258    decode_flags(&dec, &intra_ener, &has_pitch, &shortBlocks, &has_fold);
1259    if (shortBlocks)
1260    {
1261       transient_shift = ec_dec_uint(&dec, 4);
1262       if (transient_shift == 3)
1263       {
1264          transient_time = ec_dec_uint(&dec, N+st->mode->overlap);
1265       } else {
1266          mdct_weight_shift = transient_shift;
1267          if (mdct_weight_shift && st->mode->nbShortMdcts>2)
1268             mdct_weight_pos = ec_dec_uint(&dec, st->mode->nbShortMdcts-1);
1269          transient_shift = 0;
1270          transient_time = 0;
1271       }
1272    } else {
1273       transient_time = -1;
1274       transient_shift = 0;
1275    }
1276    
1277    if (has_pitch)
1278    {
1279       pitch_index = ec_dec_uint(&dec, MAX_PERIOD-(2*N-2*N4));
1280       gain_id = ec_dec_uint(&dec, 16);
1281    } else {
1282       pitch_index = 0;
1283    }
1284
1285    ALLOC(fine_quant, st->mode->nbEBands, int);
1286    /* Get band energies */
1287    unquant_coarse_energy(st->mode, bandE, st->oldBandE, len*8/3, intra_ener, st->mode->prob, &dec);
1288    
1289    ALLOC(pulses, st->mode->nbEBands, int);
1290    ALLOC(offsets, st->mode->nbEBands, int);
1291    ALLOC(fine_priority, st->mode->nbEBands, int);
1292
1293    for (i=0;i<st->mode->nbEBands;i++)
1294       offsets[i] = 0;
1295
1296    bits = len*8 - ec_dec_tell(&dec, 0) - 1;
1297    compute_allocation(st->mode, offsets, bits, pulses, fine_quant, fine_priority);
1298    /*bits = ec_dec_tell(&dec, 0);
1299    compute_fine_allocation(st->mode, fine_quant, (20*C+len*8/5-(ec_dec_tell(&dec, 0)-bits))/C);*/
1300    
1301    unquant_fine_energy(st->mode, bandE, st->oldBandE, fine_quant, &dec);
1302
1303    ALLOC(pitch_freq, C*N, celt_sig_t); /**< Interleaved signal MDCTs */
1304    if (has_pitch) 
1305    {
1306       /* Pitch MDCT */
1307       compute_mdcts(st->mode, 0, st->out_mem+pitch_index*C, pitch_freq);
1308    }
1309
1310    /* Decode fixed codebook and merge with pitch */
1311    if (C==1)
1312       unquant_bands(st->mode, X, P, bandE, pulses, shortBlocks, has_fold, len*8, &dec);
1313 #ifndef DISABLE_STEREO
1314    else
1315       unquant_bands_stereo(st->mode, X, P, bandE, pulses, shortBlocks, has_fold, len*8, &dec);
1316 #endif
1317    unquant_energy_finalise(st->mode, bandE, st->oldBandE, fine_quant, fine_priority, len*8-ec_dec_tell(&dec, 0), &dec);
1318    
1319    /* Synthesis */
1320    denormalise_bands(st->mode, X, freq, bandE);
1321
1322
1323    CELT_MOVE(st->decode_mem, st->decode_mem+C*N, C*(DECODE_BUFFER_SIZE+st->overlap-N));
1324    if (mdct_weight_shift)
1325    {
1326       int m;
1327       for (c=0;c<C;c++)
1328          for (m=mdct_weight_pos+1;m<st->mode->nbShortMdcts;m++)
1329             for (i=m+c*N;i<(c+1)*N;i+=st->mode->nbShortMdcts)
1330 #ifdef FIXED_POINT
1331                freq[i] = SHL32(freq[i], mdct_weight_shift);
1332 #else
1333                freq[i] = (1<<mdct_weight_shift)*freq[i];
1334 #endif
1335    }
1336    
1337    if (has_pitch)
1338       apply_new_pitch(st->mode, freq, pitch_freq, gain_id, 0);
1339
1340    /* Compute inverse MDCTs */
1341    compute_inv_mdcts(st->mode, shortBlocks, freq, transient_time, transient_shift, st->out_mem);
1342
1343    for (c=0;c<C;c++)
1344    {
1345       int j;
1346       for (j=0;j<N;j++)
1347       {
1348          celt_sig_t tmp = MAC16_32_Q15(st->out_mem[C*(MAX_PERIOD-N)+C*j+c],
1349                                 preemph,st->preemph_memD[c]);
1350          st->preemph_memD[c] = tmp;
1351          pcm[C*j+c] = SCALEOUT(SIG2WORD16(tmp));
1352       }
1353    }
1354
1355    RESTORE_STACK;
1356    return 0;
1357 }
1358
1359 #ifdef FIXED_POINT
1360 #ifndef DISABLE_FLOAT_API
1361 int celt_decode_float(CELTDecoder * restrict st, const unsigned char *data, int len, float * restrict pcm)
1362 {
1363    int j, ret, C, N;
1364    VARDECL(celt_int16_t, out);
1365    SAVE_STACK;
1366
1367    if (check_decoder(st) != CELT_OK)
1368       return CELT_INVALID_STATE;
1369
1370    if (check_mode(st->mode) != CELT_OK)
1371       return CELT_INVALID_MODE;
1372
1373    if (pcm==NULL)
1374       return CELT_BAD_ARG;
1375
1376    C = CHANNELS(st->mode);
1377    N = st->block_size;
1378    
1379    ALLOC(out, C*N, celt_int16_t);
1380    ret=celt_decode(st, data, len, out);
1381    for (j=0;j<C*N;j++)
1382       pcm[j]=out[j]*(1/32768.);
1383      
1384    RESTORE_STACK;
1385    return ret;
1386 }
1387 #endif /*DISABLE_FLOAT_API*/
1388 #else
1389 int celt_decode(CELTDecoder * restrict st, const unsigned char *data, int len, celt_int16_t * restrict pcm)
1390 {
1391    int j, ret, C, N;
1392    VARDECL(celt_sig_t, out);
1393    SAVE_STACK;
1394
1395    if (check_decoder(st) != CELT_OK)
1396       return CELT_INVALID_STATE;
1397
1398    if (check_mode(st->mode) != CELT_OK)
1399       return CELT_INVALID_MODE;
1400
1401    if (pcm==NULL)
1402       return CELT_BAD_ARG;
1403
1404    C = CHANNELS(st->mode);
1405    N = st->block_size;
1406    ALLOC(out, C*N, celt_sig_t);
1407
1408    ret=celt_decode_float(st, data, len, out);
1409
1410    for (j=0;j<C*N;j++)
1411       pcm[j] = FLOAT2INT16 (out[j]);
1412    
1413    RESTORE_STACK;
1414    return ret;
1415 }
1416 #endif
1417
1418 int celt_decoder_ctl(CELTDecoder * restrict st, int request, ...)
1419 {
1420    va_list ap;
1421
1422    if (check_decoder(st) != CELT_OK)
1423       return CELT_INVALID_STATE;
1424
1425    va_start(ap, request);
1426    if ((request!=CELT_GET_MODE_REQUEST) && (check_mode(st->mode) != CELT_OK))
1427      goto bad_mode;
1428    switch (request)
1429    {
1430       case CELT_GET_MODE_REQUEST:
1431       {
1432          const CELTMode ** value = va_arg(ap, const CELTMode**);
1433          if (value==0)
1434             goto bad_arg;
1435          *value=st->mode;
1436       }
1437       break;
1438       case CELT_RESET_STATE:
1439       {
1440          const CELTMode *mode = st->mode;
1441          int C = mode->nbChannels;
1442
1443          CELT_MEMSET(st->decode_mem, 0, (DECODE_BUFFER_SIZE+st->overlap)*C);
1444          CELT_MEMSET(st->oldBandE, 0, C*mode->nbEBands);
1445
1446          CELT_MEMSET(st->preemph_memD, 0, C);
1447
1448          st->loss_count = 0;
1449       }
1450       break;
1451       default:
1452          goto bad_request;
1453    }
1454    va_end(ap);
1455    return CELT_OK;
1456 bad_mode:
1457   va_end(ap);
1458   return CELT_INVALID_MODE;
1459 bad_arg:
1460    va_end(ap);
1461    return CELT_BAD_ARG;
1462 bad_request:
1463       va_end(ap);
1464   return CELT_UNIMPLEMENTED;
1465 }