const correctness. celt_mode_create() now makes a copy of the static mode
[opus.git] / libcelt / modes.c
1 /* (C) 2007-2008 Jean-Marc Valin, CSIRO
2 */
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
41 #ifdef STATIC_MODES
42 #include "static_modes.h"
43 #endif
44
45 #define MODEVALID 0xa110ca7e
46 #define MODEFREED 0xb10cf8ee
47
48 #ifndef M_PI
49 #define M_PI 3.141592653
50 #endif
51
52
53 int celt_mode_info(const CELTMode *mode, int request, celt_int32_t *value)
54 {
55    switch (request)
56    {
57       case CELT_GET_FRAME_SIZE:
58          *value = mode->mdctSize;
59          break;
60       case CELT_GET_LOOKAHEAD:
61          *value = mode->overlap;
62          break;
63       case CELT_GET_NB_CHANNELS:
64          *value = mode->nbChannels;
65          break;
66       default:
67          return CELT_BAD_ARG;
68    }
69    return CELT_OK;
70 }
71
72 #ifndef STATIC_MODES
73
74 #define PBANDS 8
75 #define MIN_BINS 4
76 /* Defining 25 critical bands for the full 0-20 kHz audio bandwidth
77    Taken from http://ccrma.stanford.edu/~jos/bbt/Bark_Frequency_Scale.html */
78 #define BARK_BANDS 25
79 static const celt_int16_t bark_freq[BARK_BANDS+1] = {
80       0,   100,   200,   300,   400,
81     510,   630,   770,   920,  1080,
82    1270,  1480,  1720,  2000,  2320,
83    2700,  3150,  3700,  4400,  5300,
84    6400,  7700,  9500, 12000, 15500,
85   20000};
86
87 static const celt_int16_t pitch_freq[PBANDS+1] ={0, 345, 689, 1034, 1378, 2067, 3273, 5340, 6374};
88
89 /* This allocation table is per critical band. When creating a mode, the bits get added together 
90    into the codec bands, which are sometimes larger than one critical band at low frequency */
91 #define BITALLOC_SIZE 10
92 static const int band_allocation[BARK_BANDS*BITALLOC_SIZE] = 
93    {  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,
94       2,  2,  2,  1,  2,  2,  2,  2,  2,  1,  2,  2,  5,  5,  7,  7,  7,  5,  4,  0,  0,  0,  0,  0,  0,
95       2,  2,  2,  2,  3,  2,  2,  2,  2,  2,  3,  2,  6,  6,  8,  8,  8,  6,  5,  4,  0,  0,  0,  0,  0,
96       3,  2,  2,  2,  3,  3,  2,  3,  2,  2,  4,  3,  7,  7,  9,  9,  9,  7,  6,  5,  5,  5,  0,  0,  0,
97       3,  3,  2,  2,  3,  3,  3,  3,  3,  2,  4,  4,  9,  9, 10, 10, 10,  9,  6,  5,  5,  5,  5,  0,  0,
98       3,  3,  2,  2,  3,  3,  3,  3,  3,  3,  4,  4, 10, 10, 12, 12, 12, 10, 10, 10, 11, 10, 10,  5,  5,
99       4,  4,  4,  4,  5,  5,  5,  5,  5,  4,  7,  7, 14, 13, 13, 13, 13, 13, 15, 16, 17, 18, 20, 18, 11,
100       7,  7,  6,  6,  9,  8,  8,  8,  8,  8, 11, 11, 20, 18, 19, 19, 25, 22, 25, 30, 30, 35, 35, 35, 35,
101       8,  8,  8,  8, 10, 10, 10, 10,  9,  9, 19, 18, 25, 24, 23, 21, 29, 27, 35, 40, 42, 50, 59, 54, 51,
102      11, 11, 10, 10, 14, 13, 13, 13, 13, 12, 19, 18, 35, 34, 33, 31, 39, 37, 45, 50, 52, 60, 60, 60, 60,
103    };
104
105
106 static celt_int16_t *compute_ebands(celt_int32_t Fs, int frame_size, int *nbEBands)
107 {
108    celt_int16_t *eBands;
109    int i, res, min_width, lin, low, high;
110    res = (Fs+frame_size)/(2*frame_size);
111    min_width = MIN_BINS*res;
112    /*printf ("min_width = %d\n", min_width);*/
113
114    /* Find where the linear part ends (i.e. where the spacing is more than min_width */
115    for (lin=0;lin<BARK_BANDS;lin++)
116       if (bark_freq[lin+1]-bark_freq[lin] >= min_width)
117          break;
118    
119    /*printf ("lin = %d (%d Hz)\n", lin, bark_freq[lin]);*/
120    low = ((bark_freq[lin]/res)+(MIN_BINS-1))/MIN_BINS;
121    high = BARK_BANDS-lin;
122    *nbEBands = low+high;
123    eBands = celt_alloc(sizeof(celt_int16_t)*(*nbEBands+2));
124    
125    /* Linear spacing (min_width) */
126    for (i=0;i<low;i++)
127       eBands[i] = MIN_BINS*i;
128    /* Spacing follows critical bands */
129    for (i=0;i<high;i++)
130       eBands[i+low] = (bark_freq[lin+i]+res/2)/res;
131    /* Enforce the minimum spacing at the boundary */
132    for (i=0;i<*nbEBands;i++)
133       if (eBands[i] < MIN_BINS*i)
134          eBands[i] = MIN_BINS*i;
135    eBands[*nbEBands] = (bark_freq[BARK_BANDS]+res/2)/res;
136    eBands[*nbEBands+1] = frame_size;
137    if (eBands[*nbEBands] > eBands[*nbEBands+1])
138       eBands[*nbEBands] = eBands[*nbEBands+1];
139    
140    /* FIXME: Remove last band if too small */
141    /*for (i=0;i<*nbEBands+2;i++)
142       printf("%d ", eBands[i]);
143    printf ("\n");*/
144    return eBands;
145 }
146
147 static void compute_pbands(CELTMode *mode, int res)
148 {
149    int i;
150    celt_int16_t *pBands;
151    pBands=celt_alloc(sizeof(celt_int16_t)*(PBANDS+2));
152    mode->nbPBands = PBANDS;
153    for (i=0;i<PBANDS+1;i++)
154    {
155       pBands[i] = (pitch_freq[i]+res/2)/res;
156       if (pBands[i] < mode->eBands[i])
157          pBands[i] = mode->eBands[i];
158    }
159    pBands[PBANDS+1] = mode->eBands[mode->nbEBands+1];
160    for (i=1;i<mode->nbPBands+1;i++)
161    {
162       int j;
163       for (j=0;j<mode->nbEBands;j++)
164          if (mode->eBands[j] <= pBands[i] && mode->eBands[j+1] > pBands[i])
165             break;
166       /*printf ("%d %d\n", i, j);*/
167       if (mode->eBands[j] != pBands[i])
168       {
169          if (pBands[i]-mode->eBands[j] < mode->eBands[j+1]-pBands[i] && 
170              mode->eBands[j] != pBands[i-1])
171             pBands[i] = mode->eBands[j];
172          else
173             pBands[i] = mode->eBands[j+1];
174       }
175    }
176    /*for (i=0;i<mode->nbPBands+2;i++)
177       printf("%d ", pBands[i]);
178    printf ("\n");*/
179    mode->pBands = pBands;
180    mode->pitchEnd = pBands[PBANDS];
181 }
182
183 static void compute_allocation_table(CELTMode *mode, int res)
184 {
185    int i, j, eband;
186    celt_int16_t *allocVectors;
187    
188    mode->nbAllocVectors = BITALLOC_SIZE;
189    allocVectors = celt_alloc(sizeof(celt_int16_t)*(BITALLOC_SIZE*mode->nbEBands));
190    for (i=0;i<BITALLOC_SIZE;i++)
191    {
192       eband = 0;
193       for (j=0;j<BARK_BANDS;j++)
194       {
195          int edge, low;
196          edge = mode->eBands[eband+1]*res;
197          if (edge < bark_freq[j+1])
198          {
199             int num, den;
200             num = band_allocation[i*BARK_BANDS+j] * (edge-bark_freq[j]);
201             den = bark_freq[j+1]-bark_freq[j];
202             low = (num+den/2)/den;
203             allocVectors[i*mode->nbEBands+eband] += low;
204             eband++;
205             allocVectors[i*mode->nbEBands+eband] += band_allocation[i*BARK_BANDS+j]-low;
206          } else {
207             allocVectors[i*mode->nbEBands+eband] += band_allocation[i*BARK_BANDS+j];
208          }
209       }
210    }
211    /*for (i=0;i<BITALLOC_SIZE;i++)
212    {
213       for (j=0;j<mode->nbEBands;j++)
214          printf ("%2d ", allocVectors[i*mode->nbEBands+j]);
215       printf ("\n");
216    }*/
217    mode->allocVectors = allocVectors;
218 }
219
220 #endif /* STATIC_MODES */
221
222 CELTMode *celt_mode_create(celt_int32_t Fs, int channels, int frame_size, int lookahead, int *error)
223 {
224 #ifdef STATIC_MODES
225    const CELTMode *m = NULL;
226    CELTMode *mode=NULL;
227    int i;
228    for (i=0;i<TOTAL_MODES;i++)
229    {
230       if (Fs == static_mode_list[i]->Fs &&
231           channels == static_mode_list[i]->nbChannels &&
232           frame_size == static_mode_list[i]->mdctSize &&
233           lookahead == static_mode_list[i]->overlap)
234       {
235          m = static_mode_list[i];
236          break;
237       }
238    }
239    if (m == NULL)
240    {
241       celt_warning("Mode not included as part of the static modes");
242       if (error)
243          *error = CELT_BAD_ARG;
244       return NULL;
245    }
246    mode = (CELTMode*)celt_alloc(sizeof(CELTMode));
247    CELT_COPY(mode, m, 1);
248 #else
249    int res;
250    int i;
251    CELTMode *mode;
252    celt_word16_t *window;
253
254    /* The good thing here is that permutation of the arguments will automatically be invalid */
255    
256    if (Fs < 32000 || Fs > 64000)
257    {
258       celt_warning("Sampling rate must be between 32 kHz and 64 kHz");
259       if (error)
260          *error = CELT_BAD_ARG;
261       return NULL;
262    }
263    if (channels < 0 || channels > 2)
264    {
265       celt_warning("Only mono and stereo supported");
266       if (error)
267          *error = CELT_BAD_ARG;
268       return NULL;
269    }
270    if (frame_size < 64 || frame_size > 256 || frame_size%2!=0)
271    {
272       celt_warning("Only even frame sizes between 64 and 256 are supported");
273       if (error)
274          *error = CELT_BAD_ARG;
275       return NULL;
276    }
277    if (lookahead < 32 || lookahead > frame_size)
278    {
279       celt_warning("The overlap must be between 32 and the frame size");
280       if (error)
281          *error = CELT_BAD_ARG;
282       return NULL;
283    }
284    res = (Fs+frame_size)/(2*frame_size);
285    
286    mode = celt_alloc(sizeof(CELTMode));
287    mode->Fs = Fs;
288    mode->overlap = lookahead;
289    mode->mdctSize = frame_size;
290    mode->nbMdctBlocks = 1;
291    mode->nbChannels = channels;
292    mode->eBands = compute_ebands(Fs, frame_size, &mode->nbEBands);
293    compute_pbands(mode, res);
294    mode->ePredCoef = QCONST16(.8f,15);
295    
296    compute_allocation_table(mode, res);
297    /*printf ("%d bands\n", mode->nbEBands);*/
298    
299    window = (celt_word16_t*)celt_alloc(mode->overlap*sizeof(celt_word16_t));
300
301 #ifndef FIXED_POINT
302    for (i=0;i<mode->overlap;i++)
303       window[i] = Q15ONE*sin(.5*M_PI* sin(.5*M_PI*(i+.5)/mode->overlap) * sin(.5*M_PI*(i+.5)/mode->overlap));
304 #else
305    for (i=0;i<mode->overlap;i++)
306       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)));
307 #endif
308    mode->window = window;
309
310    compute_alloc_cache(mode);
311
312    psydecay_init(&mode->psy, MAX_PERIOD/2, mode->Fs);
313
314    mode->marker_start = MODEVALID;
315    mode->marker_end = MODEVALID;
316 #endif /* !STATIC_MODES */
317    mdct_init(&mode->mdct, 2*mode->mdctSize);
318    if (error)
319       *error = CELT_OK;
320    return mode;
321 }
322
323 void celt_mode_destroy(CELTMode *mode)
324 {
325    mdct_clear(&mode->mdct);
326 #ifndef STATIC_MODES
327    int i;
328    const celt_int16_t *prevPtr = NULL;
329    for (i=0;i<mode->nbEBands;i++)
330    {
331       if (mode->bits[i] != prevPtr)
332       {
333          prevPtr = mode->bits[i];
334          celt_free((int*)mode->bits[i]);
335       }
336    }
337    celt_free((int**)mode->bits);
338    if (check_mode(mode) != CELT_OK)
339       return;
340    celt_free((int*)mode->eBands);
341    celt_free((int*)mode->pBands);
342    celt_free((int*)mode->allocVectors);
343    
344    celt_free((celt_word16_t*)mode->window);
345
346    mode->marker_start = MODEFREED;
347    mode->marker_end = MODEFREED;
348    psydecay_clear(&mode->psy);
349 #endif
350    celt_free((CELTMode *)mode);
351 }
352
353 int check_mode(const CELTMode *mode)
354 {
355    if (mode->marker_start == MODEVALID && mode->marker_end == MODEVALID)
356       return CELT_OK;
357    if (mode->marker_start == MODEFREED || mode->marker_end == MODEFREED)
358       celt_warning("Using a mode that has already been freed");
359    else
360       celt_warning("This is not a valid CELT mode");
361    return CELT_INVALID_MODE;
362 }