ietf doc: more source code formatting changes, got rid of float_cast.h
[opus.git] / libcelt / modes.c
1 /* (C) 2007-2009 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 #include "celt.h"
37 #include "modes.h"
38 #include "rate.h"
39 #include "os_support.h"
40 #include "stack_alloc.h"
41 #include "quant_bands.h"
42
43 #ifdef STATIC_MODES
44 #include "static_modes.c"
45 #endif
46
47 #define MODEVALID   0xa110ca7e
48 #define MODEPARTIAL 0x7eca10a1
49 #define MODEFREED   0xb10cf8ee
50
51 #ifndef M_PI
52 #define M_PI 3.141592653
53 #endif
54
55
56 int celt_mode_info(const CELTMode *mode, int request, celt_int32_t *value)
57 {
58    if (check_mode(mode) != CELT_OK)
59       return CELT_INVALID_MODE;
60    switch (request)
61    {
62       case CELT_GET_FRAME_SIZE:
63          *value = mode->mdctSize;
64          break;
65       case CELT_GET_LOOKAHEAD:
66          *value = mode->overlap;
67          break;
68       case CELT_GET_NB_CHANNELS:
69          *value = mode->nbChannels;
70          break;
71       case CELT_GET_BITSTREAM_VERSION:
72          *value = CELT_BITSTREAM_VERSION;
73          break;
74       case CELT_GET_SAMPLE_RATE:
75          *value = mode->Fs;
76          break;
77       default:
78          return CELT_UNIMPLEMENTED;
79    }
80    return CELT_OK;
81 }
82
83 #ifndef STATIC_MODES
84
85 #define PBANDS 8
86
87 #ifdef STDIN_TUNING
88 int MIN_BINS;
89 #else
90 #define MIN_BINS 3
91 #endif
92
93 /* Defining 25 critical bands for the full 0-20 kHz audio bandwidth
94    Taken from http://ccrma.stanford.edu/~jos/bbt/Bark_Frequency_Scale.html */
95 #define BARK_BANDS 25
96 static const celt_int16_t bark_freq[BARK_BANDS+1] = {
97       0,   100,   200,   300,   400,
98     510,   630,   770,   920,  1080,
99    1270,  1480,  1720,  2000,  2320,
100    2700,  3150,  3700,  4400,  5300,
101    6400,  7700,  9500, 12000, 15500,
102   20000};
103
104 static const celt_int16_t pitch_freq[PBANDS+1] ={0, 345, 689, 1034, 1378, 2067, 3273, 5340, 6374};
105
106 /* This allocation table is per critical band. When creating a mode, the bits get added together 
107    into the codec bands, which are sometimes larger than one critical band at low frequency */
108
109 #ifdef STDIN_TUNING
110 int BITALLOC_SIZE;
111 int *band_allocation;
112 #else
113 #define BITALLOC_SIZE 12
114 static const int band_allocation[BARK_BANDS*BITALLOC_SIZE] = 
115    {  4,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
116       2,  2,  1,  1,  2,  2,  1,  1,  1,  1,  1,  1,  1,  1,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
117       2,  2,  2,  1,  2,  2,  2,  2,  2,  1,  2,  2,  4,  5,  7,  7,  7,  5,  4,  0,  0,  0,  0,  0,  0,
118       2,  2,  2,  2,  3,  2,  2,  2,  2,  2,  3,  3,  5,  6,  8,  8,  8,  6,  5,  4,  0,  0,  0,  0,  0,
119       3,  2,  2,  2,  3,  3,  2,  3,  2,  3,  4,  4,  6,  7,  9,  9,  9,  7,  6,  5,  5,  5,  0,  0,  0,
120       3,  3,  2,  2,  3,  3,  3,  3,  3,  4,  4,  5,  7,  9, 10, 10, 10,  9,  6,  5,  5,  5,  5,  1,  0,
121       4,  3,  3,  3,  3,  3,  3,  3,  4,  4,  6,  7,  7,  9, 11, 10, 10,  9,  9,  8, 11, 10, 10,  1,  1,
122       5,  5,  5,  5,  5,  5,  5,  6,  6,  6,  8,  8, 10, 12, 12, 11, 11, 17, 12, 15, 15, 20, 18, 10,  1,
123       8,  7,  7,  7,  7,  7,  8,  8,  9, 10, 11, 12, 14, 17, 18, 21, 22, 27, 29, 39, 37, 38, 40, 35,  1,
124       7,  7,  7,  7,  7,  7, 10, 10, 10, 13, 14, 18, 20, 24, 28, 32, 32, 35, 38, 38, 42, 50, 59, 54, 31,
125       8,  8,  8,  8,  8,  9, 10, 12, 14, 20, 22, 25, 28, 30, 35, 42, 46, 50, 55, 60, 62, 62, 72, 82, 62,
126       9,  9,  9, 10, 12, 13, 15, 18, 22, 30, 32, 35, 40, 45, 55, 62, 66, 70, 85, 90, 92, 92, 92,102, 92,
127    };
128 #endif
129
130 static celt_int16_t *compute_ebands(celt_int32_t Fs, int frame_size, int *nbEBands)
131 {
132    celt_int16_t *eBands;
133    int i, res, min_width, lin, low, high, nBark;
134    res = (Fs+frame_size)/(2*frame_size);
135    min_width = MIN_BINS*res;
136    /*printf ("min_width = %d\n", min_width);*/
137
138    /* Find the number of critical bands supported by our sampling rate */
139    for (nBark=1;nBark<BARK_BANDS;nBark++)
140     if (bark_freq[nBark+1]*2 >= Fs)
141        break;
142
143    /* Find where the linear part ends (i.e. where the spacing is more than min_width */
144    for (lin=0;lin<nBark;lin++)
145       if (bark_freq[lin+1]-bark_freq[lin] >= min_width)
146          break;
147    
148    /*printf ("lin = %d (%d Hz)\n", lin, bark_freq[lin]);*/
149    low = ((bark_freq[lin]/res)+(MIN_BINS-1))/MIN_BINS;
150    high = nBark-lin;
151    *nbEBands = low+high;
152    eBands = celt_alloc(sizeof(celt_int16_t)*(*nbEBands+2));
153    
154    if (eBands==NULL)
155       return NULL;
156    
157    /* Linear spacing (min_width) */
158    for (i=0;i<low;i++)
159       eBands[i] = MIN_BINS*i;
160    /* Spacing follows critical bands */
161    for (i=0;i<high;i++)
162       eBands[i+low] = (bark_freq[lin+i]+res/2)/res;
163    /* Enforce the minimum spacing at the boundary */
164    for (i=0;i<*nbEBands;i++)
165       if (eBands[i] < MIN_BINS*i)
166          eBands[i] = MIN_BINS*i;
167    eBands[*nbEBands] = (bark_freq[nBark]+res/2)/res;
168    eBands[*nbEBands+1] = frame_size;
169    if (eBands[*nbEBands] > eBands[*nbEBands+1])
170       eBands[*nbEBands] = eBands[*nbEBands+1];
171    
172    /* FIXME: Remove last band if too small */
173    /*for (i=0;i<*nbEBands+2;i++)
174       printf("%d ", eBands[i]);
175    printf ("\n");
176    exit(1);*/
177    return eBands;
178 }
179
180 static void compute_pbands(CELTMode *mode, int res)
181 {
182    int i;
183    celt_int16_t *pBands;
184    pBands=celt_alloc(sizeof(celt_int16_t)*(PBANDS+2));
185    mode->pBands = pBands;
186    if (pBands==NULL)
187      return;
188    mode->nbPBands = PBANDS;
189    for (i=0;i<PBANDS+1;i++)
190    {
191       pBands[i] = (pitch_freq[i]+res/2)/res;
192       if (pBands[i] < mode->eBands[i])
193          pBands[i] = mode->eBands[i];
194    }
195    pBands[PBANDS+1] = mode->eBands[mode->nbEBands+1];
196    for (i=1;i<mode->nbPBands+1;i++)
197    {
198       int j;
199       for (j=0;j<mode->nbEBands;j++)
200          if (mode->eBands[j] <= pBands[i] && mode->eBands[j+1] > pBands[i])
201             break;
202       /*printf ("%d %d\n", i, j);*/
203       if (mode->eBands[j] != pBands[i])
204       {
205          if (pBands[i]-mode->eBands[j] < mode->eBands[j+1]-pBands[i] && 
206              mode->eBands[j] != pBands[i-1])
207             pBands[i] = mode->eBands[j];
208          else
209             pBands[i] = mode->eBands[j+1];
210       }
211    }
212    /*for (i=0;i<mode->nbPBands+2;i++)
213       printf("%d ", pBands[i]);
214    printf ("\n");*/
215    mode->pitchEnd = pBands[PBANDS];
216 }
217
218 static void compute_allocation_table(CELTMode *mode, int res)
219 {
220    int i, j, nBark;
221    celt_int16_t *allocVectors;
222    const int C = CHANNELS(mode);
223
224    /* Find the number of critical bands supported by our sampling rate */
225    for (nBark=1;nBark<BARK_BANDS;nBark++)
226     if (bark_freq[nBark+1]*2 >= mode->Fs)
227        break;
228
229    mode->nbAllocVectors = BITALLOC_SIZE;
230    allocVectors = celt_alloc(sizeof(celt_int16_t)*(BITALLOC_SIZE*mode->nbEBands));
231    if (allocVectors==NULL)
232       return;
233    /* Compute per-codec-band allocation from per-critical-band matrix */
234    for (i=0;i<BITALLOC_SIZE;i++)
235    {
236       celt_int32_t current = 0;
237       int eband = 0;
238       for (j=0;j<nBark;j++)
239       {
240          int edge, low;
241          celt_int32_t alloc;
242          edge = mode->eBands[eband+1]*res;
243          alloc = band_allocation[i*BARK_BANDS+j];
244          alloc = alloc*C*mode->mdctSize;
245          if (edge < bark_freq[j+1])
246          {
247             int num, den;
248             num = alloc * (edge-bark_freq[j]);
249             den = bark_freq[j+1]-bark_freq[j];
250             low = (num+den/2)/den;
251             allocVectors[i*mode->nbEBands+eband] = (current+low+128)/256;
252             current=0;
253             eband++;
254             current += alloc-low;
255          } else {
256             current += alloc;
257          }   
258       }
259       allocVectors[i*mode->nbEBands+eband] = (current+128)/256;
260    }
261    mode->allocVectors = allocVectors;
262 }
263
264 #endif /* STATIC_MODES */
265
266 CELTMode *celt_mode_create(celt_int32_t Fs, int channels, int frame_size, int *error)
267 {
268    int i;
269 #ifdef STDIN_TUNING
270    scanf("%d ", &MIN_BINS);
271    scanf("%d ", &BITALLOC_SIZE);
272    band_allocation = celt_alloc(sizeof(int)*BARK_BANDS*BITALLOC_SIZE);
273    for (i=0;i<BARK_BANDS*BITALLOC_SIZE;i++)
274    {
275       scanf("%d ", band_allocation+i);
276    }
277 #endif
278 #ifdef STATIC_MODES
279    const CELTMode *m = NULL;
280    CELTMode *mode=NULL;
281    ALLOC_STACK;
282 #if !defined(VAR_ARRAYS) && !defined(USE_ALLOCA)
283    if (global_stack==NULL)
284    {
285       celt_free(global_stack);
286       goto failure;
287    }
288 #endif 
289    for (i=0;i<TOTAL_MODES;i++)
290    {
291       if (Fs == static_mode_list[i]->Fs &&
292           channels == static_mode_list[i]->nbChannels &&
293           frame_size == static_mode_list[i]->mdctSize)
294       {
295          m = static_mode_list[i];
296          break;
297       }
298    }
299    if (m == NULL)
300    {
301       celt_warning("Mode not included as part of the static modes");
302       if (error)
303          *error = CELT_BAD_ARG;
304       return NULL;
305    }
306    mode = (CELTMode*)celt_alloc(sizeof(CELTMode));
307    if (mode==NULL)
308       goto failure;
309    CELT_COPY(mode, m, 1);
310    mode->marker_start = MODEPARTIAL;
311 #else
312    int res;
313    CELTMode *mode=NULL;
314    celt_word16_t *window;
315    ALLOC_STACK;
316 #if !defined(VAR_ARRAYS) && !defined(USE_ALLOCA)
317    if (global_stack==NULL)
318    {
319       celt_free(global_stack);
320       goto failure;
321    }
322 #endif 
323
324    /* The good thing here is that permutation of the arguments will automatically be invalid */
325    
326    if (Fs < 32000 || Fs > 96000)
327    {
328       celt_warning("Sampling rate must be between 32 kHz and 96 kHz");
329       if (error)
330          *error = CELT_BAD_ARG;
331       return NULL;
332    }
333    if (channels < 0 || channels > 2)
334    {
335       celt_warning("Only mono and stereo supported");
336       if (error)
337          *error = CELT_BAD_ARG;
338       return NULL;
339    }
340    if (frame_size < 64 || frame_size > 512 || frame_size%2!=0)
341    {
342       celt_warning("Only even frame sizes from 64 to 512 are supported");
343       if (error)
344          *error = CELT_BAD_ARG;
345       return NULL;
346    }
347    res = (Fs+frame_size)/(2*frame_size);
348    
349    mode = celt_alloc(sizeof(CELTMode));
350    if (mode==NULL)
351       goto failure;
352    mode->marker_start = MODEPARTIAL;
353    mode->Fs = Fs;
354    mode->mdctSize = frame_size;
355    mode->nbChannels = channels;
356    mode->eBands = compute_ebands(Fs, frame_size, &mode->nbEBands);
357    if (mode->eBands==NULL)
358       goto failure;
359    compute_pbands(mode, res);
360    if (mode->pBands==NULL)
361       goto failure;
362    mode->ePredCoef = QCONST16(.8f,15);
363
364    if (frame_size > 384 && (frame_size%8)==0)
365    {
366      mode->nbShortMdcts = 4;
367    } else if (frame_size > 384 && (frame_size%10)==0)
368    {
369      mode->nbShortMdcts = 5;
370    } else if (frame_size > 256 && (frame_size%6)==0)
371    {
372      mode->nbShortMdcts = 3;
373    } else if (frame_size > 256 && (frame_size%8)==0)
374    {
375      mode->nbShortMdcts = 4;
376    } else if (frame_size > 64 && (frame_size%4)==0)
377    {
378      mode->nbShortMdcts = 2;
379    } else if (frame_size > 128 && (frame_size%6)==0)
380    {
381      mode->nbShortMdcts = 3;
382    } else
383    {
384      mode->nbShortMdcts = 1;
385    }
386
387    /* Overlap must be divisible by 4 */
388    if (mode->nbShortMdcts > 1)
389       mode->overlap = ((frame_size/mode->nbShortMdcts)>>2)<<2; 
390    else
391       mode->overlap = (frame_size>>3)<<2;
392
393    compute_allocation_table(mode, res);
394    if (mode->allocVectors==NULL)
395       goto failure;
396    /*printf ("%d bands\n", mode->nbEBands);*/
397    
398    window = (celt_word16_t*)celt_alloc(mode->overlap*sizeof(celt_word16_t));
399    if (window==NULL)
400       goto failure;
401
402 #ifndef FIXED_POINT
403    for (i=0;i<mode->overlap;i++)
404       window[i] = Q15ONE*sin(.5*M_PI* sin(.5*M_PI*(i+.5)/mode->overlap) * sin(.5*M_PI*(i+.5)/mode->overlap));
405 #else
406    for (i=0;i<mode->overlap;i++)
407       window[i] = MIN32(32767,32768.*sin(.5*M_PI* sin(.5*M_PI*(i+.5)/mode->overlap) * sin(.5*M_PI*(i+.5)/mode->overlap)));
408 #endif
409    mode->window = window;
410
411    mode->bits = (const celt_int16_t **)compute_alloc_cache(mode, 1);
412    if (mode->bits==NULL)
413       goto failure;
414
415 #ifndef SHORTCUTS
416    psydecay_init(&mode->psy, MAX_PERIOD/2, mode->Fs);
417    if (mode->psy.decayR==NULL)
418       goto failure;
419 #endif
420    
421 #endif /* !STATIC_MODES */
422
423 #ifdef DISABLE_STEREO
424    if (channels > 1)
425    {
426       celt_warning("Stereo support was disable from this build");
427       if (error)
428          *error = CELT_BAD_ARG;
429       return NULL;
430    }
431 #endif
432
433    mdct_init(&mode->mdct, 2*mode->mdctSize);
434    mode->fft = pitch_state_alloc(MAX_PERIOD);
435
436    mode->shortMdctSize = mode->mdctSize/mode->nbShortMdcts;
437    mdct_init(&mode->shortMdct, 2*mode->shortMdctSize);
438    mode->shortWindow = mode->window;
439    mode->prob = quant_prob_alloc(mode);
440    if ((mode->mdct.trig==NULL) || (mode->mdct.kfft==NULL) || (mode->fft==NULL) ||
441        (mode->shortMdct.trig==NULL) || (mode->shortMdct.kfft==NULL) || (mode->prob==NULL))
442      goto failure;
443
444    mode->marker_start = MODEVALID;
445    mode->marker_end   = MODEVALID;
446    if (error)
447       *error = CELT_OK;
448    return mode;
449 failure: 
450    if (error)
451       *error = CELT_INVALID_MODE;
452    if (mode!=NULL)
453       celt_mode_destroy(mode);
454    return NULL;
455 }
456
457 void celt_mode_destroy(CELTMode *mode)
458 {
459    int i;
460    const celt_int16_t *prevPtr = NULL;
461    if (mode == NULL)
462    {
463       celt_warning("NULL passed to celt_mode_destroy");
464       return;
465    }
466
467    if (mode->marker_start == MODEFREED || mode->marker_end == MODEFREED)
468    {
469       celt_warning("Freeing a mode which has already been freed"); 
470       return;
471    }
472
473    if (mode->marker_start != MODEVALID && mode->marker_start != MODEPARTIAL)
474    {
475       celt_warning("This is not a valid CELT mode structure");
476       return;  
477    }
478    mode->marker_start = MODEFREED;
479 #ifndef STATIC_MODES
480    if (mode->bits!=NULL)
481    {
482       for (i=0;i<mode->nbEBands;i++)
483       {
484          if (mode->bits[i] != prevPtr)
485          {
486             prevPtr = mode->bits[i];
487             celt_free((int*)mode->bits[i]);
488           }
489       }
490    }   
491    celt_free((int**)mode->bits);
492    celt_free((int*)mode->eBands);
493    celt_free((int*)mode->pBands);
494    celt_free((int*)mode->allocVectors);
495    
496    celt_free((celt_word16_t*)mode->window);
497
498 #ifndef SHORTCUTS
499    psydecay_clear(&mode->psy);
500 #endif
501 #endif
502    mdct_clear(&mode->mdct);
503    mdct_clear(&mode->shortMdct);
504    pitch_state_free(mode->fft);
505    quant_prob_free(mode->prob);
506    mode->marker_end = MODEFREED;
507    celt_free((CELTMode *)mode);
508 }
509
510 int check_mode(const CELTMode *mode)
511 {
512    if (mode==NULL)
513       return CELT_INVALID_MODE;
514    if (mode->marker_start == MODEVALID && mode->marker_end == MODEVALID)
515       return CELT_OK;
516    if (mode->marker_start == MODEFREED || mode->marker_end == MODEFREED)
517       celt_warning("Using a mode that has already been freed");
518    else
519       celt_warning("This is not a valid CELT mode");
520    return CELT_INVALID_MODE;
521 }