Fixes a seed issue introduced in 5367dac
[opus.git] / celt / bands.c
index 89bfd45..62f0ee7 100644 (file)
@@ -648,6 +648,19 @@ static int compute_qn(int N, int b, int offset, int pulse_cap, int stereo)
    return qn;
 }
 
+struct band_ctx {
+   int encode;
+   const CELTMode *m;
+   int i;
+   int intensity;
+   int spread;
+   int tf_change;
+   ec_ctx *ec;
+   opus_int32 remaining_bits;
+   const celt_ener *bandE;
+   opus_uint32 seed;
+};
+
 struct split_ctx {
    int inv;
    int imid;
@@ -657,10 +670,10 @@ struct split_ctx {
    int qalloc;
 };
 
-static void compute_theta(struct split_ctx *ctx, int encode, const CELTMode *m,
-      int i, celt_norm *X, celt_norm *Y, int N, int *b, int B, int B0,
-      int intensity, ec_ctx *ec, opus_int32 *remaining_bits, int LM,
-      const celt_ener *bandE, int stereo, int *fill)
+static void compute_theta(struct band_ctx *ctx, struct split_ctx *sctx,
+      celt_norm *X, celt_norm *Y, int N, int *b, int B, int B0,
+      int LM,
+      int stereo, int *fill)
 {
    int qn;
    int itheta=0;
@@ -671,6 +684,19 @@ static void compute_theta(struct split_ctx *ctx, int encode, const CELTMode *m,
    int offset;
    opus_int32 tell;
    int inv=0;
+   int encode;
+   const CELTMode *m;
+   int i;
+   int intensity;
+   ec_ctx *ec;
+   const celt_ener *bandE;
+
+   encode = ctx->encode;
+   m = ctx->m;
+   i = ctx->i;
+   intensity = ctx->intensity;
+   ec = ctx->ec;
+   bandE = ctx->bandE;
 
    /* Decide on the resolution to give to the split parameter theta */
    pulse_cap = m->logN[i]+LM*(1<<BITRES);
@@ -777,7 +803,7 @@ static void compute_theta(struct split_ctx *ctx, int encode, const CELTMode *m,
          }
          intensity_stereo(m, X, Y, bandE, i, N);
       }
-      if (*b>2<<BITRES && *remaining_bits > 2<<BITRES)
+      if (*b>2<<BITRES && ctx->remaining_bits > 2<<BITRES)
       {
          if (encode)
             ec_enc_bit_logp(ec, inv, 2);
@@ -810,28 +836,34 @@ static void compute_theta(struct split_ctx *ctx, int encode, const CELTMode *m,
       delta = FRAC_MUL16((N-1)<<7,bitexact_log2tan(iside,imid));
    }
 
-   ctx->inv = inv;
-   ctx->imid = imid;
-   ctx->iside = iside;
-   ctx->delta = delta;
-   ctx->itheta = itheta;
-   ctx->qalloc = qalloc;
+   sctx->inv = inv;
+   sctx->imid = imid;
+   sctx->iside = iside;
+   sctx->delta = delta;
+   sctx->itheta = itheta;
+   sctx->qalloc = qalloc;
 }
-static unsigned quant_band_n1(int encode, celt_norm *X, celt_norm *Y, int b,
-      opus_int32 *remaining_bits, ec_ctx *ec, celt_norm *lowband_out)
+static unsigned quant_band_n1(struct band_ctx *ctx, celt_norm *X, celt_norm *Y, int b,
+      celt_norm *lowband_out)
 {
 #ifdef RESYNTH
    int resynth = 1;
 #else
-   int resynth = !encode;
+   int resynth = !ctx->encode;
 #endif
    int c;
    int stereo;
    celt_norm *x = X;
+   int encode;
+   ec_ctx *ec;
+
+   encode = ctx->encode;
+   ec = ctx->ec;
+
    stereo = Y != NULL;
    c=0; do {
       int sign=0;
-      if (*remaining_bits>=1<<BITRES)
+      if (ctx->remaining_bits>=1<<BITRES)
       {
          if (encode)
          {
@@ -840,7 +872,7 @@ static unsigned quant_band_n1(int encode, celt_norm *X, celt_norm *Y, int b,
          } else {
             sign = ec_dec_bits(ec, 1);
          }
-         *remaining_bits -= 1<<BITRES;
+         ctx->remaining_bits -= 1<<BITRES;
          b-=1<<BITRES;
       }
       if (resynth)
@@ -856,10 +888,10 @@ static unsigned quant_band_n1(int encode, celt_norm *X, celt_norm *Y, int b,
    It can split the band in two and transmit the energy difference with
    the two half-bands. It can be called recursively so bands can end up being
    split in 8 parts. */
-static unsigned quant_partition(int encode, const CELTMode *m, int i, celt_norm *X,
-      int N, int b, int spread, int B, celt_norm *lowband, ec_ctx *ec,
-      opus_int32 *remaining_bits, int LM,
-      opus_uint32 *seed, opus_val16 gain, int fill)
+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;
@@ -872,9 +904,20 @@ static unsigned quant_partition(int encode, const CELTMode *m, int i, celt_norm
 #ifdef RESYNTH
    int resynth = 1;
 #else
-   int resynth = !encode;
+   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;
 
@@ -885,7 +928,10 @@ static unsigned quant_partition(int encode, const CELTMode *m, int i, celt_norm
       int mbits, sbits, delta;
       int itheta;
       int qalloc;
-      struct split_ctx ctx;
+      struct split_ctx sctx;
+      celt_norm *next_lowband2=NULL;
+      opus_int32 rebalance;
+
       N >>= 1;
       Y = X+N;
       LM -= 1;
@@ -893,13 +939,13 @@ static unsigned quant_partition(int encode, const CELTMode *m, int i, celt_norm
          fill = (fill&1)|(fill<<1);
       B = (B+1)>>1;
 
-      compute_theta(&ctx, encode, m, i, X, Y, N, &b, B, B0, 0, ec,
-            remaining_bits, LM, NULL, 0, &fill);
-      imid = ctx.imid;
-      iside = ctx.iside;
-      delta = ctx.delta;
-      itheta = ctx.itheta;
-      qalloc = ctx.qalloc;
+      compute_theta(ctx, &sctx, X, Y, N, &b, B, B0,
+            LM, 0, &fill);
+      imid = sctx.imid;
+      iside = sctx.iside;
+      delta = sctx.delta;
+      itheta = sctx.itheta;
+      qalloc = sctx.qalloc;
 #ifdef FIXED_POINT
       mid = imid;
       side = iside;
@@ -908,9 +954,6 @@ static unsigned quant_partition(int encode, const CELTMode *m, int i, celt_norm
       side = (1.f/32768)*iside;
 #endif
 
-      celt_norm *next_lowband2=NULL;
-      opus_int32 rebalance;
-
       /* Give more bits to low-energy MDCTs than they would otherwise deserve */
       if (B0>1 && (itheta&0x3fff))
       {
@@ -923,56 +966,47 @@ static unsigned quant_partition(int encode, const CELTMode *m, int i, celt_norm
       }
       mbits = IMAX(0, IMIN(b, (b-delta)/2));
       sbits = b-mbits;
-      *remaining_bits -= qalloc;
+      ctx->remaining_bits -= qalloc;
 
       if (lowband)
          next_lowband2 = lowband+N; /* >32-bit split case */
 
-      rebalance = *remaining_bits;
+      rebalance = ctx->remaining_bits;
       if (mbits >= sbits)
       {
-         /* In stereo mode, we do not apply a scaling to the mid because we need the normalized
-               mid for folding later */
-         cm = quant_partition(encode, m, i, X, N, mbits, spread, B,
-               lowband, ec, remaining_bits, LM,
-               seed, MULT16_16_P15(gain,mid), fill);
-         rebalance = mbits - (rebalance-*remaining_bits);
+         cm = quant_partition(ctx, X, N, mbits, B,
+               lowband, LM,
+               MULT16_16_P15(gain,mid), fill);
+         rebalance = mbits - (rebalance-ctx->remaining_bits);
          if (rebalance > 3<<BITRES && itheta!=0)
             sbits += rebalance - (3<<BITRES);
-
-         /* For a stereo split, the high bits of fill are always zero, so no
-               folding will be done to the side. */
-         cm |= quant_partition(encode, m, i, Y, N, sbits, spread, B,
-               next_lowband2, ec, remaining_bits, LM,
-               seed, MULT16_16_P15(gain,side), fill>>B)<<(B0>>1);
+         cm |= quant_partition(ctx, Y, N, sbits, B,
+               next_lowband2, LM,
+               MULT16_16_P15(gain,side), fill>>B)<<(B0>>1);
       } else {
-         /* For a stereo split, the high bits of fill are always zero, so no
-               folding will be done to the side. */
-         cm = quant_partition(encode, m, i, Y, N, sbits, spread, B,
-               next_lowband2, ec, remaining_bits, LM,
-               seed, MULT16_16_P15(gain,side), fill>>B)<<(B0>>1);
-         rebalance = sbits - (rebalance-*remaining_bits);
+         cm = quant_partition(ctx, Y, N, sbits, B,
+               next_lowband2, LM,
+               MULT16_16_P15(gain,side), fill>>B)<<(B0>>1);
+         rebalance = sbits - (rebalance-ctx->remaining_bits);
          if (rebalance > 3<<BITRES && itheta!=16384)
             mbits += rebalance - (3<<BITRES);
-         /* In stereo mode, we do not apply a scaling to the mid because we need the normalized
-               mid for folding later */
-         cm |= quant_partition(encode, m, i, X, N, mbits, spread, B,
-               lowband, ec, remaining_bits, LM,
-               seed, MULT16_16_P15(gain,mid), fill);
+         cm |= quant_partition(ctx, X, N, mbits, B,
+               lowband, LM,
+               MULT16_16_P15(gain,mid), fill);
       }
    } else {
       /* This is the basic no-split case */
       q = bits2pulses(m, i, LM, b);
       curr_bits = pulses2bits(m, i, LM, q);
-      *remaining_bits -= curr_bits;
+      ctx->remaining_bits -= curr_bits;
 
       /* Ensures we can never bust the budget */
-      while (*remaining_bits < 0 && q > 0)
+      while (ctx->remaining_bits < 0 && q > 0)
       {
-         *remaining_bits += curr_bits;
+         ctx->remaining_bits += curr_bits;
          q--;
          curr_bits = pulses2bits(m, i, LM, q);
-         *remaining_bits -= curr_bits;
+         ctx->remaining_bits -= curr_bits;
       }
 
       if (q!=0)
@@ -996,7 +1030,7 @@ static unsigned quant_partition(int encode, const CELTMode *m, int i, celt_norm
          if (resynth)
          {
             unsigned cm_mask;
-            /*B can be as large as 16, so this shift might overflow an int on a
+            /* B can be as large as 16, so this shift might overflow an int on a
                16-bit platform; use a long to get defined behavior.*/
             cm_mask = (unsigned)(1UL<<B)-1;
             fill &= cm_mask;
@@ -1010,8 +1044,8 @@ static unsigned quant_partition(int encode, const CELTMode *m, int i, celt_norm
                   /* Noise */
                   for (j=0;j<N;j++)
                   {
-                     *seed = celt_lcg_rand(*seed);
-                     X[j] = (celt_norm)((opus_int32)*seed>>20);
+                     ctx->seed = celt_lcg_rand(ctx->seed);
+                     X[j] = (celt_norm)((opus_int32)ctx->seed>>20);
                   }
                   cm = cm_mask;
                } else {
@@ -1019,10 +1053,10 @@ static unsigned quant_partition(int encode, const CELTMode *m, int i, celt_norm
                   for (j=0;j<N;j++)
                   {
                      opus_val16 tmp;
-                     *seed = celt_lcg_rand(*seed);
+                     ctx->seed = celt_lcg_rand(ctx->seed);
                      /* About 48 dB below the "normal" folding level */
                      tmp = QCONST16(1.0f/256, 10);
-                     tmp = (*seed)&0x8000 ? tmp : -tmp;
+                     tmp = (ctx->seed)&0x8000 ? tmp : -tmp;
                      X[j] = lowband[j]+tmp;
                   }
                   cm = fill;
@@ -1038,10 +1072,10 @@ static unsigned quant_partition(int encode, const CELTMode *m, int i, celt_norm
 
 
 /* This function is responsible for encoding and decoding a band for the mono case. */
-static unsigned quant_band(int encode, const CELTMode *m, int i, celt_norm *X,
-      int N, int b, int spread, int B, int tf_change, celt_norm *lowband, ec_ctx *ec,
-      opus_int32 *remaining_bits, int LM, celt_norm *lowband_out,
-      opus_uint32 *seed, opus_val16 gain, celt_norm *lowband_scratch, int fill)
+static unsigned quant_band(struct band_ctx *ctx, celt_norm *X,
+      int N, int b, int B, celt_norm *lowband,
+      int LM, celt_norm *lowband_out,
+      opus_val16 gain, celt_norm *lowband_scratch, int fill)
 {
    int N0=N;
    int N_B=N;
@@ -1054,9 +1088,14 @@ static unsigned quant_band(int encode, const CELTMode *m, int i, celt_norm *X,
 #ifdef RESYNTH
    int resynth = 1;
 #else
-   int resynth = !encode;
+   int resynth = !ctx->encode;
 #endif
    int k;
+   int encode;
+   int tf_change;
+
+   encode = ctx->encode;
+   tf_change = ctx->tf_change;
 
    longBlocks = B0==1;
 
@@ -1066,7 +1105,7 @@ static unsigned quant_band(int encode, const CELTMode *m, int i, celt_norm *X,
    /* Special case for one sample */
    if (N==1)
    {
-      return quant_band_n1(encode, X, NULL, b, remaining_bits, ec, lowband_out);
+      return quant_band_n1(ctx, X, NULL, b, lowband_out);
    }
 
    if (tf_change>0)
@@ -1120,8 +1159,8 @@ static unsigned quant_band(int encode, const CELTMode *m, int i, celt_norm *X,
          deinterleave_hadamard(lowband, N_B>>recombine, B0<<recombine, longBlocks);
    }
 
-   cm = quant_partition(encode, m, i, X, N, b, spread, B, lowband, ec,
-         remaining_bits, LM, seed, gain, fill);
+   cm = quant_partition(ctx, X, N, b, B, lowband,
+         LM, gain, fill);
 
    /* This code is used by the decoder and by the resynthesis-enabled encoder */
    if (resynth)
@@ -1168,10 +1207,10 @@ static unsigned quant_band(int encode, const CELTMode *m, int i, celt_norm *X,
 
 
 /* This function is responsible for encoding and decoding a band for the stereo case. */
-static unsigned quant_band_stereo(int encode, const CELTMode *m, int i, celt_norm *X, celt_norm *Y,
-      int N, int b, int spread, int B, int intensity, int tf_change, celt_norm *lowband, ec_ctx *ec,
-      opus_int32 *remaining_bits, int LM, celt_norm *lowband_out, const celt_ener *bandE,
-      opus_uint32 *seed, celt_norm *lowband_scratch, int fill)
+static unsigned quant_band_stereo(struct band_ctx *ctx, celt_norm *X, celt_norm *Y,
+      int N, int b, int B, celt_norm *lowband,
+      int LM, celt_norm *lowband_out,
+      celt_norm *lowband_scratch, int fill)
 {
    int imid=0, iside=0;
    int inv = 0;
@@ -1180,31 +1219,35 @@ static unsigned quant_band_stereo(int encode, const CELTMode *m, int i, celt_nor
 #ifdef RESYNTH
    int resynth = 1;
 #else
-   int resynth = !encode;
+   int resynth = !ctx->encode;
 #endif
    int mbits, sbits, delta;
    int itheta;
    int qalloc;
-   struct split_ctx ctx;
+   struct split_ctx sctx;
    int orig_fill;
+   int encode;
+   ec_ctx *ec;
 
+   encode = ctx->encode;
+   ec = ctx->ec;
 
    /* Special case for one sample */
    if (N==1)
    {
-      return quant_band_n1(encode, X, Y, b, remaining_bits, ec, lowband_out);
+      return quant_band_n1(ctx, X, Y, b, lowband_out);
    }
 
    orig_fill = fill;
 
-   compute_theta(&ctx, encode, m, i, X, Y, N, &b, B, B, intensity, ec,
-         remaining_bits, LM, bandE, 1, &fill);
-   inv = ctx.inv;
-   imid = ctx.imid;
-   iside = ctx.iside;
-   delta = ctx.delta;
-   itheta = ctx.itheta;
-   qalloc = ctx.qalloc;
+   compute_theta(ctx, &sctx, X, Y, N, &b, B, B,
+         LM, 1, &fill);
+   inv = sctx.inv;
+   imid = sctx.imid;
+   iside = sctx.iside;
+   delta = sctx.delta;
+   itheta = sctx.itheta;
+   qalloc = sctx.qalloc;
 #ifdef FIXED_POINT
    mid = imid;
    side = iside;
@@ -1214,8 +1257,8 @@ static unsigned quant_band_stereo(int encode, const CELTMode *m, int i, celt_nor
 #endif
 
    /* This is a special case for N=2 that only works for stereo and takes
-         advantage of the fact that mid and side are orthogonal to encode
-         the side with just one bit. */
+      advantage of the fact that mid and side are orthogonal to encode
+      the side with just one bit. */
    if (N==2)
    {
       int c;
@@ -1223,12 +1266,12 @@ static unsigned quant_band_stereo(int encode, const CELTMode *m, int i, celt_nor
       celt_norm *x2, *y2;
       mbits = b;
       sbits = 0;
-      /* Only need one bit for the side */
+      /* Only need one bit for the side. */
       if (itheta != 0 && itheta != 16384)
          sbits = 1<<BITRES;
       mbits -= sbits;
       c = itheta > 8192;
-      *remaining_bits -= qalloc+sbits;
+      ctx->remaining_bits -= qalloc+sbits;
 
       x2 = c ? Y : X;
       y2 = c ? X : Y;
@@ -1236,7 +1279,7 @@ static unsigned quant_band_stereo(int encode, const CELTMode *m, int i, celt_nor
       {
          if (encode)
          {
-            /* Here we only need to encode a sign for the side */
+            /* Here we only need to encode a sign for the side. */
             sign = x2[0]*y2[1] - x2[1]*y2[0] < 0;
             ec_enc_bits(ec, sign, 1);
          } else {
@@ -1245,10 +1288,11 @@ static unsigned quant_band_stereo(int encode, const CELTMode *m, int i, celt_nor
       }
       sign = 1-2*sign;
       /* We use orig_fill here because we want to fold the side, but if
-             itheta==16384, we'll have cleared the low bits of fill. */
-      cm = quant_band(encode, m, i, x2, N, mbits, spread, B, tf_change, lowband, ec, remaining_bits, LM, lowband_out, seed, Q15ONE, lowband_scratch, orig_fill);
+         itheta==16384, we'll have cleared the low bits of fill. */
+      cm = quant_band(ctx, x2, N, mbits, B, lowband,
+            LM, lowband_out, Q15ONE, lowband_scratch, orig_fill);
       /* We don't split N=2 bands, so cm is either 1 or 0 (for a fold-collapse),
-             and there's no need to worry about mixing with the other channel. */
+         and there's no need to worry about mixing with the other channel. */
       y2[0] = -sign*x2[1];
       y2[1] = sign*x2[0];
       if (resynth)
@@ -1267,49 +1311,43 @@ static unsigned quant_band_stereo(int encode, const CELTMode *m, int i, celt_nor
       }
    } else {
       /* "Normal" split code */
-      celt_norm *next_lowband2=NULL;
-      celt_norm *next_lowband_out1=NULL;
       opus_int32 rebalance;
 
       mbits = IMAX(0, IMIN(b, (b-delta)/2));
       sbits = b-mbits;
-      *remaining_bits -= qalloc;
-
-      /* Only stereo needs to pass on lowband_out. Otherwise, it's
-            handled at the end */
-      next_lowband_out1 = lowband_out;
+      ctx->remaining_bits -= qalloc;
 
-      rebalance = *remaining_bits;
+      rebalance = ctx->remaining_bits;
       if (mbits >= sbits)
       {
          /* In stereo mode, we do not apply a scaling to the mid because we need the normalized
-               mid for folding later */
-         cm = quant_band(encode, m, i, X, N, mbits, spread, B, tf_change,
-               lowband, ec, remaining_bits, LM, next_lowband_out1,
-               seed, Q15ONE, lowband_scratch, fill);
-         rebalance = mbits - (rebalance-*remaining_bits);
+            mid for folding later. */
+         cm = quant_band(ctx, X, N, mbits, B,
+               lowband, LM, lowband_out,
+               Q15ONE, lowband_scratch, fill);
+         rebalance = mbits - (rebalance-ctx->remaining_bits);
          if (rebalance > 3<<BITRES && itheta!=0)
             sbits += rebalance - (3<<BITRES);
 
          /* For a stereo split, the high bits of fill are always zero, so no
-               folding will be done to the side. */
-         cm |= quant_band(encode, m, i, Y, N, sbits, spread, B, tf_change,
-               next_lowband2, ec, remaining_bits, LM, NULL,
-               seed, side, NULL, fill>>B);
+            folding will be done to the side. */
+         cm |= quant_band(ctx, Y, N, sbits, B,
+               NULL, LM, NULL,
+               side, NULL, fill>>B);
       } else {
          /* For a stereo split, the high bits of fill are always zero, so no
-               folding will be done to the side. */
-         cm = quant_band(encode, m, i, Y, N, sbits, spread, B, tf_change,
-               next_lowband2, ec, remaining_bits, LM, NULL,
-               seed, side, NULL, fill>>B);
-         rebalance = sbits - (rebalance-*remaining_bits);
+            folding will be done to the side. */
+         cm = quant_band(ctx, Y, N, sbits, B,
+               NULL, LM, NULL,
+               side, NULL, fill>>B);
+         rebalance = sbits - (rebalance-ctx->remaining_bits);
          if (rebalance > 3<<BITRES && itheta!=16384)
             mbits += rebalance - (3<<BITRES);
          /* In stereo mode, we do not apply a scaling to the mid because we need the normalized
-               mid for folding later */
-         cm |= quant_band(encode, m, i, X, N, mbits, spread, B, tf_change,
-               lowband, ec, remaining_bits, LM, next_lowband_out1,
-               seed, Q15ONE, lowband_scratch, fill);
+            mid for folding later. */
+         cm |= quant_band(ctx, X, N, mbits, B,
+               lowband, LM, lowband_out,
+               Q15ONE, lowband_scratch, fill);
       }
    }
 
@@ -1352,21 +1390,29 @@ void quant_all_bands(int encode, const CELTMode *m, int start, int end,
 #else
    int resynth = !encode;
 #endif
+   struct band_ctx ctx;
    SAVE_STACK;
 
    M = 1<<LM;
    B = shortBlocks ? M : 1;
    norm_offset = M*eBands[start];
    /* No need to allocate norm for the last band because we don't need an
-      output in that band */
+      output in that band. */
    ALLOC(_norm, C*(M*eBands[m->nbEBands-1]-norm_offset), celt_norm);
    norm = _norm;
    norm2 = norm + M*eBands[m->nbEBands-1]-norm_offset;
    /* We can use the last band as scratch space because we don't need that
-      scratch space for the last band */
+      scratch space for the last band. */
    lowband_scratch = X_+M*eBands[m->nbEBands-1];
 
    lowband_offset = 0;
+   ctx.bandE = bandE;
+   ctx.ec = ec;
+   ctx.encode = encode;
+   ctx.intensity = intensity;
+   ctx.m = m;
+   ctx.seed = *seed;
+   ctx.spread = spread;
    for (i=start;i<end;i++)
    {
       opus_int32 tell;
@@ -1380,6 +1426,7 @@ void quant_all_bands(int encode, const CELTMode *m, int start, int end,
       unsigned y_cm;
       int last;
 
+      ctx.i = i;
       last = (i==end-1);
 
       X = X_+M*eBands[i];
@@ -1394,6 +1441,7 @@ void quant_all_bands(int encode, const CELTMode *m, int start, int end,
       if (i != start)
          balance -= tell;
       remaining_bits = total_bits-tell-1;
+      ctx.remaining_bits = remaining_bits;
       if (i <= codedBands-1)
       {
          curr_balance = balance / IMIN(3, codedBands-i);
@@ -1406,6 +1454,7 @@ void quant_all_bands(int encode, const CELTMode *m, int start, int end,
             lowband_offset = i;
 
       tf_change = tf_res[i];
+      ctx.tf_change = tf_change;
       if (i>=m->effEBands)
       {
          X=norm;
@@ -1417,7 +1466,7 @@ void quant_all_bands(int encode, const CELTMode *m, int start, int end,
          lowband_scratch = NULL;
 
       /* Get a conservative estimate of the collapse_mask's for the bands we're
-          going to be folding from. */
+         going to be folding from. */
       if (lowband_offset != 0 && (spread!=SPREAD_AGGRESSIVE || B>1 || tf_change<0))
       {
          int fold_start;
@@ -1436,7 +1485,7 @@ void quant_all_bands(int encode, const CELTMode *m, int start, int end,
          } while (++fold_i<fold_end);
       }
       /* Otherwise, we'll be using the LCG to fold, so all blocks will (almost
-          always) be non-zero.*/
+         always) be non-zero. */
       else
          x_cm = y_cm = (1<<B)-1;
 
@@ -1444,7 +1493,7 @@ void quant_all_bands(int encode, const CELTMode *m, int start, int end,
       {
          int j;
 
-         /* Switch off dual stereo to do intensity */
+         /* Switch off dual stereo to do intensity. */
          dual_stereo = 0;
          if (resynth)
             for (j=0;j<M*eBands[i]-norm_offset;j++)
@@ -1452,22 +1501,22 @@ void quant_all_bands(int encode, const CELTMode *m, int start, int end,
       }
       if (dual_stereo)
       {
-         x_cm = quant_band(encode, m, i, X, N, b/2, spread, B, tf_change,
-               effective_lowband != -1 ? norm+effective_lowband : NULL, ec, &remaining_bits, LM,
-               last?NULL:norm+M*eBands[i]-norm_offset, seed, Q15ONE, lowband_scratch, x_cm);
-         y_cm = quant_band(encode, m, i, Y, N, b/2, spread, B, tf_change,
-               effective_lowband != -1 ? norm2+effective_lowband : NULL, ec, &remaining_bits, LM,
-               last?NULL:norm2+M*eBands[i]-norm_offset, seed, Q15ONE, lowband_scratch, y_cm);
+         x_cm = quant_band(&ctx, X, N, b/2, B,
+               effective_lowband != -1 ? norm+effective_lowband : NULL, LM,
+               last?NULL:norm+M*eBands[i]-norm_offset, Q15ONE, lowband_scratch, x_cm);
+         y_cm = quant_band(&ctx, Y, N, b/2, B,
+               effective_lowband != -1 ? norm2+effective_lowband : NULL, LM,
+               last?NULL:norm2+M*eBands[i]-norm_offset, Q15ONE, lowband_scratch, y_cm);
       } else {
          if (Y!=NULL)
          {
-            x_cm = quant_band_stereo(encode, m, i, X, Y, N, b, spread, B, intensity, tf_change,
-                  effective_lowband != -1 ? norm+effective_lowband : NULL, ec, &remaining_bits, LM,
-                        last?NULL:norm+M*eBands[i]-norm_offset, bandE, seed, lowband_scratch, x_cm|y_cm);
+            x_cm = quant_band_stereo(&ctx, X, Y, N, b, B,
+                  effective_lowband != -1 ? norm+effective_lowband : NULL, LM,
+                        last?NULL:norm+M*eBands[i]-norm_offset, lowband_scratch, x_cm|y_cm);
          } else {
-            x_cm = quant_band(encode, m, i, X, N, b, spread, B, tf_change,
-                  effective_lowband != -1 ? norm+effective_lowband : NULL, ec, &remaining_bits, LM,
-                        last?NULL:norm+M*eBands[i]-norm_offset, seed, Q15ONE, lowband_scratch, x_cm|y_cm);
+            x_cm = quant_band(&ctx, X, N, b, B,
+                  effective_lowband != -1 ? norm+effective_lowband : NULL, LM,
+                        last?NULL:norm+M*eBands[i]-norm_offset, Q15ONE, lowband_scratch, x_cm|y_cm);
          }
          y_cm = x_cm;
       }
@@ -1475,9 +1524,11 @@ void quant_all_bands(int encode, const CELTMode *m, int start, int end,
       collapse_masks[i*C+C-1] = (unsigned char)y_cm;
       balance += pulses[i] + tell;
 
-      /* Update the folding position only as long as we have 1 bit/sample depth */
+      /* Update the folding position only as long as we have 1 bit/sample depth. */
       update_lowband = b>(N<<BITRES);
    }
+   *seed = ctx.seed;
+
    RESTORE_STACK;
 }