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