More simplifications from denorm pitch
[opus.git] / libcelt / modes.c
index a2eb973..8a9f223 100644 (file)
@@ -1,5 +1,5 @@
-/* (C) 2007-2008 Jean-Marc Valin, CSIRO
-*/
+/* (C) 2007-2009 Jean-Marc Valin, CSIRO
+   (C) 2008 Gregory Maxwell */
 /*
    Redistribution and use in source and binary forms, with or without
    modification, are permitted provided that the following conditions
@@ -44,8 +44,9 @@
 #include "static_modes.c"
 #endif
 
-#define MODEVALID 0xa110ca7e
-#define MODEFREED 0xb10cf8ee
+#define MODEVALID   0xa110ca7e
+#define MODEPARTIAL 0x7eca10a1
+#define MODEFREED   0xb10cf8ee
 
 #ifndef M_PI
 #define M_PI 3.141592653
@@ -54,6 +55,8 @@
 
 int celt_mode_info(const CELTMode *mode, int request, celt_int32_t *value)
 {
+   if (check_mode(mode) != CELT_OK)
+      return CELT_INVALID_MODE;
    switch (request)
    {
       case CELT_GET_FRAME_SIZE:
@@ -68,22 +71,17 @@ int celt_mode_info(const CELTMode *mode, int request, celt_int32_t *value)
       case CELT_GET_BITSTREAM_VERSION:
          *value = CELT_BITSTREAM_VERSION;
          break;
+      case CELT_GET_SAMPLE_RATE:
+         *value = mode->Fs;
+         break;
       default:
-         return CELT_BAD_ARG;
+         return CELT_UNIMPLEMENTED;
    }
    return CELT_OK;
 }
 
 #ifndef STATIC_MODES
 
-#define PBANDS 8
-
-#ifdef STDIN_TUNING
-int MIN_BINS;
-#else
-#define MIN_BINS 3
-#endif
-
 /* Defining 25 critical bands for the full 0-20 kHz audio bandwidth
    Taken from http://ccrma.stanford.edu/~jos/bbt/Bark_Frequency_Scale.html */
 #define BARK_BANDS 25
@@ -95,8 +93,6 @@ static const celt_int16_t bark_freq[BARK_BANDS+1] = {
    6400,  7700,  9500, 12000, 15500,
   20000};
 
-static const celt_int16_t pitch_freq[PBANDS+1] ={0, 345, 689, 1034, 1378, 2067, 3273, 5340, 6374};
-
 /* This allocation table is per critical band. When creating a mode, the bits get added together 
    into the codec bands, which are sometimes larger than one critical band at low frequency */
 
@@ -106,159 +102,122 @@ int *band_allocation;
 #else
 #define BITALLOC_SIZE 12
 static const int band_allocation[BARK_BANDS*BITALLOC_SIZE] = 
