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