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(int 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(int Fs, int channels, int frame_size, int lookahead, int *error)
 217 {
 218    int res;
 219    int N, N2, N4, i;
 220    CELTMode *mode;
 221
 222    /* The good thing here is that permutation of the arguments will automatically be invalid */
 223
 224    if (Fs < 32000 || Fs > 64000)
 225    {
 226       celt_warning("Sampling rate must be between 32 kHz and 64 kHz");
 227       if (error)
 228          *error = CELT_BAD_ARG;
 229       return NULL;
 230    }
 231    if (channels < 0 || channels > 2)
 232    {
 233       celt_warning("Only mono and stereo supported");
 234       if (error)
 235          *error = CELT_BAD_ARG;
 236       return NULL;
 237    }
 238    if (frame_size < 64 || frame_size > 256 || frame_size%2!=0)
 239    {
 240       celt_warning("Only even frame sizes between 64 and 256 are supported");
 241       if (error)
 242          *error = CELT_BAD_ARG;
 243       return NULL;
 244    }
 245    if (lookahead < 32 || lookahead > frame_size)
 246    {
 247       celt_warning("The overlap must be between 32 and the frame size");
 248       if (error)
 249          *error = CELT_BAD_ARG;
 250       return NULL;
 251    }
 252    res = (Fs+frame_size)/(2*frame_size);
 253
 254    mode = celt_alloc(sizeof(CELTMode));
 255    mode->Fs = Fs;
 256    mode->overlap = lookahead;
 257    mode->mdctSize = frame_size;
 258    mode->nbMdctBlocks = 1;
 259    mode->nbChannels = channels;
 260    mode->eBands = compute_ebands(Fs, frame_size, &mode->nbEBands);
 261    compute_pbands(mode, res);
 262    mode->ePredCoef = QCONST16(.8f,15);
 263
 264    compute_allocation_table(mode, res);
 265    compute_alloc_cache(mode);
 266    /*printf ("%d bands\n", mode->nbEBands);*/
 267
 268    N = mode->mdctSize;
 269    N2 = N/2;
 270    N4 = N/4;
 271    mdct_init(&mode->mdct, 2*N);
 272
 273    mode->window = (celt_word16_t*)celt_alloc(2*N*sizeof(celt_word16_t));
 274
 275    for (i=0;i<2*N;i++)
 276       mode->window[i] = 0;
 277 #ifndef FIXED_POINT
 278    for (i=0;i<mode->overlap;i++)
 279       mode->window[N4+i] = mode->window[2*N-N4-i-1]
 280             = Q15ONE*sin(.5*M_PI* sin(.5*M_PI*(i+.5)/mode->overlap) * sin(.5*M_PI*(i+.5)/mode->overlap));
 281 #else
 282    for (i=0;i<mode->overlap;i++)
 283       mode->window[N4+i] = mode->window[2*N-N4-i-1]
 284             = MIN32(32767,32768.*sin(.5*M_PI* sin(.5*M_PI*(i+.5)/mode->overlap) * sin(.5*M_PI*(i+.5)/mode->overlap)));
 285 #endif
 286    for (i=0;i<N2;i++)
 287       mode->window[N-N4+i] = Q15ONE;
 288
 289    mode->marker_start = MODEVALID;
 290    mode->marker_end = MODEVALID;
 291    return mode;
 292 }
 293
 294 void celt_mode_destroy(CELTMode *mode)
 295 {
 296    int i;
 297    const int *prevPtr = NULL;
 298    if (check_mode(mode) != CELT_OK)
 299       return;
 300    celt_free((int*)mode->eBands);
 301    celt_free((int*)mode->pBands);
 302    celt_free((int*)mode->allocVectors);
 303
 304    for (i=0;i<mode->nbEBands;i++)
 305    {
 306       if (mode->bits[i] != prevPtr)
 307       {
 308          prevPtr = mode->bits[i];
 309          celt_free((int*)mode->bits[i]);
 310       }
 311    }
 312    celt_free((int**)mode->bits);
 313    mdct_clear(&mode->mdct);
 314    celt_free(mode->window);
 315
 316    mode->marker_start = MODEFREED;
 317    mode->marker_end = MODEFREED;
 318    celt_free((CELTMode *)mode);
 319
 320 }
 321
 322 int check_mode(const CELTMode *mode)
 323 {
 324    if (mode->marker_start == MODEVALID && mode->marker_end == MODEVALID)
 325       return CELT_OK;
 326    if (mode->marker_start == MODEFREED || mode->marker_end == MODEFREED)
 327       celt_warning("Using a mode that has already been freed");
 328    else
 329       celt_warning("This is not a valid CELT mode");
 330    return CELT_INVALID_MODE;
 331 }