Fix whitespace in encode_new

1 files changed, 343 insertions, 343 deletions

diff --git a/libtoolame-dab/encode_new.c b/libtoolame-dab/encode_new.c
index 2e797c9..31c296b 100644
--- a/libtoolame-dab/encode_new.c
+++ b/libtoolame-dab/encode_new.c
@@ -109,9 +109,9 @@ int encode_init(frame_info *frame) {
   ws = frame->header->sampling_frequency;
   sfrq = s_freq[frame->header->version][ws];
   /* decision rules refer to per-channel bitrates (kbits/sec/chan) */
-  if (frame->header->version == MPEG_AUDIO_ID) {	/* MPEG-1 */
+  if (frame->header->version == MPEG_AUDIO_ID) {        /* MPEG-1 */
     if ((sfrq == 48 && br_per_ch >= 56)
-	|| (br_per_ch >= 56 && br_per_ch <= 80))
+        || (br_per_ch >= 56 && br_per_ch <= 80))
       tablenum = 0;
     else if (sfrq != 48 && br_per_ch >= 96)
       tablenum = 1;
@@ -119,7 +119,7 @@ int encode_init(frame_info *frame) {
       tablenum = 2;
     else
       tablenum = 3;
-  } else {			/* MPEG-2 LSF */
+  } else {                      /* MPEG-2 LSF */
     tablenum = 4;
   }
   fprintf(stdout,"encode_init: using tablenum %i with sblimit %i\n",tablenum, table_sblimit[tablenum]);
@@ -134,18 +134,18 @@ int encode_init(frame_info *frame) {
       fprintf(stdout,"Tablenum %i\n",tablenumber);
       fprintf(stdout,"sb nbal ");
       for (j=0;j<16;j++)
-	fprintf(stdout,"%6i ",j);
+        fprintf(stdout,"%6i ",j);
       fprintf(stdout,"\n");
       fprintf(stdout,"-----------------------------------------------------------------------------------------------------------------------\n");
       
       sblimit = table_sblimit[tablenumber];
       for (sb=0;sb<SBLIMIT;sb++) {
-	int thisline = line[tablenumber][sb];
-	fprintf(stdout,"%2i %4i ",sb,nbal[thisline]);
-	if (nbal[thisline] != 0)
-	  for (j=0; j<(1<<nbal[thisline]); j++)
-	    fprintf(stdout,"%6i ", steps[ step_index[thisline][j] ]);
-	fprintf(stdout,"\n");
+        int thisline = line[tablenumber][sb];
+        fprintf(stdout,"%2i %4i ",sb,nbal[thisline]);
+        if (nbal[thisline] != 0)
+          for (j=0; j<(1<<nbal[thisline]); j++)
+            fprintf(stdout,"%6i ", steps[ step_index[thisline][j] ]);
+        fprintf(stdout,"\n");
       }
       fprintf(stdout,"\n");
     }
@@ -177,8 +177,8 @@ int encode_init(frame_info *frame) {
 
 
 void scalefactor_calc_new (double sb_sample[][3][SCALE_BLOCK][SBLIMIT],
-			unsigned int sf_index[][3][SBLIMIT], int nch,
-			int sblimit)
+                        unsigned int sf_index[][3][SBLIMIT], int nch,
+                        int sblimit)
 {
   /* Optimized to use binary search instead of linear scan through the
      scalefactor table; guarantees to find scalefactor in only 5
@@ -193,38 +193,38 @@ void scalefactor_calc_new (double sb_sample[][3][SCALE_BLOCK][SBLIMIT],
     for (gr = 3; gr--;) {
       int sb;
       for (sb = sblimit; sb--;) {
-	int j;
-	unsigned int l;
-	register double temp;
-	unsigned int scale_fac;
-	/* Determination of max. over each set of 12 subband samples:  */
-	/* PDS TODO: maybe this could/should ??!! be integrated into   */
-	/* the subband filtering routines?                             */
-	register double cur_max = fabs (sb_sample[ch][gr][SCALE_BLOCK - 1][sb]);
-	for (j = SCALE_BLOCK - 1; j--;) {
-	  if ((temp = fabs (sb_sample[ch][gr][j][sb])) > cur_max)
-	    cur_max = temp;
-	}
-	/* PDS: binary search in the scalefactor table: */
-	/* This is the real speed up: */
-	for (l = 16, scale_fac = 32; l; l >>= 1) {
-	  if (cur_max <= scalefactor[scale_fac])
-	    scale_fac += l;
-	  else
-	    scale_fac -= l;
-	}
-	if (cur_max > scalefactor[scale_fac])
-	  scale_fac--;
-	sf_index[ch][gr][sb] = scale_fac;
-	/* There is a direct way of working out the index, if the 
-	   maximum value is known but since
-	   it involves a log it isn't really speedy.
-	   Items in the scalefactor[] table are calculated by:
-	     the n'th entry = 2 / (cuberoot(2) ^ n)
-	   And so using a bit of maths you get:
-	  index = (int)(log(2.0/cur_max) / LNCUBEROOTTWO);
-	  fprintf(stdout,"cur_max %.14lf scalefactorindex %i multiple %.14lf\n",cur_max, scale_fac, scalefactor[scale_fac]);
-	*/
+        int j;
+        unsigned int l;
+        register double temp;
+        unsigned int scale_fac;
+        /* Determination of max. over each set of 12 subband samples:  */
+        /* PDS TODO: maybe this could/should ??!! be integrated into   */
+        /* the subband filtering routines?                             */
+        register double cur_max = fabs (sb_sample[ch][gr][SCALE_BLOCK - 1][sb]);
+        for (j = SCALE_BLOCK - 1; j--;) {
+          if ((temp = fabs (sb_sample[ch][gr][j][sb])) > cur_max)
+            cur_max = temp;
+        }
+        /* PDS: binary search in the scalefactor table: */
+        /* This is the real speed up: */
+        for (l = 16, scale_fac = 32; l; l >>= 1) {
+          if (cur_max <= scalefactor[scale_fac])
+            scale_fac += l;
+          else
+            scale_fac -= l;
+        }
+        if (cur_max > scalefactor[scale_fac])
+          scale_fac--;
+        sf_index[ch][gr][sb] = scale_fac;
+        /* There is a direct way of working out the index, if the 
+           maximum value is known but since
+           it involves a log it isn't really speedy.
+           Items in the scalefactor[] table are calculated by:
+             the n'th entry = 2 / (cuberoot(2) ^ n)
+           And so using a bit of maths you get:
+          index = (int)(log(2.0/cur_max) / LNCUBEROOTTWO);
+          fprintf(stdout,"cur_max %.14lf scalefactorindex %i multiple %.14lf\n",cur_max, scale_fac, scalefactor[scale_fac]);
+        */
       }
     }
 }
