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