Cleanup: getting rid of some old bits of stereo code that are no longer useful
[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 MODEFREED 0xb10cf8ee
49
50 #ifndef M_PI
51 #define M_PI 3.141592653
52 #endif
53
54
55 int celt_mode_info(const CELTMode *mode, int request, celt_int32_t *value)
56 {
57    switch (request)
58    {
59       case CELT_GET_FRAME_SIZE:
60          *value = mode->mdctSize;
61          break;
62       case CELT_GET_LOOKAHEAD:
63          *value = mode->overlap;
64          break;
65       case CELT_GET_NB_CHANNELS:
66          *value = mode->nbChannels;
67          break;
68       case CELT_GET_BITSTREAM_VERSION:
69          *value = CELT_BITSTREAM_VERSION;
70          break;
71       default:
72          return CELT_UNIMPLEMENTED;
73    }
74    return CELT_OK;
75 }
76
77 #ifndef STATIC_MODES
78
79 #define PBANDS 8
80
81 #ifdef STDIN_TUNING
82 int MIN_BINS;
83 #else
84 #define MIN_BINS 3
85 #endif
86
87 /* Defining 25 critical bands for the full 0-20 kHz audio bandwidth
88    Taken from http://ccrma.stanford.edu/~jos/bbt/Bark_Frequency_Scale.html */
89 #define BARK_BANDS 25
90 static const celt_int16_t bark_freq[BARK_BANDS+1] = {
91       0,   100,   200,   300,   400,
92     510,   630,   770,   920,  1080,
93    1270,  1480,  1720,  2000,  2320,
94    2700,  3150,  3700,  4400,  5300,
95    6400,  7700,  9500, 12000, 15500,
96   20000};
97
98 static const celt_int16_t pitch_freq[PBANDS+1] ={0, 345, 689, 1034, 1378, 2067, 3273, 5340, 6374};
99
100 /* This allocation table is per critical band. When creating a mode, the bits get added together 
101    into the codec bands, which are sometimes larger than one critical band at low frequency */
102
103 #ifdef STDIN_TUNING
104 int BITALLOC_SIZE;
105 int *band_allocation;
106 #else
107 #define BITALLOC_SIZE 12
108 static const int band_allocation[BARK_BANDS*BITALLOC_SIZE] = 
109    {  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,
110       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,
111       2,  2,  2,  1,  2,  2,  2,  2,  2,  1,  2,  2,  4,  5,  7,  7,  7,  5,  4,  0,  0,  0,  0,  0,  0,
112       2,  2,  2,  2,  3,  2,  2,  2,  2,  2,  3,  3,  5,  6,  8,  8,  8,  6,  5,  4,  0,  0,  0,  0,  0,
113       3,  2,  2,  2,  3,  3,  2,  3,  2,  3,  4,  4,  6,  7,  9,  9,  9,  7,  6,  5,  5,  5,  0,  0,  0,
114       3,  3,  2,  2,  3,  3,  3,  3,  3,  4,  4,  5,  7,  9, 10, 10, 10,  9,  6,  5,  5,  5,  5,  1,  0,
115       4,  3,  3,  3,  3,  3,  3,  3,  4,  4,  6,  7,  7,  9, 11, 10, 10,  9,  9,  8, 11, 10, 10,  1,  1,
116       5,  5,  5,  5,  5,  5,  5,  6,  6,  6,  8,  8, 10, 12, 12, 11, 11, 17, 12, 15, 15, 20, 18, 10,  1,
117       8,  7,  7,  7,  7,  7,  8,  8,  9, 10, 11, 12, 14, 17, 18, 21, 22, 27, 29, 39, 37, 38, 40, 35,  1,
118       7,  7,  7,  7,  7,  7, 10, 10, 10, 13, 14, 18, 20, 24, 28, 32, 32, 35, 38, 38, 42, 50, 59, 54, 31,
119       8,  8,  8,  8,  8,  9, 10, 12, 14, 20, 22, 25, 28, 30, 35, 42, 46, 50, 55, 60, 62, 62, 62, 62, 62,
120      12, 12, 12, 12, 12, 13, 15, 18, 22, 30, 32, 35, 40, 45, 55, 62, 66, 70, 85, 90, 92, 92, 92, 92, 92,
121    };
122 #endif
123
124 static celt_int16_t *compute_ebands(celt_int32_t Fs, int frame_size, int *nbEBands)
125 {
126    celt_int16_t *eBands;
127    int i, res, min_width, lin, low, high, nBark;
128    res = (Fs+frame_size)/(2*frame_size);
129    min_width = MIN_BINS*res;
130    /*printf ("min_width = %d\n", min_width);*/
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    /*printf ("lin = %d (%d Hz)\n", lin, bark_freq[lin]);*/
143    low = ((bark_freq[lin]/res)+(MIN_BINS-1))/MIN_BINS;
144    high = nBark-lin;
145    *nbEBands = low+high;
146    eBands = celt_alloc(sizeof(celt_int16_t)*(*nbEBands+2));
147    
148    /* Linear spacing (min_width) */
149    for (i=0;i<low;i++)
150       eBands[i] = MIN_BINS*i;
151    /* Spacing follows critical bands */
152    for (i=0;i<high;i++)
153       eBands[i+low] = (bark_freq[lin+i]+res/2)/res;
154    /* Enforce the minimum spacing at the boundary */
155    for (i=0;i<*nbEBands;i++)
156       if (eBands[i] < MIN_BINS*i)
157          eBands[i] = MIN_BINS*i;
158    eBands[*nbEBands] = (bark_freq[nBark]+res/2)/res;
159    eBands[*nbEBands+1] = frame_size;
160    if (eBands[*nbEBands] > eBands[*nbEBands+1])
161       eBands[*nbEBands] = eBands[*nbEBands+1];
162    
163    /* FIXME: Remove last band if too small */
164    /*for (i=0;i<*nbEBands+2;i++)
165       printf("%d ", eBands[i]);
166    printf ("\n");
167    exit(1);*/
168    return eBands;
169 }
170
171 static void compute_pbands(CELTMode *mode, int res)
172 {
173    int i;
174    celt_int16_t *pBands;
175    pBands=celt_alloc(sizeof(celt_int16_t)*(PBANDS+2));
176    mode->nbPBands = PBANDS;
177    for (i=0;i<PBANDS+1;i++)
178    {
179       pBands[i] = (pitch_freq[i]+res/2)/res;
180       if (pBands[i] < mode->eBands[i])
181          pBands[i] = mode->eBands[i];
182    }
183    pBands[PBANDS+1] = mode->eBands[mode->nbEBands+1];
184    for (i=1;i<mode->nbPBands+1;i++)
185    {
186       int j;
187       for (j=0;j<mode->nbEBands;j++)
188          if (mode->eBands[j] <= pBands[i] && mode->eBands[j+1] > pBands[i])
189             break;
190       /*printf ("%d %d\n", i, j);*/
191       if (mode->eBands[j] != pBands[i])
192       {
193          if (pBands[i]-mode->eBands[j] < mode->eBands[j+1]-pBands[i] && 
194              mode->eBands[j] != pBands[i-1])
195             pBands[i] = mode->eBands[j];
196          else
197             pBands[i] = mode->eBands[j+1];
198       }
199    }
200    /*for (i=0;i<mode->nbPBands+2;i++)
201       printf("%d ", pBands[i]);
202    printf ("\n");*/
203    mode->pBands = pBands;
204    mode->pitchEnd = pBands[PBANDS];
205 }
206
207 static void compute_allocation_table(CELTMode *mode, int res)
208 {
209    int i, j, eband, nBark;
210    celt_int16_t *allocVectors, *allocEnergy;
211    const int C = CHANNELS(mode);
212
213    /* Find the number of critical bands supported by our sampling rate */
214    for (nBark=1;nBark<BARK_BANDS;nBark++)
215     if (bark_freq[nBark+1]*2 >= mode->Fs)
216        break;
217
218    mode->nbAllocVectors = BITALLOC_SIZE;
219    allocVectors = celt_alloc(sizeof(celt_int16_t)*(BITALLOC_SIZE*mode->nbEBands));
220    allocEnergy = celt_alloc(sizeof(celt_int16_t)*(mode->nbAllocVectors*(mode->nbEBands+1)));
221    /* Compute per-codec-band allocation from per-critical-band matrix */
222    for (i=0;i<BITALLOC_SIZE;i++)
223    {
224       eband = 0;
225       for (j=0;j<nBark;j++)
226       {
227          int edge, low;
228          celt_int32_t alloc;
229          edge = mode->eBands[eband+1]*res;
230          alloc = band_allocation[i*BARK_BANDS+j];
231          alloc = alloc*C*mode->mdctSize/4;
232          if (edge < bark_freq[j+1])
233          {
234             int num, den;
235             num = alloc * (edge-bark_freq[j]);
236             den = bark_freq[j+1]-bark_freq[j];
237             low = (num+den/2)/den;
238             allocVectors[i*mode->nbEBands+eband] += low;
239             eband++;
240             allocVectors[i*mode->nbEBands+eband] += alloc-low;
241          } else {
242             allocVectors[i*mode->nbEBands+eband] += alloc;
243          }
244       }
245    }
246    for (i=0;i<mode->nbAllocVectors;i++)
247    {
248       for (j=0;j<mode->nbEBands;j++)
249          allocVectors[i*mode->nbEBands+j] = (allocVectors[i*mode->nbEBands+j]+32)/64;
250    }
251    /*for (i=0;i<mode->nbAllocVectors;i++)
252    {
253       for (j=0;j<mode->nbEBands;j++)
254          allocVectors[i*mode->nbEBands+j] += C;
255    }*/
256    mode->allocVectors = allocVectors;
257 }
258
259 #endif /* STATIC_MODES */
260
261 CELTMode *celt_mode_create(celt_int32_t Fs, int channels, int frame_size, int *error)
262 {
263    int i;
264 #ifdef STDIN_TUNING
265    scanf("%d ", &MIN_BINS);
266    scanf("%d ", &BITALLOC_SIZE);
267    band_allocation = celt_alloc(sizeof(int)*BARK_BANDS*BITALLOC_SIZE);
268    for (i=0;i<BARK_BANDS*BITALLOC_SIZE;i++)
269    {
270       scanf("%d ", band_allocation+i);
271    }
272 #endif
273 #ifdef STATIC_MODES
274    const CELTMode *m = NULL;
275    CELTMode *mode=NULL;
276    ALLOC_STACK;
277    for (i=0;i<TOTAL_MODES;i++)
278    {
279       if (Fs == static_mode_list[i]->Fs &&
280           channels == static_mode_list[i]->nbChannels &&
281           frame_size == static_mode_list[i]->mdctSize)
282       {
283          m = static_mode_list[i];
284          break;
285       }
286    }
287    if (m == NULL)
288    {
289       celt_warning("Mode not included as part of the static modes");
290       if (error)
291          *error = CELT_BAD_ARG;
292       return NULL;
293    }
294    mode = (CELTMode*)celt_alloc(sizeof(CELTMode));
295    CELT_COPY(mode, m, 1);
296 #else
297    int res;
298    CELTMode *mode;
299    celt_word16_t *window;
300    ALLOC_STACK;
301
302    /* The good thing here is that permutation of the arguments will automatically be invalid */
303    
304    if (Fs < 32000 || Fs > 96000)
305    {
306       celt_warning("Sampling rate must be between 32 kHz and 96 kHz");
307       if (error)
308          *error = CELT_BAD_ARG;
309       return NULL;
310    }
311    if (channels < 0 || channels > 2)
312    {
313       celt_warning("Only mono and stereo supported");
314       if (error)
315          *error = CELT_BAD_ARG;
316       return NULL;
317    }
318    if (frame_size < 64 || frame_size > 512 || frame_size%2!=0)
319    {
320       celt_warning("Only even frame sizes from 64 to 512 are supported");
321       if (error)
322          *error = CELT_BAD_ARG;
323       return NULL;
324    }
325    res = (Fs+frame_size)/(2*frame_size);
326    
327    mode = celt_alloc(sizeof(CELTMode));
328    mode->Fs = Fs;
329    mode->mdctSize = frame_size;
330    mode->nbChannels = channels;
331    mode->eBands = compute_ebands(Fs, frame_size, &mode->nbEBands);
332    compute_pbands(mode, res);
333    mode->ePredCoef = QCONST16(.8f,15);
334
335    if (frame_size > 384 && (frame_size%8)==0)
336    {
337      mode->nbShortMdcts = 4;
338    } else if (frame_size > 384 && (frame_size%10)==0)
339    {
340      mode->nbShortMdcts = 5;
341    } else if (frame_size > 256 && (frame_size%6)==0)
342    {
343      mode->nbShortMdcts = 3;
344    } else if (frame_size > 256 && (frame_size%8)==0)
345    {
346      mode->nbShortMdcts = 4;
347    } else if (frame_size > 64 && (frame_size%4)==0)
348    {
349      mode->nbShortMdcts = 2;
350    } else if (frame_size > 128 && (frame_size%6)==0)
351    {
352      mode->nbShortMdcts = 3;
353    } else
354    {
355      mode->nbShortMdcts = 1;
356    }
357
358    if (mode->nbShortMdcts > 1)
359       mode->overlap = ((frame_size/mode->nbShortMdcts)>>2)<<2; /* Overlap must be divisible by 4 */
360    else
361       mode->overlap = (frame_size>>3)<<2;
362
363    compute_allocation_table(mode, res);
364    /*printf ("%d bands\n", mode->nbEBands);*/
365    
366    window = (celt_word16_t*)celt_alloc(mode->overlap*sizeof(celt_word16_t));
367
368 #ifndef FIXED_POINT
369    for (i=0;i<mode->overlap;i++)
370       window[i] = Q15ONE*sin(.5*M_PI* sin(.5*M_PI*(i+.5)/mode->overlap) * sin(.5*M_PI*(i+.5)/mode->overlap));
371 #else
372    for (i=0;i<mode->overlap;i++)
373       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)));
374 #endif
375    mode->window = window;
376
377    mode->bits = (const celt_int16_t **)compute_alloc_cache(mode, 1);
378
379 #ifndef SHORTCUTS
380    psydecay_init(&mode->psy, MAX_PERIOD/2, mode->Fs);
381 #endif
382    
383    mode->marker_start = MODEVALID;
384    mode->marker_end = MODEVALID;
385 #endif /* !STATIC_MODES */
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
393    mode->prob = quant_prob_alloc(mode);
394
395    if (error)
396       *error = CELT_OK;
397    return mode;
398 }
399
400 void celt_mode_destroy(CELTMode *mode)
401 {
402 #ifndef STATIC_MODES
403    int i;
404    const celt_int16_t *prevPtr = NULL;
405    for (i=0;i<mode->nbEBands;i++)
406    {
407       if (mode->bits[i] != prevPtr)
408       {
409          prevPtr = mode->bits[i];
410          celt_free((int*)mode->bits[i]);
411       }
412    }
413    celt_free((int**)mode->bits);
414    if (check_mode(mode) != CELT_OK)
415       return;
416    celt_free((int*)mode->eBands);
417    celt_free((int*)mode->pBands);
418    celt_free((int*)mode->allocVectors);
419
420    celt_free((celt_word16_t*)mode->window);
421
422    mode->marker_start = MODEFREED;
423    mode->marker_end = MODEFREED;
424 #ifndef SHORTCUTS
425    psydecay_clear(&mode->psy);
426 #endif
427 #endif
428    mdct_clear(&mode->mdct);
429    mdct_clear(&mode->shortMdct);
430    pitch_state_free(mode->fft);
431    quant_prob_free(mode->prob);
432    celt_free((CELTMode *)mode);
433 }
434
435 int check_mode(const CELTMode *mode)
436 {
437    if (mode->marker_start == MODEVALID && mode->marker_end == MODEVALID)
438       return CELT_OK;
439    if (mode->marker_start == MODEFREED || mode->marker_end == MODEFREED)
440       celt_warning("Using a mode that has already been freed");
441    else
442       celt_warning("This is not a valid CELT mode");
443    return CELT_INVALID_MODE;
444 }