Updating Opus to release 1.1

celt/bands.c

 /* Copyright (c) 2007-2008 CSIRO
    Copyright (c) 2007-2009 Xiph.Org Foundation
    Copyright (c) 2008-2009 Gregory Maxwell
    Written by Jean-Marc Valin and Gregory Maxwell */
 /*
    Redistribution and use in source and binary forms, with or without
    modification, are permitted provided that the following conditions
    are met:
 
    - Redistributions of source code must retain the above copyright
@@ skipping 196 matching lines @@
       {
          int j, band_end;
          opus_val16 g;
          opus_val16 lg;
 #ifdef FIXED_POINT
          int shift;
 #endif
          j=M*eBands[i];
          band_end = M*eBands[i+1];
          lg = ADD16(bandLogE[i+c*m->nbEBands], SHL16((opus_val16)eMeans[i],6));
-#ifdef FIXED_POINT
+#ifndef FIXED_POINT
+         g = celt_exp2(lg);
+#else
          /* Handle the integer part of the log energy */
          shift = 16-(lg>>DB_SHIFT);
          if (shift>31)
          {
             shift=0;
             g=0;
          } else {
             /* Handle the fractional part. */
             g = celt_exp2_frac(lg&((1<<DB_SHIFT)-1));
          }
-#else
-         g = celt_exp2(lg);
+         /* Handle extreme gains with negative shift. */
+         if (shift<0)
+         {
+            /* For shift < -2 we'd be likely to overflow, so we're capping
+               the gain here. This shouldn't happen unless the bitstream is
+               already corrupted. */
+            if (shift < -2)
+            {
+               g = 32767;
+               shift = -2;
+            }
+            do {
+               *f++ = SHL32(MULT16_16(*x++, g), -shift);
+            } while (++j<band_end);
+         } else
 #endif
+         /* Be careful of the fixed-point "else" just above when changing this code */
          do {
             *f++ = SHR32(MULT16_16(*x++, g), shift);
          } while (++j<band_end);
       }
       celt_assert(start <= end);
       for (i=M*eBands[end];i<N;i++)
          *f++ = 0;
    } while (++c<C);
 }
 
@@ skipping 244 matching lines @@
       else if (*tapset_decision==0)
          hf_sum -= 4;
       if (hf_sum > 22)
          *tapset_decision=2;
       else if (hf_sum > 18)
          *tapset_decision=1;
       else
          *tapset_decision=0;
    }
    /*printf("%d %d %d\n", hf_sum, *hf_average, *tapset_decision);*/
-   celt_assert(nbBands>0); /*M*(eBands[end]-eBands[end-1]) <= 8 assures this*/
+   celt_assert(nbBands>0); /* end has to be non-zero */
    sum /= nbBands;
    /* Recursive averaging */
    sum = (sum+*average)>>1;
    *average = sum;
    /* Hysteresis */
    sum = (3*sum + (((3-last_decision)<<7) + 64) + 2)>>2;
    if (sum < 80)
    {
       decision = SPREAD_AGGRESSIVE;
    } else if (sum < 256)
@@ skipping 356 matching lines @@
    split in 8 parts. */
 static unsigned quant_partition(struct band_ctx *ctx, celt_norm *X,
       int N, int b, int B, celt_norm *lowband,
       int LM,
       opus_val16 gain, int fill)
 {
    const unsigned char *cache;
    int q;
    int curr_bits;
    int imid=0, iside=0;
-   int N_B=N;
    int B0=B;
    opus_val16 mid=0, side=0;
    unsigned cm=0;
 #ifdef RESYNTH
    int resynth = 1;
 #else
    int resynth = !ctx->encode;
 #endif
    celt_norm *Y=NULL;
    int encode;
    const CELTMode *m;
    int i;
    int spread;
    ec_ctx *ec;
 
    encode = ctx->encode;
    m = ctx->m;
    i = ctx->i;
    spread = ctx->spread;
    ec = ctx->ec;
 
-   N_B /= B;
-
    /* If we need 1.5 more bit than we can produce, split the band in two. */
    cache = m->cache.bits + m->cache.index[(LM+1)*m->nbEBands+i];
    if (LM != -1 && b > cache[cache[0]]+12 && N>2)
    {
       int mbits, sbits, delta;
       int itheta;
       int qalloc;
       struct split_ctx sctx;
       celt_norm *next_lowband2=NULL;
       opus_int32 rebalance;
@@ skipping 159 matching lines @@
    int k;
    int encode;
    int tf_change;
 
    encode = ctx->encode;
    tf_change = ctx->tf_change;
 
    longBlocks = B0==1;
 
    N_B /= B;
-   N_B0 = N_B;
 
    /* Special case for one sample */
    if (N==1)
    {
       return quant_band_n1(ctx, X, NULL, b, lowband_out);
    }
 
    if (tf_change>0)
       recombine = tf_change;
    /* Band recombining to increase frequency resolution */
@@ skipping 411 matching lines @@
       balance += pulses[i] + tell;
 
       /* Update the folding position only as long as we have 1 bit/sample depth. */
       update_lowband = b>(N<<BITRES);
    }
    *seed = ctx.seed;
 
    RESTORE_STACK;
 }