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