Re-introducing the successive rotations as a way to control low-bitrate
[opus.git] / libcelt / celt.c
1 /* (C) 2007-2008 Jean-Marc Valin, CSIRO
2    (C) 2008 Gregory Maxwell */
3 /*
4    Redistribution and use in source and binary forms, with or without
5    modification, are permitted provided that the following conditions
6    are met:
7    
8    - Redistributions of source code must retain the above copyright
9    notice, this list of conditions and the following disclaimer.
10    
11    - Redistributions in binary form must reproduce the above copyright
12    notice, this list of conditions and the following disclaimer in the
13    documentation and/or other materials provided with the distribution.
14    
15    - Neither the name of the Xiph.org Foundation nor the names of its
16    contributors may be used to endorse or promote products derived from
17    this software without specific prior written permission.
18    
19    THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
20    ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
21    LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
22    A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR
23    CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
24    EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
25    PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
26    PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
27    LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
28    NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
29    SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
30 */
31
32 #ifdef HAVE_CONFIG_H
33 #include "config.h"
34 #endif
35
36 #define CELT_C
37
38 #include "os_support.h"
39 #include "mdct.h"
40 #include <math.h>
41 #include "celt.h"
42 #include "pitch.h"
43 #include "kiss_fftr.h"
44 #include "bands.h"
45 #include "modes.h"
46 #include "entcode.h"
47 #include "quant_bands.h"
48 #include "psy.h"
49 #include "rate.h"
50 #include "stack_alloc.h"
51 #include "mathops.h"
52 #include "float_cast.h"
53 #include <stdarg.h>
54
55 static const celt_word16_t preemph = QCONST16(0.8f,15);
56
57 #ifdef FIXED_POINT
58 static const celt_word16_t transientWindow[16] = {
59      279,  1106,  2454,  4276,  6510,  9081, 11900, 14872,
60    17896, 20868, 23687, 26258, 28492, 30314, 31662, 32489};
61 #else
62 static const float transientWindow[16] = {
63    0.0085135, 0.0337639, 0.0748914, 0.1304955, 
64    0.1986827, 0.2771308, 0.3631685, 0.4538658,
65    0.5461342, 0.6368315, 0.7228692, 0.8013173, 
66    0.8695045, 0.9251086, 0.9662361, 0.9914865};
67 #endif
68
69 #define ENCODERVALID   0x4c434554
70 #define ENCODERPARTIAL 0x5445434c
71 #define ENCODERFREED   0x4c004500
72    
73 /** Encoder state 
74  @brief Encoder state
75  */
76 struct CELTEncoder {
77    celt_uint32_t marker;
78    const CELTMode *mode;     /**< Mode used by the encoder */
79    int frame_size;
80    int block_size;
81    int overlap;
82    int channels;
83    
84    int pitch_enabled;       /* Complexity level is allowed to use pitch */
85    int pitch_permitted;     /*  Use of the LTP is permitted by the user */
86    int pitch_available;     /*  Amount of pitch buffer available */
87    int force_intra;
88    int delayedIntra;
89    celt_word16_t tonal_average;
90    int fold_decision;
91
92    int VBR_rate; /* Target number of 16th bits per frame */
93    celt_word16_t * restrict preemph_memE; 
94    celt_sig_t    * restrict preemph_memD;
95
96    celt_sig_t *in_mem;
97    celt_sig_t *out_mem;
98
99    celt_word16_t *oldBandE;
100 #ifdef EXP_PSY
101    celt_word16_t *psy_mem;
102    struct PsyDecay psy;
103 #endif
104 };
105
106 int check_encoder(const CELTEncoder *st) 
107 {
108    if (st==NULL)
109    {
110       celt_warning("NULL passed as an encoder structure");  
111       return CELT_INVALID_STATE;
112    }
113    if (st->marker == ENCODERVALID)
114       return CELT_OK;
115    if (st->marker == ENCODERFREED)
116       celt_warning("Referencing an encoder that has already been freed");
117    else
118       celt_warning("This is not a valid CELT encoder structure");
119    return CELT_INVALID_STATE;
120 }
121
122 CELTEncoder *celt_encoder_create(const CELTMode *mode)
123 {
124    int N, C;
125    CELTEncoder *st;
126
127    if (check_mode(mode) != CELT_OK)
128       return NULL;
129
130    N = mode->mdctSize;
131    C = mode->nbChannels;
132    st = celt_alloc(sizeof(CELTEncoder));
133    
134    if (st==NULL) 
135       return NULL;   
136    st->marker = ENCODERPARTIAL;
137    st->mode = mode;
138    st->frame_size = N;
139    st->block_size = N;
140    st->overlap = mode->overlap;
141
142    st->VBR_rate = 0;
143    st->pitch_enabled = 1;
144    st->pitch_permitted = 1;
145    st->pitch_available = 1;
146    st->force_intra  = 0;
147    st->delayedIntra = 1;
148    st->tonal_average = QCONST16(1.,8);
149    st->fold_decision = 1;
150
151    st->in_mem = celt_alloc(st->overlap*C*sizeof(celt_sig_t));
152    st->out_mem = celt_alloc((MAX_PERIOD+st->overlap)*C*sizeof(celt_sig_t));
153
154    st->oldBandE = (celt_word16_t*)celt_alloc(C*mode->nbEBands*sizeof(celt_word16_t));
155
156    st->preemph_memE = (celt_word16_t*)celt_alloc(C*sizeof(celt_word16_t));
157    st->preemph_memD = (celt_sig_t*)celt_alloc(C*sizeof(celt_sig_t));
158
159 #ifdef EXP_PSY
160    st->psy_mem = celt_alloc(MAX_PERIOD*sizeof(celt_word16_t));
161    psydecay_init(&st->psy, MAX_PERIOD/2, st->mode->Fs);
162 #endif
163
164    if ((st->in_mem!=NULL) && (st->out_mem!=NULL) && (st->oldBandE!=NULL) 
165 #ifdef EXP_PSY
166        && (st->psy_mem!=NULL) 
167 #endif   
168        && (st->preemph_memE!=NULL) && (st->preemph_memD!=NULL))
169    {
170       st->marker   = ENCODERVALID;
171       return st;
172    }
173    /* If the setup fails for some reason deallocate it. */
174    celt_encoder_destroy(st);  
175    return NULL;
176 }
177
178 void celt_encoder_destroy(CELTEncoder *st)
179 {
180    if (st == NULL)
181    {
182       celt_warning("NULL passed to celt_encoder_destroy");
183       return;
184    }
185
186    if (st->marker == ENCODERFREED)
187    {
188       celt_warning("Freeing an encoder which has already been freed"); 
189       return;
190    }
191
192    if (st->marker != ENCODERVALID && st->marker != ENCODERPARTIAL)
193    {
194       celt_warning("This is not a valid CELT encoder structure");
195       return;
196    }
197    /*Check_mode is non-fatal here because we can still free
198     the encoder memory even if the mode is bad, although calling
199     the free functions in this order is a violation of the API.*/
200    check_mode(st->mode);
201    
202    celt_free(st->in_mem);
203    celt_free(st->out_mem);
204    
205    celt_free(st->oldBandE);
206    
207    celt_free(st->preemph_memE);
208    celt_free(st->preemph_memD);
209    
210 #ifdef EXP_PSY
211    celt_free (st->psy_mem);
212    psydecay_clear(&st->psy);
213 #endif
214    st->marker = ENCODERFREED;
215    
216    celt_free(st);
217 }
218
219 static inline celt_int16_t FLOAT2INT16(float x)
220 {
221    x = x*CELT_SIG_SCALE;
222    x = MAX32(x, -32768);
223    x = MIN32(x, 32767);
224    return (celt_int16_t)float2int(x);
225 }
226
227 static inline celt_word16_t SIG2WORD16(celt_sig_t x)
228 {
229 #ifdef FIXED_POINT
230    x = PSHR32(x, SIG_SHIFT);
231    x = MAX32(x, -32768);
232    x = MIN32(x, 32767);
233    return EXTRACT16(x);
234 #else
235    return (celt_word16_t)x;
236 #endif
237 }
238
239 static int transient_analysis(celt_word32_t *in, int len, int C, int *transient_time, int *transient_shift)
240 {
241    int c, i, n;
242    celt_word32_t ratio;
243    VARDECL(celt_word32_t, begin);
244    SAVE_STACK;
245    ALLOC(begin, len, celt_word32_t);
246    for (i=0;i<len;i++)
247       begin[i] = ABS32(SHR32(in[C*i],SIG_SHIFT));
248    for (c=1;c<C;c++)
249    {
250       for (i=0;i<len;i++)
251          begin[i] = MAX32(begin[i], ABS32(SHR32(in[C*i+c],SIG_SHIFT)));
252    }
253    for (i=1;i<len;i++)
254       begin[i] = MAX32(begin[i-1],begin[i]);
255    n = -1;
256    for (i=8;i<len-8;i++)
257    {
258       if (begin[i] < MULT16_32_Q15(QCONST16(.2f,15),begin[len-1]))
259          n=i;
260    }
261    if (n<32)
262    {
263       n = -1;
264       ratio = 0;
265    } else {
266       ratio = DIV32(begin[len-1],1+begin[n-16]);
267    }
268    if (ratio < 0)
269       ratio = 0;
270    if (ratio > 1000)
271       ratio = 1000;
272    ratio *= ratio;
273    
274    if (ratio > 2048)
275       *transient_shift = 3;
276    else
277       *transient_shift = 0;
278    
279    *transient_time = n;
280    
281    RESTORE_STACK;
282    return ratio > 20;
283 }
284
285 /** Apply window and compute the MDCT for all sub-frames and 
286     all channels in a frame */
287 static void compute_mdcts(const CELTMode *mode, int shortBlocks, celt_sig_t * restrict in, celt_sig_t * restrict out)
288 {
289    const int C = CHANNELS(mode);
290    if (C==1 && !shortBlocks)
291    {
292       const mdct_lookup *lookup = MDCT(mode);
293       const int overlap = OVERLAP(mode);
294       mdct_forward(lookup, in, out, mode->window, overlap);
295    } else if (!shortBlocks) {
296       const mdct_lookup *lookup = MDCT(mode);
297       const int overlap = OVERLAP(mode);
298       const int N = FRAMESIZE(mode);
299       int c;
300       VARDECL(celt_word32_t, x);
301       VARDECL(celt_word32_t, tmp);
302       SAVE_STACK;
303       ALLOC(x, N+overlap, celt_word32_t);
304       ALLOC(tmp, N, celt_word32_t);
305       for (c=0;c<C;c++)
306       {
307          int j;
308          for (j=0;j<N+overlap;j++)
309             x[j] = in[C*j+c];
310          mdct_forward(lookup, x, tmp, mode->window, overlap);
311          /* Interleaving the sub-frames */
312          for (j=0;j<N;j++)
313             out[j+c*N] = tmp[j];
314       }
315       RESTORE_STACK;
316    } else {
317       const mdct_lookup *lookup = &mode->shortMdct;
318       const int overlap = mode->overlap;
319       const int N = mode->shortMdctSize;
320       int b, c;
321       VARDECL(celt_word32_t, x);
322       VARDECL(celt_word32_t, tmp);
323       SAVE_STACK;
324       ALLOC(x, N+overlap, celt_word32_t);
325       ALLOC(tmp, N, celt_word32_t);
326       for (c=0;c<C;c++)
327       {
328          int B = mode->nbShortMdcts;
329          for (b=0;b<B;b++)
330          {
331             int j;
332             for (j=0;j<N+overlap;j++)
333                x[j] = in[C*(b*N+j)+c];
334             mdct_forward(lookup, x, tmp, mode->window, overlap);
335             /* Interleaving the sub-frames */
336             for (j=0;j<N;j++)
337                out[(j*B+b)+c*N*B] = tmp[j];
338          }
339       }
340       RESTORE_STACK;
341    }
342 }
343
344 /** Compute the IMDCT and apply window for all sub-frames and 
345     all channels in a frame */
346 static void compute_inv_mdcts(const CELTMode *mode, int shortBlocks, celt_sig_t *X, int transient_time, int transient_shift, celt_sig_t * restrict out_mem)
347 {
348    int c, N4;
349    const int C = CHANNELS(mode);
350    const int N = FRAMESIZE(mode);
351    const int overlap = OVERLAP(mode);
352    N4 = (N-overlap)>>1;
353    for (c=0;c<C;c++)
354    {
355       int j;
356       if (transient_shift==0 && C==1 && !shortBlocks) {
357          const mdct_lookup *lookup = MDCT(mode);
358          mdct_backward(lookup, X, out_mem+C*(MAX_PERIOD-N-N4), mode->window, overlap);
359       } else if (!shortBlocks) {
360          const mdct_lookup *lookup = MDCT(mode);
361          VARDECL(celt_word32_t, x);
362          VARDECL(celt_word32_t, tmp);
363          SAVE_STACK;
364          ALLOC(x, 2*N, celt_word32_t);
365          ALLOC(tmp, N, celt_word32_t);
366          /* De-interleaving the sub-frames */
367          for (j=0;j<N;j++)
368             tmp[j] = X[j+c*N];
369          /* Prevents problems from the imdct doing the overlap-add */
370          CELT_MEMSET(x+N4, 0, N);
371          mdct_backward(lookup, tmp, x, mode->window, overlap);
372          celt_assert(transient_shift == 0);
373          /* The first and last part would need to be set to zero if we actually
374             wanted to use them. */
375          for (j=0;j<overlap;j++)
376             out_mem[C*(MAX_PERIOD-N)+C*j+c] += x[j+N4];
377          for (j=0;j<overlap;j++)
378             out_mem[C*(MAX_PERIOD)+C*(overlap-j-1)+c] = x[2*N-j-N4-1];
379          for (j=0;j<2*N4;j++)
380             out_mem[C*(MAX_PERIOD-N)+C*(j+overlap)+c] = x[j+N4+overlap];
381          RESTORE_STACK;
382       } else {
383          int b;
384          const int N2 = mode->shortMdctSize;
385          const int B = mode->nbShortMdcts;
386          const mdct_lookup *lookup = &mode->shortMdct;
387          VARDECL(celt_word32_t, x);
388          VARDECL(celt_word32_t, tmp);
389          SAVE_STACK;
390          ALLOC(x, 2*N, celt_word32_t);
391          ALLOC(tmp, N, celt_word32_t);
392          /* Prevents problems from the imdct doing the overlap-add */
393          CELT_MEMSET(x+N4, 0, N2);
394          for (b=0;b<B;b++)
395          {
396             /* De-interleaving the sub-frames */
397             for (j=0;j<N2;j++)
398                tmp[j] = X[(j*B+b)+c*N2*B];
399             mdct_backward(lookup, tmp, x+N4+N2*b, mode->window, overlap);
400          }
401          if (transient_shift > 0)
402          {
403 #ifdef FIXED_POINT
404             for (j=0;j<16;j++)
405                x[N4+transient_time+j-16] = MULT16_32_Q15(SHR16(Q15_ONE-transientWindow[j],transient_shift)+transientWindow[j], SHL32(x[N4+transient_time+j-16],transient_shift));
406             for (j=transient_time;j<N+overlap;j++)
407                x[N4+j] = SHL32(x[N4+j], transient_shift);
408 #else
409             for (j=0;j<16;j++)
410                x[N4+transient_time+j-16] *= 1+transientWindow[j]*((1<<transient_shift)-1);
411             for (j=transient_time;j<N+overlap;j++)
412                x[N4+j] *= 1<<transient_shift;
413 #endif
414          }
415          /* The first and last part would need to be set to zero 
416             if we actually wanted to use them. */
417          for (j=0;j<overlap;j++)
418             out_mem[C*(MAX_PERIOD-N)+C*j+c] += x[j+N4];
419          for (j=0;j<overlap;j++)
420             out_mem[C*(MAX_PERIOD)+C*(overlap-j-1)+c] = x[2*N-j-N4-1];
421          for (j=0;j<2*N4;j++)
422             out_mem[C*(MAX_PERIOD-N)+C*(j+overlap)+c] = x[j+N4+overlap];
423          RESTORE_STACK;
424       }
425    }
426 }
427
428 #define FLAG_NONE        0
429 #define FLAG_INTRA       (1U<<13)
430 #define FLAG_PITCH       (1U<<12)
431 #define FLAG_SHORT       (1U<<11)
432 #define FLAG_FOLD        (1U<<10)
433 #define FLAG_MASK        (FLAG_INTRA|FLAG_PITCH|FLAG_SHORT|FLAG_FOLD)
434
435 int flaglist[8] = {
436       0 /*00  */ | FLAG_FOLD,
437       1 /*01  */ | FLAG_PITCH|FLAG_FOLD,
438       8 /*1000*/ | FLAG_NONE,
439       9 /*1001*/ | FLAG_SHORT|FLAG_FOLD,
440      10 /*1010*/ | FLAG_PITCH,
441      11 /*1011*/ | FLAG_INTRA,
442       6 /*110 */ | FLAG_INTRA|FLAG_FOLD,
443       7 /*111 */ | FLAG_INTRA|FLAG_SHORT|FLAG_FOLD
444 };
445
446 void encode_flags(ec_enc *enc, int intra_ener, int has_pitch, int shortBlocks, int has_fold)
447 {
448    int i;
449    int flags=FLAG_NONE;
450    int flag_bits;
451    flags |= intra_ener   ? FLAG_INTRA : 0;
452    flags |= has_pitch    ? FLAG_PITCH : 0;
453    flags |= shortBlocks  ? FLAG_SHORT : 0;
454    flags |= has_fold     ? FLAG_FOLD  : 0;
455    for (i=0;i<8;i++)
456       if (flags == (flaglist[i]&FLAG_MASK))
457          break;
458    celt_assert(i<8);
459    flag_bits = flaglist[i]&0xf;
460    /*printf ("enc %d: %d %d %d %d\n", flag_bits, intra_ener, has_pitch, shortBlocks, has_fold);*/
461    if (i<2)
462       ec_enc_uint(enc, flag_bits, 4);
463    else if (i<6)
464       ec_enc_uint(enc, flag_bits, 16);
465    else
466       ec_enc_uint(enc, flag_bits, 8);
467 }
468
469 void decode_flags(ec_dec *dec, int *intra_ener, int *has_pitch, int *shortBlocks, int *has_fold)
470 {
471    int i;
472    int flag_bits;
473    flag_bits = ec_dec_uint(dec, 4);
474    /*printf ("(%d) ", flag_bits);*/
475    if (flag_bits==2)
476       flag_bits = (flag_bits<<2) | ec_dec_uint(dec, 4);
477    else if (flag_bits==3)
478       flag_bits = (flag_bits<<1) | ec_dec_uint(dec, 2);
479    for (i=0;i<8;i++)
480       if (flag_bits == (flaglist[i]&0xf))
481          break;
482    celt_assert(i<8);
483    *intra_ener  = (flaglist[i]&FLAG_INTRA) != 0;
484    *has_pitch   = (flaglist[i]&FLAG_PITCH) != 0;
485    *shortBlocks = (flaglist[i]&FLAG_SHORT) != 0;
486    *has_fold    = (flaglist[i]&FLAG_FOLD ) != 0;
487    /*printf ("dec %d: %d %d %d %d\n", flag_bits, *intra_ener, *has_pitch, *shortBlocks, *has_fold);*/
488 }
489
490 #ifdef FIXED_POINT
491 int celt_encode(CELTEncoder * restrict st, const celt_int16_t * pcm, celt_int16_t * optional_synthesis, unsigned char *compressed, int nbCompressedBytes)
492 {
493 #else
494 int celt_encode_float(CELTEncoder * restrict st, const celt_sig_t * pcm, celt_sig_t * optional_synthesis, unsigned char *compressed, int nbCompressedBytes)
495 {
496 #endif
497    int i, c, N, N4;
498    int has_pitch;
499    int pitch_index;
500    int bits;
501    int has_fold=1;
502    unsigned coarse_needed;
503    ec_byte_buffer buf;
504    ec_enc         enc;
505    VARDECL(celt_sig_t, in);
506    VARDECL(celt_sig_t, freq);
507    VARDECL(celt_norm_t, X);
508    VARDECL(celt_norm_t, P);
509    VARDECL(celt_ener_t, bandE);
510    VARDECL(celt_word16_t, bandLogE);
511    VARDECL(celt_pgain_t, gains);
512    VARDECL(int, fine_quant);
513    VARDECL(celt_word16_t, error);
514    VARDECL(int, pulses);
515    VARDECL(int, offsets);
516    VARDECL(int, fine_priority);
517 #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 || pcm==NULL)
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_uint(&enc, transient_shift, 4);
786          ec_enc_uint(&enc, transient_time, N+st->overlap);
787       } else {
788          ec_enc_uint(&enc, mdct_weight_shift, 4);
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, BITRES);
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      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    if (has_pitch)
846       bits -= st->mode->nbPBands;
847 #ifndef STDIN_TUNING
848    compute_allocation(st->mode, offsets, bits, pulses, fine_quant, fine_priority);
849 #endif
850
851    quant_fine_energy(st->mode, bandE, st->oldBandE, error, fine_quant, &enc);
852
853    /* Residual quantisation */
854    if (C==1)
855       quant_bands(st->mode, X, P, NULL, has_pitch, gains, bandE, pulses, shortBlocks, has_fold, nbCompressedBytes*8, &enc);
856 #ifndef DISABLE_STEREO
857    else
858       quant_bands_stereo(st->mode, X, P, NULL, has_pitch, gains, bandE, pulses, shortBlocks, has_fold, nbCompressedBytes*8, &enc);
859 #endif
860
861    quant_energy_finalise(st->mode, bandE, st->oldBandE, error, fine_quant, fine_priority, nbCompressedBytes*8-ec_enc_tell(&enc, 0), &enc);
862
863    /* Re-synthesis of the coded audio if required */
864    if (st->pitch_available>0 || optional_synthesis!=NULL)
865    {
866       if (st->pitch_available>0 && st->pitch_available<MAX_PERIOD)
867         st->pitch_available+=st->frame_size;
868
869       /* Synthesis */
870       denormalise_bands(st->mode, X, freq, bandE);
871       
872       
873       CELT_MOVE(st->out_mem, st->out_mem+C*N, C*(MAX_PERIOD+st->overlap-N));
874       
875       if (mdct_weight_shift)
876       {
877          int m;
878          for (c=0;c<C;c++)
879             for (m=mdct_weight_pos+1;m<st->mode->nbShortMdcts;m++)
880                for (i=m+c*N;i<(c+1)*N;i+=st->mode->nbShortMdcts)
881 #ifdef FIXED_POINT
882                   freq[i] = SHL32(freq[i], mdct_weight_shift);
883 #else
884                   freq[i] = (1<<mdct_weight_shift)*freq[i];
885 #endif
886       }
887       compute_inv_mdcts(st->mode, shortBlocks, freq, transient_time, transient_shift, st->out_mem);
888       /* De-emphasis and put everything back at the right place 
889          in the synthesis history */
890       if (optional_synthesis != NULL) {
891          for (c=0;c<C;c++)
892          {
893             int j;
894             for (j=0;j<N;j++)
895             {
896                celt_sig_t tmp = MAC16_32_Q15(st->out_mem[C*(MAX_PERIOD-N)+C*j+c],
897                                    preemph,st->preemph_memD[c]);
898                st->preemph_memD[c] = tmp;
899                optional_synthesis[C*j+c] = SCALEOUT(SIG2WORD16(tmp));
900             }
901          }
902       }
903    }
904
905    ec_enc_done(&enc);
906    
907    RESTORE_STACK;
908    return nbCompressedBytes;
909 }
910
911 #ifdef FIXED_POINT
912 #ifndef DISABLE_FLOAT_API
913 int celt_encode_float(CELTEncoder * restrict st, const float * pcm, float * optional_synthesis, unsigned char *compressed, int nbCompressedBytes)
914 {
915    int j, ret, C, N;
916    VARDECL(celt_int16_t, in);
917    SAVE_STACK;
918
919    if (check_encoder(st) != CELT_OK)
920       return CELT_INVALID_STATE;
921
922    if (check_mode(st->mode) != CELT_OK)
923       return CELT_INVALID_MODE;
924
925    if (pcm==NULL)
926       return CELT_BAD_ARG;
927
928    C = CHANNELS(st->mode);
929    N = st->block_size;
930    ALLOC(in, C*N, celt_int16_t);
931
932    for (j=0;j<C*N;j++)
933      in[j] = FLOAT2INT16(pcm[j]);
934
935    if (optional_synthesis != NULL) {
936      ret=celt_encode(st,in,in,compressed,nbCompressedBytes);
937       for (j=0;j<C*N;j++)
938          optional_synthesis[j]=in[j]*(1/32768.);
939    } else {
940      ret=celt_encode(st,in,NULL,compressed,nbCompressedBytes);
941    }
942    RESTORE_STACK;
943    return ret;
944
945 }
946 #endif /*DISABLE_FLOAT_API*/
947 #else
948 int celt_encode(CELTEncoder * restrict st, const celt_int16_t * pcm, celt_int16_t * optional_synthesis, unsigned char *compressed, int nbCompressedBytes)
949 {
950    int j, ret, C, N;
951    VARDECL(celt_sig_t, in);
952    SAVE_STACK;
953
954    if (check_encoder(st) != CELT_OK)
955       return CELT_INVALID_STATE;
956
957    if (check_mode(st->mode) != CELT_OK)
958       return CELT_INVALID_MODE;
959
960    if (pcm==NULL)
961       return CELT_BAD_ARG;
962
963    C=CHANNELS(st->mode);
964    N=st->block_size;
965    ALLOC(in, C*N, celt_sig_t);
966    for (j=0;j<C*N;j++) {
967      in[j] = SCALEOUT(pcm[j]);
968    }
969
970    if (optional_synthesis != NULL) {
971       ret = celt_encode_float(st,in,in,compressed,nbCompressedBytes);
972       for (j=0;j<C*N;j++)
973          optional_synthesis[j] = FLOAT2INT16(in[j]);
974    } else {
975       ret = celt_encode_float(st,in,NULL,compressed,nbCompressedBytes);
976    }
977    RESTORE_STACK;
978    return ret;
979 }
980 #endif
981
982 int celt_encoder_ctl(CELTEncoder * restrict st, int request, ...)
983 {
984    va_list ap;
985    
986    if (check_encoder(st) != CELT_OK)
987       return CELT_INVALID_STATE;
988
989    va_start(ap, request);
990    if ((request!=CELT_GET_MODE_REQUEST) && (check_mode(st->mode) != CELT_OK))
991      goto bad_mode;
992    switch (request)
993    {
994       case CELT_GET_MODE_REQUEST:
995       {
996          const CELTMode ** value = va_arg(ap, const CELTMode**);
997          if (value==0)
998             goto bad_arg;
999          *value=st->mode;
1000       }
1001       break;
1002       case CELT_SET_COMPLEXITY_REQUEST:
1003       {
1004          int value = va_arg(ap, celt_int32_t);
1005          if (value<0 || value>10)
1006             goto bad_arg;
1007          if (value<=2) {
1008             st->pitch_enabled = 0; 
1009             st->pitch_available = 0;
1010          } else {
1011               st->pitch_enabled = 1;
1012               if (st->pitch_available<1)
1013                 st->pitch_available = 1;
1014          }   
1015       }
1016       break;
1017       case CELT_SET_PREDICTION_REQUEST:
1018       {
1019          int value = va_arg(ap, celt_int32_t);
1020          if (value<0 || value>2)
1021             goto bad_arg;
1022          if (value==0)
1023          {
1024             st->force_intra   = 1;
1025             st->pitch_permitted = 0;
1026          } else if (value==1) {
1027             st->force_intra   = 0;
1028             st->pitch_permitted = 0;
1029          } else {
1030             st->force_intra   = 0;
1031             st->pitch_permitted = 1;
1032          }   
1033       }
1034       break;
1035       case CELT_SET_VBR_RATE_REQUEST:
1036       {
1037          celt_int32_t value = va_arg(ap, celt_int32_t);
1038          if (value<0)
1039             goto bad_arg;
1040          if (value>3072000)
1041             value = 3072000;
1042          st->VBR_rate = ((st->mode->Fs<<3)+(st->block_size>>1))/st->block_size;
1043          st->VBR_rate = ((value<<7)+(st->VBR_rate>>1))/st->VBR_rate;
1044       }
1045       break;
1046       case CELT_RESET_STATE:
1047       {
1048          const CELTMode *mode = st->mode;
1049          int C = mode->nbChannels;
1050
1051          if (st->pitch_available > 0) st->pitch_available = 1;
1052
1053          CELT_MEMSET(st->in_mem, 0, st->overlap*C);
1054          CELT_MEMSET(st->out_mem, 0, (MAX_PERIOD+st->overlap)*C);
1055
1056          CELT_MEMSET(st->oldBandE, 0, C*mode->nbEBands);
1057
1058          CELT_MEMSET(st->preemph_memE, 0, C);
1059          CELT_MEMSET(st->preemph_memD, 0, C);
1060          st->delayedIntra = 1;
1061       }
1062       break;
1063       default:
1064          goto bad_request;
1065    }
1066    va_end(ap);
1067    return CELT_OK;
1068 bad_mode:
1069   va_end(ap);
1070   return CELT_INVALID_MODE;
1071 bad_arg:
1072    va_end(ap);
1073    return CELT_BAD_ARG;
1074 bad_request:
1075    va_end(ap);
1076    return CELT_UNIMPLEMENTED;
1077 }
1078
1079 /**********************************************************************/
1080 /*                                                                    */
1081 /*                             DECODER                                */
1082 /*                                                                    */
1083 /**********************************************************************/
1084 #ifdef NEW_PLC
1085 #define DECODE_BUFFER_SIZE 2048
1086 #else
1087 #define DECODE_BUFFER_SIZE MAX_PERIOD
1088 #endif
1089
1090 #define DECODERVALID   0x4c434454
1091 #define DECODERPARTIAL 0x5444434c
1092 #define DECODERFREED   0x4c004400
1093
1094 /** Decoder state 
1095  @brief Decoder state
1096  */
1097 struct CELTDecoder {
1098    celt_uint32_t marker;
1099    const CELTMode *mode;
1100    int frame_size;
1101    int block_size;
1102    int overlap;
1103
1104    ec_byte_buffer buf;
1105    ec_enc         enc;
1106
1107    celt_sig_t * restrict preemph_memD;
1108
1109    celt_sig_t *out_mem;
1110    celt_sig_t *decode_mem;
1111
1112    celt_word16_t *oldBandE;
1113    
1114    int last_pitch_index;
1115    int loss_count;
1116 };
1117
1118 int check_decoder(const CELTDecoder *st) 
1119 {
1120    if (st==NULL)
1121    {
1122       celt_warning("NULL passed a decoder structure");  
1123       return CELT_INVALID_STATE;
1124    }
1125    if (st->marker == DECODERVALID)
1126       return CELT_OK;
1127    if (st->marker == DECODERFREED)
1128       celt_warning("Referencing a decoder that has already been freed");
1129    else
1130       celt_warning("This is not a valid CELT decoder structure");
1131    return CELT_INVALID_STATE;
1132 }
1133
1134 CELTDecoder *celt_decoder_create(const CELTMode *mode)
1135 {
1136    int N, C;
1137    CELTDecoder *st;
1138
1139    if (check_mode(mode) != CELT_OK)
1140       return NULL;
1141
1142    N = mode->mdctSize;
1143    C = CHANNELS(mode);
1144    st = celt_alloc(sizeof(CELTDecoder));
1145
1146    if (st==NULL)
1147       return NULL;
1148    
1149    st->marker = DECODERPARTIAL;
1150    st->mode = mode;
1151    st->frame_size = N;
1152    st->block_size = N;
1153    st->overlap = mode->overlap;
1154
1155    st->decode_mem = celt_alloc((DECODE_BUFFER_SIZE+st->overlap)*C*sizeof(celt_sig_t));
1156    st->out_mem = st->decode_mem+DECODE_BUFFER_SIZE-MAX_PERIOD;
1157    
1158    st->oldBandE = (celt_word16_t*)celt_alloc(C*mode->nbEBands*sizeof(celt_word16_t));
1159    
1160    st->preemph_memD = (celt_sig_t*)celt_alloc(C*sizeof(celt_sig_t));
1161
1162    st->loss_count = 0;
1163
1164    if ((st->decode_mem!=NULL) && (st->out_mem!=NULL) && (st->oldBandE!=NULL) &&
1165        (st->preemph_memD!=NULL))
1166    {
1167       st->marker = DECODERVALID;
1168       return st;
1169    }
1170    /* If the setup fails for some reason deallocate it. */
1171    celt_decoder_destroy(st);
1172    return NULL;
1173 }
1174
1175 void celt_decoder_destroy(CELTDecoder *st)
1176 {
1177    if (st == NULL)
1178    {
1179       celt_warning("NULL passed to celt_decoder_destroy");
1180       return;
1181    }
1182
1183    if (st->marker == DECODERFREED) 
1184    {
1185       celt_warning("Freeing a decoder which has already been freed"); 
1186       return;
1187    }
1188    
1189    if (st->marker != DECODERVALID && st->marker != DECODERPARTIAL)
1190    {
1191       celt_warning("This is not a valid CELT decoder structure");
1192       return;
1193    }
1194    
1195    /*Check_mode is non-fatal here because we can still free
1196      the encoder memory even if the mode is bad, although calling
1197      the free functions in this order is a violation of the API.*/
1198    check_mode(st->mode);
1199    
1200    celt_free(st->decode_mem);
1201    celt_free(st->oldBandE);
1202    celt_free(st->preemph_memD);
1203    
1204    st->marker = DECODERFREED;
1205    
1206    celt_free(st);
1207 }
1208
1209 /** Handles lost packets by just copying past data with the same
1210     offset as the last
1211     pitch period */
1212 #ifdef NEW_PLC
1213 #include "plc.c"
1214 #else
1215 static void celt_decode_lost(CELTDecoder * restrict st, celt_word16_t * restrict pcm)
1216 {
1217    int c, N;
1218    int pitch_index;
1219    celt_word16_t fade = Q15ONE;
1220    int i, len;
1221    VARDECL(celt_sig_t, freq);
1222    const int C = CHANNELS(st->mode);
1223    int offset;
1224    SAVE_STACK;
1225    N = st->block_size;
1226    ALLOC(freq,C*N, celt_sig_t); /**< Interleaved signal MDCTs */
1227    
1228    len = N+st->mode->overlap;
1229    
1230    if (st->loss_count == 0)
1231    {
1232       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);
1233       pitch_index = MAX_PERIOD-len-pitch_index;
1234       st->last_pitch_index = pitch_index;
1235    } else {
1236       pitch_index = st->last_pitch_index;
1237       if (st->loss_count < 5)
1238          fade = QCONST16(.8f,15);
1239       else
1240          fade = 0;
1241    }
1242
1243    offset = MAX_PERIOD-pitch_index;
1244    while (offset+len >= MAX_PERIOD)
1245       offset -= pitch_index;
1246    compute_mdcts(st->mode, 0, st->out_mem+offset*C, freq);
1247    for (i=0;i<C*N;i++)
1248       freq[i] = ADD32(VERY_SMALL, MULT16_32_Q15(fade,freq[i]));
1249
1250    CELT_MOVE(st->out_mem, st->out_mem+C*N, C*(MAX_PERIOD+st->mode->overlap-N));
1251    /* Compute inverse MDCTs */
1252    compute_inv_mdcts(st->mode, 0, freq, -1, 0, st->out_mem);
1253
1254    for (c=0;c<C;c++)
1255    {
1256       int j;
1257       for (j=0;j<N;j++)
1258       {
1259          celt_sig_t tmp = MAC16_32_Q15(st->out_mem[C*(MAX_PERIOD-N)+C*j+c],
1260                                 preemph,st->preemph_memD[c]);
1261          st->preemph_memD[c] = tmp;
1262          pcm[C*j+c] = SCALEOUT(SIG2WORD16(tmp));
1263       }
1264    }
1265    
1266    st->loss_count++;
1267
1268    RESTORE_STACK;
1269 }
1270 #endif
1271
1272 #ifdef FIXED_POINT
1273 int celt_decode(CELTDecoder * restrict st, const unsigned char *data, int len, celt_int16_t * restrict pcm)
1274 {
1275 #else
1276 int celt_decode_float(CELTDecoder * restrict st, const unsigned char *data, int len, celt_sig_t * restrict pcm)
1277 {
1278 #endif
1279    int i, c, N, N4;
1280    int has_pitch, has_fold;
1281    int pitch_index;
1282    int bits;
1283    ec_dec dec;
1284    ec_byte_buffer buf;
1285    VARDECL(celt_sig_t, freq);
1286    VARDECL(celt_norm_t, X);
1287    VARDECL(celt_norm_t, P);
1288    VARDECL(celt_ener_t, bandE);
1289    VARDECL(celt_pgain_t, gains);
1290    VARDECL(int, fine_quant);
1291    VARDECL(int, pulses);
1292    VARDECL(int, offsets);
1293    VARDECL(int, fine_priority);
1294
1295    int shortBlocks;
1296    int intra_ener;
1297    int transient_time;
1298    int transient_shift;
1299    int mdct_weight_shift=0;
1300    const int C = CHANNELS(st->mode);
1301    int mdct_weight_pos=0;
1302    SAVE_STACK;
1303
1304    if (check_decoder(st) != CELT_OK)
1305       return CELT_INVALID_STATE;
1306
1307    if (check_mode(st->mode) != CELT_OK)
1308       return CELT_INVALID_MODE;
1309
1310    if (pcm==NULL)
1311       return CELT_BAD_ARG;
1312
1313    N = st->block_size;
1314    N4 = (N-st->overlap)>>1;
1315
1316    ALLOC(freq, C*N, celt_sig_t); /**< Interleaved signal MDCTs */
1317    ALLOC(X, C*N, celt_norm_t);   /**< Interleaved normalised MDCTs */
1318    ALLOC(P, C*N, celt_norm_t);   /**< Interleaved normalised pitch MDCTs*/
1319    ALLOC(bandE, st->mode->nbEBands*C, celt_ener_t);
1320    ALLOC(gains, st->mode->nbPBands, celt_pgain_t);
1321    
1322    if (data == NULL)
1323    {
1324       celt_decode_lost(st, pcm);
1325       RESTORE_STACK;
1326       return 0;
1327    } else {
1328       st->loss_count = 0;
1329    }
1330    if (len<0) {
1331      RESTORE_STACK;
1332      return CELT_BAD_ARG;
1333    }
1334    
1335    ec_byte_readinit(&buf,(unsigned char*)data,len);
1336    ec_dec_init(&dec,&buf);
1337    
1338    decode_flags(&dec, &intra_ener, &has_pitch, &shortBlocks, &has_fold);
1339    if (shortBlocks)
1340    {
1341       transient_shift = ec_dec_uint(&dec, 4);
1342       if (transient_shift == 3)
1343       {
1344          transient_time = ec_dec_uint(&dec, N+st->mode->overlap);
1345       } else {
1346          mdct_weight_shift = transient_shift;
1347          if (mdct_weight_shift && st->mode->nbShortMdcts>2)
1348             mdct_weight_pos = ec_dec_uint(&dec, st->mode->nbShortMdcts-1);
1349          transient_shift = 0;
1350          transient_time = 0;
1351       }
1352    } else {
1353       transient_time = -1;
1354       transient_shift = 0;
1355    }
1356    
1357    if (has_pitch)
1358    {
1359       pitch_index = ec_dec_uint(&dec, MAX_PERIOD-(2*N-2*N4));
1360    } else {
1361       pitch_index = 0;
1362       for (i=0;i<st->mode->nbPBands;i++)
1363          gains[i] = 0;
1364    }
1365
1366    ALLOC(fine_quant, st->mode->nbEBands, int);
1367    /* Get band energies */
1368    unquant_coarse_energy(st->mode, bandE, st->oldBandE, len*8/3, intra_ener, st->mode->prob, &dec);
1369    
1370    ALLOC(pulses, st->mode->nbEBands, int);
1371    ALLOC(offsets, st->mode->nbEBands, int);
1372    ALLOC(fine_priority, st->mode->nbEBands, int);
1373
1374    for (i=0;i<st->mode->nbEBands;i++)
1375       offsets[i] = 0;
1376
1377    bits = len*8 - ec_dec_tell(&dec, 0) - 1;
1378    if (has_pitch)
1379       bits -= st->mode->nbPBands;
1380    compute_allocation(st->mode, offsets, bits, pulses, fine_quant, fine_priority);
1381    /*bits = ec_dec_tell(&dec, 0);
1382    compute_fine_allocation(st->mode, fine_quant, (20*C+len*8/5-(ec_dec_tell(&dec, 0)-bits))/C);*/
1383    
1384    unquant_fine_energy(st->mode, bandE, st->oldBandE, fine_quant, &dec);
1385
1386
1387    if (has_pitch) 
1388    {
1389       VARDECL(celt_ener_t, bandEp);
1390       
1391       /* Pitch MDCT */
1392       compute_mdcts(st->mode, 0, st->out_mem+pitch_index*C, freq);
1393       ALLOC(bandEp, st->mode->nbEBands*C, celt_ener_t);
1394       compute_band_energies(st->mode, freq, bandEp);
1395       normalise_bands(st->mode, freq, P, bandEp);
1396       /* Apply pitch gains */
1397    } else {
1398       for (i=0;i<C*N;i++)
1399          P[i] = 0;
1400    }
1401
1402    /* Decode fixed codebook and merge with pitch */
1403    if (C==1)
1404       unquant_bands(st->mode, X, P, has_pitch, gains, bandE, pulses, shortBlocks, has_fold, len*8, &dec);
1405 #ifndef DISABLE_STEREO
1406    else
1407       unquant_bands_stereo(st->mode, X, P, has_pitch, gains, 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);
1410    
1411    /* Synthesis */
1412    denormalise_bands(st->mode, X, freq, bandE);
1413
1414
1415    CELT_MOVE(st->decode_mem, st->decode_mem+C*N, C*(DECODE_BUFFER_SIZE+st->overlap-N));
1416    if (mdct_weight_shift)
1417    {
1418       int m;
1419       for (c=0;c<C;c++)
1420          for (m=mdct_weight_pos+1;m<st->mode->nbShortMdcts;m++)
1421             for (i=m+c*N;i<(c+1)*N;i+=st->mode->nbShortMdcts)
1422 #ifdef FIXED_POINT
1423                freq[i] = SHL32(freq[i], mdct_weight_shift);
1424 #else
1425                freq[i] = (1<<mdct_weight_shift)*freq[i];
1426 #endif
1427    }
1428    /* Compute inverse MDCTs */
1429    compute_inv_mdcts(st->mode, shortBlocks, freq, transient_time, transient_shift, st->out_mem);
1430
1431    for (c=0;c<C;c++)
1432    {
1433       int j;
1434       for (j=0;j<N;j++)
1435       {
1436          celt_sig_t tmp = MAC16_32_Q15(st->out_mem[C*(MAX_PERIOD-N)+C*j+c],
1437                                 preemph,st->preemph_memD[c]);
1438          st->preemph_memD[c] = tmp;
1439          pcm[C*j+c] = SCALEOUT(SIG2WORD16(tmp));
1440       }
1441    }
1442
1443    RESTORE_STACK;
1444    return 0;
1445 }
1446
1447 #ifdef FIXED_POINT
1448 #ifndef DISABLE_FLOAT_API
1449 int celt_decode_float(CELTDecoder * restrict st, const unsigned char *data, int len, float * restrict pcm)
1450 {
1451    int j, ret, C, N;
1452    VARDECL(celt_int16_t, out);
1453    SAVE_STACK;
1454
1455    if (check_decoder(st) != CELT_OK)
1456       return CELT_INVALID_STATE;
1457
1458    if (check_mode(st->mode) != CELT_OK)
1459       return CELT_INVALID_MODE;
1460
1461    if (pcm==NULL)
1462       return CELT_BAD_ARG;
1463
1464    C = CHANNELS(st->mode);
1465    N = st->block_size;
1466    
1467    ALLOC(out, C*N, celt_int16_t);
1468    ret=celt_decode(st, data, len, out);
1469    for (j=0;j<C*N;j++)
1470       pcm[j]=out[j]*(1/32768.);
1471      
1472    RESTORE_STACK;
1473    return ret;
1474 }
1475 #endif /*DISABLE_FLOAT_API*/
1476 #else
1477 int celt_decode(CELTDecoder * restrict st, const unsigned char *data, int len, celt_int16_t * restrict pcm)
1478 {
1479    int j, ret, C, N;
1480    VARDECL(celt_sig_t, out);
1481    SAVE_STACK;
1482
1483    if (check_decoder(st) != CELT_OK)
1484       return CELT_INVALID_STATE;
1485
1486    if (check_mode(st->mode) != CELT_OK)
1487       return CELT_INVALID_MODE;
1488
1489    if (pcm==NULL)
1490       return CELT_BAD_ARG;
1491
1492    C = CHANNELS(st->mode);
1493    N = st->block_size;
1494    ALLOC(out, C*N, celt_sig_t);
1495
1496    ret=celt_decode_float(st, data, len, out);
1497
1498    for (j=0;j<C*N;j++)
1499       pcm[j] = FLOAT2INT16 (out[j]);
1500    
1501    RESTORE_STACK;
1502    return ret;
1503 }
1504 #endif
1505
1506 int celt_decoder_ctl(CELTDecoder * restrict st, int request, ...)
1507 {
1508    va_list ap;
1509
1510    if (check_decoder(st) != CELT_OK)
1511       return CELT_INVALID_STATE;
1512
1513    va_start(ap, request);
1514    if ((request!=CELT_GET_MODE_REQUEST) && (check_mode(st->mode) != CELT_OK))
1515      goto bad_mode;
1516    switch (request)
1517    {
1518       case CELT_GET_MODE_REQUEST:
1519       {
1520          const CELTMode ** value = va_arg(ap, const CELTMode**);
1521          if (value==0)
1522             goto bad_arg;
1523          *value=st->mode;
1524       }
1525       break;
1526       case CELT_RESET_STATE:
1527       {
1528          const CELTMode *mode = st->mode;
1529          int C = mode->nbChannels;
1530
1531          CELT_MEMSET(st->decode_mem, 0, (DECODE_BUFFER_SIZE+st->overlap)*C);
1532          CELT_MEMSET(st->oldBandE, 0, C*mode->nbEBands);
1533
1534          CELT_MEMSET(st->preemph_memD, 0, C);
1535
1536          st->loss_count = 0;
1537       }
1538       break;
1539       default:
1540          goto bad_request;
1541    }
1542    va_end(ap);
1543    return CELT_OK;
1544 bad_mode:
1545   va_end(ap);
1546   return CELT_INVALID_MODE;
1547 bad_arg:
1548    va_end(ap);
1549    return CELT_BAD_ARG;
1550 bad_request:
1551       va_end(ap);
1552   return CELT_UNIMPLEMENTED;
1553 }