Remove model markers
[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 #ifdef STATIC_MODES
46 #include "static_modes.c"
47 #endif
48
49 #ifndef M_PI
50 #define M_PI 3.141592653
51 #endif
52
53
54 int celt_mode_info(const CELTMode *mode, int request, celt_int32 *value)
55 {
56    switch (request)
57    {
58       case CELT_GET_LOOKAHEAD:
59          *value = mode->overlap;
60          break;
61       case CELT_GET_BITSTREAM_VERSION:
62          *value = CELT_BITSTREAM_VERSION;
63          break;
64       case CELT_GET_SAMPLE_RATE:
65          *value = mode->Fs;
66          break;
67       default:
68          return CELT_UNIMPLEMENTED;
69    }
70    return CELT_OK;
71 }
72
73 #ifndef STATIC_MODES
74
75 /* Defining 25 critical bands for the full 0-20 kHz audio bandwidth
76    Taken from http://ccrma.stanford.edu/~jos/bbt/Bark_Frequency_Scale.html */
77 #define BARK_BANDS 25
78 static const celt_int16 bark_freq[BARK_BANDS+1] = {
79       0,   100,   200,   300,   400,
80     510,   630,   770,   920,  1080,
81    1270,  1480,  1720,  2000,  2320,
82    2700,  3150,  3700,  4400,  5300,
83    6400,  7700,  9500, 12000, 15500,
84   20000};
85
86 /* This allocation table is per critical band. When creating a mode, the bits get added together 
87    into the codec bands, which are sometimes larger than one critical band at low frequency */
88
89 #define BITALLOC_SIZE 10
90
91 static const celt_int16 eband5ms[] = {
92        0,  1,  2,  3,  4,  5,  6,  7,  8, 10, 12, 14, 16, 20, 24, 28, 34, 40, 48, 60, 78, 100
93 };
94
95 static const unsigned char band_allocation[] = {
96     /* 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 */
97        0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
98       10, 10, 14, 11, 10,  8,  6,  5, 10, 12, 13, 11,  8,  4,  2,  1,  0,  0,  0,  0,  0,
99       13, 10, 17, 16, 14, 12, 10,  8, 12, 14, 14, 12,  9,  5,  3,  2,  2,  1,  0,  0,  0,
100       17, 21, 23, 26, 24, 20, 17, 16, 17, 18, 16, 14, 11,  6,  3,  2,  2,  1,  1,  0,  0,
101       21, 21, 36, 32, 28, 24, 23, 23, 22, 18, 18, 14, 11,  7,  5,  5,  5,  3,  3,  0,  0,
102       31, 35, 40, 32, 30, 28, 26, 26, 25, 24, 19, 15, 15, 13,  9,  9,  8,  7,  5,  2,  0,
103       42, 46, 46, 37, 35, 34, 33, 32, 34, 35, 32, 31, 27, 24, 23, 23, 18, 14, 11,  7,  0,
104       46, 49, 46, 46, 42, 43, 44, 47, 50, 52, 51, 48, 39, 32, 27, 24, 22, 19, 17, 11,  5,
105       53, 53, 49, 48, 55, 66, 71, 71, 71, 65, 64, 64, 56, 47, 41, 37, 31, 24, 20, 16, 10,
106       60, 64, 74, 74, 87,103,106,102,101,100,101, 95, 80, 69, 63, 55, 47, 36, 26, 21, 15,
107 };
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, 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       eBands[i+low] = (target+(offset+res)/2)/res;
151       offset = eBands[i+low]*res - target;
152    }
153    /* Enforce the minimum spacing at the boundary */
154    for (i=0;i<*nbEBands;i++)
155       if (eBands[i] < i)
156          eBands[i] = i;
157    eBands[*nbEBands] = (bark_freq[nBark]+res/2)/res;
158    if (eBands[*nbEBands] > frame_size)
159       eBands[*nbEBands] = frame_size;
160    for (i=1;i<*nbEBands-1;i++)
161    {
162       if (eBands[i+1]-eBands[i] < eBands[i]-eBands[i-1])
163       {
164          eBands[i] -= (2*eBands[i]-eBands[i-1]-eBands[i+1])/2;
165       }
166    }
167    /*for (i=0;i<=*nbEBands+1;i++)
168       printf ("%d ", eBands[i]);
169    printf ("\n");
170    exit(1);*/
171    /* FIXME: Remove last band if too small */
172    return eBands;
173 }
174
175 static void compute_allocation_table(CELTMode *mode, int res)
176 {
177    int i, j;
178    unsigned char *allocVectors;
179    int maxBands = sizeof(eband5ms)/sizeof(eband5ms[0])-1;
180
181    mode->nbAllocVectors = BITALLOC_SIZE;
182    allocVectors = celt_alloc(sizeof(unsigned char)*(BITALLOC_SIZE*mode->nbEBands));
183    if (allocVectors==NULL)
184       return;
185
186    /* Check for standard mode */
187    if (mode->Fs == 400*(celt_int32)mode->shortMdctSize && mode->Fs >= 40000)
188    {
189       for (i=0;i<BITALLOC_SIZE*mode->nbEBands;i++)
190          allocVectors[i] = band_allocation[i];
191       mode->allocVectors = allocVectors;
192       return;
193    }
194    /* If not the standard mode, interpolate */
195
196    /* Compute per-codec-band allocation from per-critical-band matrix */
197    for (i=0;i<BITALLOC_SIZE;i++)
198    {
199       celt_int32 current = 0;
200       int eband = 0;
201       /* We may be looping over too many bands, but eband will stop being
202          incremented once we reach the last band */
203       for (j=0;j<maxBands;j++)
204       {
205          int edge, low, high;
206          celt_int32 alloc;
207          alloc = band_allocation[i*maxBands + j]*(mode->eBands[eband+1]-mode->eBands[eband])<<4;
208          low = eband5ms[j]*200;
209          high = eband5ms[j+1]*200;
210          edge = mode->eBands[eband+1]*res;
211          while (edge <= high && eband < mode->nbEBands)
212          {
213             celt_int32 num;
214             int den, bits;
215             int N = (mode->eBands[eband+1]-mode->eBands[eband]);
216             num = alloc * (edge-low);
217             den = high-low;
218             /* Divide with rounding */
219             bits = (2*num+den)/(2*den);
220             allocVectors[i*mode->nbEBands+eband] = (2*(current+bits)+(N<<4))/(2*N<<4);
221             /* Remove the part of the band we just allocated */
222             low = edge;
223             alloc -= bits;
224
225             /* Move to next eband */
226             current = 0;
227             eband++;
228             if (eband < mode->nbEBands)
229                edge = mode->eBands[eband+1]*res;
230          }
231          current += alloc;
232       }
233       if (eband < mode->nbEBands)
234       {
235          int N = (mode->eBands[eband+1]-mode->eBands[eband]);
236          allocVectors[i*mode->nbEBands+eband] = (2*current+(N<<4))/(2*N<<4);
237       }
238    }
239    /*printf ("\n");
240    for (i=0;i<BITALLOC_SIZE;i++)
241    {
242       for (j=0;j<mode->nbEBands;j++)
243          printf ("%d ", allocVectors[i*mode->nbEBands+j]);
244       printf ("\n");
245    }
246    exit(0);*/
247
248    mode->allocVectors = allocVectors;
249 }
250
251 #endif /* STATIC_MODES */
252
253 CELTMode *celt_mode_create(celt_int32 Fs, int frame_size, int *error)
254 {
255    int i;
256 #ifdef STATIC_MODES
257    for (i=0;i<TOTAL_MODES;i++)
258    {
259       if (Fs == static_mode_list[i]->Fs &&
260           frame_size == static_mode_list[i]->shortMdctSize*static_mode_list[i]->nbShortMdcts)
261       {
262          return (CELTMode*)static_mode_list[i];
263       }
264    }
265    celt_warning("Mode not included as part of the static modes");
266    if (error)
267       *error = CELT_BAD_ARG;
268    return NULL;
269 #else
270    int res;
271    CELTMode *mode=NULL;
272    celt_word16 *window;
273    celt_int16 *logN;
274    int LM;
275 #ifdef STDIN_TUNING
276    scanf("%d ", &MIN_BINS);
277    scanf("%d ", &BITALLOC_SIZE);
278    band_allocation = celt_alloc(sizeof(int)*BARK_BANDS*BITALLOC_SIZE);
279    for (i=0;i<BARK_BANDS*BITALLOC_SIZE;i++)
280    {
281       scanf("%d ", band_allocation+i);
282    }
283 #endif
284    ALLOC_STACK;
285 #if !defined(VAR_ARRAYS) && !defined(USE_ALLOCA)
286    if (global_stack==NULL)
287       goto failure;
288 #endif 
289
290    /* The good thing here is that permutation of the arguments will automatically be invalid */
291    
292    if (Fs < 8000 || Fs > 96000)
293    {
294       celt_warning("Sampling rate must be between 8 kHz and 96 kHz");
295       if (error)
296          *error = CELT_BAD_ARG;
297       return NULL;
298    }
299    if (frame_size < 40 || frame_size > 1024 || frame_size%2!=0)
300    {
301       celt_warning("Only even frame sizes from 40 to 1024 are supported");
302       if (error)
303          *error = CELT_BAD_ARG;
304       return NULL;
305    }
306    
307    mode = celt_alloc(sizeof(CELTMode));
308    if (mode==NULL)
309       goto failure;
310    mode->Fs = Fs;
311
312    /* Pre/de-emphasis depends on sampling rate. The "standard" pre-emphasis
313       is defined as A(z) = 1 - 0.85*z^-1 at 48 kHz. Other rates should
314       approximate that. */
315    if(Fs < 12000) /* 8 kHz */
316    {
317       mode->preemph[0] =  QCONST16(.35f, 15);
318       mode->preemph[1] = -QCONST16(.18f, 15);
319       mode->preemph[2] =  QCONST16(.272f, SIG_SHIFT);
320       mode->preemph[3] =  QCONST16(3.6765f, 13);
321    } else if(Fs < 24000) /* 16 kHz */
322    {
323       mode->preemph[0] =  QCONST16(.6f, 15);
324       mode->preemph[1] = -QCONST16(.18f, 15);
325       mode->preemph[2] =  QCONST16(.4425f, SIG_SHIFT);
326       mode->preemph[3] =  QCONST16(2.259887f, 13);
327    } else if(Fs < 40000) /* 32 kHz */
328    {
329       mode->preemph[0] =  QCONST16(.78f, 15);
330       mode->preemph[1] = -QCONST16(.1f, 15);
331       mode->preemph[2] =  QCONST16(.75f, SIG_SHIFT);
332       mode->preemph[3] =  QCONST16(1.33333333f, 13);
333    } else /* 48 kHz */
334    {
335       mode->preemph[0] =  QCONST16(.85f, 15);
336       mode->preemph[1] =  QCONST16(.0f, 15);
337       mode->preemph[2] =  QCONST16(1.f, SIG_SHIFT);
338       mode->preemph[3] =  QCONST16(1.f, 13);
339    }
340
341    if ((celt_int32)frame_size*75 >= Fs && (frame_size%16)==0)
342    {
343      LM = 3;
344    } else if ((celt_int32)frame_size*150 >= Fs && (frame_size%8)==0)
345    {
346      LM = 2;
347    } else if ((celt_int32)frame_size*300 >= Fs && (frame_size%4)==0)
348    {
349      LM = 1;
350    } else
351    {
352      LM = 0;
353    }
354
355    mode->maxLM = LM;
356    mode->nbShortMdcts = 1<<LM;
357    mode->shortMdctSize = frame_size/mode->nbShortMdcts;
358    res = (mode->Fs+mode->shortMdctSize)/(2*mode->shortMdctSize);
359
360    mode->eBands = compute_ebands(Fs, mode->shortMdctSize, res, &mode->nbEBands);
361    if (mode->eBands==NULL)
362       goto failure;
363
364    mode->effEBands = mode->nbEBands;
365    while (mode->eBands[mode->effEBands] > mode->shortMdctSize)
366       mode->effEBands--;
367    
368    /* Overlap must be divisible by 4 */
369    if (mode->nbShortMdcts > 1)
370       mode->overlap = (mode->shortMdctSize>>2)<<2;
371    else
372       mode->overlap = (frame_size>>3)<<2;
373
374
375    compute_allocation_table(mode, res);
376    if (mode->allocVectors==NULL)
377       goto failure;
378    
379    window = (celt_word16*)celt_alloc(mode->overlap*sizeof(celt_word16));
380    if (window==NULL)
381       goto failure;
382
383 #ifndef FIXED_POINT
384    for (i=0;i<mode->overlap;i++)
385       window[i] = Q15ONE*sin(.5*M_PI* sin(.5*M_PI*(i+.5)/mode->overlap) * sin(.5*M_PI*(i+.5)/mode->overlap));
386 #else
387    for (i=0;i<mode->overlap;i++)
388       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))));
389 #endif
390    mode->window = window;
391
392    logN = (celt_int16*)celt_alloc(mode->nbEBands*sizeof(celt_int16));
393    if (logN==NULL)
394       goto failure;
395
396    for (i=0;i<mode->nbEBands;i++)
397       logN[i] = log2_frac(mode->eBands[i+1]-mode->eBands[i], BITRES);
398    mode->logN = logN;
399
400    compute_pulse_cache(mode, mode->maxLM);
401
402    clt_mdct_init(&mode->mdct, 2*mode->shortMdctSize*mode->nbShortMdcts, mode->maxLM);
403    if ((mode->mdct.trig==NULL)
404 #ifndef ENABLE_TI_DSPLIB55
405          || (mode->mdct.kfft==NULL)
406 #endif
407    )
408       goto failure;
409
410    mode->prob = quant_prob_alloc(mode);
411    if (mode->prob==NULL)
412      goto failure;
413
414    if (error)
415       *error = CELT_OK;
416
417    return mode;
418 failure: 
419    if (error)
420       *error = CELT_INVALID_MODE;
421    if (mode!=NULL)
422       celt_mode_destroy(mode);
423    return NULL;
424 #endif /* !STATIC_MODES */
425 }
426
427 void celt_mode_destroy(CELTMode *mode)
428 {
429 #ifndef STATIC_MODES
430    if (mode == NULL)
431    {
432       celt_warning("NULL passed to celt_mode_destroy");
433       return;
434    }
435
436    celt_free((celt_int16*)mode->eBands);
437    celt_free((celt_int16*)mode->allocVectors);
438    
439    celt_free((celt_word16*)mode->window);
440    celt_free((celt_int16*)mode->logN);
441
442    celt_free((celt_int16*)mode->cache.index);
443    celt_free((unsigned char*)mode->cache.bits);
444    clt_mdct_clear(&mode->mdct);
445    quant_prob_free(mode->prob);
446
447    celt_free((CELTMode *)mode);
448 #endif
449 }