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