35985b662c333d6a0c1010d39fe8b801b15203df
[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       if (Fs == static_mode_list[i]->Fs &&
282           frame_size == static_mode_list[i]->shortMdctSize*static_mode_list[i]->nbShortMdcts)
283       {
284          return (CELTMode*)static_mode_list[i];
285       }
286    }
287 #ifndef CUSTOM_MODES
288    if (error)
289       *error = CELT_BAD_ARG;
290    return NULL;
291 #else
292
293    /* The good thing here is that permutation of the arguments will automatically be invalid */
294    
295    if (Fs < 8000 || Fs > 96000)
296    {
297       if (error)
298          *error = CELT_BAD_ARG;
299       return NULL;
300    }
301    if (frame_size < 40 || frame_size > 1024 || frame_size%2!=0)
302    {
303       if (error)
304          *error = CELT_BAD_ARG;
305       return NULL;
306    }
307    
308    mode = celt_alloc(sizeof(CELTMode));
309    if (mode==NULL)
310       goto failure;
311    mode->Fs = Fs;
312
313    /* Pre/de-emphasis depends on sampling rate. The "standard" pre-emphasis
314       is defined as A(z) = 1 - 0.85*z^-1 at 48 kHz. Other rates should
315       approximate that. */
316    if(Fs < 12000) /* 8 kHz */
317    {
318       mode->preemph[0] =  QCONST16(0.3500061035f, 15);
319       mode->preemph[1] = -QCONST16(0.1799926758f, 15);
320       mode->preemph[2] =  QCONST16(0.2719968125f, SIG_SHIFT); /* exact 1/preemph[3] */
321       mode->preemph[3] =  QCONST16(3.6765136719f, 13);
322    } else if(Fs < 24000) /* 16 kHz */
323    {
324       mode->preemph[0] =  QCONST16(0.6000061035f, 15);
325       mode->preemph[1] = -QCONST16(0.1799926758f, 15);
326       mode->preemph[2] =  QCONST16(0.4424998650f, SIG_SHIFT); /* exact 1/preemph[3] */
327       mode->preemph[3] =  QCONST16(2.2598876953f, 13);
328    } else if(Fs < 40000) /* 32 kHz */
329    {
330       mode->preemph[0] =  QCONST16(0.7799987793f, 15);
331       mode->preemph[1] = -QCONST16(0.1000061035f, 15);
332       mode->preemph[2] =  QCONST16(0.7499771125f, SIG_SHIFT); /* exact 1/preemph[3] */
333       mode->preemph[3] =  QCONST16(1.3333740234f, 13);
334    } else /* 48 kHz */
335    {
336       mode->preemph[0] =  QCONST16(0.8500061035f, 15);
337       mode->preemph[1] =  QCONST16(0.0f, 15);
338       mode->preemph[2] =  QCONST16(1.f, SIG_SHIFT);
339       mode->preemph[3] =  QCONST16(1.f, 13);
340    }
341
342    if ((celt_int32)frame_size*75 >= Fs && (frame_size%16)==0)
343    {
344      LM = 3;
345    } else if ((celt_int32)frame_size*150 >= Fs && (frame_size%8)==0)
346    {
347      LM = 2;
348    } else if ((celt_int32)frame_size*300 >= Fs && (frame_size%4)==0)
349    {
350      LM = 1;
351    } else
352    {
353      LM = 0;
354    }
355
356    mode->maxLM = LM;
357    mode->nbShortMdcts = 1<<LM;
358    mode->shortMdctSize = frame_size/mode->nbShortMdcts;
359    res = (mode->Fs+mode->shortMdctSize)/(2*mode->shortMdctSize);
360
361    mode->eBands = compute_ebands(Fs, mode->shortMdctSize, res, &mode->nbEBands);
362    if (mode->eBands==NULL)
363       goto failure;
364
365    mode->effEBands = mode->nbEBands;
366    while (mode->eBands[mode->effEBands] > mode->shortMdctSize)
367       mode->effEBands--;
368    
369    /* Overlap must be divisible by 4 */
370    mode->overlap = ((mode->shortMdctSize>>2)<<2);
371
372    compute_allocation_table(mode);
373    if (mode->allocVectors==NULL)
374       goto failure;
375    
376    window = (celt_word16*)celt_alloc(mode->overlap*sizeof(celt_word16));
377    if (window==NULL)
378       goto failure;
379
380 #ifndef FIXED_POINT
381    for (i=0;i<mode->overlap;i++)
382       window[i] = Q15ONE*sin(.5*M_PI* sin(.5*M_PI*(i+.5)/mode->overlap) * sin(.5*M_PI*(i+.5)/mode->overlap));
383 #else
384    for (i=0;i<mode->overlap;i++)
385       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))));
386 #endif
387    mode->window = window;
388
389    logN = (celt_int16*)celt_alloc(mode->nbEBands*sizeof(celt_int16));
390    if (logN==NULL)
391       goto failure;
392
393    for (i=0;i<mode->nbEBands;i++)
394       logN[i] = log2_frac(mode->eBands[i+1]-mode->eBands[i], BITRES);
395    mode->logN = logN;
396
397    compute_pulse_cache(mode, mode->maxLM);
398
399    clt_mdct_init(&mode->mdct, 2*mode->shortMdctSize*mode->nbShortMdcts, mode->maxLM);
400    if ((mode->mdct.trig==NULL)
401 #ifndef ENABLE_TI_DSPLIB55
402          || (mode->mdct.kfft==NULL)
403 #endif
404    )
405       goto failure;
406
407    if (error)
408       *error = CELT_OK;
409
410    return mode;
411 failure: 
412    if (error)
413       *error = CELT_INVALID_MODE;
414    if (mode!=NULL)
415       celt_mode_destroy(mode);
416    return NULL;
417 #endif /* !CUSTOM_MODES */
418 }
419
420 void celt_mode_destroy(CELTMode *mode)
421 {
422 #ifdef CUSTOM_MODES
423    int i;
424    if (mode == NULL)
425       return;
426    for (i=0;i<TOTAL_MODES;i++)
427    {
428       if (mode == static_mode_list[i])
429       {
430          return;
431       }
432    }
433
434    celt_free((celt_int16*)mode->eBands);
435    celt_free((celt_int16*)mode->allocVectors);
436    
437    celt_free((celt_word16*)mode->window);
438    celt_free((celt_int16*)mode->logN);
439
440    celt_free((celt_int16*)mode->cache.index);
441    celt_free((unsigned char*)mode->cache.bits);
442    clt_mdct_clear(&mode->mdct);
443
444    celt_free((CELTMode *)mode);
445 #endif
446 }