Note some more platforms where float-approx is tested, fix a bug in the prediction...
[opus.git] / libcelt / celt.c
index 0cdf97f..5d32fdc 100644 (file)
@@ -60,8 +60,10 @@ static const celt_word16_t transientWindow[16] = {
    17896, 20868, 23687, 26258, 28492, 30314, 31662, 32489};
 #else
 static const float transientWindow[16] = {
-   0.0085135, 0.0337639, 0.0748914, 0.1304955, 0.1986827, 0.2771308, 0.3631685, 0.4538658,
-   0.5461342, 0.6368315, 0.7228692, 0.8013173, 0.8695045, 0.9251086, 0.9662361, 0.9914865};
+   0.0085135, 0.0337639, 0.0748914, 0.1304955, 
+   0.1986827, 0.2771308, 0.3631685, 0.4538658,
+   0.5461342, 0.6368315, 0.7228692, 0.8013173, 
+   0.8695045, 0.9251086, 0.9662361, 0.9914865};
 #endif
 
 #define ENCODERVALID   0x4c434554
@@ -88,7 +90,7 @@ struct CELTEncoder {
    int fold_decision;
 
    int VBR_rate; /* Target number of 16th bits per frame */
-   celt_word16_t * restrict preemph_memE; /* Input is 16-bit, so why bother with 32 */
+   celt_word16_t * restrict preemph_memE; 
    celt_sig_t    * restrict preemph_memD;
 
    celt_sig_t *in_mem;
@@ -282,7 +284,8 @@ static int transient_analysis(celt_word32_t *in, int len, int C, int *transient_
    return ratio > 20;
 }
 
-/** Apply window and compute the MDCT for all sub-frames and all channels in a frame */
+/** Apply window and compute the MDCT for all sub-frames and 
+    all channels in a frame */
 static void compute_mdcts(const CELTMode *mode, int shortBlocks, celt_sig_t * restrict in, celt_sig_t * restrict out)
 {
    const int C = CHANNELS(mode);
@@ -309,7 +312,7 @@ static void compute_mdcts(const CELTMode *mode, int shortBlocks, celt_sig_t * re
          mdct_forward(lookup, x, tmp, mode->window, overlap);
          /* Interleaving the sub-frames */
          for (j=0;j<N;j++)
-            out[C*j+c] = tmp[j];
+            out[j+c*N] = tmp[j];
       }
       RESTORE_STACK;
    } else {
@@ -333,14 +336,15 @@ static void compute_mdcts(const CELTMode *mode, int shortBlocks, celt_sig_t * re
             mdct_forward(lookup, x, tmp, mode->window, overlap);
             /* Interleaving the sub-frames */
             for (j=0;j<N;j++)
-               out[C*(j*B+b)+c] = tmp[j];
+               out[(j*B+b)+c*N*B] = tmp[j];
          }
       }
       RESTORE_STACK;
    }
 }
 
