Changed some of the mode data from int to celt_int16_t to save memory.
[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    CELTMode *mode = NULL;
226    int i;
227    for (i=0;i<TOTAL_MODES;i++)
228    {
229       if (Fs == static_mode_list[i]->Fs &&
230           channels == static_mode_list[i]->nbChannels &&
231           frame_size == static_mode_list[i]->mdctSize &&
232           lookahead == static_mode_list[i]->overlap)
233       {
234          mode = static_mode_list[i];
235          break;
236       }
237    }
238    if (mode == NULL)
239    {
240       celt_warning("Mode not included as part of the static modes");
241       if (error)
242          *error = CELT_BAD_ARG;
243       return NULL;
244    }
245 #else
246    int res;
247    int i;
248    CELTMode *mode;
249    celt_word16_t *window;
250
251    /* The good thing here is that permutation of the arguments will automatically be invalid */
252    
253    if (Fs < 32000 || Fs > 64000)
254    {
255       celt_warning("Sampling rate must be between 32 kHz and 64 kHz");
256       if (error)
257          *error = CELT_BAD_ARG;
258       return NULL;
259    }
260    if (channels < 0 || channels > 2)
261    {
262       celt_warning("Only mono and stereo supported");
263       if (error)
264          *error = CELT_BAD_ARG;
265       return NULL;
266    }
267    if (frame_size < 64 || frame_size > 256 || frame_size%2!=0)
268    {
269       celt_warning("Only even frame sizes between 64 and 256 are supported");
270       if (error)
271          *error = CELT_BAD_ARG;
272       return NULL;
273    }
274    if (lookahead < 32 || lookahead > frame_size)
275    {
276       celt_warning("The overlap must be between 32 and the frame size");
277       if (error)
278          *error = CELT_BAD_ARG;
279       return NULL;
280    }
281    res = (Fs+frame_size)/(2*frame_size);
282    
283    mode = celt_alloc(sizeof(CELTMode));
284    mode->Fs = Fs;
285    mode->overlap = lookahead;
286    mode->mdctSize = frame_size;
287    mode->nbMdctBlocks = 1;
288    mode->nbChannels = channels;
289    mode->eBands = compute_ebands(Fs, frame_size, &mode->nbEBands);
290    compute_pbands(mode, res);
291    mode->ePredCoef = QCONST16(.8f,15);
292    
293    compute_allocation_table(mode, res);
294    /*printf ("%d bands\n", mode->nbEBands);*/
295    
296    window = (celt_word16_t*)celt_alloc(mode->overlap*sizeof(celt_word16_t));
297
298 #ifndef FIXED_POINT
299    for (i=0;i<mode->overlap;i++)
300       window[i] = Q15ONE*sin(.5*M_PI* sin(.5*M_PI*(i+.5)/mode->overlap) * sin(.5*M_PI*(i+.5)/mode->overlap));
301 #else
302    for (i=0;i<mode->overlap;i++)
303       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)));
304 #endif
305    mode->window = window;
306
307    compute_alloc_cache(mode);
308
309    psydecay_init(&mode->psy, MAX_PERIOD/2, mode->Fs);
310
311    mode->marker_start = MODEVALID;
312    mode->marker_end = MODEVALID;
313 #endif /* !STATIC_MODES */
314    mdct_init(&mode->mdct, 2*mode->mdctSize);
315    if (error)
316       *error = CELT_OK;
317    return mode;
318 }
319
320 void celt_mode_destroy(CELTMode *mode)
321 {
322 #ifndef STATIC_MODES
323    int i;
324    const celt_int16_t *prevPtr = NULL;
325    for (i=0;i<mode->nbEBands;i++)
326    {
327       if (mode->bits[i] != prevPtr)
328       {
329          prevPtr = mode->bits[i];
330          celt_free((int*)mode->bits[i]);
331       }
332    }
333    celt_free((int**)mode->bits);
334    mdct_clear(&mode->mdct);
335    if (check_mode(mode) != CELT_OK)
336       return;
337    celt_free((int*)mode->eBands);
338    celt_free((int*)mode->pBands);
339    celt_free((int*)mode->allocVectors);
340    
341    celt_free((celt_word16_t*)mode->window);
342
343    mode->marker_start = MODEFREED;
344    mode->marker_end = MODEFREED;
345    celt_free((CELTMode *)mode);
346    psydecay_clear(&mode->psy);
347 #endif
348 }
349
350 int check_mode(const CELTMode *mode)
351 {
352    if (mode->marker_start == MODEVALID && mode->marker_end == MODEVALID)
353       return CELT_OK;
354    if (mode->marker_start == MODEFREED || mode->marker_end == MODEFREED)
355       celt_warning("Using a mode that has already been freed");
356    else
357       celt_warning("This is not a valid CELT mode");
358    return CELT_INVALID_MODE;
359 }