Gives an error when trying to create a stereo mode with DISABLE_STEREO defined.
[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;
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    if (mode->nbShortMdcts > 1)
388       mode->overlap = ((frame_size/mode->nbShortMdcts)>>2)<<2; /* Overlap must be divisible by 4 */
389    else
390       mode->overlap = (frame_size>>3)<<2;
391
392    compute_allocation_table(mode, res);
393    if (mode->allocVectors==NULL)
394       goto failure;
395    /*printf ("%d bands\n", mode->nbEBands);*/
396    
397    window = (celt_word16_t*)celt_alloc(mode->overlap*sizeof(celt_word16_t));
398    if (window==NULL)
399       goto failure;
400
401 #ifndef FIXED_POINT
402    for (i=0;i<mode->overlap;i++)
403       window[i] = Q15ONE*sin(.5*M_PI* sin(.5*M_PI*(i+.5)/mode->overlap) * sin(.5*M_PI*(i+.5)/mode->overlap));
404 #else
405    for (i=0;i<mode->overlap;i++)
406       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)));
407 #endif
408    mode->window = window;
409
410    mode->bits = (const celt_int16_t **)compute_alloc_cache(mode, 1);
411    if (mode->bits==NULL)
412       goto failure;
413
414 #ifndef SHORTCUTS
415    psydecay_init(&mode->psy, MAX_PERIOD/2, mode->Fs);
416    if (mode->psy.decayR==NULL)
417       goto failure;
418 #endif
419    
420 #endif /* !STATIC_MODES */
421
422 #ifdef DISABLE_STEREO
423    if (channels > 1)
424    {
425       celt_warning("Stereo support was disable from this build");
426       if (error)
427          *error = CELT_BAD_ARG;
428       return NULL;
429    }
430 #endif
431
432    mdct_init(&mode->mdct, 2*mode->mdctSize);
433    mode->fft = pitch_state_alloc(MAX_PERIOD);
434
435    mode->shortMdctSize = mode->mdctSize/mode->nbShortMdcts;
436    mdct_init(&mode->shortMdct, 2*mode->shortMdctSize);
437    mode->shortWindow = mode->window;
438    mode->prob = quant_prob_alloc(mode);
439    if ((mode->mdct.trig==NULL) || (mode->mdct.kfft==NULL) || (mode->fft==NULL) ||
440        (mode->shortMdct.trig==NULL) || (mode->shortMdct.kfft==NULL) || (mode->prob==NULL))
441      goto failure;
442
443    mode->marker_start = MODEVALID;
444    mode->marker_end   = MODEVALID;
445    if (error)
446       *error = CELT_OK;
447    return mode;
448 failure: 
449    if (error)
450       *error = CELT_INVALID_MODE;
451    if (mode!=NULL)
452       celt_mode_destroy(mode);
453    return NULL;
454 }
455
456 void celt_mode_destroy(CELTMode *mode)
457 {
458    int i;
459    const celt_int16_t *prevPtr = NULL;
460    if (mode == NULL)
461    {
462       celt_warning("NULL passed to celt_mode_destroy");
463       return;
464    }
465
466    if (mode->marker_start == MODEFREED || mode->marker_end == MODEFREED)
467    {
468       celt_warning("Freeing a mode which has already been freed"); 
469       return;
470    }
471
472    if (mode->marker_start != MODEVALID && mode->marker_start != MODEPARTIAL)
473    {
474       celt_warning("This is not a valid CELT mode structure");
475       return;  
476    }
477    mode->marker_start = MODEFREED;
478 #ifndef STATIC_MODES
479    if (mode->bits!=NULL)
480    {
481       for (i=0;i<mode->nbEBands;i++)
482       {
483          if (mode->bits[i] != prevPtr)
484          {
485             prevPtr = mode->bits[i];
486             celt_free((int*)mode->bits[i]);
487           }
488       }
489    }   
490    celt_free((int**)mode->bits);
491    celt_free((int*)mode->eBands);
492    celt_free((int*)mode->pBands);
493    celt_free((int*)mode->allocVectors);
494    
495    celt_free((celt_word16_t*)mode->window);
496
497 #ifndef SHORTCUTS
498    psydecay_clear(&mode->psy);
499 #endif
500 #endif
501    mdct_clear(&mode->mdct);
502    mdct_clear(&mode->shortMdct);
503    pitch_state_free(mode->fft);
504    quant_prob_free(mode->prob);
505    mode->marker_end = MODEFREED;
506    celt_free((CELTMode *)mode);
507 }
508
509 int check_mode(const CELTMode *mode)
510 {
511    if (mode==NULL)
512       return CELT_INVALID_MODE;
513    if (mode->marker_start == MODEVALID && mode->marker_end == MODEVALID)
514       return CELT_OK;
515    if (mode->marker_start == MODEFREED || mode->marker_end == MODEFREED)
516       celt_warning("Using a mode that has already been freed");
517    else
518       celt_warning("This is not a valid CELT mode");
519    return CELT_INVALID_MODE;
520 }