@@ -235,14 +235,14 @@ double mod (double a)
 
 /* Combine L&R channels into a mono joint stereo channel */
 void combine_LR_new (double sb_sample[2][3][SCALE_BLOCK][SBLIMIT],
-		     double joint_sample[3][SCALE_BLOCK][SBLIMIT], int sblimit) {
+                     double joint_sample[3][SCALE_BLOCK][SBLIMIT], int sblimit) {
   int sb, sample, gr;
 
   for (sb = 0; sb < sblimit; ++sb)
     for (sample = 0; sample < SCALE_BLOCK; ++sample)
       for (gr = 0; gr < 3; ++gr)
-	joint_sample[gr][sample][sb] =
-	  .5 * (sb_sample[0][gr][sample][sb] + sb_sample[1][gr][sample][sb]);
+        joint_sample[gr][sample][sb] =
+          .5 * (sb_sample[0][gr][sample][sb] + sb_sample[1][gr][sample][sb]);
 }
 
 /* PURPOSE:For each subband, puts the smallest scalefactor of the 3
@@ -258,7 +258,7 @@ void combine_LR_new (double sb_sample[2][3][SCALE_BLOCK][SBLIMIT],
    MFC FIX: Feb 2003 - is this only needed for psy model 1?
 */
 void find_sf_max (unsigned int sf_index[2][3][SBLIMIT], frame_info * frame,
-		 double sf_max[2][SBLIMIT])
+                 double sf_max[2][SBLIMIT])
 {
   int sb, gr, ch;
   int lowest_sf_index;
@@ -268,8 +268,8 @@ void find_sf_max (unsigned int sf_index[2][3][SBLIMIT], frame_info * frame,
   for (ch = 0; ch < nch; ch++)
     for (sb = 0; sb < sblimit; sb++) {
       for (gr = 1, lowest_sf_index = sf_index[ch][0][sb]; gr < 3; gr++)
-	if (lowest_sf_index > sf_index[ch][gr][sb])
-	  lowest_sf_index = sf_index[ch][gr][sb];
+        if (lowest_sf_index > sf_index[ch][gr][sb])
+          lowest_sf_index = sf_index[ch][gr][sb];
       sf_max[ch][sb] = multiple[lowest_sf_index];
     }
   for (sb = sblimit; sb < SBLIMIT; sb++)
@@ -286,8 +286,8 @@ void find_sf_max (unsigned int sf_index[2][3][SBLIMIT], frame_info * frame,
     Table C.4 "LayerII Scalefactors Transmission Pattern"
 */
 void sf_transmission_pattern (unsigned int sf_index[2][3][SBLIMIT],
-			   unsigned int sf_selectinfo[2][SBLIMIT],
-			   frame_info * frame)
+                           unsigned int sf_selectinfo[2][SBLIMIT],
+                           frame_info * frame)
 {
   int nch = frame->nch;
   int sblimit = frame->sblimit;
@@ -305,50 +305,50 @@ void sf_transmission_pattern (unsigned int sf_index[2][3][SBLIMIT],
       dscf[0] = (sf_index[k][0][i] - sf_index[k][1][i]);
       dscf[1] = (sf_index[k][1][i] - sf_index[k][2][i]);
       for (j = 0; j < 2; j++) {
-	if (dscf[j] <= -3)
-	  class[j] = 0;
-	else if (dscf[j] > -3 && dscf[j] < 0)
-	  class[j] = 1;
-	else if (dscf[j] == 0)
-	  class[j] = 2;
-	else if (dscf[j] > 0 && dscf[j] < 3)
-	  class[j] = 3;
-	else
-	  class[j] = 4;
+        if (dscf[j] <= -3)
+          class[j] = 0;
+        else if (dscf[j] > -3 && dscf[j] < 0)
+          class[j] = 1;
+        else if (dscf[j] == 0)
+          class[j] = 2;
+        else if (dscf[j] > 0 && dscf[j] < 3)
+          class[j] = 3;
+        else
+          class[j] = 4;
       }
       switch (pattern[class[0]][class[1]]) {
       case 0x123:
-	sf_selectinfo[k][i] = 0;
-	break;
+        sf_selectinfo[k][i] = 0;
+        break;
       case 0x122:
-	sf_selectinfo[k][i] = 3;
-	sf_index[k][2][i] = sf_index[k][1][i];
-	break;
+        sf_selectinfo[k][i] = 3;
+        sf_index[k][2][i] = sf_index[k][1][i];
+        break;
       case 0x133:
-	sf_selectinfo[k][i] = 3;
-	sf_index[k][1][i] = sf_index[k][2][i];
-	break;
+        sf_selectinfo[k][i] = 3;
+        sf_index[k][1][i] = sf_index[k][2][i];
+        break;
       case 0x113:
-	sf_selectinfo[k][i] = 1;
-	sf_index[k][1][i] = sf_index[k][0][i];
-	break;
+        sf_selectinfo[k][i] = 1;
+        sf_index[k][1][i] = sf_index[k][0][i];
+        break;
       case 0x111:
-	sf_selectinfo[k][i] = 2;
-	sf_index[k][1][i] = sf_index[k][2][i] = sf_index[k][0][i];
-	break;
+        sf_selectinfo[k][i] = 2;
+        sf_index[k][1][i] = sf_index[k][2][i] = sf_index[k][0][i];
+        break;
       case 0x222:
-	sf_selectinfo[k][i] = 2;
-	sf_index[k][0][i] = sf_index[k][2][i] = sf_index[k][1][i];
-	break;
+        sf_selectinfo[k][i] = 2;
+        sf_index[k][0][i] = sf_index[k][2][i] = sf_index[k][1][i];
+        break;
       case 0x333:
-	sf_selectinfo[k][i] = 2;
-	sf_index[k][0][i] = sf_index[k][1][i] = sf_index[k][2][i];
-	break;
+        sf_selectinfo[k][i] = 2;
+        sf_index[k][0][i] = sf_index[k][1][i] = sf_index[k][2][i];
+        break;
       case 0x444:
-	sf_selectinfo[k][i] = 2;
-	if (sf_index[k][0][i] > sf_index[k][2][i])
-	  sf_index[k][0][i] = sf_index[k][2][i];
-	sf_index[k][1][i] = sf_index[k][2][i] = sf_index[k][0][i];
+        sf_selectinfo[k][i] = 2;
+        if (sf_index[k][0][i] > sf_index[k][2][i])
+          sf_index[k][0][i] = sf_index[k][2][i];
+        sf_index[k][1][i] = sf_index[k][2][i] = sf_index[k][0][i];
       }
     }
 }
@@ -357,14 +357,14 @@ void write_header (frame_info * frame, Bit_stream_struc * bs)
 {
   frame_header *header = frame->header;
 
-  putbits (bs, 0xfff, 12);	/* syncword 12 bits */
-  put1bit (bs, header->version);	/* ID        1 bit  */
-  putbits (bs, 4 - header->lay, 2);	/* layer     2 bits */
-  put1bit (bs, !header->error_protection);	/* bit set => no err prot */
+  putbits (bs, 0xfff, 12);      /* syncword 12 bits */
+  put1bit (bs, header->version);        /* ID        1 bit  */
+  putbits (bs, 4 - header->lay, 2);     /* layer     2 bits */
+  put1bit (bs, !header->error_protection);      /* bit set => no err prot */
   putbits (bs, header->bitrate_index, 4);
   putbits (bs, header->sampling_frequency, 2);
   put1bit (bs, header->padding);
-  put1bit (bs, header->extension);	/* private_bit */
+  put1bit (bs, header->extension);      /* private_bit */
   putbits (bs, header->mode, 2);
   putbits (bs, header->mode_ext, 2);
   put1bit (bs, header->copyright);
@@ -381,7 +381,7 @@ void write_header (frame_info * frame, Bit_stream_struc * bs)
 
 ************************************************************************/
 void write_bit_alloc (unsigned int bit_alloc[2][SBLIMIT],
-		       frame_info * frame, Bit_stream_struc * bs)
+                       frame_info * frame, Bit_stream_struc * bs)
 {
   int sb, ch;
   int nch = frame->nch;
@@ -391,7 +391,7 @@ void write_bit_alloc (unsigned int bit_alloc[2][SBLIMIT],
   for (sb = 0; sb < sblimit; sb++) {
     if (sb < jsbound) {
       for (ch = 0; ch < ((sb < jsbound) ? nch : 1); ch++)
-	putbits (bs, bit_alloc[ch][sb], nbal[ line[tablenum][sb] ]); // (*alloc)[sb][0].bits);
+        putbits (bs, bit_alloc[ch][sb], nbal[ line[tablenum][sb] ]); // (*alloc)[sb][0].bits);
     }
     else
       putbits (bs, bit_alloc[0][sb], nbal[ line[tablenum][sb] ]); //(*alloc)[sb][0].bits);
@@ -411,9 +411,9 @@ void write_bit_alloc (unsigned int bit_alloc[2][SBLIMIT],
 ************************************************************************/
 
 void write_scalefactors (unsigned int bit_alloc[2][SBLIMIT],
-	      unsigned int sf_selectinfo[2][SBLIMIT],
-	      unsigned int sf_index[2][3][SBLIMIT], frame_info * frame,
-	      Bit_stream_struc * bs)
+              unsigned int sf_selectinfo[2][SBLIMIT],
+              unsigned int sf_index[2][3][SBLIMIT], frame_info * frame,
+              Bit_stream_struc * bs)
 {
   int nch = frame->nch;
   int sblimit = frame->sblimit;
@@ -423,24 +423,24 @@ void write_scalefactors (unsigned int bit_alloc[2][SBLIMIT],
   for (sb = 0; sb < sblimit; sb++)
     for (ch = 0; ch < nch; ch++)
       if (bit_alloc[ch][sb])
-	putbits (bs, sf_selectinfo[ch][sb], 2);
+        putbits (bs, sf_selectinfo[ch][sb], 2);
 
   for (sb = 0; sb < sblimit; sb++)
     for (ch = 0; ch < nch; ch++)
-      if (bit_alloc[ch][sb])	/* above jsbound, bit_alloc[0][i] == ba[1][i] */
-	switch (sf_selectinfo[ch][sb]) {
-	case 0:
-	  for (gr = 0; gr < 3; gr++)
-	    putbits (bs, sf_index[ch][gr][sb], 6);
-	  break;
-	case 1:
-	case 3:
-	  putbits (bs, sf_index[ch][0][sb], 6);
-	  putbits (bs, sf_index[ch][2][sb], 6);
-	  break;
-	case 2:
-	  putbits (bs, sf_index[ch][0][sb], 6);
-	}
+      if (bit_alloc[ch][sb])    /* above jsbound, bit_alloc[0][i] == ba[1][i] */
+        switch (sf_selectinfo[ch][sb]) {
+        case 0:
+          for (gr = 0; gr < 3; gr++)
+            putbits (bs, sf_index[ch][gr][sb], 6);
+          break;
+        case 1:
+        case 3:
+          putbits (bs, sf_index[ch][0][sb], 6);
+          putbits (bs, sf_index[ch][2][sb], 6);
+          break;
+        case 2:
+          putbits (bs, sf_index[ch][0][sb], 6);
+        }
 }
 
 
@@ -478,12 +478,12 @@ static double b[18] = {
 ************************************************************************/
 void
 subband_quantization_new (unsigned int sf_index[2][3][SBLIMIT],
-		      double sb_samples[2][3][SCALE_BLOCK][SBLIMIT],
-		      unsigned int j_scale[3][SBLIMIT],
-		      double j_samps[3][SCALE_BLOCK][SBLIMIT],
-		      unsigned int bit_alloc[2][SBLIMIT],
-		      unsigned int sbband[2][3][SCALE_BLOCK][SBLIMIT],
-		      frame_info * frame)
+                      double sb_samples[2][3][SCALE_BLOCK][SBLIMIT],
+                      unsigned int j_scale[3][SBLIMIT],
+                      double j_samps[3][SCALE_BLOCK][SBLIMIT],
+                      unsigned int bit_alloc[2][SBLIMIT],
+                      unsigned int sbband[2][3][SCALE_BLOCK][SBLIMIT],
+                      frame_info * frame)
 {
   int sb, j, ch, gr, qnt_coeff_index, sig;
   int nch = frame->nch;
@@ -493,57 +493,57 @@ subband_quantization_new (unsigned int sf_index[2][3][SBLIMIT],
 
     for (gr = 0; gr < 3; gr++)
       for (j = 0; j < SCALE_BLOCK; j++)
-	for (sb = 0; sb < sblimit; sb++)
-	  for (ch = 0; ch < ((sb < jsbound) ? nch : 1); ch++)
-
-	  if (bit_alloc[ch][sb]) {
-	    /* scale and quantize FLOATing point sample */
-	    if (nch == 2 && sb >= jsbound)	/* use j-stereo samples */
-	      d = j_samps[gr][j][sb] / scalefactor[j_scale[gr][sb]];
-	    else
-	      d = sb_samples[ch][gr][j][sb] / scalefactor[sf_index[ch][gr][sb]];
-
-	    /* Check that the wrong scale factor hasn't been chosen -
-	       which would result in a scaled sample being > 1.0 
-	       This error shouldn't ever happen *unless* something went wrong in 
-	       scalefactor calc
-
-	     if (mod (d) > 1.0)
-	       fprintf (stderr, "Not scaled properly %d %d %d %d\n", ch, gr, j,
-	      sb); 
-	    */
-	    
-	    {
-	      /* 'index' indicates which "step line" we are using */
-	      int index = line[tablenum][sb];
-	      
-	      /* Find the "step index" within that line */
-	      qnt_coeff_index = step_index[index][bit_alloc[ch][sb]];
-	    }
-	    d = d * a[qnt_coeff_index] + b[qnt_coeff_index];
-
-	    /* extract MSB N-1 bits from the FLOATing point sample */
-	    if (d >= 0)
-	      sig = 1;
-	    else {
-	      sig = 0;
-	      d += 1.0;
-	    }
-
-	    sbband[ch][gr][j][sb] = (unsigned int) (d * (double)steps2n[qnt_coeff_index]);
-	    /* tag the inverted sign bit to sbband at position N */
-	    /* The bit inversion is a must for grouping with 3,5,9 steps
-	       so it is done for all subbands */
-	    if (sig)
-	      sbband[ch][gr][j][sb] |= steps2n[qnt_coeff_index];
-	  }
+        for (sb = 0; sb < sblimit; sb++)
+          for (ch = 0; ch < ((sb < jsbound) ? nch : 1); ch++)
+
+          if (bit_alloc[ch][sb]) {
+            /* scale and quantize FLOATing point sample */
+            if (nch == 2 && sb >= jsbound)      /* use j-stereo samples */
+              d = j_samps[gr][j][sb] / scalefactor[j_scale[gr][sb]];
+            else
+              d = sb_samples[ch][gr][j][sb] / scalefactor[sf_index[ch][gr][sb]];
+
+            /* Check that the wrong scale factor hasn't been chosen -
+               which would result in a scaled sample being > 1.0 
+               This error shouldn't ever happen *unless* something went wrong in 
+               scalefactor calc
+
+             if (mod (d) > 1.0)
+               fprintf (stderr, "Not scaled properly %d %d %d %d\n", ch, gr, j,
+              sb); 
+            */
+            
+            {
+              /* 'index' indicates which "step line" we are using */
+              int index = line[tablenum][sb];
+              
+              /* Find the "step index" within that line */
+              qnt_coeff_index = step_index[index][bit_alloc[ch][sb]];
+            }
+            d = d * a[qnt_coeff_index] + b[qnt_coeff_index];
+
+            /* extract MSB N-1 bits from the FLOATing point sample */
+            if (d >= 0)
+              sig = 1;
+            else {
+              sig = 0;
+              d += 1.0;
+            }
+
+            sbband[ch][gr][j][sb] = (unsigned int) (d * (double)steps2n[qnt_coeff_index]);
+            /* tag the inverted sign bit to sbband at position N */
+            /* The bit inversion is a must for grouping with 3,5,9 steps
+               so it is done for all subbands */
+            if (sig)
+              sbband[ch][gr][j][sb] |= steps2n[qnt_coeff_index];
+          }
 
   /* Set everything above the sblimit to 0 */
   for (ch = 0; ch < nch; ch++)
     for (gr = 0; gr < 3; gr++)
       for (sb = 0; sb < SCALE_BLOCK; sb++)
-	for (j = sblimit; j < SBLIMIT; j++)
-	  sbband[ch][gr][sb][j] = 0;
+        for (j = sblimit; j < SBLIMIT; j++)
+          sbband[ch][gr][sb][j] = 0;
 }
 
 /************************************************************************
@@ -558,8 +558,8 @@ subband_quantization_new (unsigned int sf_index[2][3][SBLIMIT],
 
 ***********************************************************************/
 void write_samples_new (unsigned int sbband[2][3][SCALE_BLOCK][SBLIMIT],
-		      unsigned int bit_alloc[2][SBLIMIT],
-		      frame_info * frame, Bit_stream_struc * bs)
+                      unsigned int bit_alloc[2][SBLIMIT],
+                      frame_info * frame, Bit_stream_struc * bs)
 {
   unsigned int temp;
   unsigned int sb, j, ch, gr, x, y;
@@ -570,31 +570,31 @@ void write_samples_new (unsigned int sbband[2][3][SCALE_BLOCK][SBLIMIT],
   for (gr = 0; gr < 3; gr++)
     for (j = 0; j < SCALE_BLOCK; j += 3)
       for (sb = 0; sb < sblimit; sb++)
-	for (ch = 0; ch < ((sb < jsbound) ? nch : 1); ch++)
-
-	  if (bit_alloc[ch][sb]) {
-	    int thisline = line[tablenum][sb];
-	    int thisstep_index = step_index[thisline][bit_alloc[ch][sb]];
-	    /* Check how many samples per codeword */
-	    if (group[thisstep_index] == 3) {
-	      /* Going to send 1 sample per codeword -> 3 samples */
-	      for (x = 0; x < 3; x++) {
-		putbits (bs, sbband[ch][gr][j + x][sb], bits[thisstep_index]); 
-	      }
-	    } else {
-	      /* ISO11172 Sec C.1.5.2.8 
-		 If steps=3, 5 or 9, then three consecutive samples are coded
-		 as one codeword i.e. only one value (V) is transmitted for this 
-		 triplet. If the 3 subband samples are x,y,z then
-		 V = (steps*steps)*z + steps*y +x
-	      */
-	      y = steps[thisstep_index];
-	      temp =
-		sbband[ch][gr][j][sb] + sbband[ch][gr][j + 1][sb] * y +
-		sbband[ch][gr][j + 2][sb] * y * y;
-	      putbits (bs, temp, bits[thisstep_index]); 
-	    }
-	  }
+        for (ch = 0; ch < ((sb < jsbound) ? nch : 1); ch++)
+
+          if (bit_alloc[ch][sb]) {
+            int thisline = line[tablenum][sb];
+            int thisstep_index = step_index[thisline][bit_alloc[ch][sb]];
+            /* Check how many samples per codeword */
+            if (group[thisstep_index] == 3) {
+              /* Going to send 1 sample per codeword -> 3 samples */
+              for (x = 0; x < 3; x++) {
+                putbits (bs, sbband[ch][gr][j + x][sb], bits[thisstep_index]); 
+              }
+            } else {
+              /* ISO11172 Sec C.1.5.2.8 
+                 If steps=3, 5 or 9, then three consecutive samples are coded
+                 as one codeword i.e. only one value (V) is transmitted for this 
+                 triplet. If the 3 subband samples are x,y,z then
+                 V = (steps*steps)*z + steps*y +x
+              */
+              y = steps[thisstep_index];
+              temp =
+                sbband[ch][gr][j][sb] + sbband[ch][gr][j + 1][sb] * y +
+                sbband[ch][gr][j + 2][sb] * y * y;
+              putbits (bs, temp, bits[thisstep_index]); 
+            }
+          }
 }
 
 
@@ -632,8 +632,8 @@ void write_samples_new (unsigned int sbband[2][3][SCALE_BLOCK][SBLIMIT],
 ************************************************************************/
 
 int bits_for_nonoise_new (double SMR[2][SBLIMIT],
-			  unsigned int scfsi[2][SBLIMIT], frame_info * frame, float min_mnr,
-			  unsigned int bit_alloc[2][SBLIMIT])
+                          unsigned int scfsi[2][SBLIMIT], frame_info * frame, float min_mnr,
+                          unsigned int bit_alloc[2][SBLIMIT])
 {
   int sb, ch, ba;
   int nch = frame->nch;
@@ -641,7 +641,7 @@ int bits_for_nonoise_new (double SMR[2][SBLIMIT],
   int jsbound = frame->jsbound;
   int req_bits = 0, bbal = 0, berr = 0, banc = 32;
   int maxAlloc, sel_bits, sc_bits, smp_bits;
-  static int sfsPerScfsi[] = { 3, 2, 1, 2 };	/* lookup # sfs per scfsi */
+  static int sfsPerScfsi[] = { 3, 2, 1, 2 };    /* lookup # sfs per scfsi */
 
   /* MFC Feb 2003
      This works out the basic number of bits just to get a valid (but empty)
@@ -673,31 +673,31 @@ int bits_for_nonoise_new (double SMR[2][SBLIMIT],
       maxAlloc = (1 << nbal[ line[tablenum][sb] ]) -1; //(*alloc)[sb][0].bits) - 1;
       sel_bits = sc_bits = smp_bits = 0;
       /* Keep choosing the next number of steps (and hence our SNR value)
-	 until we have the required MNR value */
+         until we have the required MNR value */
       for (ba = 0; ba < maxAlloc - 1; ++ba) {
         int thisstep_index = step_index[thisline][ba];
-	if ((SNR[thisstep_index] - SMR[ch][sb]) >= min_mnr)
-	  break;		/* we found enough bits */
+        if ((SNR[thisstep_index] - SMR[ch][sb]) >= min_mnr)
+          break;                /* we found enough bits */
       }
-      if (nch == 2 && sb >= jsbound)	/* check other JS channel */
-	for (; ba < maxAlloc - 1; ++ba) {
-	  int thisstep_index = step_index[thisline][ba];
-	  if ((SNR[thisstep_index] - SMR[1-ch][sb]) >= min_mnr)
-	    break;
-	}
+      if (nch == 2 && sb >= jsbound)    /* check other JS channel */
+        for (; ba < maxAlloc - 1; ++ba) {
+          int thisstep_index = step_index[thisline][ba];
+          if ((SNR[thisstep_index] - SMR[1-ch][sb]) >= min_mnr)
+            break;
+        }
       if (ba > 0) {
-	//smp_bits = SCALE_BLOCK * ((*alloc)[sb][ba].group * (*alloc)[sb][ba].bits);
-	int thisstep_index = step_index[thisline][ba];
-	smp_bits = SCALE_BLOCK * group[thisstep_index] * bits[thisstep_index];
-	/* scale factor bits required for subband */
-	sel_bits = 2;
-	sc_bits = 6 * sfsPerScfsi[scfsi[ch][sb]];
-	if (nch == 2 && sb >= jsbound) {
-	  /* each new js sb has L+R scfsis */
-	  sel_bits += 2;
-	  sc_bits += 6 * sfsPerScfsi[scfsi[1 - ch][sb]];
-	}
-	req_bits += smp_bits + sel_bits + sc_bits;
+        //smp_bits = SCALE_BLOCK * ((*alloc)[sb][ba].group * (*alloc)[sb][ba].bits);
+        int thisstep_index = step_index[thisline][ba];
+        smp_bits = SCALE_BLOCK * group[thisstep_index] * bits[thisstep_index];
+        /* scale factor bits required for subband */
+        sel_bits = 2;
+        sc_bits = 6 * sfsPerScfsi[scfsi[ch][sb]];
+        if (nch == 2 && sb >= jsbound) {
+          /* each new js sb has L+R scfsis */
+          sel_bits += 2;
+          sc_bits += 6 * sfsPerScfsi[scfsi[1 - ch][sb]];
+        }
+        req_bits += smp_bits + sel_bits + sc_bits;
       }
       bit_alloc[ch][sb] = ba;
     }
@@ -731,13 +731,13 @@ int bits_for_nonoise_new (double SMR[2][SBLIMIT],
 *
 ************************************************************************/
 void main_bit_allocation_new (double SMR[2][SBLIMIT],
-			      unsigned int scfsi[2][SBLIMIT],
-			      unsigned int bit_alloc[2][SBLIMIT], int *adb,
-			      frame_info * frame, options * glopts)
+                              unsigned int scfsi[2][SBLIMIT],
+                              unsigned int bit_alloc[2][SBLIMIT], int *adb,
+                              frame_info * frame, options * glopts)
 {
   int noisy_sbs;
   int mode, mode_ext, lay;
-  int rq_db;			/* av_db = *adb; Not Used MFC Nov 99 */
+  int rq_db;                    /* av_db = *adb; Not Used MFC Nov 99 */
 
   /* these are the tables which specify the limits within which the VBR can vary 
      You can't vary outside these ranges, otherwise a new alloc table would have to 
@@ -777,7 +777,7 @@ void main_bit_allocation_new (double SMR[2][SBLIMIT],
       upper = 14;
     } else {
       if (frame->actual_mode == MPG_MD_MONO)
-	nch = 1;
+        nch = 1;
       sfreq = header->sampling_frequency;
       lower = vbrlimits[nch-1][sfreq][0];
       upper = vbrlimits[nch-1][sfreq][1];
@@ -785,16 +785,16 @@ void main_bit_allocation_new (double SMR[2][SBLIMIT],
     if (glopts->verbosity > 2)
       fprintf (stdout, "VBR bitrate index limits [%i -> %i]\n", lower, upper);
 
-    {				
+    {                           
       /* set up a conversion table for bitrateindex->bits for this version/sampl freq 
-	 This will be used to find the best bitrate to cope with the number of bits that
-	 are needed (as determined by VBR_bits_for_nonoise) */
+         This will be used to find the best bitrate to cope with the number of bits that
+         are needed (as determined by VBR_bits_for_nonoise) */
       int brindex;
       frame_header *header = frame->header;
       for (brindex = lower; brindex <= upper; brindex++) {
-	bitrateindextobits[brindex] =
-	  (int) (1152.0 / s_freq[header->version][header->sampling_frequency]) *
-	  ((double) bitrate[header->version][brindex]);
+        bitrateindextobits[brindex] =
+          (int) (1152.0 / s_freq[header->version][header->sampling_frequency]) *
+          ((double) bitrate[header->version][brindex]);
       }
     }
 
@@ -806,23 +806,23 @@ void main_bit_allocation_new (double SMR[2][SBLIMIT],
     frame->jsbound = frame->sblimit;
     if ((rq_db = bits_for_nonoise_new (SMR, scfsi, frame, 0, bit_alloc)) > *adb) {
       frame->header->mode = MPG_MD_JOINT_STEREO;
-      mode_ext = 4;		/* 3 is least severe reduction */
+      mode_ext = 4;             /* 3 is least severe reduction */
       lay = frame->header->lay;
       do {
-	--mode_ext;
-	frame->jsbound = js_bound (mode_ext);
-	rq_db = bits_for_nonoise_new (SMR, scfsi, frame, 0, bit_alloc);
+        --mode_ext;
+        frame->jsbound = js_bound (mode_ext);
+        rq_db = bits_for_nonoise_new (SMR, scfsi, frame, 0, bit_alloc);
       }
       while ((rq_db > *adb) && (mode_ext > 0));
       frame->header->mode_ext = mode_ext;
-    }				/* well we either eliminated noisy sbs or mode_ext == 0 */
+    }                           /* well we either eliminated noisy sbs or mode_ext == 0 */
   }
 
   /* decide on which bit allocation method to use */
   if (glopts->vbr == FALSE) {
     /* Just do the old bit allocation method */
     noisy_sbs = a_bit_allocation_new (SMR, scfsi, bit_alloc, adb, frame);
-  } else {			
+  } else {                      
     /* do the VBR bit allocation method */
     frame->header->bitrate_index = lower;
     *adb = available_bits (frame->header, glopts);
@@ -832,26 +832,26 @@ void main_bit_allocation_new (double SMR[2][SBLIMIT],
 
       /* Work out how many bits are needed for there to be no noise (ie all MNR > VBRLEVEL) */
       int req =
-	bits_for_nonoise_new (SMR, scfsi, frame, glopts->vbrlevel, bit_alloc);
+        bits_for_nonoise_new (SMR, scfsi, frame, glopts->vbrlevel, bit_alloc);
 
       /* Look up this value in the bitrateindextobits table to find what bitrate we should use for 
          this frame */
       for (brindex = lower; brindex <= upper; brindex++) {
-	if (bitrateindextobits[brindex] > req) {
-	  /* this method always *overestimates* the bits that are needed
-	     i.e. it will usually  guess right but
-	     when it's wrong it'll guess a higher bitrate than actually required.
-	     e.g. on "messages from earth" track 6, the guess was 
-	     wrong on 75/36341 frames. each time it guessed higher. 
-	     MFC Feb 2003 */
-	  guessindex = brindex;
-	  found = TRUE;
-	  break;
-	}
+        if (bitrateindextobits[brindex] > req) {
+          /* this method always *overestimates* the bits that are needed
+             i.e. it will usually  guess right but
+             when it's wrong it'll guess a higher bitrate than actually required.
+             e.g. on "messages from earth" track 6, the guess was 
+             wrong on 75/36341 frames. each time it guessed higher. 
+             MFC Feb 2003 */
+          guessindex = brindex;
+          found = TRUE;
+          break;
+        }
       }
       /* Just for sanity */
       if (found == FALSE)
-	guessindex = upper;
+        guessindex = upper;
     }
 
     frame->header->bitrate_index = guessindex;
@@ -865,18 +865,18 @@ void main_bit_allocation_new (double SMR[2][SBLIMIT],
       static int count = 0;
       int i;
       if ((count++ % 1000) == 0) {
-	for (i = 1; i < 15; i++)
-	  fprintf (stdout, "%4i ", vbrstats_new[i]);
-	fprintf (stdout, "\n");
+        for (i = 1; i < 15; i++)
+          fprintf (stdout, "%4i ", vbrstats_new[i]);
+        fprintf (stdout, "\n");
       }
 
       /* Print out *every* frames bitrateindex, bits required, and bits available at this bitrate */
       if (glopts->verbosity > 5)
-	fprintf (stdout,
-		 "> bitrate index %2i has %i bits available to encode the %i bits\n",
-		 frame->header->bitrate_index, *adb,
-		 bits_for_nonoise_new (SMR, scfsi, frame,
-				       glopts->vbrlevel, bit_alloc));
+        fprintf (stdout,
+                 "> bitrate index %2i has %i bits available to encode the %i bits\n",
+                 frame->header->bitrate_index, *adb,
+                 bits_for_nonoise_new (SMR, scfsi, frame,
+                                       glopts->vbrlevel, bit_alloc));
 
     }
 
@@ -886,7 +886,7 @@ void main_bit_allocation_new (double SMR[2][SBLIMIT],
 }
 
 void VBR_maxmnr_new (double mnr[2][SBLIMIT], char used[2][SBLIMIT], int sblimit,
-		 int nch, int *min_sb, int *min_ch, options * glopts)
+                 int nch, int *min_sb, int *min_ch, options * glopts)
 {
   int sb, ch;
   double small;
@@ -901,11 +901,11 @@ void VBR_maxmnr_new (double mnr[2][SBLIMIT], char used[2][SBLIMIT], int sblimit,
   for (ch=0;ch<nch;ch++)
     for (sb=0;sb<sblimit;sb++)
       if (mnr[ch][sb] < glopts->vbrlevel) {
-	*min_sb = sb;
-	*min_ch = ch;
-	//fprintf(stdout,".");
-	//fflush(stdout);
-	return;
+        *min_sb = sb;
+        *min_ch = ch;
+        //fprintf(stdout,".");
+        //fflush(stdout);
+        return;
       }
 #endif
 
@@ -913,9 +913,9 @@ void VBR_maxmnr_new (double mnr[2][SBLIMIT], char used[2][SBLIMIT], int sblimit,
   for (ch = 0; ch < nch; ++ch)
     for (sb = 0; sb < sblimit; sb++)
       if (used[ch][sb] != 2 && small > mnr[ch][sb]) {
-	small = mnr[ch][sb];
-	*min_sb = sb;
-	*min_ch = ch;
+        small = mnr[ch][sb];
+        *min_sb = sb;
+        *min_ch = ch;
       }
   //fprintf(stdout,"Min sb: %i\n",*min_sb);
 }
@@ -932,9 +932,9 @@ This function doesn't chew much CPU, so I haven't made any attempt
 to do this yet.
 *********************/
 int VBR_bit_allocation_new (double SMR[2][SBLIMIT],
-			    unsigned int scfsi[2][SBLIMIT],
-			    unsigned int bit_alloc[2][SBLIMIT], int *adb,
-			    frame_info * frame, options *glopts)
+                            unsigned int scfsi[2][SBLIMIT],
+                            unsigned int bit_alloc[2][SBLIMIT], int *adb,
+                            frame_info * frame, options *glopts)
 {
   int sb, min_ch, min_sb, oth_ch, ch, increment, scale, seli, ba;
   int bspl, bscf, bsel, ad, bbal = 0;
@@ -946,14 +946,14 @@ int VBR_bit_allocation_new (double SMR[2][SBLIMIT],
   //al_table *alloc = frame->alloc;
   static char init = 0;
   static int banc = 32, berr = 0;
-  static int sfsPerScfsi[] = { 3, 2, 1, 2 };	/* lookup # sfs per scfsi */
+  static int sfsPerScfsi[] = { 3, 2, 1, 2 };    /* lookup # sfs per scfsi */
 
   int thisstep_index;
 
   if (!init) {
     init = 1;
     if (frame->header->error_protection)
-      berr = 16;		/* added 92-08-11 shn */
+      berr = 16;                /* added 92-08-11 shn */
   }
 
   /* No need to worry about jsbound here as JS is disabled for VBR mode */
@@ -974,52 +974,52 @@ int VBR_bit_allocation_new (double SMR[2][SBLIMIT],
     /* locate the subband with minimum SMR */
     VBR_maxmnr_new (mnr, used, sblimit, nch, &min_sb, &min_ch, glopts);
 
-    if (min_sb > -1) {		/* there was something to find */
+    if (min_sb > -1) {          /* there was something to find */
       int thisline = line[tablenum][min_sb]; {
-	/* find increase in bit allocation in subband [min] */
-	int nextstep_index = step_index[thisline][bit_alloc[min_ch][min_sb]+1];					  
-	increment = SCALE_BLOCK * group[nextstep_index] * bits[nextstep_index];
+        /* find increase in bit allocation in subband [min] */
+        int nextstep_index = step_index[thisline][bit_alloc[min_ch][min_sb]+1];                                   
+        increment = SCALE_BLOCK * group[nextstep_index] * bits[nextstep_index];
       }
       if (used[min_ch][min_sb]) {
-	/* If we've already increased the limit on this ch/sb, then
-	   subtract the last thing that we added */
-	thisstep_index = step_index[thisline][bit_alloc[min_ch][min_sb]];
-	increment -= SCALE_BLOCK * group[thisstep_index] * bits[thisstep_index];
+        /* If we've already increased the limit on this ch/sb, then
+           subtract the last thing that we added */
+        thisstep_index = step_index[thisline][bit_alloc[min_ch][min_sb]];
+        increment -= SCALE_BLOCK * group[thisstep_index] * bits[thisstep_index];
       }
 
       /* scale factor bits required for subband [min] */
-      oth_ch = 1 - min_ch;	/* above js bound, need both chans */
+      oth_ch = 1 - min_ch;      /* above js bound, need both chans */
       if (used[min_ch][min_sb])
-	scale = seli = 0;
-      else {			/* this channel had no bits or scfs before */
-	seli = 2;
-	scale = 6 * sfsPerScfsi[scfsi[min_ch][min_sb]];
-	if (nch == 2 && min_sb >= jsbound) {
-	  /* each new js sb has L+R scfsis */
-	  seli += 2;
-	  scale += 6 * sfsPerScfsi[scfsi[oth_ch][min_sb]];
-	}
+        scale = seli = 0;
+      else {                    /* this channel had no bits or scfs before */
+        seli = 2;
+        scale = 6 * sfsPerScfsi[scfsi[min_ch][min_sb]];
+        if (nch == 2 && min_sb >= jsbound) {
+          /* each new js sb has L+R scfsis */
+          seli += 2;
+          scale += 6 * sfsPerScfsi[scfsi[oth_ch][min_sb]];
+        }
       }
 
       /* check to see enough bits were available for */
       /* increasing resolution in the minimum band */
       if (ad >= bspl + bscf + bsel + seli + scale + increment) {
-	/* Then there are enough bits to have another go at allocating */
-	ba = ++bit_alloc[min_ch][min_sb];	/* next up alloc */
-	bspl += increment;	/* bits for subband sample */
-	bscf += scale;		/* bits for scale factor */
-	bsel += seli;		/* bits for scfsi code */
-	used[min_ch][min_sb] = 1;	/* subband has bits */
-	thisstep_index = step_index[thisline][ba];
-	mnr[min_ch][min_sb] = SNR[thisstep_index] - SMR[min_ch][min_sb];
-	/* Check if this min_sb subband has been fully allocated max bits */
-	if (ba >= (1 << nbal[ line[tablenum][min_sb] ]) -1 ) //(*alloc)[min_sb][0].bits) - 1)
-	  used[min_ch][min_sb] = 2;	/* don't let this sb get any more bits */
+        /* Then there are enough bits to have another go at allocating */
+        ba = ++bit_alloc[min_ch][min_sb];       /* next up alloc */
+        bspl += increment;      /* bits for subband sample */
+        bscf += scale;          /* bits for scale factor */
+        bsel += seli;           /* bits for scfsi code */
+        used[min_ch][min_sb] = 1;       /* subband has bits */
+        thisstep_index = step_index[thisline][ba];
+        mnr[min_ch][min_sb] = SNR[thisstep_index] - SMR[min_ch][min_sb];
+        /* Check if this min_sb subband has been fully allocated max bits */
+        if (ba >= (1 << nbal[ line[tablenum][min_sb] ]) -1 ) //(*alloc)[min_sb][0].bits) - 1)
+          used[min_ch][min_sb] = 2;     /* don't let this sb get any more bits */
       } else
-	used[min_ch][min_sb] = 2;	/* can't increase this alloc */
+        used[min_ch][min_sb] = 2;       /* can't increase this alloc */
     }
   }
-  while (min_sb > -1);		/* until could find no channel */
+  while (min_sb > -1);          /* until could find no channel */
 
   /* Calculate the number of bits left */
   ad -= bspl + bscf + bsel;
@@ -1059,7 +1059,7 @@ int VBR_bit_allocation_new (double SMR[2][SBLIMIT],
 ************************************************************************/
 
 void maxmnr_new (double mnr[2][SBLIMIT], char used[2][SBLIMIT], int sblimit,
-	     int nch, int *min_sb, int *min_ch)
+             int nch, int *min_sb, int *min_ch)
 {
   int sb, ch;
   double small;
@@ -1070,15 +1070,15 @@ void maxmnr_new (double mnr[2][SBLIMIT], char used[2][SBLIMIT], int sblimit,
   for (ch = 0; ch < nch; ++ch)
     for (sb = 0; sb < sblimit; sb++)
       if (used[ch][sb] != 2 && small > mnr[ch][sb]) {
-	small = mnr[ch][sb];
-	*min_sb = sb;
-	*min_ch = ch;
+        small = mnr[ch][sb];
+        *min_sb = sb;
+        *min_ch = ch;
       }
 }
 int a_bit_allocation_new (double SMR[2][SBLIMIT],
-			    unsigned int scfsi[2][SBLIMIT],
-			    unsigned int bit_alloc[2][SBLIMIT], int *adb,
-			    frame_info * frame)
+                            unsigned int scfsi[2][SBLIMIT],
+                            unsigned int bit_alloc[2][SBLIMIT], int *adb,
+                            frame_info * frame)
 {
   int sb, min_ch, min_sb, oth_ch, ch, increment, scale, seli, ba;
   int bspl, bscf, bsel, ad, bbal = 0;
@@ -1090,14 +1090,14 @@ int a_bit_allocation_new (double SMR[2][SBLIMIT],
   //al_table *alloc = frame->alloc;
   static char init = 0;
   static int banc = 32, berr = 0;
-  static int sfsPerScfsi[] = { 3, 2, 1, 2 };	/* lookup # sfs per scfsi */
+  static int sfsPerScfsi[] = { 3, 2, 1, 2 };    /* lookup # sfs per scfsi */
 
   int thisstep_index;
 
   if (!init) {
     init = 1;
     if (frame->header->error_protection)
-      berr = 16;		/* added 92-08-11 shn */
+      berr = 16;                /* added 92-08-11 shn */
   }
 
   for (sb = 0; sb < jsbound; sb++)
@@ -1119,62 +1119,62 @@ int a_bit_allocation_new (double SMR[2][SBLIMIT],
     /* locate the subband with minimum SMR */
     maxmnr_new (mnr, used, sblimit, nch, &min_sb, &min_ch);
 
-    if (min_sb > -1) {		/* there was something to find */
+    if (min_sb > -1) {          /* there was something to find */
       int thisline = line[tablenum][min_sb]; {
-	/* find increase in bit allocation in subband [min] */
-	int nextstep_index = step_index[thisline][bit_alloc[min_ch][min_sb]+1];					  
-	increment = SCALE_BLOCK * group[nextstep_index] * bits[nextstep_index];
+        /* find increase in bit allocation in subband [min] */
+        int nextstep_index = step_index[thisline][bit_alloc[min_ch][min_sb]+1];                                   
+        increment = SCALE_BLOCK * group[nextstep_index] * bits[nextstep_index];
       }
       if (used[min_ch][min_sb]) {
-	/* If we've already increased the limit on this ch/sb, then
-	   subtract the last thing that we added */
-	thisstep_index = step_index[thisline][bit_alloc[min_ch][min_sb]];
-	increment -= SCALE_BLOCK * group[thisstep_index] * bits[thisstep_index];
+        /* If we've already increased the limit on this ch/sb, then
+           subtract the last thing that we added */
+        thisstep_index = step_index[thisline][bit_alloc[min_ch][min_sb]];
+        increment -= SCALE_BLOCK * group[thisstep_index] * bits[thisstep_index];
       }
 
       /* scale factor bits required for subband [min] */
-      oth_ch = 1 - min_ch;	/* above js bound, need both chans */
+      oth_ch = 1 - min_ch;      /* above js bound, need both chans */
       if (used[min_ch][min_sb])
-	scale = seli = 0;
-      else {			/* this channel had no bits or scfs before */
-	seli = 2;
-	scale = 6 * sfsPerScfsi[scfsi[min_ch][min_sb]];
-	if (nch == 2 && min_sb >= jsbound) {
-	  /* each new js sb has L+R scfsis */
-	  seli += 2;
-	  scale += 6 * sfsPerScfsi[scfsi[oth_ch][min_sb]];
-	}
+        scale = seli = 0;
+      else {                    /* this channel had no bits or scfs before */
+        seli = 2;
+        scale = 6 * sfsPerScfsi[scfsi[min_ch][min_sb]];
+        if (nch == 2 && min_sb >= jsbound) {
+          /* each new js sb has L+R scfsis */
+          seli += 2;
+          scale += 6 * sfsPerScfsi[scfsi[oth_ch][min_sb]];
+        }
       }
 
       /* check to see enough bits were available for */
       /* increasing resolution in the minimum band */
       if (ad >= bspl + bscf + bsel + seli + scale + increment) {
-	/* Then there are enough bits to have another go at allocating */
-	ba = ++bit_alloc[min_ch][min_sb];	/* next up alloc */
-	bspl += increment;	/* bits for subband sample */
-	bscf += scale;		/* bits for scale factor */
-	bsel += seli;		/* bits for scfsi code */
-	used[min_ch][min_sb] = 1;	/* subband has bits */
-	thisstep_index = step_index[thisline][ba];
-	mnr[min_ch][min_sb] = SNR[thisstep_index] - SMR[min_ch][min_sb];
-	/* Check if this min_sb subband has been fully allocated max bits */
-	if (ba >= (1 << nbal[ line[tablenum][min_sb] ]) -1 ) //(*alloc)[min_sb][0].bits) - 1)
-	  used[min_ch][min_sb] = 2;	/* don't let this sb get any more bits */
+        /* Then there are enough bits to have another go at allocating */
+        ba = ++bit_alloc[min_ch][min_sb];       /* next up alloc */
+        bspl += increment;      /* bits for subband sample */
+        bscf += scale;          /* bits for scale factor */
+        bsel += seli;           /* bits for scfsi code */
+        used[min_ch][min_sb] = 1;       /* subband has bits */
+        thisstep_index = step_index[thisline][ba];
+        mnr[min_ch][min_sb] = SNR[thisstep_index] - SMR[min_ch][min_sb];
+        /* Check if this min_sb subband has been fully allocated max bits */
+        if (ba >= (1 << nbal[ line[tablenum][min_sb] ]) -1 ) //(*alloc)[min_sb][0].bits) - 1)
+          used[min_ch][min_sb] = 2;     /* don't let this sb get any more bits */
       } else
-	used[min_ch][min_sb] = 2;	/* can't increase this alloc */
+        used[min_ch][min_sb] = 2;       /* can't increase this alloc */
 
       if (min_sb >= jsbound && nch == 2) {
-	/* above jsbound, alloc applies L+R */
-	ba = bit_alloc[oth_ch][min_sb] = bit_alloc[min_ch][min_sb];
-	used[oth_ch][min_sb] = used[min_ch][min_sb];
-	thisstep_index = step_index[thisline][ba];
-	mnr[oth_ch][min_sb] = SNR[thisstep_index] - SMR[oth_ch][min_sb];
-	//mnr[oth_ch][min_sb] = SNR[(*alloc)[min_sb][ba].quant + 1] - SMR[oth_ch][min_sb];
+        /* above jsbound, alloc applies L+R */
+        ba = bit_alloc[oth_ch][min_sb] = bit_alloc[min_ch][min_sb];
+        used[oth_ch][min_sb] = used[min_ch][min_sb];
+        thisstep_index = step_index[thisline][ba];
+        mnr[oth_ch][min_sb] = SNR[thisstep_index] - SMR[oth_ch][min_sb];
+        //mnr[oth_ch][min_sb] = SNR[(*alloc)[min_sb][ba].quant + 1] - SMR[oth_ch][min_sb];
       }
 
     }
   }
-  while (min_sb > -1);		/* until could find no channel */
+  while (min_sb > -1);          /* until could find no channel */
 
   /* Calculate the number of bits left */
   ad -= bspl + bscf + bsel;