-   {  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,
-      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,
-      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,
-      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,
-      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,
-      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,
-      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,
-      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,
-      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,
-      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,
-      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,
-     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,
+   /* 0 100 200 300 400 510 630 770 920 1k  1.2 1.5 1.7 2k  2.3 2.7 3.1 3.7 4.4 5.3 6.4 7.7 9.5 12k 15k  */
+   {  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, /*0*/
+      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, /*1*/
+      2,  2,  2,  1,  2,  2,  2,  2,  2,  2,  2,  2,  4,  5,  7,  7,  7,  5,  4,  0,  0,  0,  0,  0,  0, /*2*/
+      2,  2,  2,  2,  3,  3,  3,  3,  3,  3,  3,  3,  5,  6,  8,  8,  8,  6,  5,  4,  0,  0,  0,  0,  0, /*3*/
+      3,  2,  2,  2,  3,  4,  4,  4,  4,  4,  4,  4,  6,  7,  9,  9,  9,  7,  6,  5,  5,  5,  0,  0,  0, /*4*/
+      3,  3,  3,  4,  4,  5,  6,  6,  6,  6,  6,  7,  7,  9, 10, 10, 10,  9,  6,  5,  5,  5,  5,  1,  0, /*5*/
+      4,  3,  3,  4,  6,  7,  7,  7,  7,  7,  8,  9,  9,  9, 11, 10, 10,  9,  9,  8, 11, 10, 10,  1,  0, /*6*/
+      5,  5,  5,  6,  7,  7,  7,  7,  8,  8,  9, 10, 10, 12, 12, 11, 11, 17, 12, 15, 15, 20, 18, 10,  1, /*7*/
+      6,  7,  7,  7,  8,  8,  8,  8,  9, 10, 11, 12, 14, 17, 18, 21, 22, 27, 29, 39, 37, 38, 40, 35,  1, /*8*/
+      7,  7,  7,  8,  8,  8, 10, 10, 10, 13, 14, 18, 20, 24, 28, 32, 32, 35, 38, 38, 42, 50, 59, 54, 31, /*9*/
+      8,  8,  8,  8,  8,  9, 10, 12, 14, 20, 22, 25, 28, 30, 35, 42, 46, 50, 55, 60, 62, 62, 72, 82, 62, /*10*/
+      9,  9,  9, 10, 12, 13, 15, 18, 22, 30, 32, 35, 40, 45, 55, 62, 66, 70, 85, 90, 92, 92, 92,102, 92, /*11*/
    };
 #endif
 
-static celt_int16_t *compute_ebands(celt_int32_t Fs, int frame_size, int *nbEBands)
+static celt_int16_t *compute_ebands(celt_int32_t Fs, int frame_size, int nbShortMdcts, int *nbEBands)
 {
+   int min_bins = 2;
    celt_int16_t *eBands;
-   int i, res, min_width, lin, low, high;
+   int i, res, min_width, lin, low, high, nBark;
+
+   if (min_bins < nbShortMdcts)
+      min_bins = nbShortMdcts;
    res = (Fs+frame_size)/(2*frame_size);
-   min_width = MIN_BINS*res;
-   /*printf ("min_width = %d\n", min_width);*/
+   min_width = min_bins*res;
+
+   /* Find the number of critical bands supported by our sampling rate */
+   for (nBark=1;nBark<BARK_BANDS;nBark++)
+    if (bark_freq[nBark+1]*2 >= Fs)
+       break;
 
    /* Find where the linear part ends (i.e. where the spacing is more than min_width */
-   for (lin=0;lin<BARK_BANDS;lin++)
+   for (lin=0;lin<nBark;lin++)
       if (bark_freq[lin+1]-bark_freq[lin] >= min_width)
          break;
    
-   /*printf ("lin = %d (%d Hz)\n", lin, bark_freq[lin]);*/
-   low = ((bark_freq[lin]/res)+(MIN_BINS-1))/MIN_BINS;
-   high = BARK_BANDS-lin;
+   low = ((bark_freq[lin]/res)+(min_bins-1))/min_bins;
+   high = nBark-lin;
    *nbEBands = low+high;
    eBands = celt_alloc(sizeof(celt_int16_t)*(*nbEBands+2));
    
+   if (eBands==NULL)
+      return NULL;
+   
    /* Linear spacing (min_width) */
    for (i=0;i<low;i++)
-      eBands[i] = MIN_BINS*i;
+      eBands[i] = min_bins*i;
    /* Spacing follows critical bands */
    for (i=0;i<high;i++)
-      eBands[i+low] = (bark_freq[lin+i]+res/2)/res;
+      eBands[i+low] = (bark_freq[lin+i]+res/2)/res/nbShortMdcts*nbShortMdcts;
    /* Enforce the minimum spacing at the boundary */
    for (i=0;i<*nbEBands;i++)
-      if (eBands[i] < MIN_BINS*i)
-         eBands[i] = MIN_BINS*i;
-   eBands[*nbEBands] = (bark_freq[BARK_BANDS]+res/2)/res;
+      if (eBands[i] < min_bins*i)
+         eBands[i] = min_bins*i;
+   eBands[*nbEBands] = (bark_freq[nBark]+res/2)/res/nbShortMdcts*nbShortMdcts;
    eBands[*nbEBands+1] = frame_size;
    if (eBands[*nbEBands] > eBands[*nbEBands+1])
       eBands[*nbEBands] = eBands[*nbEBands+1];
-   
-   /* FIXME: Remove last band if too small */
-   /*for (i=0;i<*nbEBands+2;i++)
-      printf("%d ", eBands[i]);
-   printf ("\n");
-   exit(1);*/
-   return eBands;
-}
-
-static void compute_pbands(CELTMode *mode, int res)
-{
-   int i;
-   celt_int16_t *pBands;
-   pBands=celt_alloc(sizeof(celt_int16_t)*(PBANDS+2));
-   mode->nbPBands = PBANDS;
-   for (i=0;i<PBANDS+1;i++)
+   for (i=1;i<*nbEBands-1;i++)
    {
-      pBands[i] = (pitch_freq[i]+res/2)/res;
-      if (pBands[i] < mode->eBands[i])
-         pBands[i] = mode->eBands[i];
-   }
-   pBands[PBANDS+1] = mode->eBands[mode->nbEBands+1];
-   for (i=1;i<mode->nbPBands+1;i++)
-   {
-      int j;
-      for (j=0;j<mode->nbEBands;j++)
-         if (mode->eBands[j] <= pBands[i] && mode->eBands[j+1] > pBands[i])
-            break;
-      /*printf ("%d %d\n", i, j);*/
-      if (mode->eBands[j] != pBands[i])
+      if (eBands[i+1]-eBands[i] < eBands[i]-eBands[i-1])
       {
-         if (pBands[i]-mode->eBands[j] < mode->eBands[j+1]-pBands[i] && 
-             mode->eBands[j] != pBands[i-1])
-            pBands[i] = mode->eBands[j];
-         else
-            pBands[i] = mode->eBands[j+1];
+         eBands[i] -= min_bins;
       }
    }
-   /*for (i=0;i<mode->nbPBands+2;i++)
-      printf("%d ", pBands[i]);
+   /*for (i=0;i<*nbEBands+1;i++)
+      printf ("%d ", eBands[i]);
    printf ("\n");*/
-   mode->pBands = pBands;
-   mode->pitchEnd = pBands[PBANDS];
+   /* FIXME: Remove last band if too small */
+   return eBands;
 }
 
 static void compute_allocation_table(CELTMode *mode, int res)
 {
-   int i, j, eband;
-   celt_int16_t *allocVectors, *allocEnergy;
+   int i, j, nBark;
+   celt_int16_t *allocVectors;
    const int C = CHANNELS(mode);
 
+   /* Find the number of critical bands supported by our sampling rate */
+   for (nBark=1;nBark<BARK_BANDS;nBark++)
+    if (bark_freq[nBark+1]*2 >= mode->Fs)
+       break;
+
    mode->nbAllocVectors = BITALLOC_SIZE;
    allocVectors = celt_alloc(sizeof(celt_int16_t)*(BITALLOC_SIZE*mode->nbEBands));
-   allocEnergy = celt_alloc(sizeof(celt_int16_t)*(mode->nbAllocVectors*(mode->nbEBands+1)));
+   if (allocVectors==NULL)
+      return;
    /* Compute per-codec-band allocation from per-critical-band matrix */
    for (i=0;i<BITALLOC_SIZE;i++)
    {
-      eband = 0;
-      for (j=0;j<BARK_BANDS;j++)
+      celt_int32_t current = 0;
+      int eband = 0;
+      for (j=0;j<nBark;j++)
       {
          int edge, low;
          celt_int32_t alloc;
          edge = mode->eBands[eband+1]*res;
          alloc = band_allocation[i*BARK_BANDS+j];
-         alloc = alloc*C*mode->mdctSize/256;
+         alloc = alloc*C*mode->mdctSize;
          if (edge < bark_freq[j+1])
          {
             int num, den;
             num = alloc * (edge-bark_freq[j]);
             den = bark_freq[j+1]-bark_freq[j];
             low = (num+den/2)/den;
-            allocVectors[i*mode->nbEBands+eband] += low;
+            allocVectors[i*mode->nbEBands+eband] = (current+low+128)/256;
+            current=0;
             eband++;
-            allocVectors[i*mode->nbEBands+eband] += alloc-low;
+            current += alloc-low;
          } else {
-            allocVectors[i*mode->nbEBands+eband] += alloc;
-         }
+            current += alloc;
+         }   
       }
+      allocVectors[i*mode->nbEBands+eband] = (current+128)/256;
    }
-   /* Compute fine energy resolution and update the pulse allocation table to subtract that */
-   for (i=0;i<mode->nbAllocVectors;i++)
-   {
-      int sum = 0;
-      for (j=0;j<mode->nbEBands;j++)
-      {
-         int ebits;
-         int min_bits=0;
-         if (allocVectors[i*mode->nbEBands+j] > 0)
-            min_bits = 1;
-         ebits = IMAX(min_bits , allocVectors[i*mode->nbEBands+j] / (C*(mode->eBands[j+1]-mode->eBands[j])));
-         if (ebits>7)
-            ebits=7;
-         /* The bits used for fine allocation can't be used for pulses */
-         /* However, we give two "free" bits to all modes to compensate for the fact that some energy
-            resolution is needed regardless of the frame size. */
-         if (ebits>1)
-            allocVectors[i*mode->nbEBands+j] -= C*(ebits-2);
-         if (allocVectors[i*mode->nbEBands+j] < 0)
-            allocVectors[i*mode->nbEBands+j] = 0;
-         sum += ebits;
-         allocEnergy[i*(mode->nbEBands+1)+j] = ebits;
-      }
-      allocEnergy[i*(mode->nbEBands+1)+mode->nbEBands] = sum;
-   }
-   mode->energy_alloc = allocEnergy;
    mode->allocVectors = allocVectors;
 }
 
