9729a4fae982228e81109377017784566c3ba5dc
[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 *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_BITSTREAM_VERSION:
69          *value = CELT_BITSTREAM_VERSION;
70          break;
71       case CELT_GET_SAMPLE_RATE:
72          *value = mode->Fs;
73          break;
74       default:
75          return CELT_UNIMPLEMENTED;
76    }
77    return CELT_OK;
78 }
79
80 #ifndef STATIC_MODES
81
82 /* Defining 25 critical bands for the full 0-20 kHz audio bandwidth
83    Taken from http://ccrma.stanford.edu/~jos/bbt/Bark_Frequency_Scale.html */
84 #define BARK_BANDS 25
85 static const celt_int16 bark_freq[BARK_BANDS+1] = {
86       0,   100,   200,   300,   400,
87     510,   630,   770,   920,  1080,
88    1270,  1480,  1720,  2000,  2320,
89    2700,  3150,  3700,  4400,  5300,
90    6400,  7700,  9500, 12000, 15500,
91   20000};
92
93 /* This allocation table is per critical band. When creating a mode, the bits get added together 
94    into the codec bands, which are sometimes larger than one critical band at low frequency */
95
96 #ifdef STDIN_TUNING
97 int BITALLOC_SIZE;
98 int *band_allocation;
99 #else
100 #define BITALLOC_SIZE 12
101 static const int band_allocation[BARK_BANDS*BITALLOC_SIZE] = 
102    /* 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  */
103    {  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*/
104       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*/
105       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*/
106       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*/
107       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*/
108       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*/
109       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*/
110       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*/
111       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*/
112       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*/
113       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*/
114       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*/
115    };
116 #endif
117
118 static celt_int16 *compute_ebands(celt_int32 Fs, int frame_size, int nbShortMdcts, int *nbEBands)
119 {
120    int min_bins = 3;
121    celt_int16 *eBands;
122    int i, res, min_width, lin, low, high, nBark, offset=0;
123
124    /*if (min_bins < nbShortMdcts)
125       min_bins = nbShortMdcts;*/
126    res = (Fs+frame_size)/(2*frame_size);
127    min_width = min_bins*res;
128
129    /* Find the number of critical bands supported by our sampling rate */
130    for (nBark=1;nBark<BARK_BANDS;nBark++)
131     if (bark_freq[nBark+1]*2 >= Fs)
132        break;
133
134    /* Find where the linear part ends (i.e. where the spacing is more than min_width */
135    for (lin=0;lin<nBark;lin++)
136       if (bark_freq[lin+1]-bark_freq[lin] >= min_width)
137          break;
138    
139    low = ((bark_freq[lin]/res)+(min_bins-1))/min_bins;
140    high = nBark-lin;
141    *nbEBands = low+high;
142    eBands = celt_alloc(sizeof(celt_int16)*(*nbEBands+2));
143    
144    if (eBands==NULL)
145       return NULL;
146    
147    /* Linear spacing (min_width) */
148    for (i=0;i<low;i++)
149       eBands[i] = min_bins*i;
150    /* Spacing follows critical bands */
151    for (i=0;i<high;i++)
152    {
153       int target = bark_freq[lin+i];
154       eBands[i+low] = (2*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] < min_bins*i)
160          eBands[i] = min_bins*i;
161    eBands[*nbEBands] = (bark_freq[nBark]+res/2)/res;
162    eBands[*nbEBands+1] = frame_size;
163    if (eBands[*nbEBands] > eBands[*nbEBands+1])
164       eBands[*nbEBands] = eBands[*nbEBands+1];
165    for (i=1;i<*nbEBands-1;i++)
166    {
167       if (eBands[i+1]-eBands[i] < eBands[i]-eBands[i-1])
168       {
169          eBands[i] -= (2*eBands[i]-eBands[i-1]-eBands[i+1]+1)/2;
170       }
171    }
172    /*for (i=0;i<*nbEBands+1;i++)
173       printf ("%d ", eBands[i]);
174    printf ("\n");
175    exit(1);*/
176    /* FIXME: Remove last band if too small */
177    return eBands;
178 }
179
180 static void compute_allocation_table(CELTMode *mode, int res)
181 {
182    int i, j, nBark;
183    celt_int16 *allocVectors;
184
185    /* Find the number of critical bands supported by our sampling rate */
186    for (nBark=1;nBark<BARK_BANDS;nBark++)
187     if (bark_freq[nBark+1]*2 >= mode->Fs)
188        break;
189
190    mode->nbAllocVectors = BITALLOC_SIZE;
191    allocVectors = celt_alloc(sizeof(celt_int16)*(BITALLOC_SIZE*mode->nbEBands));
192    if (allocVectors==NULL)
193       return;
194    /* Compute per-codec-band allocation from per-critical-band matrix */
195    for (i=0;i<BITALLOC_SIZE;i++)
196    {
197       celt_int32 current = 0;
198       int eband = 0;
199       for (j=0;j<nBark;j++)
200       {
201          int edge, low;
202          celt_int32 alloc;
203          edge = mode->eBands[eband+1]*res;
204          alloc = mode->mdctSize*band_allocation[i*BARK_BANDS+j];
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 Fs, 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           frame_size == static_mode_list[i]->mdctSize)
253       {
254          m = static_mode_list[i];
255          break;
256       }
257    }
258    if (m == NULL)
259    {
260       celt_warning("Mode not included as part of the static modes");
261       if (error)
262          *error = CELT_BAD_ARG;
263       return NULL;
264    }
265    mode = (CELTMode*)celt_alloc(sizeof(CELTMode));
266    if (mode==NULL)
267       goto failure;
268    CELT_COPY(mode, m, 1);
269    mode->marker_start = MODEPARTIAL;
270 #else
271    int res;
272    CELTMode *mode=NULL;
273    celt_word16_t *window;
274    ALLOC_STACK;
275 #if !defined(VAR_ARRAYS) && !defined(USE_ALLOCA)
276    if (global_stack==NULL)
277    {
278       celt_free(global_stack);
279       goto failure;
280    }
281 #endif 
282
283    /* The good thing here is that permutation of the arguments will automatically be invalid */
284    
285    if (Fs < 32000 || Fs > 96000)
286    {
287       celt_warning("Sampling rate must be between 32 kHz and 96 kHz");
288       if (error)
289          *error = CELT_BAD_ARG;
290       return NULL;
291    }
292    if (frame_size < 64 || frame_size > 1024 || frame_size%2!=0)
293    {
294       celt_warning("Only even frame sizes from 64 to 1024 are supported");
295       if (error)
296          *error = CELT_BAD_ARG;
297       return NULL;
298    }
299    res = (Fs+frame_size)/(2*frame_size);
300    
301    mode = celt_alloc(sizeof(CELTMode));
302    if (mode==NULL)
303       goto failure;
304    mode->marker_start = MODEPARTIAL;
305    mode->Fs = Fs;
306    mode->mdctSize = frame_size;
307    mode->ePredCoef = QCONST16(.8f,15);
308
309    if (frame_size > 640 && (frame_size%16)==0)
310    {
311      mode->nbShortMdcts = 8;
312    } else if (frame_size > 384 && (frame_size%8)==0)
313    {
314      mode->nbShortMdcts = 4;
315    } else if (frame_size > 384 && (frame_size%10)==0)
316    {
317      mode->nbShortMdcts = 5;
318    } else if (frame_size > 256 && (frame_size%6)==0)
319    {
320      mode->nbShortMdcts = 3;
321    } else if (frame_size > 256 && (frame_size%8)==0)
322    {
323      mode->nbShortMdcts = 4;
324    } else if (frame_size > 64 && (frame_size%4)==0)
325    {
326      mode->nbShortMdcts = 2;
327    } else if (frame_size > 128 && (frame_size%6)==0)
328    {
329      mode->nbShortMdcts = 3;
330    } else
331    {
332      mode->nbShortMdcts = 1;
333    }
334
335    mode->eBands = compute_ebands(Fs, frame_size, mode->nbShortMdcts, &mode->nbEBands);
336    if (mode->eBands==NULL)
337       goto failure;
338
339    mode->pitchEnd = 4000*(celt_int32)frame_size/Fs;
340    
341    /* Overlap must be divisible by 4 */
342    if (mode->nbShortMdcts > 1)
343       mode->overlap = ((frame_size/mode->nbShortMdcts)>>2)<<2; 
344    else
345       mode->overlap = (frame_size>>3)<<2;
346
347    compute_allocation_table(mode, res);
348    if (mode->allocVectors==NULL)
349       goto failure;
350    
351    window = (celt_word16_t*)celt_alloc(mode->overlap*sizeof(celt_word16_t));
352    if (window==NULL)
353       goto failure;
354
355 #ifndef FIXED_POINT
356    for (i=0;i<mode->overlap;i++)
357       window[i] = Q15ONE*sin(.5*M_PI* sin(.5*M_PI*(i+.5)/mode->overlap) * sin(.5*M_PI*(i+.5)/mode->overlap));
358 #else
359    for (i=0;i<mode->overlap;i++)
360       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)));
361 #endif
362    mode->window = window;
363
364    mode->bits = (const celt_int16 **)compute_alloc_cache(mode, 1);
365    if (mode->bits==NULL)
366       goto failure;
367
368 #ifndef SHORTCUTS
369    psydecay_init(&mode->psy, MAX_PERIOD/2, mode->Fs);
370    if (mode->psy.decayR==NULL)
371       goto failure;
372 #endif
373    
374 #endif /* !STATIC_MODES */
375
376 #ifdef DISABLE_STEREO
377    if (channels > 1)
378    {
379       celt_warning("Stereo support was disable from this build");
380       if (error)
381          *error = CELT_BAD_ARG;
382       return NULL;
383    }
384 #endif
385
386    mdct_init(&mode->mdct, 2*mode->mdctSize);
387    mode->fft = pitch_state_alloc(MAX_PERIOD);
388
389    mode->shortMdctSize = mode->mdctSize/mode->nbShortMdcts;
390    mdct_init(&mode->shortMdct, 2*mode->shortMdctSize);
391    mode->shortWindow = mode->window;
392    mode->prob = quant_prob_alloc(mode);
393    if ((mode->mdct.trig==NULL) || (mode->shortMdct.trig==NULL)
394 #ifndef ENABLE_TI_DSPLIB55
395         || (mode->mdct.kfft==NULL) || (mode->fft==NULL) || (mode->shortMdct.kfft==NULL)
396 #endif
397         || (mode->prob==NULL))
398      goto failure;
399
400    mode->marker_start = MODEVALID;
401    mode->marker_end   = MODEVALID;
402    if (error)
403       *error = CELT_OK;
404    return mode;
405 failure: 
406    if (error)
407       *error = CELT_INVALID_MODE;
408    if (mode!=NULL)
409       celt_mode_destroy(mode);
410    return NULL;
411 }
412
413 void celt_mode_destroy(CELTMode *mode)
414 {
415    int i;
416    const celt_int16 *prevPtr = NULL;
417    if (mode == NULL)
418    {
419       celt_warning("NULL passed to celt_mode_destroy");
420       return;
421    }
422
423    if (mode->marker_start == MODEFREED || mode->marker_end == MODEFREED)
424    {
425       celt_warning("Freeing a mode which has already been freed"); 
426       return;
427    }
428
429    if (mode->marker_start != MODEVALID && mode->marker_start != MODEPARTIAL)
430    {
431       celt_warning("This is not a valid CELT mode structure");
432       return;  
433    }
434    mode->marker_start = MODEFREED;
435 #ifndef STATIC_MODES
436    if (mode->bits!=NULL)
437    {
438       for (i=0;i<mode->nbEBands;i++)
439       {
440          if (mode->bits[i] != prevPtr)
441          {
442             prevPtr = mode->bits[i];
443             celt_free((int*)mode->bits[i]);
444           }
445       }
446    }   
447    celt_free((int**)mode->bits);
448    celt_free((int*)mode->eBands);
449    celt_free((int*)mode->allocVectors);
450    
451    celt_free((celt_word16_t*)mode->window);
452
453 #ifndef SHORTCUTS
454    psydecay_clear(&mode->psy);
455 #endif
456 #endif
457    mdct_clear(&mode->mdct);
458    mdct_clear(&mode->shortMdct);
459    pitch_state_free(mode->fft);
460    quant_prob_free(mode->prob);
461    mode->marker_end = MODEFREED;
462    celt_free((CELTMode *)mode);
463 }
464
465 int check_mode(const CELTMode *mode)
466 {
467    if (mode==NULL)
468       return CELT_INVALID_MODE;
469    if (mode->marker_start == MODEVALID && mode->marker_end == MODEVALID)
470       return CELT_OK;
471    if (mode->marker_start == MODEFREED || mode->marker_end == MODEFREED)
472       celt_warning("Using a mode that has already been freed");
473    else
474       celt_warning("This is not a valid CELT mode");
475    return CELT_INVALID_MODE;
476 }