Error handling in _create() functions
[opus.git] / libcelt / modes.c
1 /* Copyright (c) 2007-2008 CSIRO
2    Copyright (c) 2007-2009 Xiph.Org Foundation
3    Copyright (c) 2008 Gregory Maxwell 
4    Written by Jean-Marc Valin and Gregory Maxwell */
5 /*
6    Redistribution and use in source and binary forms, with or without
7    modification, are permitted provided that the following conditions
8    are met:
9    
10    - Redistributions of source code must retain the above copyright
11    notice, this list of conditions and the following disclaimer.
12    
13    - Redistributions in binary form must reproduce the above copyright
14    notice, this list of conditions and the following disclaimer in the
15    documentation and/or other materials provided with the distribution.
16    
17    - Neither the name of the Xiph.org Foundation nor the names of its
18    contributors may be used to endorse or promote products derived from
19    this software without specific prior written permission.
20    
21    THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
22    ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
23    LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
24    A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR
25    CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
26    EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
27    PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
28    PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
29    LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
30    NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
31    SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
32 */
33
34 #ifdef HAVE_CONFIG_H
35 #include "config.h"
36 #endif
37
38 #include "celt.h"
39 #include "modes.h"
40 #include "rate.h"
41 #include "os_support.h"
42 #include "stack_alloc.h"
43 #include "quant_bands.h"
44
45 static const celt_int16 eband5ms[] = {
46   0,  1,  2,  3,  4,  5,  6,  7,  8, 10, 12, 14, 16, 20, 24, 28, 34, 40, 48, 60, 78, 100
47 };
48
49 #if 0
50
51 #define BITALLOC_SIZE 9
52 /* Bit allocation table in units of 1/32 bit/sample (0.1875 dB SNR) */
53 static const unsigned char band_allocation[] = {
54 /*0  200 400 600 800  1k 1.2 1.4 1.6  2k 2.4 2.8 3.2  4k 4.8 5.6 6.8  8k 9.6 12k 15.6 */
55   0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
56  95, 90, 80, 75, 65, 60, 55, 50, 44, 40, 35, 30, 15,  1,  0,  0,  0,  0,  0,  0,  0,
57 100, 95, 90, 88, 85, 82, 78, 74, 70, 65, 60, 54, 45, 35, 25, 15,  1,  0,  0,  0,  0,
58 120,110,110,110,100, 96, 90, 88, 84, 76, 70, 65, 60, 45, 35, 25, 20,  1,  1,  0,  0,
59 135,125,125,125,115,112,104,104,100, 96, 83, 78, 70, 55, 46, 36, 32, 28, 20,  8,  0,
60 170,165,157,155,149,145,143,138,138,138,129,124,108, 96, 88, 83, 72, 56, 44, 28,  2,
61 192,192,160,160,160,160,160,160,160,160,150,140,120,110,100, 90, 80, 70, 60, 50, 20,
62 224,224,192,192,192,192,192,192,192,160,160,160,160,160,160,160,160,120, 80, 64, 40,
63 255,255,224,224,224,224,224,224,224,192,192,192,192,192,192,192,192,192,192,192,120,
64 };
65
66 #else
67
68 /* Alternate tuning (partially derived from Vorbis) */
69 #define BITALLOC_SIZE 12
70 /* Bit allocation table in units of 1/32 bit/sample (0.1875 dB SNR) */
71 static const unsigned char band_allocation[] = {
72 /*0  200 400 600 800  1k 1.2 1.4 1.6  2k 2.4 2.8 3.2  4k 4.8 5.6 6.8  8k 9.6 12k 15.6 */
73   0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
74  90, 80, 75, 69, 63, 56, 49, 40, 34, 29, 20, 18, 10,  0,  0,  0,  0,  0,  0,  0,  0,
75 110,100, 90, 84, 78, 71, 65, 58, 51, 45, 39, 32, 26, 20, 12,  0,  0,  0,  0,  0,  0,
76 118,110,103, 93, 86, 80, 75, 70, 65, 59, 53, 47, 40, 31, 23, 15,  4,  0,  0,  0,  0,
77 126,119,112,104, 95, 89, 83, 78, 72, 66, 60, 54, 47, 39, 32, 25, 17, 12,  1,  0,  0,
78 134,127,120,114,103, 97, 91, 85, 78, 72, 66, 60, 54, 47, 41, 35, 29, 23, 16, 10,  1,
79 144,137,130,124,113,107,101, 95, 88, 82, 76, 70, 64, 57, 51, 45, 39, 33, 26, 15,  1,
80 152,145,138,132,123,117,111,105, 98, 92, 86, 80, 74, 67, 61, 55, 49, 43, 36, 20,  1,
81 162,155,148,142,133,127,121,115,108,102, 96, 90, 84, 77, 71, 65, 59, 53, 46, 30,  1,
82 172,165,158,152,143,137,131,125,118,112,106,100, 94, 87, 81, 75, 69, 63, 56, 45, 20,
83 200,200,200,200,200,200,200,200,198,193,188,183,178,173,168,163,158,153,148,143,120,
84 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,
85 };
86 #endif
87
88 #ifdef FIXED_POINT
89 #include "static_modes_fixed.c"
90 #else
91 #include "static_modes_float.c"
92 #endif
93
94 #ifndef M_PI
95 #define M_PI 3.141592653
96 #endif
97
98
99 int celt_mode_info(const CELTMode *mode, int request, celt_int32 *value)
100 {
101    switch (request)
102    {
103       case CELT_GET_LOOKAHEAD:
104          *value = mode->overlap;
105          break;
106       case CELT_GET_BITSTREAM_VERSION:
107          *value = CELT_BITSTREAM_VERSION;
108          break;
109       case CELT_GET_SAMPLE_RATE:
110          *value = mode->Fs;
111          break;
112       default:
113          return CELT_UNIMPLEMENTED;
114    }
115    return CELT_OK;
116 }
117
118 #ifdef CUSTOM_MODES
119
120 /* Defining 25 critical bands for the full 0-20 kHz audio bandwidth
121    Taken from http://ccrma.stanford.edu/~jos/bbt/Bark_Frequency_Scale.html */
122 #define BARK_BANDS 25
123 static const celt_int16 bark_freq[BARK_BANDS+1] = {
124       0,   100,   200,   300,   400,
125     510,   630,   770,   920,  1080,
126    1270,  1480,  1720,  2000,  2320,
127    2700,  3150,  3700,  4400,  5300,
128    6400,  7700,  9500, 12000, 15500,
129   20000};
130
131 static celt_int16 *compute_ebands(celt_int32 Fs, int frame_size, int res, int *nbEBands)
132 {
133    celt_int16 *eBands;
134    int i, lin, low, high, nBark, offset=0;
135
136    /* All modes that have 2.5 ms short blocks use the same definition */
137    if (Fs == 400*(celt_int32)frame_size)
138    {
139       *nbEBands = sizeof(eband5ms)/sizeof(eband5ms[0])-1;
140       eBands = celt_alloc(sizeof(celt_int16)*(*nbEBands+1));
141       for (i=0;i<*nbEBands+1;i++)
142          eBands[i] = eband5ms[i];
143       return eBands;
144    }
145    /* Find the number of critical bands supported by our sampling rate */
146    for (nBark=1;nBark<BARK_BANDS;nBark++)
147     if (bark_freq[nBark+1]*2 >= Fs)
148        break;
149
150    /* Find where the linear part ends (i.e. where the spacing is more than min_width */
151    for (lin=0;lin<nBark;lin++)
152       if (bark_freq[lin+1]-bark_freq[lin] >= res)
153          break;
154
155    low = (bark_freq[lin]+res/2)/res;
156    high = nBark-lin;
157    *nbEBands = low+high;
158    eBands = celt_alloc(sizeof(celt_int16)*(*nbEBands+2));
159    
160    if (eBands==NULL)
161       return NULL;
162    
163    /* Linear spacing (min_width) */
164    for (i=0;i<low;i++)
165       eBands[i] = i;
166    if (low>0)
167       offset = eBands[low-1]*res - bark_freq[lin-1];
168    /* Spacing follows critical bands */
169    for (i=0;i<high;i++)
170    {
171       int target = bark_freq[lin+i];
172       /* Round to an even value */
173       eBands[i+low] = (target+offset/2+res)/(2*res)*2;
174       offset = eBands[i+low]*res - target;
175    }
176    /* Enforce the minimum spacing at the boundary */
177    for (i=0;i<*nbEBands;i++)
178       if (eBands[i] < i)
179          eBands[i] = i;
180    /* Round to an even value */
181    eBands[*nbEBands] = (bark_freq[nBark]+res)/(2*res)*2;
182    if (eBands[*nbEBands] > frame_size)
183       eBands[*nbEBands] = frame_size;
184    for (i=1;i<*nbEBands-1;i++)
185    {
186       if (eBands[i+1]-eBands[i] < eBands[i]-eBands[i-1])
187       {
188          eBands[i] -= (2*eBands[i]-eBands[i-1]-eBands[i+1])/2;
189       }
190    }
191    /*for (i=0;i<=*nbEBands+1;i++)
192       printf ("%d ", eBands[i]);
193    printf ("\n");
194    exit(1);*/
195    /* FIXME: Remove last band if too small */
196    return eBands;
197 }
198
199 static void compute_allocation_table(CELTMode *mode)
200 {
201    int i, j;
202    unsigned char *allocVectors;
203    int maxBands = sizeof(eband5ms)/sizeof(eband5ms[0])-1;
204
205    mode->nbAllocVectors = BITALLOC_SIZE;
206    allocVectors = celt_alloc(sizeof(unsigned char)*(BITALLOC_SIZE*mode->nbEBands));
207    if (allocVectors==NULL)
208       return;
209
210    /* Check for standard mode */
211    if (mode->Fs == 400*(celt_int32)mode->shortMdctSize)
212    {
213       for (i=0;i<BITALLOC_SIZE*mode->nbEBands;i++)
214          allocVectors[i] = band_allocation[i];
215       mode->allocVectors = allocVectors;
216       return;
217    }
218    /* If not the standard mode, interpolate */
219    /* Compute per-codec-band allocation from per-critical-band matrix */
220    for (i=0;i<BITALLOC_SIZE;i++)
221    {
222       for (j=0;j<mode->nbEBands;j++)
223       {
224          int k;
225          for (k=0;k<maxBands;k++)
226          {
227             if (400*(celt_int32)eband5ms[k] > mode->eBands[j]*(celt_int32)mode->Fs/mode->shortMdctSize)
228                break;
229          }
230          if (k>mode->nbEBands-1)
231             allocVectors[i*mode->nbEBands+j] = band_allocation[i*maxBands + maxBands-1];
232          else {
233             celt_int32 a0, a1;
234             a1 = mode->eBands[j]*(celt_int32)mode->Fs/mode->shortMdctSize - 400*(celt_int32)eband5ms[k-1];
235             a0 = 400*(celt_int32)eband5ms[k] - mode->eBands[j]*(celt_int32)mode->Fs/mode->shortMdctSize;
236             allocVectors[i*mode->nbEBands+j] = (a0*band_allocation[i*maxBands+k-1]
237                                              + a1*band_allocation[i*maxBands+k])/(a0+a1);
238          }
239       }
240    }
241
242    /*printf ("\n");
243    for (i=0;i<BITALLOC_SIZE;i++)
244    {
245       for (j=0;j<mode->nbEBands;j++)
246          printf ("%d ", allocVectors[i*mode->nbEBands+j]);
247       printf ("\n");
248    }
249    exit(0);*/
250
251    mode->allocVectors = allocVectors;
252 }
253
254 #endif /* CUSTOM_MODES */
255
256 CELTMode *celt_mode_create(celt_int32 Fs, int frame_size, int *error)
257 {
258    int i;
259    int res;
260    CELTMode *mode=NULL;
261    celt_word16 *window;
262    celt_int16 *logN;
263    int LM;
264 #ifdef STDIN_TUNING
265    scanf("%d ", &MIN_BINS);
266    scanf("%d ", &BITALLOC_SIZE);
267    band_allocation = celt_alloc(sizeof(int)*BARK_BANDS*BITALLOC_SIZE);
268    for (i=0;i<BARK_BANDS*BITALLOC_SIZE;i++)
269    {
270       scanf("%d ", band_allocation+i);
271    }
272 #endif
273    ALLOC_STACK;
274 #if !defined(VAR_ARRAYS) && !defined(USE_ALLOCA)
275    if (global_stack==NULL)
276       goto failure;
277 #endif 
278
279    for (i=0;i<TOTAL_MODES;i++)
280    {
281       int j;
282       for (j=0;j<4;j++)
283       {
284          if (Fs == static_mode_list[i]->Fs &&
285                (frame_size<<j) == static_mode_list[i]->shortMdctSize*static_mode_list[i]->nbShortMdcts)
286          {
287             if (error)
288                *error = CELT_OK;
289             return (CELTMode*)static_mode_list[i];
290          }
291       }
292    }
293 #ifndef CUSTOM_MODES
294    if (error)
295       *error = CELT_BAD_ARG;
296    return NULL;
297 #else
298
299    /* The good thing here is that permutation of the arguments will automatically be invalid */
300    
301    if (Fs < 8000 || Fs > 96000)
302    {
303       if (error)
304          *error = CELT_BAD_ARG;
305       return NULL;
306    }
307    if (frame_size < 40 || frame_size > 1024 || frame_size%2!=0)
308    {
309       if (error)
310          *error = CELT_BAD_ARG;
311       return NULL;
312    }
313    
314    mode = celt_alloc(sizeof(CELTMode));
315    if (mode==NULL)
316       goto failure;
317    mode->Fs = Fs;
318
319    /* Pre/de-emphasis depends on sampling rate. The "standard" pre-emphasis
320       is defined as A(z) = 1 - 0.85*z^-1 at 48 kHz. Other rates should
321       approximate that. */
322    if(Fs < 12000) /* 8 kHz */
323    {
324       mode->preemph[0] =  QCONST16(0.3500061035f, 15);
325       mode->preemph[1] = -QCONST16(0.1799926758f, 15);
326       mode->preemph[2] =  QCONST16(0.2719968125f, SIG_SHIFT); /* exact 1/preemph[3] */
327       mode->preemph[3] =  QCONST16(3.6765136719f, 13);
328    } else if(Fs < 24000) /* 16 kHz */
329    {
330       mode->preemph[0] =  QCONST16(0.6000061035f, 15);
331       mode->preemph[1] = -QCONST16(0.1799926758f, 15);
332       mode->preemph[2] =  QCONST16(0.4424998650f, SIG_SHIFT); /* exact 1/preemph[3] */
333       mode->preemph[3] =  QCONST16(2.2598876953f, 13);
334    } else if(Fs < 40000) /* 32 kHz */
335    {
336       mode->preemph[0] =  QCONST16(0.7799987793f, 15);
337       mode->preemph[1] = -QCONST16(0.1000061035f, 15);
338       mode->preemph[2] =  QCONST16(0.7499771125f, SIG_SHIFT); /* exact 1/preemph[3] */
339       mode->preemph[3] =  QCONST16(1.3333740234f, 13);
340    } else /* 48 kHz */
341    {
342       mode->preemph[0] =  QCONST16(0.8500061035f, 15);
343       mode->preemph[1] =  QCONST16(0.0f, 15);
344       mode->preemph[2] =  QCONST16(1.f, SIG_SHIFT);
345       mode->preemph[3] =  QCONST16(1.f, 13);
346    }
347
348    if ((celt_int32)frame_size*75 >= Fs && (frame_size%16)==0)
349    {
350      LM = 3;
351    } else if ((celt_int32)frame_size*150 >= Fs && (frame_size%8)==0)
352    {
353      LM = 2;
354    } else if ((celt_int32)frame_size*300 >= Fs && (frame_size%4)==0)
355    {
356      LM = 1;
357    } else
358    {
359      LM = 0;
360    }
361
362    mode->maxLM = LM;
363    mode->nbShortMdcts = 1<<LM;
364    mode->shortMdctSize = frame_size/mode->nbShortMdcts;
365    res = (mode->Fs+mode->shortMdctSize)/(2*mode->shortMdctSize);
366
367    mode->eBands = compute_ebands(Fs, mode->shortMdctSize, res, &mode->nbEBands);
368    if (mode->eBands==NULL)
369       goto failure;
370
371    mode->effEBands = mode->nbEBands;
372    while (mode->eBands[mode->effEBands] > mode->shortMdctSize)
373       mode->effEBands--;
374    
375    /* Overlap must be divisible by 4 */
376    mode->overlap = ((mode->shortMdctSize>>2)<<2);
377
378    compute_allocation_table(mode);
379    if (mode->allocVectors==NULL)
380       goto failure;
381    
382    window = (celt_word16*)celt_alloc(mode->overlap*sizeof(celt_word16));
383    if (window==NULL)
384       goto failure;
385
386 #ifndef FIXED_POINT
387    for (i=0;i<mode->overlap;i++)
388       window[i] = Q15ONE*sin(.5*M_PI* sin(.5*M_PI*(i+.5)/mode->overlap) * sin(.5*M_PI*(i+.5)/mode->overlap));
389 #else
390    for (i=0;i<mode->overlap;i++)
391       window[i] = MIN32(32767,floor(.5+32768.*sin(.5*M_PI* sin(.5*M_PI*(i+.5)/mode->overlap) * sin(.5*M_PI*(i+.5)/mode->overlap))));
392 #endif
393    mode->window = window;
394
395    logN = (celt_int16*)celt_alloc(mode->nbEBands*sizeof(celt_int16));
396    if (logN==NULL)
397       goto failure;
398
399    for (i=0;i<mode->nbEBands;i++)
400       logN[i] = log2_frac(mode->eBands[i+1]-mode->eBands[i], BITRES);
401    mode->logN = logN;
402
403    compute_pulse_cache(mode, mode->maxLM);
404
405    clt_mdct_init(&mode->mdct, 2*mode->shortMdctSize*mode->nbShortMdcts, mode->maxLM);
406    if ((mode->mdct.trig==NULL)
407 #ifndef ENABLE_TI_DSPLIB55
408          || (mode->mdct.kfft==NULL)
409 #endif
410    )
411       goto failure;
412
413    if (error)
414       *error = CELT_OK;
415
416    return mode;
417 failure: 
418    if (error)
419       *error = CELT_INVALID_MODE;
420    if (mode!=NULL)
421       celt_mode_destroy(mode);
422    return NULL;
423 #endif /* !CUSTOM_MODES */
424 }
425
426 void celt_mode_destroy(CELTMode *mode)
427 {
428 #ifdef CUSTOM_MODES
429    int i;
430    if (mode == NULL)
431       return;
432    for (i=0;i<TOTAL_MODES;i++)
433    {
434       if (mode == static_mode_list[i])
435       {
436          return;
437       }
438    }
439
440    celt_free((celt_int16*)mode->eBands);
441    celt_free((celt_int16*)mode->allocVectors);
442    
443    celt_free((celt_word16*)mode->window);
444    celt_free((celt_int16*)mode->logN);
445
446    celt_free((celt_int16*)mode->cache.index);
447    celt_free((unsigned char*)mode->cache.bits);
448    clt_mdct_clear(&mode->mdct);
449
450    celt_free((CELTMode *)mode);
451 #endif
452 }