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