Fixing the encoder's handling of no-folding; with folding enabled
[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, 0.1986827, 0.2771308, 0.3631685, 0.4538658,
64    0.5461342, 0.6368315, 0.7228692, 0.8013173, 0.8695045, 0.9251086, 0.9662361, 0.9914865};
65 #endif
66
67    
68 /** Encoder state 
69  @brief Encoder state
70  */
71 struct CELTEncoder {
72    const CELTMode *mode;     /**< Mode used by the encoder */
73    int frame_size;
74    int block_size;
75    int overlap;
76    int channels;
77    
78    int pitch_enabled;
79    int pitch_available;
80    int delayedIntra;
81    int VBR_rate; /* Target number of 16th bits per frame */
82    celt_word16_t * restrict preemph_memE; /* Input is 16-bit, so why bother with 32 */
83    celt_sig_t    * restrict preemph_memD;
84
85    celt_sig_t *in_mem;
86    celt_sig_t *out_mem;
87
88    celt_word16_t *oldBandE;
89 #ifdef EXP_PSY
90    celt_word16_t *psy_mem;
91    struct PsyDecay psy;
92 #endif
93 };
94
95 CELTEncoder *celt_encoder_create(const CELTMode *mode)
96 {
97    int N, C;
98    CELTEncoder *st;
99
100    if (check_mode(mode) != CELT_OK)
101       return NULL;
102
103    N = mode->mdctSize;
104    C = mode->nbChannels;
105    st = celt_alloc(sizeof(CELTEncoder));
106    
107    st->mode = mode;
108    st->frame_size = N;
109    st->block_size = N;
110    st->overlap = mode->overlap;
111
112    st->VBR_rate = 0;
113    st->pitch_enabled = 1;
114    st->pitch_available = 1;
115    st->delayedIntra = 1;
116
117    st->in_mem = celt_alloc(st->overlap*C*sizeof(celt_sig_t));
118    st->out_mem = celt_alloc((MAX_PERIOD+st->overlap)*C*sizeof(celt_sig_t));
119
120    st->oldBandE = (celt_word16_t*)celt_alloc(C*mode->nbEBands*sizeof(celt_word16_t));
121
122    st->preemph_memE = (celt_word16_t*)celt_alloc(C*sizeof(celt_word16_t));
123    st->preemph_memD = (celt_sig_t*)celt_alloc(C*sizeof(celt_sig_t));
124
125 #ifdef EXP_PSY
126    st->psy_mem = celt_alloc(MAX_PERIOD*sizeof(celt_word16_t));
127    psydecay_init(&st->psy, MAX_PERIOD/2, st->mode->Fs);
128 #endif
129
130    return st;
131 }
132
133 void celt_encoder_destroy(CELTEncoder *st)
134 {
135    if (st == NULL)
136    {
137       celt_warning("NULL passed to celt_encoder_destroy");
138       return;
139    }
140    if (check_mode(st->mode) != CELT_OK)
141       return;
142
143    celt_free(st->in_mem);
144    celt_free(st->out_mem);
145    
146    celt_free(st->oldBandE);
147    
148    celt_free(st->preemph_memE);
149    celt_free(st->preemph_memD);
150    
151 #ifdef EXP_PSY
152    celt_free (st->psy_mem);
153    psydecay_clear(&st->psy);
154 #endif
155    
156    celt_free(st);
157 }
158
159 static inline celt_int16_t FLOAT2INT16(float x)
160 {
161    x = x*CELT_SIG_SCALE;
162    x = MAX32(x, -32768);
163    x = MIN32(x, 32767);
164    return (celt_int16_t)float2int(x);
165 }
166
167 static inline celt_word16_t SIG2WORD16(celt_sig_t x)
168 {
169 #ifdef FIXED_POINT
170    x = PSHR32(x, SIG_SHIFT);
171    x = MAX32(x, -32768);
172    x = MIN32(x, 32767);
173    return EXTRACT16(x);
174 #else
175    return (celt_word16_t)x;
176 #endif
177 }
178
179 static int transient_analysis(celt_word32_t *in, int len, int C, int *transient_time, int *transient_shift)
180 {
181    int c, i, n;
182    celt_word32_t ratio;
183    /* FIXME: Remove the floats here */
184    VARDECL(celt_word32_t, begin);
185    SAVE_STACK;
186    ALLOC(begin, len, celt_word32_t);
187    for (i=0;i<len;i++)
188       begin[i] = ABS32(SHR32(in[C*i],SIG_SHIFT));
189    for (c=1;c<C;c++)
190    {
191       for (i=0;i<len;i++)
192          begin[i] = MAX32(begin[i], ABS32(SHR32(in[C*i+c],SIG_SHIFT)));
193    }
194    for (i=1;i<len;i++)
195       begin[i] = MAX32(begin[i-1],begin[i]);
196    n = -1;
197    for (i=8;i<len-8;i++)
198    {
199       if (begin[i] < MULT16_32_Q15(QCONST16(.2f,15),begin[len-1]))
200          n=i;
201    }
202    if (n<32)
203    {
204       n = -1;
205       ratio = 0;
206    } else {
207       ratio = DIV32(begin[len-1],1+begin[n-16]);
208    }
209    /*printf ("%d %f\n", n, ratio*ratio);*/
210    if (ratio < 0)
211       ratio = 0;
212    if (ratio > 1000)
213       ratio = 1000;
214    ratio *= ratio;
215    if (ratio < 50)
216       *transient_shift = 0;
217    else if (ratio < 256)
218       *transient_shift = 1;
219    else if (ratio < 4096)
220       *transient_shift = 2;
221    else
222       *transient_shift = 3;
223    *transient_time = n;
224    
225    RESTORE_STACK;
226    return ratio > 20;
227 }
228
229 /** Apply window and compute the MDCT for all sub-frames and all channels in a frame */
230 static void compute_mdcts(const CELTMode *mode, int shortBlocks, celt_sig_t * restrict in, celt_sig_t * restrict out)
231 {
232    const int C = CHANNELS(mode);
233    if (C==1 && !shortBlocks)
234    {
235       const mdct_lookup *lookup = MDCT(mode);
236       const int overlap = OVERLAP(mode);
237       mdct_forward(lookup, in, out, mode->window, overlap);
238    } else if (!shortBlocks) {
239       const mdct_lookup *lookup = MDCT(mode);
240       const int overlap = OVERLAP(mode);
241       const int N = FRAMESIZE(mode);
242       int c;
243       VARDECL(celt_word32_t, x);
244       VARDECL(celt_word32_t, tmp);
245       SAVE_STACK;
246       ALLOC(x, N+overlap, celt_word32_t);
247       ALLOC(tmp, N, celt_word32_t);
248       for (c=0;c<C;c++)
249       {
250          int j;
251          for (j=0;j<N+overlap;j++)
252             x[j] = in[C*j+c];
253          mdct_forward(lookup, x, tmp, mode->window, overlap);
254          /* Interleaving the sub-frames */
255          for (j=0;j<N;j++)
256             out[C*j+c] = tmp[j];
257       }
258       RESTORE_STACK;
259    } else {
260       const mdct_lookup *lookup = &mode->shortMdct;
261       const int overlap = mode->overlap;
262       const int N = mode->shortMdctSize;
263       int b, c;
264       VARDECL(celt_word32_t, x);
265       VARDECL(celt_word32_t, tmp);
266       SAVE_STACK;
267       ALLOC(x, N+overlap, celt_word32_t);
268       ALLOC(tmp, N, celt_word32_t);
269       for (c=0;c<C;c++)
270       {
271          int B = mode->nbShortMdcts;
272          for (b=0;b<B;b++)
273          {
274             int j;
275             for (j=0;j<N+overlap;j++)
276                x[j] = in[C*(b*N+j)+c];
277             mdct_forward(lookup, x, tmp, mode->window, overlap);
278             /* Interleaving the sub-frames */
279             for (j=0;j<N;j++)
280                out[C*(j*B+b)+c] = tmp[j];
281          }
282       }
283       RESTORE_STACK;
284    }
285 }
286
287 /** Compute the IMDCT and apply window for all sub-frames and all channels in a frame */
288 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)
289 {
290    int c, N4;
291    const int C = CHANNELS(mode);
292    const int N = FRAMESIZE(mode);
293    const int overlap = OVERLAP(mode);
294    N4 = (N-overlap)>>1;
295    for (c=0;c<C;c++)
296    {
297       int j;
298       if (transient_shift==0 && C==1 && !shortBlocks) {
299          const mdct_lookup *lookup = MDCT(mode);
300          mdct_backward(lookup, X, out_mem+C*(MAX_PERIOD-N-N4), mode->window, overlap);
301       } else if (!shortBlocks) {
302          const mdct_lookup *lookup = MDCT(mode);
303          VARDECL(celt_word32_t, x);
304          VARDECL(celt_word32_t, tmp);
305          SAVE_STACK;
306          ALLOC(x, 2*N, celt_word32_t);
307          ALLOC(tmp, N, celt_word32_t);
308          /* De-interleaving the sub-frames */
309          for (j=0;j<N;j++)
310             tmp[j] = X[C*j+c];
311          /* Prevents problems from the imdct doing the overlap-add */
312          CELT_MEMSET(x+N4, 0, N);
313          mdct_backward(lookup, tmp, x, mode->window, overlap);
314          celt_assert(transient_shift == 0);
315          /* The first and last part would need to be set to zero if we actually
316             wanted to use them. */
317          for (j=0;j<overlap;j++)
318             out_mem[C*(MAX_PERIOD-N)+C*j+c] += x[j+N4];
319          for (j=0;j<overlap;j++)
320             out_mem[C*(MAX_PERIOD)+C*(overlap-j-1)+c] = x[2*N-j-N4-1];
321          for (j=0;j<2*N4;j++)
322             out_mem[C*(MAX_PERIOD-N)+C*(j+overlap)+c] = x[j+N4+overlap];
323          RESTORE_STACK;
324       } else {
325          int b;
326          const int N2 = mode->shortMdctSize;
327          const int B = mode->nbShortMdcts;
328          const mdct_lookup *lookup = &mode->shortMdct;
329          VARDECL(celt_word32_t, x);
330          VARDECL(celt_word32_t, tmp);
331          SAVE_STACK;
332          ALLOC(x, 2*N, celt_word32_t);
333          ALLOC(tmp, N, celt_word32_t);
334          /* Prevents problems from the imdct doing the overlap-add */
335          CELT_MEMSET(x+N4, 0, N2);
336          for (b=0;b<B;b++)
337          {
338             /* De-interleaving the sub-frames */
339             for (j=0;j<N2;j++)
340                tmp[j] = X[C*(j*B+b)+c];
341             mdct_backward(lookup, tmp, x+N4+N2*b, mode->window, overlap);
342          }
343          if (transient_shift > 0)
344          {
345 #ifdef FIXED_POINT
346             for (j=0;j<16;j++)
347                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));
348             for (j=transient_time;j<N+overlap;j++)
349                x[N4+j] = SHL32(x[N4+j], transient_shift);
350 #else
351             for (j=0;j<16;j++)
352                x[N4+transient_time+j-16] *= 1+transientWindow[j]*((1<<transient_shift)-1);
353             for (j=transient_time;j<N+overlap;j++)
354                x[N4+j] *= 1<<transient_shift;
355 #endif
356          }
357          /* The first and last part would need to be set to zero if we actually
358          wanted to use them. */
359          for (j=0;j<overlap;j++)
360             out_mem[C*(MAX_PERIOD-N)+C*j+c] += x[j+N4];
361          for (j=0;j<overlap;j++)
362             out_mem[C*(MAX_PERIOD)+C*(overlap-j-1)+c] = x[2*N-j-N4-1];
363          for (j=0;j<2*N4;j++)
364             out_mem[C*(MAX_PERIOD-N)+C*(j+overlap)+c] = x[j+N4+overlap];
365          RESTORE_STACK;
366       }
367    }
368 }
369
370 #define FLAG_NONE        0
371 #define FLAG_INTRA       1U<<16
372 #define FLAG_PITCH       1U<<15
373 #define FLAG_SHORT       1U<<14
374 #define FLAG_FOLD        1U<<13
375 #define FLAG_MASK        (FLAG_INTRA|FLAG_PITCH|FLAG_SHORT|FLAG_FOLD)
376
377 celt_int32_t flaglist[8] = {
378       0 /*00  */ | FLAG_FOLD,
379       1 /*01  */ | FLAG_PITCH|FLAG_FOLD,
380       8 /*1000*/ | FLAG_NONE,
381       9 /*1001*/ | FLAG_SHORT|FLAG_FOLD,
382      10 /*1010*/ | FLAG_PITCH,
383      11 /*1011*/ | FLAG_INTRA,
384       6 /*110 */ | FLAG_INTRA|FLAG_FOLD,
385       7 /*111 */ | FLAG_INTRA|FLAG_SHORT|FLAG_FOLD
386 };
387
388 void encode_flags(ec_enc *enc, int intra_ener, int has_pitch, int shortBlocks, int has_fold)
389 {
390    int i;
391    int flags=FLAG_NONE;
392    int flag_bits;
393    flags |= intra_ener   ? FLAG_INTRA : 0;
394    flags |= has_pitch    ? FLAG_PITCH : 0;
395    flags |= shortBlocks  ? FLAG_SHORT : 0;
396    flags |= has_fold     ? FLAG_FOLD  : 0;
397    for (i=0;i<8;i++)
398       if (flags == (flaglist[i]&FLAG_MASK))
399          break;
400    celt_assert(i<8);
401    flag_bits = flaglist[i]&0xf;
402    /*printf ("enc %d: %d %d %d %d\n", flag_bits, intra_ener, has_pitch, shortBlocks, has_fold);*/
403    if (i<2)
404       ec_enc_bits(enc, flag_bits, 2);
405    else if (i<6)
406       ec_enc_bits(enc, flag_bits, 4);
407    else
408       ec_enc_bits(enc, flag_bits, 3);
409 }
410
411 void decode_flags(ec_dec *dec, int *intra_ener, int *has_pitch, int *shortBlocks, int *has_fold)
412 {
413    int i;
414    int flag_bits;
415    flag_bits = ec_dec_bits(dec, 2);
416    /*printf ("(%d) ", flag_bits);*/
417    if (flag_bits==2)
418       flag_bits = (flag_bits<<2) | ec_dec_bits(dec, 2);
419    else if (flag_bits==3)
420       flag_bits = (flag_bits<<1) | ec_dec_bits(dec, 1);
421    for (i=0;i<8;i++)
422       if (flag_bits == (flaglist[i]&0xf))
423          break;
424    celt_assert(i<8);
425    *intra_ener  = (flaglist[i]&FLAG_INTRA) != 0;
426    *has_pitch   = (flaglist[i]&FLAG_PITCH) != 0;
427    *shortBlocks = (flaglist[i]&FLAG_SHORT) != 0;
428    *has_fold    = (flaglist[i]&FLAG_FOLD ) != 0;
429    /*printf ("dec %d: %d %d %d %d\n", flag_bits, *intra_ener, *has_pitch, *shortBlocks, *has_fold);*/
430 }
431
432 #ifdef FIXED_POINT
433 int celt_encode(CELTEncoder * restrict st, const celt_int16_t * pcm, celt_int16_t * optional_synthesis, unsigned char *compressed, int nbCompressedBytes)
434 {
435 #else
436 int celt_encode_float(CELTEncoder * restrict st, const celt_sig_t * pcm, celt_sig_t * optional_synthesis, unsigned char *compressed, int nbCompressedBytes)
437 {
438 #endif
439    int i, c, N, N4;
440    int has_pitch;
441    int pitch_index;
442    int bits;
443    int has_fold=1;
444    unsigned coarse_needed;
445    ec_byte_buffer buf;
446    ec_enc         enc;
447    VARDECL(celt_sig_t, in);
448    VARDECL(celt_sig_t, freq);
449    VARDECL(celt_norm_t, X);
450    VARDECL(celt_norm_t, P);
451    VARDECL(celt_ener_t, bandE);
452    VARDECL(celt_pgain_t, gains);
453    VARDECL(int, stereo_mode);
454    VARDECL(int, fine_quant);
455    VARDECL(celt_word16_t, error);
456    VARDECL(int, pulses);
457    VARDECL(int, offsets);
458 #ifdef EXP_PSY
459    VARDECL(celt_word32_t, mask);
460    VARDECL(celt_word32_t, tonality);
461    VARDECL(celt_word32_t, bandM);
462    VARDECL(celt_ener_t, bandN);
463 #endif
464    int intra_ener = 0;
465    int shortBlocks=0;
466    int transient_time;
467    int transient_shift;
468    const int C = CHANNELS(st->mode);
469    SAVE_STACK;
470
471    if (check_mode(st->mode) != CELT_OK)
472       return CELT_INVALID_MODE;
473
474    if (nbCompressedBytes<0)
475      return CELT_BAD_ARG; 
476
477    /* The memset is important for now in case the encoder doesn't fill up all the bytes */
478    CELT_MEMSET(compressed, 0, nbCompressedBytes);
479    ec_byte_writeinit_buffer(&buf, compressed, nbCompressedBytes);
480    ec_enc_init(&enc,&buf);
481
482    N = st->block_size;
483    N4 = (N-st->overlap)>>1;
484    ALLOC(in, 2*C*N-2*C*N4, celt_sig_t);
485
486    CELT_COPY(in, st->in_mem, C*st->overlap);
487    for (c=0;c<C;c++)
488    {
489       const celt_word16_t * restrict pcmp = pcm+c;
490       celt_sig_t * restrict inp = in+C*st->overlap+c;
491       for (i=0;i<N;i++)
492       {
493          /* Apply pre-emphasis */
494          celt_sig_t tmp = SCALEIN(SHL32(EXTEND32(*pcmp), SIG_SHIFT));
495          *inp = SUB32(tmp, SHR32(MULT16_16(preemph,st->preemph_memE[c]),3));
496          st->preemph_memE[c] = SCALEIN(*pcmp);
497          inp += C;
498          pcmp += C;
499       }
500    }
501    CELT_COPY(st->in_mem, in+C*(2*N-2*N4-st->overlap), C*st->overlap);
502    
503    /* Transient handling */
504    if (st->mode->nbShortMdcts > 1)
505    {
506       if (transient_analysis(in, N+st->overlap, C, &transient_time, &transient_shift))
507       {
508 #ifndef FIXED_POINT
509          float gain_1;
510 #endif
511          /* Apply the inverse shaping window */
512          if (transient_shift)
513          {
514 #ifdef FIXED_POINT
515             for (c=0;c<C;c++)
516                for (i=0;i<16;i++)
517                   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]);
518             for (c=0;c<C;c++)
519                for (i=transient_time;i<N+st->overlap;i++)
520                   in[C*i+c] = SHR32(in[C*i+c], transient_shift);
521 #else
522             for (c=0;c<C;c++)
523                for (i=0;i<16;i++)
524                   in[C*(transient_time+i-16)+c] /= 1+transientWindow[i]*((1<<transient_shift)-1);
525             gain_1 = 1./(1<<transient_shift);
526             for (c=0;c<C;c++)
527                for (i=transient_time;i<N+st->overlap;i++)
528                   in[C*i+c] *= gain_1;
529 #endif
530          }
531          shortBlocks = 1;
532          has_fold = 1;
533       } else {
534          transient_time = -1;
535          transient_shift = 0;
536          shortBlocks = 0;
537       }
538    } else {
539       transient_time = -1;
540       transient_shift = 0;
541       shortBlocks = 0;
542    }
543
544    ALLOC(freq, C*N, celt_sig_t); /**< Interleaved signal MDCTs */
545    ALLOC(bandE,st->mode->nbEBands*C, celt_ener_t);
546    /* Compute MDCTs */
547    compute_mdcts(st->mode, shortBlocks, in, freq);
548    compute_band_energies(st->mode, freq, bandE);
549
550    intra_ener = st->delayedIntra;
551    if (intra_decision(bandE, st->oldBandE, st->mode->nbEBands) || shortBlocks)
552       st->delayedIntra = 1;
553    else
554       st->delayedIntra = 0;
555    /* Pitch analysis: we do it early to save on the peak stack space */
556    /* Don't use pitch if there isn't enough data available yet, or if we're using shortBlocks */
557    has_pitch = st->pitch_enabled && (st->pitch_available >= MAX_PERIOD) && (!shortBlocks) && !intra_ener;
558 #ifdef EXP_PSY
559    ALLOC(tonality, MAX_PERIOD/4, celt_word16_t);
560    {
561       VARDECL(celt_word16_t, X);
562       ALLOC(X, MAX_PERIOD/2, celt_word16_t);
563       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);
564       compute_tonality(st->mode, X, st->psy_mem, MAX_PERIOD, tonality, MAX_PERIOD/4);
565    }
566 #else
567    if (has_pitch)
568    {
569       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);
570    }
571 #endif
572
573 #ifdef EXP_PSY
574    ALLOC(mask, N, celt_sig_t);
575    compute_mdct_masking(&st->psy, freq, tonality, st->psy_mem, mask, C*N);
576    /*for (i=0;i<256;i++)
577       printf ("%f %f %f ", freq[i], tonality[i], mask[i]);
578    printf ("\n");*/
579 #endif
580
581    /* Deferred allocation after find_spectral_pitch() to reduce the peak memory usage */
582    ALLOC(X, C*N, celt_norm_t);         /**< Interleaved normalised MDCTs */
583    ALLOC(P, C*N, celt_norm_t);         /**< Interleaved normalised pitch MDCTs*/
584    ALLOC(gains,st->mode->nbPBands, celt_pgain_t);
585
586
587    /* Band normalisation */
588    normalise_bands(st->mode, freq, X, bandE);
589
590 #ifdef EXP_PSY
591    ALLOC(bandN,C*st->mode->nbEBands, celt_ener_t);
592    ALLOC(bandM,st->mode->nbEBands, celt_ener_t);
593    compute_noise_energies(st->mode, freq, tonality, bandN);
594
595    /*for (i=0;i<st->mode->nbEBands;i++)
596       printf ("%f ", (.1+bandN[i])/(.1+bandE[i]));
597    printf ("\n");*/
598    has_fold = 0;
599    for (i=st->mode->nbPBands;i<st->mode->nbEBands;i++)
600       if (bandN[i] < .4*bandE[i])
601          has_fold++;
602    /*printf ("%d\n", has_fold);*/
603    if (has_fold>=2)
604       has_fold = 0;
605    else
606       has_fold = 1;
607    for (i=0;i<N;i++)
608       mask[i] = sqrt(mask[i]);
609    compute_band_energies(st->mode, mask, bandM);
610    /*for (i=0;i<st->mode->nbEBands;i++)
611       printf ("%f %f ", bandE[i], bandM[i]);
612    printf ("\n");*/
613 #endif
614
615    /* Compute MDCTs of the pitch part */
616    if (has_pitch)
617    {
618       celt_word32_t curr_power, pitch_power=0;
619       /* Normalise the pitch vector as well (discard the energies) */
620       VARDECL(celt_ener_t, bandEp);
621       
622       compute_mdcts(st->mode, 0, st->out_mem+pitch_index*C, freq);
623       ALLOC(bandEp, st->mode->nbEBands*st->mode->nbChannels, celt_ener_t);
624       compute_band_energies(st->mode, freq, bandEp);
625       normalise_bands(st->mode, freq, P, bandEp);
626       pitch_power = bandEp[0]+bandEp[1]+bandEp[2];
627       /* Check if we can safely use the pitch (i.e. effective gain isn't too high) */
628       curr_power = bandE[0]+bandE[1]+bandE[2];
629       if ((MULT16_32_Q15(QCONST16(.1f, 15),curr_power) + QCONST32(10.f,ENER_SHIFT) < pitch_power))
630       {
631          /* Pitch prediction */
632          has_pitch = compute_pitch_gain(st->mode, X, P, gains);
633       } else {
634          has_pitch = 0;
635       }
636    }
637    
638    encode_flags(&enc, intra_ener, has_pitch, shortBlocks, has_fold);
639    if (has_pitch)
640    {
641       ec_enc_uint(&enc, pitch_index, MAX_PERIOD-(2*N-2*N4));
642    } else {
643       for (i=0;i<st->mode->nbPBands;i++)
644          gains[i] = 0;
645       for (i=0;i<C*N;i++)
646          P[i] = 0;
647    }
648    if (shortBlocks)
649    {
650       ec_enc_bits(&enc, transient_shift, 2);
651       if (transient_shift)
652          ec_enc_uint(&enc, transient_time, N+st->overlap);
653    }
654
655 #ifdef STDIN_TUNING2
656    static int fine_quant[30];
657    static int pulses[30];
658    static int init=0;
659    if (!init)
660    {
661       for (i=0;i<st->mode->nbEBands;i++)
662          scanf("%d ", &fine_quant[i]);
663       for (i=0;i<st->mode->nbEBands;i++)
664          scanf("%d ", &pulses[i]);
665       init = 1;
666    }
667 #else
668    ALLOC(fine_quant, st->mode->nbEBands, int);
669    ALLOC(pulses, st->mode->nbEBands, int);
670 #endif
671
672    /* Bit allocation */
673    ALLOC(error, C*st->mode->nbEBands, celt_word16_t);
674    coarse_needed = quant_coarse_energy(st->mode, bandE, st->oldBandE, nbCompressedBytes*8/3, intra_ener, st->mode->prob, error, &enc);
675    coarse_needed = ((coarse_needed*3-1)>>3)+1;
676
677    /* Variable bitrate */
678    if (st->VBR_rate>0)
679    {
680      /* The target rate in 16th bits per frame */
681      int target=st->VBR_rate;
682    
683      /* Shortblocks get a large boost in bitrate, but since they are uncommon long blocks are not greatly effected */
684      if (shortBlocks)
685        target*=2;
686      else if (st->mode->nbShortMdcts > 1)
687        target-=(target+14)/28;     
688
689      /*The average energy is removed from the target and the actual energy added*/
690      target=target-588+ec_enc_tell(&enc, 4);
691
692      /* In VBR mode the frame size must not be reduced so much that it would result in the coarse energy busting its budget */
693      target=IMAX(coarse_needed,(target+64)/128);
694      nbCompressedBytes=IMIN(nbCompressedBytes,target);
695    }
696
697    ALLOC(offsets, st->mode->nbEBands, int);
698    ALLOC(stereo_mode, st->mode->nbEBands, int);
699    stereo_decision(st->mode, X, stereo_mode, st->mode->nbEBands);
700
701    for (i=0;i<st->mode->nbEBands;i++)
702       offsets[i] = 0;
703    bits = nbCompressedBytes*8 - ec_enc_tell(&enc, 0) - 1;
704    if (has_pitch)
705       bits -= st->mode->nbPBands;
706 #ifndef STDIN_TUNING
707    compute_allocation(st->mode, offsets, stereo_mode, bits, pulses, fine_quant);
708 #endif
709
710    quant_fine_energy(st->mode, bandE, st->oldBandE, error, fine_quant, &enc);
711
712    /* Residual quantisation */
713    if (C==1)
714       quant_bands(st->mode, X, P, NULL, has_pitch, gains, bandE, pulses, shortBlocks, has_fold, nbCompressedBytes*8, &enc);
715    else
716       quant_bands_stereo(st->mode, X, P, NULL, has_pitch, gains, bandE, pulses, shortBlocks, has_fold, nbCompressedBytes*8, &enc);
717
718    /* Re-synthesis of the coded audio if required */
719    if (st->pitch_available>0 || optional_synthesis!=NULL)
720    {
721       if (st->pitch_available>0 && st->pitch_available<MAX_PERIOD)
722         st->pitch_available+=st->frame_size;
723
724       /* Synthesis */
725       denormalise_bands(st->mode, X, freq, bandE);
726       
727       
728       CELT_MOVE(st->out_mem, st->out_mem+C*N, C*(MAX_PERIOD+st->overlap-N));
729       
730       compute_inv_mdcts(st->mode, shortBlocks, freq, transient_time, transient_shift, st->out_mem);
731       /* De-emphasis and put everything back at the right place in the synthesis history */
732       if (optional_synthesis != NULL) {
733          for (c=0;c<C;c++)
734          {
735             int j;
736             for (j=0;j<N;j++)
737             {
738                celt_sig_t tmp = MAC16_32_Q15(st->out_mem[C*(MAX_PERIOD-N)+C*j+c],
739                                    preemph,st->preemph_memD[c]);
740                st->preemph_memD[c] = tmp;
741                optional_synthesis[C*j+c] = SCALEOUT(SIG2WORD16(tmp));
742             }
743          }
744       }
745    }
746
747    /*fprintf (stderr, "remaining bits after encode = %d\n", nbCompressedBytes*8-ec_enc_tell(&enc, 0));*/
748    /*if (ec_enc_tell(&enc, 0) < nbCompressedBytes*8 - 7)
749       celt_warning_int ("many unused bits: ", nbCompressedBytes*8-ec_enc_tell(&enc, 0));*/
750
751    /* Finishing the stream with a 0101... pattern so that the decoder can check is everything's right */
752    {
753       int val = 0;
754       while (ec_enc_tell(&enc, 0) < nbCompressedBytes*8)
755       {
756          ec_enc_uint(&enc, val, 2);
757          val = 1-val;
758       }
759    }
760    ec_enc_done(&enc);
761    {
762       /*unsigned char *data;*/
763       int nbBytes = ec_byte_bytes(&buf);
764       if (nbBytes > nbCompressedBytes)
765       {
766          celt_warning_int ("got too many bytes:", nbBytes);
767          RESTORE_STACK;
768          return CELT_INTERNAL_ERROR;
769       }
770    }
771
772    RESTORE_STACK;
773    return nbCompressedBytes;
774 }
775
776 #ifdef FIXED_POINT
777 #ifndef DISABLE_FLOAT_API
778 int celt_encode_float(CELTEncoder * restrict st, const float * pcm, float * optional_synthesis, unsigned char *compressed, int nbCompressedBytes)
779 {
780    int j, ret;
781    const int C = CHANNELS(st->mode);
782    const int N = st->block_size;
783    VARDECL(celt_int16_t, in);
784    SAVE_STACK;
785    ALLOC(in, C*N, celt_int16_t);
786
787    for (j=0;j<C*N;j++)
788      in[j] = FLOAT2INT16(pcm[j]);
789
790    if (optional_synthesis != NULL) {
791      ret=celt_encode(st,in,in,compressed,nbCompressedBytes);
792       for (j=0;j<C*N;j++)
793          optional_synthesis[j]=in[j]*(1/32768.);
794    } else {
795      ret=celt_encode(st,in,NULL,compressed,nbCompressedBytes);
796    }
797    RESTORE_STACK;
798    return ret;
799
800 }
801 #endif /*DISABLE_FLOAT_API*/
802 #else
803 int celt_encode(CELTEncoder * restrict st, const celt_int16_t * pcm, celt_int16_t * optional_synthesis, unsigned char *compressed, int nbCompressedBytes)
804 {
805    int j, ret;
806    VARDECL(celt_sig_t, in);
807    const int C = CHANNELS(st->mode);
808    const int N = st->block_size;
809    SAVE_STACK;
810    ALLOC(in, C*N, celt_sig_t);
811    for (j=0;j<C*N;j++) {
812      in[j] = SCALEOUT(pcm[j]);
813    }
814
815    if (optional_synthesis != NULL) {
816       ret = celt_encode_float(st,in,in,compressed,nbCompressedBytes);
817       for (j=0;j<C*N;j++)
818          optional_synthesis[j] = FLOAT2INT16(in[j]);
819    } else {
820       ret = celt_encode_float(st,in,NULL,compressed,nbCompressedBytes);
821    }
822    RESTORE_STACK;
823    return ret;
824 }
825 #endif
826
827 int celt_encoder_ctl(CELTEncoder * restrict st, int request, ...)
828 {
829    va_list ap;
830    va_start(ap, request);
831    switch (request)
832    {
833       case CELT_SET_COMPLEXITY_REQUEST:
834       {
835          int value = va_arg(ap, celt_int32_t);
836          if (value<0 || value>10)
837             goto bad_arg;
838          if (value<=2) {
839             st->pitch_enabled = 0; 
840             st->pitch_available = 0;
841          } else {
842               st->pitch_enabled = 1;
843               if (st->pitch_available<1)
844                 st->pitch_available = 1;
845          }   
846       }
847       break;
848       case CELT_SET_LTP_REQUEST:
849       {
850          int value = va_arg(ap, celt_int32_t);
851          if (value<0 || value>1 || (value==1 && st->pitch_available==0))
852             goto bad_arg;
853          if (value==0)
854             st->pitch_enabled = 0;
855          else
856             st->pitch_enabled = 1;
857       }
858       break;
859       case CELT_SET_VBR_RATE_REQUEST:
860       {
861          int value = va_arg(ap, celt_int32_t);
862          if (value<0)
863             goto bad_arg;
864          if (value>3072000)
865             value = 3072000;
866          st->VBR_rate = ((st->mode->Fs<<3)+(st->block_size>>1))/st->block_size;
867          st->VBR_rate = ((value<<7)+(st->VBR_rate>>1))/st->VBR_rate;
868       }
869       break;
870       case CELT_RESET_STATE:
871       {
872          const CELTMode *mode = st->mode;
873          int C = mode->nbChannels;
874
875          if (st->pitch_available > 0) st->pitch_available = 1;
876
877          CELT_MEMSET(st->in_mem, 0, st->overlap*C);
878          CELT_MEMSET(st->out_mem, 0, (MAX_PERIOD+st->overlap)*C);
879
880          CELT_MEMSET(st->oldBandE, 0, C*mode->nbEBands);
881
882          CELT_MEMSET(st->preemph_memE, 0, C);
883          CELT_MEMSET(st->preemph_memD, 0, C);
884          st->delayedIntra = 1;
885       }
886       break;
887       default:
888          goto bad_request;
889    }
890    va_end(ap);
891    return CELT_OK;
892 bad_arg:
893    va_end(ap);
894    return CELT_BAD_ARG;
895 bad_request:
896    va_end(ap);
897    return CELT_UNIMPLEMENTED;
898 }
899
900 /****************************************************************************/
901 /*                                                                          */
902 /*                                DECODER                                   */
903 /*                                                                          */
904 /****************************************************************************/
905 #ifdef NEW_PLC
906 #define DECODE_BUFFER_SIZE 2048
907 #else
908 #define DECODE_BUFFER_SIZE MAX_PERIOD
909 #endif
910
911 /** Decoder state 
912  @brief Decoder state
913  */
914 struct CELTDecoder {
915    const CELTMode *mode;
916    int frame_size;
917    int block_size;
918    int overlap;
919
920    ec_byte_buffer buf;
921    ec_enc         enc;
922
923    celt_sig_t * restrict preemph_memD;
924
925    celt_sig_t *out_mem;
926    celt_sig_t *decode_mem;
927
928    celt_word16_t *oldBandE;
929    
930    int last_pitch_index;
931 };
932
933 CELTDecoder *celt_decoder_create(const CELTMode *mode)
934 {
935    int N, C;
936    CELTDecoder *st;
937
938    if (check_mode(mode) != CELT_OK)
939       return NULL;
940
941    N = mode->mdctSize;
942    C = CHANNELS(mode);
943    st = celt_alloc(sizeof(CELTDecoder));
944    
945    st->mode = mode;
946    st->frame_size = N;
947    st->block_size = N;
948    st->overlap = mode->overlap;
949
950    st->decode_mem = celt_alloc((DECODE_BUFFER_SIZE+st->overlap)*C*sizeof(celt_sig_t));
951    st->out_mem = st->decode_mem+DECODE_BUFFER_SIZE-MAX_PERIOD;
952    
953    st->oldBandE = (celt_word16_t*)celt_alloc(C*mode->nbEBands*sizeof(celt_word16_t));
954
955    st->preemph_memD = (celt_sig_t*)celt_alloc(C*sizeof(celt_sig_t));
956
957    st->last_pitch_index = 0;
958    return st;
959 }
960
961 void celt_decoder_destroy(CELTDecoder *st)
962 {
963    if (st == NULL)
964    {
965       celt_warning("NULL passed to celt_encoder_destroy");
966       return;
967    }
968    if (check_mode(st->mode) != CELT_OK)
969       return;
970
971
972    celt_free(st->decode_mem);
973    
974    celt_free(st->oldBandE);
975    
976    celt_free(st->preemph_memD);
977
978    celt_free(st);
979 }
980
981 /** Handles lost packets by just copying past data with the same offset as the last
982     pitch period */
983 #ifdef NEW_PLC
984 #include "plc.c"
985 #else
986 static void celt_decode_lost(CELTDecoder * restrict st, celt_word16_t * restrict pcm)
987 {
988    int c, N;
989    int pitch_index;
990    int i, len;
991    VARDECL(celt_sig_t, freq);
992    const int C = CHANNELS(st->mode);
993    int offset;
994    SAVE_STACK;
995    N = st->block_size;
996    ALLOC(freq,C*N, celt_sig_t);         /**< Interleaved signal MDCTs */
997    
998    len = N+st->mode->overlap;
999 #if 0
1000    pitch_index = st->last_pitch_index;
1001    
1002    /* Use the pitch MDCT as the "guessed" signal */
1003    compute_mdcts(st->mode, st->mode->window, st->out_mem+pitch_index*C, freq);
1004
1005 #else
1006    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);
1007    pitch_index = MAX_PERIOD-len-pitch_index;
1008    offset = MAX_PERIOD-pitch_index;
1009    while (offset+len >= MAX_PERIOD)
1010       offset -= pitch_index;
1011    compute_mdcts(st->mode, 0, st->out_mem+offset*C, freq);
1012    for (i=0;i<N;i++)
1013       freq[i] = ADD32(EPSILON, MULT16_32_Q15(QCONST16(.9f,15),freq[i]));
1014 #endif
1015    
1016    
1017    
1018    CELT_MOVE(st->out_mem, st->out_mem+C*N, C*(MAX_PERIOD+st->mode->overlap-N));
1019    /* Compute inverse MDCTs */
1020    compute_inv_mdcts(st->mode, 0, freq, -1, 0, st->out_mem);
1021
1022    for (c=0;c<C;c++)
1023    {
1024       int j;
1025       for (j=0;j<N;j++)
1026       {
1027          celt_sig_t tmp = MAC16_32_Q15(st->out_mem[C*(MAX_PERIOD-N)+C*j+c],
1028                                 preemph,st->preemph_memD[c]);
1029          st->preemph_memD[c] = tmp;
1030          pcm[C*j+c] = SCALEOUT(SIG2WORD16(tmp));
1031       }
1032    }
1033    RESTORE_STACK;
1034 }
1035 #endif
1036
1037 #ifdef FIXED_POINT
1038 int celt_decode(CELTDecoder * restrict st, const unsigned char *data, int len, celt_int16_t * restrict pcm)
1039 {
1040 #else
1041 int celt_decode_float(CELTDecoder * restrict st, const unsigned char *data, int len, celt_sig_t * restrict pcm)
1042 {
1043 #endif
1044    int i, c, N, N4;
1045    int has_pitch, has_fold;
1046    int pitch_index;
1047    int bits;
1048    ec_dec dec;
1049    ec_byte_buffer buf;
1050    VARDECL(celt_sig_t, freq);
1051    VARDECL(celt_norm_t, X);
1052    VARDECL(celt_norm_t, P);
1053    VARDECL(celt_ener_t, bandE);
1054    VARDECL(celt_pgain_t, gains);
1055    VARDECL(int, stereo_mode);
1056    VARDECL(int, fine_quant);
1057    VARDECL(int, pulses);
1058    VARDECL(int, offsets);
1059
1060    int shortBlocks;
1061    int intra_ener;
1062    int transient_time;
1063    int transient_shift;
1064    const int C = CHANNELS(st->mode);
1065    SAVE_STACK;
1066
1067    if (check_mode(st->mode) != CELT_OK)
1068       return CELT_INVALID_MODE;
1069
1070    N = st->block_size;
1071    N4 = (N-st->overlap)>>1;
1072
1073    ALLOC(freq, C*N, celt_sig_t); /**< Interleaved signal MDCTs */
1074    ALLOC(X, C*N, celt_norm_t);         /**< Interleaved normalised MDCTs */
1075    ALLOC(P, C*N, celt_norm_t);         /**< Interleaved normalised pitch MDCTs*/
1076    ALLOC(bandE, st->mode->nbEBands*C, celt_ener_t);
1077    ALLOC(gains, st->mode->nbPBands, celt_pgain_t);
1078    
1079    if (check_mode(st->mode) != CELT_OK)
1080    {
1081       RESTORE_STACK;
1082       return CELT_INVALID_MODE;
1083    }
1084    if (data == NULL)
1085    {
1086       celt_decode_lost(st, pcm);
1087       RESTORE_STACK;
1088       return 0;
1089    }
1090    if (len<0) {
1091      RESTORE_STACK;
1092      return CELT_BAD_ARG;
1093    }
1094    
1095    ec_byte_readinit(&buf,(unsigned char*)data,len);
1096    ec_dec_init(&dec,&buf);
1097    
1098    decode_flags(&dec, &intra_ener, &has_pitch, &shortBlocks, &has_fold);
1099    if (shortBlocks)
1100    {
1101       transient_shift = ec_dec_bits(&dec, 2);
1102       if (transient_shift)
1103          transient_time = ec_dec_uint(&dec, N+st->mode->overlap);
1104       else
1105          transient_time = 0;
1106    } else {
1107       transient_time = -1;
1108       transient_shift = 0;
1109    }
1110    
1111    if (has_pitch)
1112    {
1113       pitch_index = ec_dec_uint(&dec, MAX_PERIOD-(2*N-2*N4));
1114       st->last_pitch_index = pitch_index;
1115    } else {
1116       pitch_index = 0;
1117       for (i=0;i<st->mode->nbPBands;i++)
1118          gains[i] = 0;
1119    }
1120
1121    ALLOC(fine_quant, st->mode->nbEBands, int);
1122    /* Get band energies */
1123    unquant_coarse_energy(st->mode, bandE, st->oldBandE, len*8/3, intra_ener, st->mode->prob, &dec);
1124    
1125    ALLOC(pulses, st->mode->nbEBands, int);
1126    ALLOC(offsets, st->mode->nbEBands, int);
1127    ALLOC(stereo_mode, st->mode->nbEBands, int);
1128    stereo_decision(st->mode, X, stereo_mode, st->mode->nbEBands);
1129
1130    for (i=0;i<st->mode->nbEBands;i++)
1131       offsets[i] = 0;
1132
1133    bits = len*8 - ec_dec_tell(&dec, 0) - 1;
1134    if (has_pitch)
1135       bits -= st->mode->nbPBands;
1136    compute_allocation(st->mode, offsets, stereo_mode, bits, pulses, fine_quant);
1137    /*bits = ec_dec_tell(&dec, 0);
1138    compute_fine_allocation(st->mode, fine_quant, (20*C+len*8/5-(ec_dec_tell(&dec, 0)-bits))/C);*/
1139    
1140    unquant_fine_energy(st->mode, bandE, st->oldBandE, fine_quant, &dec);
1141
1142
1143    if (has_pitch) 
1144    {
1145       VARDECL(celt_ener_t, bandEp);
1146       
1147       /* Pitch MDCT */
1148       compute_mdcts(st->mode, 0, st->out_mem+pitch_index*C, freq);
1149       ALLOC(bandEp, st->mode->nbEBands*C, celt_ener_t);
1150       compute_band_energies(st->mode, freq, bandEp);
1151       normalise_bands(st->mode, freq, P, bandEp);
1152       /* Apply pitch gains */
1153    } else {
1154       for (i=0;i<C*N;i++)
1155          P[i] = 0;
1156    }
1157
1158    /* Decode fixed codebook and merge with pitch */
1159    if (C==1)
1160       unquant_bands(st->mode, X, P, has_pitch, gains, bandE, pulses, shortBlocks, has_fold, len*8, &dec);
1161    else
1162       unquant_bands_stereo(st->mode, X, P, has_pitch, gains, bandE, pulses, shortBlocks, has_fold, len*8, &dec);
1163
1164    /* Synthesis */
1165    denormalise_bands(st->mode, X, freq, bandE);
1166
1167
1168    CELT_MOVE(st->decode_mem, st->decode_mem+C*N, C*(DECODE_BUFFER_SIZE+st->overlap-N));
1169    /* Compute inverse MDCTs */
1170    compute_inv_mdcts(st->mode, shortBlocks, freq, transient_time, transient_shift, st->out_mem);
1171
1172    for (c=0;c<C;c++)
1173    {
1174       int j;
1175       for (j=0;j<N;j++)
1176       {
1177          celt_sig_t tmp = MAC16_32_Q15(st->out_mem[C*(MAX_PERIOD-N)+C*j+c],
1178                                 preemph,st->preemph_memD[c]);
1179          st->preemph_memD[c] = tmp;
1180          pcm[C*j+c] = SCALEOUT(SIG2WORD16(tmp));
1181       }
1182    }
1183
1184    {
1185       unsigned int val = 0;
1186       while (ec_dec_tell(&dec, 0) < len*8)
1187       {
1188          if (ec_dec_uint(&dec, 2) != val)
1189          {
1190             celt_warning("decode error");
1191             RESTORE_STACK;
1192             return CELT_CORRUPTED_DATA;
1193          }
1194          val = 1-val;
1195       }
1196    }
1197
1198    RESTORE_STACK;
1199    return 0;
1200    /*printf ("\n");*/
1201 }
1202
1203 #ifdef FIXED_POINT
1204 #ifndef DISABLE_FLOAT_API
1205 int celt_decode_float(CELTDecoder * restrict st, const unsigned char *data, int len, float * restrict pcm)
1206 {
1207    int j, ret;
1208    const int C = CHANNELS(st->mode);
1209    const int N = st->block_size;
1210    VARDECL(celt_int16_t, out);
1211    SAVE_STACK;
1212    ALLOC(out, C*N, celt_int16_t);
1213
1214    ret=celt_decode(st, data, len, out);
1215
1216    for (j=0;j<C*N;j++)
1217      pcm[j]=out[j]*(1/32768.);
1218    RESTORE_STACK;
1219    return ret;
1220 }
1221 #endif /*DISABLE_FLOAT_API*/
1222 #else
1223 int celt_decode(CELTDecoder * restrict st, const unsigned char *data, int len, celt_int16_t * restrict pcm)
1224 {
1225    int j, ret;
1226    VARDECL(celt_sig_t, out);
1227    const int C = CHANNELS(st->mode);
1228    const int N = st->block_size;
1229    SAVE_STACK;
1230    ALLOC(out, C*N, celt_sig_t);
1231
1232    ret=celt_decode_float(st, data, len, out);
1233
1234    for (j=0;j<C*N;j++)
1235      pcm[j] = FLOAT2INT16 (out[j]);
1236
1237    RESTORE_STACK;
1238    return ret;
1239 }
1240 #endif
1241
1242 int celt_decoder_ctl(CELTDecoder * restrict st, int request, ...)
1243 {
1244    va_list ap;
1245    va_start(ap, request);
1246    switch (request)
1247    {
1248       case CELT_RESET_STATE:
1249       {
1250          const CELTMode *mode = st->mode;
1251          int C = mode->nbChannels;
1252
1253          CELT_MEMSET(st->decode_mem, 0, (DECODE_BUFFER_SIZE+st->overlap)*C);
1254          CELT_MEMSET(st->oldBandE, 0, C*mode->nbEBands);
1255
1256          CELT_MEMSET(st->preemph_memD, 0, C);
1257
1258          st->last_pitch_index = 0;
1259       }
1260       break;
1261       default:
1262          goto bad_request;
1263    }
1264    va_end(ap);
1265    return CELT_OK;
1266 #if 0    /* Put this back in if you ever need "bad_arg" */
1267 bad_arg:
1268    va_end(ap);
1269    return CELT_BAD_ARG;
1270 #endif
1271 bad_request:
1272       va_end(ap);
1273   return CELT_UNIMPLEMENTED;
1274 }