-/** Compute the IMDCT and apply window for all sub-frames and all channels in a frame */
+/** Compute the IMDCT and apply window for all sub-frames and 
+    all channels in a frame */
 static void compute_inv_mdcts(const CELTMode *mode, int shortBlocks, celt_sig_t *X, int transient_time, int transient_shift, celt_sig_t * restrict out_mem)
 {
    int c, N4;
@@ -363,7 +367,7 @@ static void compute_inv_mdcts(const CELTMode *mode, int shortBlocks, celt_sig_t
          ALLOC(tmp, N, celt_word32_t);
          /* De-interleaving the sub-frames */
          for (j=0;j<N;j++)
-            tmp[j] = X[C*j+c];
+            tmp[j] = X[j+c*N];
          /* Prevents problems from the imdct doing the overlap-add */
          CELT_MEMSET(x+N4, 0, N);
          mdct_backward(lookup, tmp, x, mode->window, overlap);
@@ -393,7 +397,7 @@ static void compute_inv_mdcts(const CELTMode *mode, int shortBlocks, celt_sig_t
          {
             /* De-interleaving the sub-frames */
             for (j=0;j<N2;j++)
-               tmp[j] = X[C*(j*B+b)+c];
+               tmp[j] = X[(j*B+b)+c*N2*B];
             mdct_backward(lookup, tmp, x+N4+N2*b, mode->window, overlap);
          }
          if (transient_shift > 0)
@@ -410,8 +414,8 @@ static void compute_inv_mdcts(const CELTMode *mode, int shortBlocks, celt_sig_t
                x[N4+j] *= 1<<transient_shift;
 #endif
          }
-         /* The first and last part would need to be set to zero if we actually
-         wanted to use them. */
+         /* The first and last part would need to be set to zero 
+            if we actually wanted to use them. */
          for (j=0;j<overlap;j++)
             out_mem[C*(MAX_PERIOD-N)+C*j+c] += x[j+N4];
          for (j=0;j<overlap;j++)
@@ -505,11 +509,13 @@ int celt_encode_float(CELTEncoder * restrict st, const celt_sig_t * pcm, celt_si
    VARDECL(celt_norm_t, X);
    VARDECL(celt_norm_t, P);
    VARDECL(celt_ener_t, bandE);
+   VARDECL(celt_word16_t, bandLogE);
    VARDECL(celt_pgain_t, gains);
    VARDECL(int, fine_quant);
    VARDECL(celt_word16_t, error);
    VARDECL(int, pulses);
    VARDECL(int, offsets);
+   VARDECL(int, fine_priority);
 #ifdef EXP_PSY
    VARDECL(celt_word32_t, mask);
    VARDECL(celt_word32_t, tonality);
@@ -534,7 +540,8 @@ int celt_encode_float(CELTEncoder * restrict st, const celt_sig_t * pcm, celt_si
    if (nbCompressedBytes<0)
      return CELT_BAD_ARG; 
 
-   /* The memset is important for now in case the encoder doesn't fill up all the bytes */
+   /* The memset is important for now in case the encoder doesn't 
+      fill up all the bytes */
    CELT_MEMSET(compressed, 0, nbCompressedBytes);
    ec_byte_writeinit_buffer(&buf, compressed, nbCompressedBytes);
    ec_enc_init(&enc,&buf);
@@ -559,52 +566,47 @@ int celt_encode_float(CELTEncoder * restrict st, const celt_sig_t * pcm, celt_si
       }
    }
    CELT_COPY(st->in_mem, in+C*(2*N-2*N4-st->overlap), C*st->overlap);
-   
+
    /* Transient handling */
-   if (st->mode->nbShortMdcts > 1)
+   transient_time = -1;
+   transient_shift = 0;
+   shortBlocks = 0;
+
+   if (st->mode->nbShortMdcts > 1 && transient_analysis(in, N+st->overlap, C, &transient_time, &transient_shift))
    {
-      if (transient_analysis(in, N+st->overlap, C, &transient_time, &transient_shift))
-      {
 #ifndef FIXED_POINT
-         float gain_1;
+      float gain_1;
 #endif
-         /* Apply the inverse shaping window */
-         if (transient_shift)
-         {
+      /* Apply the inverse shaping window */
+      if (transient_shift)
+      {
 #ifdef FIXED_POINT
-            for (c=0;c<C;c++)
-               for (i=0;i<16;i++)
-                  in[C*(transient_time+i-16)+c] = MULT16_32_Q15(EXTRACT16(SHR32(celt_rcp(Q15ONE+MULT16_16(transientWindow[i],((1<<transient_shift)-1))),1)), in[C*(transient_time+i-16)+c]);
-            for (c=0;c<C;c++)
-               for (i=transient_time;i<N+st->overlap;i++)
-                  in[C*i+c] = SHR32(in[C*i+c], transient_shift);
+         for (c=0;c<C;c++)
+            for (i=0;i<16;i++)
+               in[C*(transient_time+i-16)+c] = MULT16_32_Q15(EXTRACT16(SHR32(celt_rcp(Q15ONE+MULT16_16(transientWindow[i],((1<<transient_shift)-1))),1)), in[C*(transient_time+i-16)+c]);
+         for (c=0;c<C;c++)
+            for (i=transient_time;i<N+st->overlap;i++)
+               in[C*i+c] = SHR32(in[C*i+c], transient_shift);
 #else
-            for (c=0;c<C;c++)
-               for (i=0;i<16;i++)
-                  in[C*(transient_time+i-16)+c] /= 1+transientWindow[i]*((1<<transient_shift)-1);
-            gain_1 = 1./(1<<transient_shift);
-            for (c=0;c<C;c++)
-               for (i=transient_time;i<N+st->overlap;i++)
-                  in[C*i+c] *= gain_1;
+         for (c=0;c<C;c++)
+            for (i=0;i<16;i++)
+               in[C*(transient_time+i-16)+c] /= 1+transientWindow[i]*((1<<transient_shift)-1);
+         gain_1 = 1./(1<<transient_shift);
+         for (c=0;c<C;c++)
+            for (i=transient_time;i<N+st->overlap;i++)
+               in[C*i+c] *= gain_1;
 #endif
-         }
-         shortBlocks = 1;
-         has_fold = 1;
-      } else {
-         transient_time = -1;
-         transient_shift = 0;
-         shortBlocks = 0;
       }
-   } else {
-      transient_time = -1;
-      transient_shift = 0;
-      shortBlocks = 0;
+      shortBlocks = 1;
+      has_fold = 1;
    }
 
    ALLOC(freq, C*N, celt_sig_t); /**< Interleaved signal MDCTs */
    ALLOC(bandE,st->mode->nbEBands*C, celt_ener_t);
+   ALLOC(bandLogE,st->mode->nbEBands*C, celt_word16_t);
    /* Compute MDCTs */
    compute_mdcts(st->mode, shortBlocks, in, freq);
+
    if (shortBlocks && !transient_shift) 
    {
       celt_word32_t sum[4]={1,1,1,1};
@@ -614,7 +616,7 @@ int celt_encode_float(CELTEncoder * restrict st, const celt_sig_t * pcm, celt_si
          m=0;
          do {
             celt_word32_t tmp=0;
-            for (i=m*C+c;i<N;i+=C*st->mode->nbShortMdcts)
+            for (i=m+c*N;i<(c+1)*N;i+=st->mode->nbShortMdcts)
                tmp += ABS32(freq[i]);
             sum[m++] += tmp;
          } while (m<st->mode->nbShortMdcts);
@@ -637,7 +639,7 @@ int celt_encode_float(CELTEncoder * restrict st, const celt_sig_t * pcm, celt_si
       {
          for (c=0;c<C;c++)
             for (m=mdct_weight_pos+1;m<st->mode->nbShortMdcts;m++)
-               for (i=m*C+c;i<N;i+=C*st->mode->nbShortMdcts)
+               for (i=m+c*N;i<(c+1)*N;i+=st->mode->nbShortMdcts)
                   freq[i] = SHR32(freq[i],mdct_weight_shift);
       }
 #else
@@ -657,29 +659,26 @@ int celt_encode_float(CELTEncoder * restrict st, const celt_sig_t * pcm, celt_si
       {
          for (c=0;c<C;c++)
             for (m=mdct_weight_pos+1;m<st->mode->nbShortMdcts;m++)
-               for (i=m*C+c;i<N;i+=C*st->mode->nbShortMdcts)
+               for (i=m+c*N;i<(c+1)*N;i+=st->mode->nbShortMdcts)
                   freq[i] = (1./(1<<mdct_weight_shift))*freq[i];
       }
 #endif
-      /*printf ("%f\n", short_ratio);*/
-      /*if (short_ratio < 1)
-         short_ratio = 1;
-      short_ratio = 1<<(int)floor(.5+log2(short_ratio));
-      if (short_ratio>4)
-         short_ratio = 4;*/
-   }/* else if (transient_shift)
-      printf ("8\n");
-      else printf ("1\n");*/
+   }
 
    compute_band_energies(st->mode, freq, bandE);
+   for (i=0;i<st->mode->nbEBands*C;i++)
+      bandLogE[i] = amp2Log(bandE[i]);
 
-   intra_ener = (st->force_intra || st->delayedIntra);
-   if (shortBlocks || intra_decision(bandE, st->oldBandE, st->mode->nbEBands))
+   /* Don't use intra energy when we're operating at low bit-rate */
+   intra_ener = st->force_intra || (st->delayedIntra && nbCompressedBytes > st->mode->nbEBands);
+   if (shortBlocks || intra_decision(bandLogE, st->oldBandE, st->mode->nbEBands))
       st->delayedIntra = 1;
    else
       st->delayedIntra = 0;
+
    /* Pitch analysis: we do it early to save on the peak stack space */
-   /* Don't use pitch if there isn't enough data available yet, or if we're using shortBlocks */
+   /* Don't use pitch if there isn't enough data available yet, 
+      or if we're using shortBlocks */
    has_pitch = st->pitch_enabled && st->pitch_permitted && (st->pitch_available >= MAX_PERIOD) && (!shortBlocks) && !intra_ener;
 #ifdef EXP_PSY
    ALLOC(tonality, MAX_PERIOD/4, celt_word16_t);
@@ -704,7 +703,8 @@ int celt_encode_float(CELTEncoder * restrict st, const celt_sig_t * pcm, celt_si
    printf ("\n");*/
 #endif
 
-   /* Deferred allocation after find_spectral_pitch() to reduce the peak memory usage */
+   /* Deferred allocation after find_spectral_pitch() to reduce 
+      the peak memory usage */
    ALLOC(X, C*N, celt_norm_t);         /**< Interleaved normalised MDCTs */
    ALLOC(P, C*N, celt_norm_t);         /**< Interleaved normalised pitch MDCTs*/
    ALLOC(gains,st->mode->nbPBands, celt_pgain_t);
@@ -751,8 +751,14 @@ int celt_encode_float(CELTEncoder * restrict st, const celt_sig_t * pcm, celt_si
       compute_band_energies(st->mode, freq, bandEp);
       normalise_bands(st->mode, freq, P, bandEp);
       pitch_power = bandEp[0]+bandEp[1]+bandEp[2];
-      /* Check if we can safely use the pitch (i.e. effective gain isn't too high) */
       curr_power = bandE[0]+bandE[1]+bandE[2];
+      if (C>1)
+      {
+         pitch_power += bandEp[0+st->mode->nbEBands]+bandEp[1+st->mode->nbEBands]+bandEp[2+st->mode->nbEBands];
+         curr_power += bandE[0+st->mode->nbEBands]+bandE[1+st->mode->nbEBands]+bandE[2+st->mode->nbEBands];
+      }
+      /* Check if we can safely use the pitch (i.e. effective gain 
+      isn't too high) */
       if ((MULT16_32_Q15(QCONST16(.1f, 15),curr_power) + QCONST32(10.f,ENER_SHIFT) < pitch_power))
       {
          /* Pitch prediction */
@@ -804,7 +810,7 @@ int celt_encode_float(CELTEncoder * restrict st, const celt_sig_t * pcm, celt_si
 
    /* Bit allocation */
    ALLOC(error, C*st->mode->nbEBands, celt_word16_t);
-   coarse_needed = quant_coarse_energy(st->mode, bandE, st->oldBandE, nbCompressedBytes*8/3, intra_ener, st->mode->prob, error, &enc);
+   coarse_needed = quant_coarse_energy(st->mode, bandLogE, st->oldBandE, nbCompressedBytes*8/3, intra_ener, st->mode->prob, error, &enc);
    coarse_needed = ((coarse_needed*3-1)>>3)+1;
 
    /* Variable bitrate */
@@ -813,13 +819,15 @@ int celt_encode_float(CELTEncoder * restrict st, const celt_sig_t * pcm, celt_si
      /* The target rate in 16th bits per frame */
      int target=st->VBR_rate;
    
-     /* Shortblocks get a large boost in bitrate, but since they are uncommon long blocks are not greatly effected */
+     /* Shortblocks get a large boost in bitrate, but since they 
+        are uncommon long blocks are not greatly effected */
      if (shortBlocks)
        target*=2;
      else if (st->mode->nbShortMdcts > 1)
        target-=(target+14)/28;     
 
-     /*The average energy is removed from the target and the actual energy added*/
+     /* The average energy is removed from the target and the actual 
+        energy added*/
      target=target-588+ec_enc_tell(&enc, 4);
 
      /* In VBR mode the frame size must not be reduced so much that it would result in the coarse energy busting its budget */
@@ -828,6 +836,7 @@ int celt_encode_float(CELTEncoder * restrict st, const celt_sig_t * pcm, celt_si
    }
 
    ALLOC(offsets, st->mode->nbEBands, int);
+   ALLOC(fine_priority, st->mode->nbEBands, int);
 
    for (i=0;i<st->mode->nbEBands;i++)
       offsets[i] = 0;
@@ -835,7 +844,7 @@ int celt_encode_float(CELTEncoder * restrict st, const celt_sig_t * pcm, celt_si
    if (has_pitch)
       bits -= st->mode->nbPBands;
 #ifndef STDIN_TUNING
-   compute_allocation(st->mode, offsets, bits, pulses, fine_quant);
+   compute_allocation(st->mode, offsets, bits, pulses, fine_quant, fine_priority);
 #endif
 
    quant_fine_energy(st->mode, bandE, st->oldBandE, error, fine_quant, &enc);
@@ -847,6 +856,9 @@ int celt_encode_float(CELTEncoder * restrict st, const celt_sig_t * pcm, celt_si
    else
       quant_bands_stereo(st->mode, X, P, NULL, has_pitch, gains, bandE, pulses, shortBlocks, has_fold, nbCompressedBytes*8, &enc);
 #endif
+
+   quant_energy_finalise(st->mode, bandE, st->oldBandE, error, fine_quant, fine_priority, nbCompressedBytes*8-ec_enc_tell(&enc, 0), &enc);
+
    /* Re-synthesis of the coded audio if required */
    if (st->pitch_available>0 || optional_synthesis!=NULL)
    {
@@ -864,7 +876,7 @@ int celt_encode_float(CELTEncoder * restrict st, const celt_sig_t * pcm, celt_si
          int m;
          for (c=0;c<C;c++)
             for (m=mdct_weight_pos+1;m<st->mode->nbShortMdcts;m++)
-               for (i=m*C+c;i<N;i+=C*st->mode->nbShortMdcts)
+               for (i=m+c*N;i<(c+1)*N;i+=st->mode->nbShortMdcts)
 #ifdef FIXED_POINT
                   freq[i] = SHL32(freq[i], mdct_weight_shift);
 #else
@@ -872,7 +884,8 @@ int celt_encode_float(CELTEncoder * restrict st, const celt_sig_t * pcm, celt_si
 #endif
       }
       compute_inv_mdcts(st->mode, shortBlocks, freq, transient_time, transient_shift, st->out_mem);
-      /* De-emphasis and put everything back at the right place in the synthesis history */
+      /* De-emphasis and put everything back at the right place 
+         in the synthesis history */
       if (optional_synthesis != NULL) {
          for (c=0;c<C;c++)
          {
@@ -888,31 +901,8 @@ int celt_encode_float(CELTEncoder * restrict st, const celt_sig_t * pcm, celt_si
       }
    }
 
-   /*fprintf (stderr, "remaining bits after encode = %d\n", nbCompressedBytes*8-ec_enc_tell(&enc, 0));*/
-   /*if (ec_enc_tell(&enc, 0) < nbCompressedBytes*8 - 7)
-      celt_warning_int ("many unused bits: ", nbCompressedBytes*8-ec_enc_tell(&enc, 0));*/
-
-   /* Finishing the stream with a 0101... pattern so that the decoder can check is everything's right */
-   {
-      int val = 0;
-      while (ec_enc_tell(&enc, 0) < nbCompressedBytes*8)
-      {
-         ec_enc_uint(&enc, val, 2);
-         val = 1-val;
-      }
-   }
    ec_enc_done(&enc);
-   {
-      /*unsigned char *data;*/
-      int nbBytes = ec_byte_bytes(&buf);
-      if (nbBytes > nbCompressedBytes)
-      {
-         celt_warning_int ("got too many bytes:", nbBytes);
-         RESTORE_STACK;
-         return CELT_INTERNAL_ERROR;
-      }
-   }
-
+   
    RESTORE_STACK;
    return nbCompressedBytes;
 }
@@ -1026,7 +1016,7 @@ int celt_encoder_ctl(CELTEncoder * restrict st, int request, ...)
          {
             st->force_intra   = 1;
             st->pitch_permitted = 0;
-         } else if (value=1) {
+         } else if (value==1) {
             st->force_intra   = 0;
             st->pitch_permitted = 0;
          } else {
@@ -1079,11 +1069,11 @@ bad_request:
    return CELT_UNIMPLEMENTED;
 }
 
-/****************************************************************************/
-/*                                                                          */
-/*                                DECODER                                   */
-/*                                                                          */
-/****************************************************************************/
+/**********************************************************************/
+/*                                                                    */
+/*                             DECODER                                */
+/*                                                                    */
+/**********************************************************************/
 #ifdef NEW_PLC
 #define DECODE_BUFFER_SIZE 2048
 #else
@@ -1208,7 +1198,8 @@ void celt_decoder_destroy(CELTDecoder *st)
    celt_free(st);
 }
 
-/** Handles lost packets by just copying past data with the same offset as the last
+/** Handles lost packets by just copying past data with the same
+    offset as the last
     pitch period */
 #ifdef NEW_PLC
 #include "plc.c"
@@ -1223,7 +1214,7 @@ static void celt_decode_lost(CELTDecoder * restrict st, celt_word16_t * restrict
    int offset;
    SAVE_STACK;
    N = st->block_size;
-   ALLOC(freq,C*N, celt_sig_t);         /**< Interleaved signal MDCTs */
+   ALLOC(freq,C*N, celt_sig_t); /**< Interleaved signal MDCTs */
    
    len = N+st->mode->overlap;
 #if 0
@@ -1239,7 +1230,7 @@ static void celt_decode_lost(CELTDecoder * restrict st, celt_word16_t * restrict
    while (offset+len >= MAX_PERIOD)
       offset -= pitch_index;
    compute_mdcts(st->mode, 0, st->out_mem+offset*C, freq);
-   for (i=0;i<N;i++)
+   for (i=0;i<C*N;i++)
       freq[i] = ADD32(EPSILON, MULT16_32_Q15(QCONST16(.9f,15),freq[i]));
 #endif
    
@@ -1285,6 +1276,7 @@ int celt_decode_float(CELTDecoder * restrict st, const unsigned char *data, int
    VARDECL(int, fine_quant);
    VARDECL(int, pulses);
    VARDECL(int, offsets);
+   VARDECL(int, fine_priority);
 
    int shortBlocks;
    int intra_ener;
@@ -1305,8 +1297,8 @@ int celt_decode_float(CELTDecoder * restrict st, const unsigned char *data, int
    N4 = (N-st->overlap)>>1;
 
    ALLOC(freq, C*N, celt_sig_t); /**< Interleaved signal MDCTs */
-   ALLOC(X, C*N, celt_norm_t);         /**< Interleaved normalised MDCTs */
-   ALLOC(P, C*N, celt_norm_t);         /**< Interleaved normalised pitch MDCTs*/
+   ALLOC(X, C*N, celt_norm_t);   /**< Interleaved normalised MDCTs */
+   ALLOC(P, C*N, celt_norm_t);   /**< Interleaved normalised pitch MDCTs*/
    ALLOC(bandE, st->mode->nbEBands*C, celt_ener_t);
    ALLOC(gains, st->mode->nbPBands, celt_pgain_t);
    
@@ -1359,6 +1351,7 @@ int celt_decode_float(CELTDecoder * restrict st, const unsigned char *data, int
    
    ALLOC(pulses, st->mode->nbEBands, int);
    ALLOC(offsets, st->mode->nbEBands, int);
+   ALLOC(fine_priority, st->mode->nbEBands, int);
 
    for (i=0;i<st->mode->nbEBands;i++)
       offsets[i] = 0;
@@ -1366,7 +1359,7 @@ int celt_decode_float(CELTDecoder * restrict st, const unsigned char *data, int
    bits = len*8 - ec_dec_tell(&dec, 0) - 1;
    if (has_pitch)
       bits -= st->mode->nbPBands;
-   compute_allocation(st->mode, offsets, bits, pulses, fine_quant);
+   compute_allocation(st->mode, offsets, bits, pulses, fine_quant, fine_priority);
    /*bits = ec_dec_tell(&dec, 0);
    compute_fine_allocation(st->mode, fine_quant, (20*C+len*8/5-(ec_dec_tell(&dec, 0)-bits))/C);*/
    
@@ -1395,6 +1388,8 @@ int celt_decode_float(CELTDecoder * restrict st, const unsigned char *data, int
    else
       unquant_bands_stereo(st->mode, X, P, has_pitch, gains, bandE, pulses, shortBlocks, has_fold, len*8, &dec);
 #endif
+   unquant_energy_finalise(st->mode, bandE, st->oldBandE, fine_quant, fine_priority, len*8-ec_dec_tell(&dec, 0), &dec);
+   
    /* Synthesis */
    denormalise_bands(st->mode, X, freq, bandE);
 
@@ -1405,7 +1400,7 @@ int celt_decode_float(CELTDecoder * restrict st, const unsigned char *data, int
       int m;
       for (c=0;c<C;c++)
          for (m=mdct_weight_pos+1;m<st->mode->nbShortMdcts;m++)
-            for (i=m*C+c;i<N;i+=C*st->mode->nbShortMdcts)
+            for (i=m+c*N;i<(c+1)*N;i+=st->mode->nbShortMdcts)
 #ifdef FIXED_POINT
                freq[i] = SHL32(freq[i], mdct_weight_shift);
 #else
@@ -1427,20 +1422,6 @@ int celt_decode_float(CELTDecoder * restrict st, const unsigned char *data, int
       }
    }
 
-   {
-      unsigned int val = 0;
-      while (ec_dec_tell(&dec, 0) < len*8)
-      {
-         if (ec_dec_uint(&dec, 2) != val)
-         {
-            celt_warning("decode error");
-            RESTORE_STACK;
-            return CELT_CORRUPTED_DATA;
-         }
-         val = 1-val;
-      }
-   }
-
    RESTORE_STACK;
    return 0;
    /*printf ("\n");*/