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