Bringing back min_bins=3 for now
[opus.git] / libcelt / modes.c
1 /* (C) 2007-2009 Jean-Marc Valin, CSIRO
2    (C) 2008 Gregory Maxwell */
3 /*
4    Redistribution and use in source and binary forms, with or without
5    modification, are permitted provided that the following conditions
6    are met:
7    
8    - Redistributions of source code must retain the above copyright
9    notice, this list of conditions and the following disclaimer.
10    
11    - Redistributions in binary form must reproduce the above copyright
12    notice, this list of conditions and the following disclaimer in the
13    documentation and/or other materials provided with the distribution.
14    
15    - Neither the name of the Xiph.org Foundation nor the names of its
16    contributors may be used to endorse or promote products derived from
17    this software without specific prior written permission.
18    
19    THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
20    ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
21    LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
22    A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR
23    CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
24    EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
25    PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
26    PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
27    LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
28    NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
29    SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
30 */
31
32 #ifdef HAVE_CONFIG_H
33 #include "config.h"
34 #endif
35
36 #include "celt.h"
37 #include "modes.h"
38 #include "rate.h"
39 #include "os_support.h"
40 #include "stack_alloc.h"
41 #include "quant_bands.h"
42
43 #ifdef STATIC_MODES
44 #include "static_modes.c"
45 #endif
46
47 #define MODEVALID   0xa110ca7e
48 #define MODEPARTIAL 0x7eca10a1
49 #define MODEFREED   0xb10cf8ee
50
51 #ifndef M_PI
52 #define M_PI 3.141592653
53 #endif
54
55
56 int celt_mode_info(const CELTMode *mode, int request, celt_int32_t *value)
57 {
58    if (check_mode(mode) != CELT_OK)
59       return CELT_INVALID_MODE;
60    switch (request)
61    {
62       case CELT_GET_FRAME_SIZE:
63          *value = mode->mdctSize;
64          break;
65       case CELT_GET_LOOKAHEAD:
66          *value = mode->overlap;
67          break;
68       case CELT_GET_NB_CHANNELS:
69          *value = mode->nbChannels;
70          break;
71       case CELT_GET_BITSTREAM_VERSION:
72          *value = CELT_BITSTREAM_VERSION;
73          break;
74       case CELT_GET_SAMPLE_RATE:
75          *value = mode->Fs;
76          break;
77       default:
78          return CELT_UNIMPLEMENTED;
79    }
80    return CELT_OK;
81 }
82
83 #ifndef STATIC_MODES
84
85 /* Defining 25 critical bands for the full 0-20 kHz audio bandwidth
86    Taken from http://ccrma.stanford.edu/~jos/bbt/Bark_Frequency_Scale.html */
87 #define BARK_BANDS 25
88 static const celt_int16_t bark_freq[BARK_BANDS+1] = {
89       0,   100,   200,   300,   400,
90     510,   630,   770,   920,  1080,
91    1270,  1480,  1720,  2000,  2320,
92    2700,  3150,  3700,  4400,  5300,
93    6400,  7700,  9500, 12000, 15500,
94   20000};
95
96 /* This allocation table is per critical band. When creating a mode, the bits get added together 
97    into the codec bands, which are sometimes larger than one critical band at low frequency */
98
99 #ifdef STDIN_TUNING
100 int BITALLOC_SIZE;
101 int *band_allocation;
102 #else
103 #define BITALLOC_SIZE 12
104 static const int band_allocation[BARK_BANDS*BITALLOC_SIZE] = 
105    /* 0 100 200 300 400 510 630 770 920 1k  1.2 1.5 1.7 2k  2.3 2.7 3.1 3.7 4.4 5.3 6.4 7.7 9.5 12k 15k  */
106    {  4,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0, /*0*/
107       2,  2,  1,  1,  2,  2,  1,  1,  1,  1,  1,  1,  1,  1,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0, /*1*/
108       2,  2,  2,  1,  2,  2,  2,  2,  2,  2,  2,  2,  4,  5,  7,  7,  7,  5,  4,  0,  0,  0,  0,  0,  0, /*2*/
109       2,  2,  2,  2,  3,  3,  3,  3,  3,  3,  3,  3,  5,  6,  8,  8,  8,  6,  5,  4,  0,  0,  0,  0,  0, /*3*/
110       3,  2,  2,  2,  3,  4,  4,  4,  4,  4,  4,  4,  6,  7,  9,  9,  9,  7,  6,  5,  5,  5,  0,  0,  0, /*4*/
111       3,  3,  3,  4,  4,  5,  6,  6,  6,  6,  6,  7,  7,  9, 10, 10, 10,  9,  6,  5,  5,  5,  5,  1,  0, /*5*/
112       4,  3,  3,  4,  6,  7,  7,  7,  7,  7,  8,  9,  9,  9, 11, 10, 10,  9,  9,  8, 11, 10, 10,  1,  0, /*6*/
113       5,  5,  5,  6,  7,  7,  7,  7,  8,  8,  9, 10, 10, 12, 12, 11, 11, 17, 12, 15, 15, 20, 18, 10,  1, /*7*/
114       6,  7,  7,  7,  8,  8,  8,  8,  9, 10, 11, 12, 14, 17, 18, 21, 22, 27, 29, 39, 37, 38, 40, 35,  1, /*8*/
115       7,  7,  7,  8,  8,  8, 10, 10, 10, 13, 14, 18, 20, 24, 28, 32, 32, 35, 38, 38, 42, 50, 59, 54, 31, /*9*/
116       8,  8,  8,  8,  8,  9, 10, 12, 14, 20, 22, 25, 28, 30, 35, 42, 46, 50, 55, 60, 62, 62, 72, 82, 62, /*10*/
117       9,  9,  9, 10, 12, 13, 15, 18, 22, 30, 32, 35, 40, 45, 55, 62, 66, 70, 85, 90, 92, 92, 92,102, 92, /*11*/
118    };
119 #endif
120
121 static celt_int16_t *compute_ebands(celt_int32_t Fs, int frame_size, int nbShortMdcts, int *nbEBands)
122 {
123    int min_bins = 3;
124    celt_int16_t *eBands;
125    int i, res, min_width, lin, low, high, nBark;
126
127    //if (min_bins < nbShortMdcts)
128    //   min_bins = nbShortMdcts;
129    res = (Fs+frame_size)/(2*frame_size);
130    min_width = min_bins*res;
131
132    /* Find the number of critical bands supported by our sampling rate */
133    for (nBark=1;nBark<BARK_BANDS;nBark++)
134     if (bark_freq[nBark+1]*2 >= Fs)
135        break;
136
137    /* Find where the linear part ends (i.e. where the spacing is more than min_width */
138    for (lin=0;lin<nBark;lin++)
139       if (bark_freq[lin+1]-bark_freq[lin] >= min_width)
140          break;
141    
142    low = ((bark_freq[lin]/res)+(min_bins-1))/min_bins;
143    high = nBark-lin;
144    *nbEBands = low+high;
145    eBands = celt_alloc(sizeof(celt_int16_t)*(*nbEBands+2));
146    
147    if (eBands==NULL)
148       return NULL;
149    
150    /* Linear spacing (min_width) */
151    for (i=0;i<low;i++)
152       eBands[i] = min_bins*i;
153    /* Spacing follows critical bands */
154    for (i=0;i<high;i++)
155       eBands[i+low] = (bark_freq[lin+i]+res/2)/res;
156    /* Enforce the minimum spacing at the boundary */
157    for (i=0;i<*nbEBands;i++)
158       if (eBands[i] < min_bins*i)
159          eBands[i] = min_bins*i;
160    eBands[*nbEBands] = (bark_freq[nBark]+res/2)/res;
161    eBands[*nbEBands+1] = frame_size;
162    if (eBands[*nbEBands] > eBands[*nbEBands+1])
163       eBands[*nbEBands] = eBands[*nbEBands+1];
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] -= min_bins;
169       }
170    }
171    /*for (i=0;i<*nbEBands+1;i++)
172       printf ("%d ", eBands[i]);
173    printf ("\n");*/
174    /* FIXME: Remove last band if too small */
175    return eBands;
176 }
177
178 static void compute_allocation_table(CELTMode *mode, int res)
179 {
180    int i, j, nBark;
181    celt_int16_t *allocVectors;
182    const int C = CHANNELS(mode);
183
184    /* Find the number of critical bands supported by our sampling rate */
185    for (nBark=1;nBark<BARK_BANDS;nBark++)
186     if (bark_freq[nBark+1]*2 >= mode->Fs)
187        break;
188
189    mode->nbAllocVectors = BITALLOC_SIZE;
190    allocVectors = celt_alloc(sizeof(celt_int16_t)*(BITALLOC_SIZE*mode->nbEBands));
191    if (allocVectors==NULL)
192       return;
193    /* Compute per-codec-band allocation from per-critical-band matrix */
194    for (i=0;i<BITALLOC_SIZE;i++)
195    {
196       celt_int32_t current = 0;
197       int eband = 0;
198       for (j=0;j<nBark;j++)
199       {
200          int edge, low;
201          celt_int32_t alloc;
202          edge = mode->eBands[eband+1]*res;
203          alloc = band_allocation[i*BARK_BANDS+j];
204          alloc = alloc*C*mode->mdctSize;
205          if (edge < bark_freq[j+1])
206          {
207             int num, den;
208             num = alloc * (edge-bark_freq[j]);
209             den = bark_freq[j+1]-bark_freq[j];
210             low = (num+den/2)/den;
211             allocVectors[i*mode->nbEBands+eband] = (current+low+128)/256;
212             current=0;
213             eband++;
214             current += alloc-low;
215          } else {
216             current += alloc;
217          }   
218       }
219       allocVectors[i*mode->nbEBands+eband] = (current+128)/256;
220    }
221    mode->allocVectors = allocVectors;
222 }
223
224 #endif /* STATIC_MODES */
225
226 CELTMode *celt_mode_create(celt_int32_t Fs, int channels, int frame_size, int *error)
227 {
228    int i;
229 #ifdef STDIN_TUNING
230    scanf("%d ", &MIN_BINS);
231    scanf("%d ", &BITALLOC_SIZE);
232    band_allocation = celt_alloc(sizeof(int)*BARK_BANDS*BITALLOC_SIZE);
233    for (i=0;i<BARK_BANDS*BITALLOC_SIZE;i++)
234    {
235       scanf("%d ", band_allocation+i);
236    }
237 #endif
238 #ifdef STATIC_MODES
239    const CELTMode *m = NULL;
240    CELTMode *mode=NULL;
241    ALLOC_STACK;
242 #if !defined(VAR_ARRAYS) && !defined(USE_ALLOCA)
243    if (global_stack==NULL)
244    {
245       celt_free(global_stack);
246       goto failure;
247    }
248 #endif 
249    for (i=0;i<TOTAL_MODES;i++)
250    {
251       if (Fs == static_mode_list[i]->Fs &&
252           channels == static_mode_list[i]->nbChannels &&
253           frame_size == static_mode_list[i]->mdctSize)
254       {
255          m = static_mode_list[i];
256          break;
257       }
258    }
259    if (m == NULL)
260    {
261       celt_warning("Mode not included as part of the static modes");
262       if (error)
263          *error = CELT_BAD_ARG;
264       return NULL;
265    }
266    mode = (CELTMode*)celt_alloc(sizeof(CELTMode));
267    if (mode==NULL)
268       goto failure;
269    CELT_COPY(mode, m, 1);
270    mode->marker_start = MODEPARTIAL;
271 #else
272    int res;
273    CELTMode *mode=NULL;
274    celt_word16_t *window;
275    ALLOC_STACK;
276 #if !defined(VAR_ARRAYS) && !defined(USE_ALLOCA)
277    if (global_stack==NULL)
278    {
279       celt_free(global_stack);
280       goto failure;
281    }
282 #endif 
283
284    /* The good thing here is that permutation of the arguments will automatically be invalid */
285    
286    if (Fs < 32000 || Fs > 96000)
287    {
288       celt_warning("Sampling rate must be between 32 kHz and 96 kHz");
289       if (error)
290          *error = CELT_BAD_ARG;
291       return NULL;
292    }
293    if (channels < 0 || channels > 2)
294    {
295       celt_warning("Only mono and stereo supported");
296       if (error)
297          *error = CELT_BAD_ARG;
298       return NULL;
299    }
300    if (frame_size < 64 || frame_size > 1024 || frame_size%2!=0)
301    {
302       celt_warning("Only even frame sizes from 64 to 1024 are supported");
303       if (error)
304          *error = CELT_BAD_ARG;
305       return NULL;
306    }
307    res = (Fs+frame_size)/(2*frame_size);
308    
309    mode = celt_alloc(sizeof(CELTMode));
310    if (mode==NULL)
311       goto failure;
312    mode->marker_start = MODEPARTIAL;
313    mode->Fs = Fs;
314    mode->mdctSize = frame_size;
315    mode->nbChannels = channels;
316    mode->ePredCoef = QCONST16(.8f,15);
317
318    if (frame_size > 640 && (frame_size%16)==0)
319    {
320      mode->nbShortMdcts = 8;
321    } else if (frame_size > 384 && (frame_size%8)==0)
322    {
323      mode->nbShortMdcts = 4;
324    } else if (frame_size > 384 && (frame_size%10)==0)
325    {
326      mode->nbShortMdcts = 5;
327    } else if (frame_size > 256 && (frame_size%6)==0)
328    {
329      mode->nbShortMdcts = 3;
330    } else if (frame_size > 256 && (frame_size%8)==0)
331    {
332      mode->nbShortMdcts = 4;
333    } else if (frame_size > 64 && (frame_size%4)==0)
334    {
335      mode->nbShortMdcts = 2;
336    } else if (frame_size > 128 && (frame_size%6)==0)
337    {
338      mode->nbShortMdcts = 3;
339    } else
340    {
341      mode->nbShortMdcts = 1;
342    }
343
344    mode->eBands = compute_ebands(Fs, frame_size, mode->nbShortMdcts, &mode->nbEBands);
345    if (mode->eBands==NULL)
346       goto failure;
347
348    mode->pitchEnd = 4000*(celt_int32_t)frame_size/Fs;
349    
350    /* Overlap must be divisible by 4 */
351    if (mode->nbShortMdcts > 1)
352       mode->overlap = ((frame_size/mode->nbShortMdcts)>>2)<<2; 
353    else
354       mode->overlap = (frame_size>>3)<<2;
355
356    compute_allocation_table(mode, res);
357    if (mode->allocVectors==NULL)
358       goto failure;
359    
360    window = (celt_word16_t*)celt_alloc(mode->overlap*sizeof(celt_word16_t));
361    if (window==NULL)
362       goto failure;
363
364 #ifndef FIXED_POINT
365    for (i=0;i<mode->overlap;i++)
366       window[i] = Q15ONE*sin(.5*M_PI* sin(.5*M_PI*(i+.5)/mode->overlap) * sin(.5*M_PI*(i+.5)/mode->overlap));
367 #else
368    for (i=0;i<mode->overlap;i++)
369       window[i] = MIN32(32767,32768.*sin(.5*M_PI* sin(.5*M_PI*(i+.5)/mode->overlap) * sin(.5*M_PI*(i+.5)/mode->overlap)));
370 #endif
371    mode->window = window;
372
373    mode->bits = (const celt_int16_t **)compute_alloc_cache(mode, 1);
374    if (mode->bits==NULL)
375       goto failure;
376
377 #ifndef SHORTCUTS
378    psydecay_init(&mode->psy, MAX_PERIOD/2, mode->Fs);
379    if (mode->psy.decayR==NULL)
380       goto failure;
381 #endif
382    
383 #endif /* !STATIC_MODES */
384
385 #ifdef DISABLE_STEREO
386    if (channels > 1)
387    {
388       celt_warning("Stereo support was disable from this build");
389       if (error)
390          *error = CELT_BAD_ARG;
391       return NULL;
392    }
393 #endif
394
395    mdct_init(&mode->mdct, 2*mode->mdctSize);
396    mode->fft = pitch_state_alloc(MAX_PERIOD);
397
398    mode->shortMdctSize = mode->mdctSize/mode->nbShortMdcts;
399    mdct_init(&mode->shortMdct, 2*mode->shortMdctSize);
400    mode->shortWindow = mode->window;
401    mode->prob = quant_prob_alloc(mode);
402    if ((mode->mdct.trig==NULL) || (mode->shortMdct.trig==NULL)
403 #ifndef ENABLE_TI_DSPLIB55
404         || (mode->mdct.kfft==NULL) || (mode->fft==NULL) || (mode->shortMdct.kfft==NULL)
405 #endif
406         || (mode->prob==NULL))
407      goto failure;
408
409    mode->marker_start = MODEVALID;
410    mode->marker_end   = MODEVALID;
411    if (error)
412       *error = CELT_OK;
413    return mode;
414 failure: 
415    if (error)
416       *error = CELT_INVALID_MODE;
417    if (mode!=NULL)
418       celt_mode_destroy(mode);
419    return NULL;
420 }
421
422 void celt_mode_destroy(CELTMode *mode)
423 {
424    int i;
425    const celt_int16_t *prevPtr = NULL;
426    if (mode == NULL)
427    {
428       celt_warning("NULL passed to celt_mode_destroy");
429       return;
430    }
431
432    if (mode->marker_start == MODEFREED || mode->marker_end == MODEFREED)
433    {
434       celt_warning("Freeing a mode which has already been freed"); 
435       return;
436    }
437
438    if (mode->marker_start != MODEVALID && mode->marker_start != MODEPARTIAL)
439    {
440       celt_warning("This is not a valid CELT mode structure");
441       return;  
442    }
443    mode->marker_start = MODEFREED;
444 #ifndef STATIC_MODES
445    if (mode->bits!=NULL)
446    {
447       for (i=0;i<mode->nbEBands;i++)
448       {
449          if (mode->bits[i] != prevPtr)
450          {
451             prevPtr = mode->bits[i];
452             celt_free((int*)mode->bits[i]);
453           }
454       }
455    }   
456    celt_free((int**)mode->bits);
457    celt_free((int*)mode->eBands);
458    celt_free((int*)mode->allocVectors);
459    
460    celt_free((celt_word16_t*)mode->window);
461
462 #ifndef SHORTCUTS
463    psydecay_clear(&mode->psy);
464 #endif
465 #endif
466    mdct_clear(&mode->mdct);
467    mdct_clear(&mode->shortMdct);
468    pitch_state_free(mode->fft);
469    quant_prob_free(mode->prob);
470    mode->marker_end = MODEFREED;
471    celt_free((CELTMode *)mode);
472 }
473
474 int check_mode(const CELTMode *mode)
475 {
476    if (mode==NULL)
477       return CELT_INVALID_MODE;
478    if (mode->marker_start == MODEVALID && mode->marker_end == MODEVALID)
479       return CELT_OK;
480    if (mode->marker_start == MODEFREED || mode->marker_end == MODEFREED)
481       celt_warning("Using a mode that has already been freed");
482    else
483       celt_warning("This is not a valid CELT mode");
484    return CELT_INVALID_MODE;
485 }