@@ -280,12 +239,18 @@ CELTMode *celt_mode_create(celt_int32_t Fs, int channels, int frame_size, int *e
    const CELTMode *m = NULL;
    CELTMode *mode=NULL;
    ALLOC_STACK;
+#if !defined(VAR_ARRAYS) && !defined(USE_ALLOCA)
+   if (global_stack==NULL)
+   {
+      celt_free(global_stack);
+      goto failure;
+   }
+#endif 
    for (i=0;i<TOTAL_MODES;i++)
    {
       if (Fs == static_mode_list[i]->Fs &&
           channels == static_mode_list[i]->nbChannels &&
-          frame_size == static_mode_list[i]->mdctSize &&
-          lookahead == static_mode_list[i]->overlap)
+          frame_size == static_mode_list[i]->mdctSize)
       {
          m = static_mode_list[i];
          break;
@@ -299,18 +264,28 @@ CELTMode *celt_mode_create(celt_int32_t Fs, int channels, int frame_size, int *e
       return NULL;
    }
    mode = (CELTMode*)celt_alloc(sizeof(CELTMode));
+   if (mode==NULL)
+      goto failure;
    CELT_COPY(mode, m, 1);
+   mode->marker_start = MODEPARTIAL;
 #else
    int res;
-   CELTMode *mode;
+   CELTMode *mode=NULL;
    celt_word16_t *window;
    ALLOC_STACK;
+#if !defined(VAR_ARRAYS) && !defined(USE_ALLOCA)
+   if (global_stack==NULL)
+   {
+      celt_free(global_stack);
+      goto failure;
+   }
+#endif 
 
    /* The good thing here is that permutation of the arguments will automatically be invalid */
    
-   if (Fs < 32000 || Fs > 64000)
+   if (Fs < 32000 || Fs > 96000)
    {
-      celt_warning("Sampling rate must be between 32 kHz and 64 kHz");
+      celt_warning("Sampling rate must be between 32 kHz and 96 kHz");
       if (error)
          *error = CELT_BAD_ARG;
       return NULL;
@@ -322,9 +297,9 @@ CELTMode *celt_mode_create(celt_int32_t Fs, int channels, int frame_size, int *e
          *error = CELT_BAD_ARG;
       return NULL;
    }
-   if (frame_size < 64 || frame_size > 512 || frame_size%2!=0)
+   if (frame_size < 64 || frame_size > 1024 || frame_size%2!=0)
    {
-      celt_warning("Only even frame sizes between 64 and 512 are supported");
+      celt_warning("Only even frame sizes from 64 to 1024 are supported");
       if (error)
          *error = CELT_BAD_ARG;
       return NULL;
@@ -332,34 +307,59 @@ CELTMode *celt_mode_create(celt_int32_t Fs, int channels, int frame_size, int *e
    res = (Fs+frame_size)/(2*frame_size);
    
    mode = celt_alloc(sizeof(CELTMode));
+   if (mode==NULL)
+      goto failure;
+   mode->marker_start = MODEPARTIAL;
    mode->Fs = Fs;
    mode->mdctSize = frame_size;
    mode->nbChannels = channels;
-   mode->eBands = compute_ebands(Fs, frame_size, &mode->nbEBands);
-   compute_pbands(mode, res);
    mode->ePredCoef = QCONST16(.8f,15);
-   
-   if (frame_size <= 64)
+
+   if (frame_size > 640 && (frame_size%16)==0)
+   {
+     mode->nbShortMdcts = 8;
+   } else if (frame_size > 384 && (frame_size%8)==0)
+   {
+     mode->nbShortMdcts = 4;
+   } else if (frame_size > 384 && (frame_size%10)==0)
+   {
+     mode->nbShortMdcts = 5;
+   } else if (frame_size > 256 && (frame_size%6)==0)
+   {
+     mode->nbShortMdcts = 3;
+   } else if (frame_size > 256 && (frame_size%8)==0)
    {
-      mode->nbShortMdcts = 1;
-   } else if (frame_size <= 256)
+     mode->nbShortMdcts = 4;
+   } else if (frame_size > 64 && (frame_size%4)==0)
    {
-      mode->nbShortMdcts = 2;
-   } else if (frame_size <= 384)
+     mode->nbShortMdcts = 2;
+   } else if (frame_size > 128 && (frame_size%6)==0)
    {
-      mode->nbShortMdcts = 3;
-   } else {
-      mode->nbShortMdcts = 4;
+     mode->nbShortMdcts = 3;
+   } else
+   {
+     mode->nbShortMdcts = 1;
    }
+
+   mode->eBands = compute_ebands(Fs, frame_size, mode->nbShortMdcts, &mode->nbEBands);
+   if (mode->eBands==NULL)
+      goto failure;
+
+   mode->pitchEnd = 3000*(celt_int32_t)frame_size/Fs;
+   
+   /* Overlap must be divisible by 4 */
    if (mode->nbShortMdcts > 1)
-      mode->overlap = frame_size/mode->nbShortMdcts;
+      mode->overlap = ((frame_size/mode->nbShortMdcts)>>2)<<2; 
    else
-      mode->overlap = frame_size/2;
-   
+      mode->overlap = (frame_size>>3)<<2;
+
    compute_allocation_table(mode, res);
-   /*printf ("%d bands\n", mode->nbEBands);*/
+   if (mode->allocVectors==NULL)
+      goto failure;
    
    window = (celt_word16_t*)celt_alloc(mode->overlap*sizeof(celt_word16_t));
+   if (window==NULL)
+      goto failure;
 
 #ifndef FIXED_POINT
    for (i=0;i<mode->overlap;i++)
@@ -371,56 +371,94 @@ CELTMode *celt_mode_create(celt_int32_t Fs, int channels, int frame_size, int *e
    mode->window = window;
 
    mode->bits = (const celt_int16_t **)compute_alloc_cache(mode, 1);
+   if (mode->bits==NULL)
+      goto failure;
 
-   mode->bits_stereo = NULL;
 #ifndef SHORTCUTS
    psydecay_init(&mode->psy, MAX_PERIOD/2, mode->Fs);
+   if (mode->psy.decayR==NULL)
+      goto failure;
 #endif
    
-   mode->marker_start = MODEVALID;
-   mode->marker_end = MODEVALID;
 #endif /* !STATIC_MODES */
+
+#ifdef DISABLE_STEREO
+   if (channels > 1)
+   {
+      celt_warning("Stereo support was disable from this build");
+      if (error)
+         *error = CELT_BAD_ARG;
+      return NULL;
+   }
+#endif
+
    mdct_init(&mode->mdct, 2*mode->mdctSize);
    mode->fft = pitch_state_alloc(MAX_PERIOD);
 
    mode->shortMdctSize = mode->mdctSize/mode->nbShortMdcts;
    mdct_init(&mode->shortMdct, 2*mode->shortMdctSize);
    mode->shortWindow = mode->window;
-
    mode->prob = quant_prob_alloc(mode);
-   
-   if (mode->nbChannels>=2)
-      mode->bits_stereo = (const celt_int16_t **)compute_alloc_cache(mode, mode->nbChannels);
+   if ((mode->mdct.trig==NULL) || (mode->shortMdct.trig==NULL)
+#ifndef ENABLE_TI_DSPLIB55
+        || (mode->mdct.kfft==NULL) || (mode->fft==NULL) || (mode->shortMdct.kfft==NULL)
+#endif
+        || (mode->prob==NULL))
+     goto failure;
 
+   mode->marker_start = MODEVALID;
+   mode->marker_end   = MODEVALID;
    if (error)
       *error = CELT_OK;
    return mode;
+failure: 
+   if (error)
+      *error = CELT_INVALID_MODE;
+   if (mode!=NULL)
+      celt_mode_destroy(mode);
+   return NULL;
 }
 
 void celt_mode_destroy(CELTMode *mode)
 {
-#ifndef STATIC_MODES
    int i;
    const celt_int16_t *prevPtr = NULL;
-   for (i=0;i<mode->nbEBands;i++)
+   if (mode == NULL)
    {
-      if (mode->bits[i] != prevPtr)
+      celt_warning("NULL passed to celt_mode_destroy");
+      return;
+   }
+
+   if (mode->marker_start == MODEFREED || mode->marker_end == MODEFREED)
+   {
+      celt_warning("Freeing a mode which has already been freed"); 
+      return;
+   }
+
+   if (mode->marker_start != MODEVALID && mode->marker_start != MODEPARTIAL)
+   {
+      celt_warning("This is not a valid CELT mode structure");
+      return;  
+   }
+   mode->marker_start = MODEFREED;
+#ifndef STATIC_MODES
+   if (mode->bits!=NULL)
+   {
+      for (i=0;i<mode->nbEBands;i++)
       {
-         prevPtr = mode->bits[i];
-         celt_free((int*)mode->bits[i]);
+         if (mode->bits[i] != prevPtr)
+         {
+            prevPtr = mode->bits[i];
+            celt_free((int*)mode->bits[i]);
+          }
       }
-   }
+   }   
    celt_free((int**)mode->bits);
-   if (check_mode(mode) != CELT_OK)
-      return;
    celt_free((int*)mode->eBands);
-   celt_free((int*)mode->pBands);
    celt_free((int*)mode->allocVectors);
    
    celt_free((celt_word16_t*)mode->window);
 
-   mode->marker_start = MODEFREED;
-   mode->marker_end = MODEFREED;
 #ifndef SHORTCUTS
    psydecay_clear(&mode->psy);
 #endif
@@ -429,12 +467,14 @@ void celt_mode_destroy(CELTMode *mode)
    mdct_clear(&mode->shortMdct);
    pitch_state_free(mode->fft);
    quant_prob_free(mode->prob);
-   celt_free((celt_int16_t *)mode->energy_alloc);
+   mode->marker_end = MODEFREED;
    celt_free((CELTMode *)mode);
 }
 
 int check_mode(const CELTMode *mode)
 {
+   if (mode==NULL)
+      return CELT_INVALID_MODE;
    if (mode->marker_start == MODEVALID && mode->marker_end == MODEVALID)
       return CELT_OK;
    if (mode->marker_start == MODEFREED || mode->marker_end == MODEFREED)