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