1 files changed, 347 insertions, 347 deletions

diff --git a/apps/codecs/libmad/layer3.c b/apps/codecs/libmad/layer3.c
index 0a53086d78..2dcdeb96d4 100644
--- a/apps/codecs/libmad/layer3.c
+++ b/apps/codecs/libmad/layer3.c
@@ -57,7 +57,7 @@
 enum {
   count1table_select = 0x01,
   scalefac_scale     = 0x02,
-  preflag            = 0x04,
+  preflag        = 0x04,
   mixed_block_flag   = 0x08
 };
 
@@ -88,7 +88,7 @@ struct sideinfo {
       unsigned char region1_count;
 
       /* from main_data */
-      unsigned char scalefac[39];       /* scalefac_l and/or scalefac_s */
+      unsigned char scalefac[39];   /* scalefac_l and/or scalefac_s */
     } ch[2];
   } gr[2];
 };
@@ -502,14 +502,14 @@ mad_fixed_t const is_lsf_table[2][15] = {
 };
 
 /*
- * NAME:        III_sideinfo()
- * DESCRIPTION: decode frame side information from a bitstream
+ * NAME:    III_sideinfo()
+ * DESCRIPTION: decode frame side information from a bitstream
  */
 static
 enum mad_error III_sideinfo(struct mad_bitptr *ptr, unsigned int nch,
-                            int lsf, struct sideinfo *si,
-                            unsigned int *data_bitlen,
-                            unsigned int *priv_bitlen)
+                int lsf, struct sideinfo *si,
+                unsigned int *data_bitlen,
+                unsigned int *priv_bitlen)
 {
   unsigned int ngr, gr, ch, i;
   enum mad_error result = MAD_ERROR_NONE;
@@ -542,46 +542,46 @@ enum mad_error III_sideinfo(struct mad_bitptr *ptr, unsigned int nch,
       *data_bitlen += channel->part2_3_length;
 
       if (channel->big_values > 288 && result == 0)
-        result = MAD_ERROR_BADBIGVALUES;
+    result = MAD_ERROR_BADBIGVALUES;
 
       channel->flags = 0;
 
       /* window_switching_flag */
       if (mad_bit_read(ptr, 1)) {
-        channel->block_type = mad_bit_read(ptr, 2);
+    channel->block_type = mad_bit_read(ptr, 2);
 
-        if (channel->block_type == 0 && result == 0)
-          result = MAD_ERROR_BADBLOCKTYPE;
+    if (channel->block_type == 0 && result == 0)
+      result = MAD_ERROR_BADBLOCKTYPE;
 
-        if (!lsf && channel->block_type == 2 && si->scfsi[ch] && result == 0)
-          result = MAD_ERROR_BADSCFSI;
+    if (!lsf && channel->block_type == 2 && si->scfsi[ch] && result == 0)
+      result = MAD_ERROR_BADSCFSI;
 
-        channel->region0_count = 7;
-        channel->region1_count = 36;
+    channel->region0_count = 7;
+    channel->region1_count = 36;
 
-        if (mad_bit_read(ptr, 1))
-          channel->flags |= mixed_block_flag;
-        else if (channel->block_type == 2)
-          channel->region0_count = 8;
+    if (mad_bit_read(ptr, 1))
+      channel->flags |= mixed_block_flag;
+    else if (channel->block_type == 2)
+      channel->region0_count = 8;
 
-        for (i = 0; i < 2; ++i)
-          channel->table_select[i] = mad_bit_read(ptr, 5);
+    for (i = 0; i < 2; ++i)
+      channel->table_select[i] = mad_bit_read(ptr, 5);
 
 # if defined(DEBUG)
-        channel->table_select[2] = 4;  /* not used */
+    channel->table_select[2] = 4;  /* not used */
 # endif
 
-        for (i = 0; i < 3; ++i)
-          channel->subblock_gain[i] = mad_bit_read(ptr, 3);
+    for (i = 0; i < 3; ++i)
+      channel->subblock_gain[i] = mad_bit_read(ptr, 3);
       }
       else {
-        channel->block_type = 0;
+    channel->block_type = 0;
 
-        for (i = 0; i < 3; ++i)
-          channel->table_select[i] = mad_bit_read(ptr, 5);
+    for (i = 0; i < 3; ++i)
+      channel->table_select[i] = mad_bit_read(ptr, 5);
 
-        channel->region0_count = mad_bit_read(ptr, 4);
-        channel->region1_count = mad_bit_read(ptr, 3);
+    channel->region0_count = mad_bit_read(ptr, 4);
+    channel->region1_count = mad_bit_read(ptr, 3);
       }
 
       /* [preflag,] scalefac_scale, count1table_select */
@@ -593,13 +593,13 @@ enum mad_error III_sideinfo(struct mad_bitptr *ptr, unsigned int nch,
 }
 
 /*
- * NAME:        III_scalefactors_lsf()
- * DESCRIPTION: decode channel scalefactors for LSF from a bitstream
+ * NAME:    III_scalefactors_lsf()
+ * DESCRIPTION: decode channel scalefactors for LSF from a bitstream
  */
 static
 unsigned int III_scalefactors_lsf(struct mad_bitptr *ptr,
-                                  struct channel *channel,
-                                  struct channel *gr1ch, int mode_extension)
+                  struct channel *channel,
+                  struct channel *gr1ch, int mode_extension)
 {
   struct mad_bitptr start;
   unsigned int scalefac_compress, index, slen[4], part, n, i;
@@ -646,7 +646,7 @@ unsigned int III_scalefactors_lsf(struct mad_bitptr *ptr,
     n = 0;
     for (part = 0; part < 4; ++part) {
       for (i = 0; i < nsfb[part]; ++i)
-        channel->scalefac[n++] = mad_bit_read(ptr, slen[part]);
+    channel->scalefac[n++] = mad_bit_read(ptr, slen[part]);
     }
 
     while (n < 39)
@@ -691,10 +691,10 @@ unsigned int III_scalefactors_lsf(struct mad_bitptr *ptr,
       max = (1 << slen[part]) - 1;
 
       for (i = 0; i < nsfb[part]; ++i) {
-        is_pos = mad_bit_read(ptr, slen[part]);
+    is_pos = mad_bit_read(ptr, slen[part]);
 
-        channel->scalefac[n] = is_pos;
-        gr1ch->scalefac[n++] = (is_pos == max);
+    channel->scalefac[n] = is_pos;
+    gr1ch->scalefac[n++] = (is_pos == max);
       }
     }
 
@@ -708,12 +708,12 @@ unsigned int III_scalefactors_lsf(struct mad_bitptr *ptr,
 }
 
 /*
- * NAME:        III_scalefactors()
- * DESCRIPTION: decode channel scalefactors of one granule from a bitstream
+ * NAME:    III_scalefactors()
+ * DESCRIPTION: decode channel scalefactors of one granule from a bitstream
  */
 static
 unsigned int III_scalefactors(struct mad_bitptr *ptr, struct channel *channel,
-                              struct channel const *gr0ch, unsigned int scfsi)
+                  struct channel const *gr0ch, unsigned int scfsi)
 {
   struct mad_bitptr start;
   unsigned int slen1, slen2, sfbi;
@@ -743,38 +743,38 @@ unsigned int III_scalefactors(struct mad_bitptr *ptr, struct channel *channel,
   else {  /* channel->block_type != 2 */
     if (scfsi & 0x8) {
       for (sfbi = 0; sfbi < 6; ++sfbi)
-        channel->scalefac[sfbi] = gr0ch->scalefac[sfbi];
+    channel->scalefac[sfbi] = gr0ch->scalefac[sfbi];
     }
     else {
       for (sfbi = 0; sfbi < 6; ++sfbi)
-        channel->scalefac[sfbi] = mad_bit_read(ptr, slen1);
+    channel->scalefac[sfbi] = mad_bit_read(ptr, slen1);
     }
 
     if (scfsi & 0x4) {
       for (sfbi = 6; sfbi < 11; ++sfbi)
-        channel->scalefac[sfbi] = gr0ch->scalefac[sfbi];
+    channel->scalefac[sfbi] = gr0ch->scalefac[sfbi];
     }
     else {
       for (sfbi = 6; sfbi < 11; ++sfbi)
-        channel->scalefac[sfbi] = mad_bit_read(ptr, slen1);
+    channel->scalefac[sfbi] = mad_bit_read(ptr, slen1);
     }
 
     if (scfsi & 0x2) {
       for (sfbi = 11; sfbi < 16; ++sfbi)
-        channel->scalefac[sfbi] = gr0ch->scalefac[sfbi];
+    channel->scalefac[sfbi] = gr0ch->scalefac[sfbi];
     }
     else {
       for (sfbi = 11; sfbi < 16; ++sfbi)
-        channel->scalefac[sfbi] = mad_bit_read(ptr, slen2);
+    channel->scalefac[sfbi] = mad_bit_read(ptr, slen2);
     }
 
     if (scfsi & 0x1) {
       for (sfbi = 16; sfbi < 21; ++sfbi)
-        channel->scalefac[sfbi] = gr0ch->scalefac[sfbi];
+    channel->scalefac[sfbi] = gr0ch->scalefac[sfbi];
     }
     else {
       for (sfbi = 16; sfbi < 21; ++sfbi)
-        channel->scalefac[sfbi] = mad_bit_read(ptr, slen2);
+    channel->scalefac[sfbi] = mad_bit_read(ptr, slen2);
     }
 
     channel->scalefac[21] = 0;
@@ -806,12 +806,12 @@ unsigned int III_scalefactors(struct mad_bitptr *ptr, struct channel *channel,
  */
 
 /*
- * NAME:        III_exponents()
- * DESCRIPTION: calculate scalefactor exponents
+ * NAME:    III_exponents()
+ * DESCRIPTION: calculate scalefactor exponents
  */
 static
 void III_exponents(struct channel const *channel,
-                   unsigned char const *sfbwidth, signed int exponents[39])
+           unsigned char const *sfbwidth, signed int exponents[39])
 {
   signed int gain;
   unsigned int scalefac_multiplier, sfbi;
@@ -833,11 +833,11 @@ void III_exponents(struct channel const *channel,
       /* long block subbands 0-1 */
 
       while (l < 36) {
-        exponents[sfbi] = gain -
-          (signed int) ((channel->scalefac[sfbi] + (pretab[sfbi] & premask)) <<
-                        scalefac_multiplier);
+    exponents[sfbi] = gain -
+      (signed int) ((channel->scalefac[sfbi] + (pretab[sfbi] & premask)) <<
+            scalefac_multiplier);
 
-        l += sfbwidth[sfbi++];
+    l += sfbwidth[sfbi++];
       }
     }
 
@@ -849,11 +849,11 @@ void III_exponents(struct channel const *channel,
 
     while (l < 576) {
       exponents[sfbi + 0] = gain0 -
-        (signed int) (channel->scalefac[sfbi + 0] << scalefac_multiplier);
+    (signed int) (channel->scalefac[sfbi + 0] << scalefac_multiplier);
       exponents[sfbi + 1] = gain1 -
-        (signed int) (channel->scalefac[sfbi + 1] << scalefac_multiplier);
+    (signed int) (channel->scalefac[sfbi + 1] << scalefac_multiplier);
       exponents[sfbi + 2] = gain2 -
-        (signed int) (channel->scalefac[sfbi + 2] << scalefac_multiplier);
+    (signed int) (channel->scalefac[sfbi + 2] << scalefac_multiplier);
       unsigned int w = sfbwidth[sfbi];
       l    += 3 * w;
       sfbi += 3;
@@ -862,23 +862,23 @@ void III_exponents(struct channel const *channel,
   else {  /* channel->block_type != 2 */
     if (channel->flags & preflag) {
       for (sfbi = 0; sfbi < 22; ++sfbi) {
-        exponents[sfbi] = gain -
-          (signed int) ((channel->scalefac[sfbi] + pretab[sfbi]) <<
-                        scalefac_multiplier);
+    exponents[sfbi] = gain -
+      (signed int) ((channel->scalefac[sfbi] + pretab[sfbi]) <<
+            scalefac_multiplier);
       }
     }
     else {
       for (sfbi = 0; sfbi < 22; ++sfbi) {
-        exponents[sfbi] = gain -
-          (signed int) (channel->scalefac[sfbi] << scalefac_multiplier);
+    exponents[sfbi] = gain -
+      (signed int) (channel->scalefac[sfbi] << scalefac_multiplier);
       }
     }
   }
 }
 
 /*
- * NAME:        III_requantize()
- * DESCRIPTION: requantize one (positive) value
+ * NAME:    III_requantize()
+ * DESCRIPTION: requantize one (positive) value
  */
 static
 mad_fixed_t III_requantize(unsigned int value, signed int exp)
@@ -910,7 +910,7 @@ mad_fixed_t III_requantize(unsigned int value, signed int exp)
       /* overflow */
 # if defined(DEBUG)
       fprintf(stderr, "requantize overflow (%f * 2^%d)\n",
-              mad_f_todouble(requantized), exp);
+          mad_f_todouble(requantized), exp);
 # endif
       requantized = MAD_F_MAX;
     }
@@ -932,21 +932,21 @@ mad_fixed_t III_requantize(unsigned int value, signed int exp)
        res; \
     })
 #else
-# define MASK(cache, sz, bits)  \
+# define MASK(cache, sz, bits)  \
     (((cache) >> ((sz) - (bits))) & ((1 << (bits)) - 1))
 #endif
 # define MASK1BIT(cache, sz)  \
     ((cache) & (1 << ((sz) - 1)))
 
 /*
- * NAME:        III_huffdecode()
- * DESCRIPTION: decode Huffman code words of one channel of one granule
+ * NAME:    III_huffdecode()
+ * DESCRIPTION: decode Huffman code words of one channel of one granule
  */
 static
 enum mad_error III_huffdecode(struct mad_bitptr *ptr, mad_fixed_t xrarr[576],
-                              struct channel *channel,
-                              unsigned char const *sfbwidth,
-                              unsigned int part2_length)
+                  struct channel *channel,
+                  unsigned char const *sfbwidth,
+                  unsigned int part2_length)
 {
   unsigned int bits;
   signed int exponents[39], exp;
@@ -999,23 +999,23 @@ enum mad_error III_huffdecode(struct mad_bitptr *ptr, mad_fixed_t xrarr[576],
         else
           if(region == 0)
             rcount = channel->region1_count + 1;
-          else
+      else
             rcount = 0;  /* all remaining */
 
-        entry     = &mad_huff_pair_table[channel->table_select[++region]];
-        table     = entry->table;
-        linbits   = entry->linbits;
-        startbits = entry->startbits;
+    entry     = &mad_huff_pair_table[channel->table_select[++region]];
+    table     = entry->table;
+    linbits   = entry->linbits;
+    startbits = entry->startbits;
 
-        if(table == 0)
-          return MAD_ERROR_BADHUFFTABLE;
+    if(table == 0)
+      return MAD_ERROR_BADHUFFTABLE;
       }
 
       if(exp != *expptr)
       {
-        exp = *expptr;
+    exp = *expptr;
         /* clear cache */
-        memset(reqcache, 0, sizeof(reqcache));
+    memset(reqcache, 0, sizeof(reqcache));
       }
 
       ++expptr;
@@ -1052,10 +1052,10 @@ enum mad_error III_huffdecode(struct mad_bitptr *ptr, mad_fixed_t xrarr[576],
 
           cachesz -= pair->value.hlen;
 
-          /* x (0..14) */
-          value = pair->value.x;
-          if(value == 0)
-            xr[0] = 0;
+      /* x (0..14) */
+      value = pair->value.x;
+      if(value == 0)
+        xr[0] = 0;
           else
           {
             if(value == 15)
@@ -1071,24 +1071,24 @@ enum mad_error III_huffdecode(struct mad_bitptr *ptr, mad_fixed_t xrarr[576],
                 cachesz += bits;
               }
 
-              requantized = III_requantize(15+MASK(bitcache, cachesz, linbits), exp);
-              cachesz    -= linbits;
+          requantized = III_requantize(15+MASK(bitcache, cachesz, linbits), exp);
+          cachesz    -= linbits;
             }
             else
             {
-              if(reqcache[value])
-                requantized = reqcache[value];
-              else
-                requantized = reqcache[value] = III_requantize(value, exp);
+          if(reqcache[value])
+            requantized = reqcache[value];
+          else
+            requantized = reqcache[value] = III_requantize(value, exp);
             }
 
             xr[0] = MASK1BIT(bitcache, cachesz--) ? -requantized : requantized;
           }
 
-          /* y (0..14) */
-          value = pair->value.y;
-          if(value == 0)
-            xr[1] = 0;
+      /* y (0..14) */
+      value = pair->value.y;
+      if(value == 0)
+        xr[1] = 0;
           else
           {
             if(value == 15)
@@ -1109,12 +1109,12 @@ enum mad_error III_huffdecode(struct mad_bitptr *ptr, mad_fixed_t xrarr[576],
             }
             else
             {
-              if(reqcache[value])
-                requantized = reqcache[value];
-              else
-                requantized = reqcache[value] = III_requantize(value, exp);
+          if(reqcache[value])
+            requantized = reqcache[value];
+          else
+            requantized = reqcache[value] = III_requantize(value, exp);
             }
-            xr[1] = MASK1BIT(bitcache, cachesz--) ? -requantized : requantized;
+        xr[1] = MASK1BIT(bitcache, cachesz--) ? -requantized : requantized;
           }
         }
       }
@@ -1162,32 +1162,32 @@ enum mad_error III_huffdecode(struct mad_bitptr *ptr, mad_fixed_t xrarr[576],
 
           cachesz -= pair->value.hlen;
 
-          /* x (0..1) */
-          value = pair->value.x;
-          if(value == 0)
-            xr[0] = 0;
-          else
+      /* x (0..1) */
+      value = pair->value.x;
+      if(value == 0)
+        xr[0] = 0;
+      else
           {
-            if(reqcache[value])
-              requantized = reqcache[value];
-            else
-              requantized = reqcache[value] = III_requantize(value, exp);
+        if(reqcache[value])
+          requantized = reqcache[value];
+        else
+          requantized = reqcache[value] = III_requantize(value, exp);
 
-            xr[0] = MASK1BIT(bitcache, cachesz--) ? -requantized : requantized;
+        xr[0] = MASK1BIT(bitcache, cachesz--) ? -requantized : requantized;
           }
 
-          /* y (0..1) */
-          value = pair->value.y;
-          if(value == 0)
-            xr[1] = 0;
-          else
+      /* y (0..1) */
+      value = pair->value.y;
+      if(value == 0)
+        xr[1] = 0;
+      else
           {
-            if(reqcache[value])
-              requantized = reqcache[value];
-            else
-              requantized = reqcache[value] = III_requantize(value, exp);
+        if(reqcache[value])
+          requantized = reqcache[value];
+        else
+          requantized = reqcache[value] = III_requantize(value, exp);
 
-            xr[1] = MASK1BIT(bitcache, cachesz--) ? -requantized : requantized;
+        xr[1] = MASK1BIT(bitcache, cachesz--) ? -requantized : requantized;
           }
         }
       }
@@ -1218,9 +1218,9 @@ enum mad_error III_huffdecode(struct mad_bitptr *ptr, mad_fixed_t xrarr[576],
         if(cachesz < 0)
           return MAD_ERROR_BADHUFFDATA;  /* cache underrun */
 
-        bits       = MAXLSHIFT - cachesz;
+    bits       = MAXLSHIFT - cachesz;
         bitcache   = (bitcache << bits) | mad_bit_read(&peek, bits);
-        cachesz   += bits;
+    cachesz   += bits;
         bits_left -= bits;
       }
 
@@ -1228,53 +1228,53 @@ enum mad_error III_huffdecode(struct mad_bitptr *ptr, mad_fixed_t xrarr[576],
 
       /* quad tables guaranteed to have at most one extra lookup */
       if (!quad->final) {
-        cachesz -= 4;
+    cachesz -= 4;
 
-        quad = &table[quad->ptr.offset +
-                      MASK(bitcache, cachesz, quad->ptr.bits)];
+    quad = &table[quad->ptr.offset +
+              MASK(bitcache, cachesz, quad->ptr.bits)];
       }
 
       cachesz -= quad->value.hlen;
 
       if (xr == sfbound) {
-        sfbound += *sfbwidth++;
+    sfbound += *sfbwidth++;
 
-        if (exp != *expptr) {
-          exp = *expptr;
-          requantized = III_requantize(1, exp);
-        }
+    if (exp != *expptr) {
+      exp = *expptr;
+      requantized = III_requantize(1, exp);
+    }
 
-        ++expptr;
+    ++expptr;
       }
 
       /* v (0..1) */
       xr[0] = quad->value.v ?
-        (MASK1BIT(bitcache, cachesz--) ? -requantized : requantized) : 0;
+    (MASK1BIT(bitcache, cachesz--) ? -requantized : requantized) : 0;
 
       /* w (0..1) */
       xr[1] = quad->value.w ?
-        (MASK1BIT(bitcache, cachesz--) ? -requantized : requantized) : 0;
+    (MASK1BIT(bitcache, cachesz--) ? -requantized : requantized) : 0;
 
       xr += 2;
 
       if (xr == sfbound) {
-        sfbound += *sfbwidth++;
+    sfbound += *sfbwidth++;
 
-        if (exp != *expptr) {
-          exp = *expptr;
-          requantized = III_requantize(1, exp);
-        }
+    if (exp != *expptr) {
+      exp = *expptr;
+      requantized = III_requantize(1, exp);
+    }
 
-        ++expptr;
+    ++expptr;
       }
 
       /* x (0..1) */
       xr[0] = quad->value.x ?
-        (MASK1BIT(bitcache, cachesz--) ? -requantized : requantized) : 0;
+    (MASK1BIT(bitcache, cachesz--) ? -requantized : requantized) : 0;
 
       /* y (0..1) */
       xr[1] = quad->value.y ?
-        (MASK1BIT(bitcache, cachesz--) ? -requantized : requantized) : 0;
+    (MASK1BIT(bitcache, cachesz--) ? -requantized : requantized) : 0;
 
       xr += 2;
     }
@@ -1282,7 +1282,7 @@ enum mad_error III_huffdecode(struct mad_bitptr *ptr, mad_fixed_t xrarr[576],
     if(bits_left + cachesz < 0)
     {
       /* technically the bitstream is misformatted, but apparently
-         some encoders are just a bit sloppy with stuffing bits */
+     some encoders are just a bit sloppy with stuffing bits */
       xr -= 4;
     }
   }
@@ -1297,12 +1297,12 @@ enum mad_error III_huffdecode(struct mad_bitptr *ptr, mad_fixed_t xrarr[576],
 # undef MASK1BIT
 
 /*
- * NAME:        III_reorder()
- * DESCRIPTION: reorder frequency lines of a short block into subband order
+ * NAME:    III_reorder()
+ * DESCRIPTION: reorder frequency lines of a short block into subband order
  */
 static
 void III_reorder(mad_fixed_t xr[576], struct channel const *channel,
-                 unsigned char const sfbwidth[39])
+         unsigned char const sfbwidth[39])
 {
   mad_fixed_t tmp[32][3][6];
   unsigned int sb, l, f, w, sbw[3], sw[3];
@@ -1345,14 +1345,14 @@ void III_reorder(mad_fixed_t xr[576], struct channel const *channel,
 }
 
 /*
- * NAME:        III_stereo()
- * DESCRIPTION: perform joint stereo processing on a granule
+ * NAME:    III_stereo()
+ * DESCRIPTION: perform joint stereo processing on a granule
  */
 static
 enum mad_error III_stereo(mad_fixed_t xr[2][576],
-                          struct granule const *granule,
-                          struct mad_header *header,
-                          unsigned char const *sfbwidth)
+              struct granule const *granule,
+              struct mad_header *header,
+              unsigned char const *sfbwidth)
 {
   short modes[39];
   unsigned int sfbi, l, n, i;
@@ -1385,55 +1385,55 @@ enum mad_error III_stereo(mad_fixed_t xr[2][576],
       sfbi = l = 0;
 
       if (right_ch->flags & mixed_block_flag) {
-        while (l < 36) {
-          n = sfbwidth[sfbi++];
+    while (l < 36) {
+      n = sfbwidth[sfbi++];
 
-          for (i = 0; i < n; ++i) {
-            if (right_xr[i]) {
-              lower = sfbi;
-              break;
-            }
-          }
+      for (i = 0; i < n; ++i) {
+        if (right_xr[i]) {
+          lower = sfbi;
+          break;
+        }
+      }
 
-          right_xr += n;
-          l += n;
-        }
+      right_xr += n;
+      l += n;
+    }
 
-        start = sfbi;
+    start = sfbi;
       }
 
       w = 0;
       while (l < 576) {
-        n = sfbwidth[sfbi++];
-
-        for (i = 0; i < n; ++i) {
-          if (right_xr[i]) {
-            max = bound[w] = sfbi;
-            break;
-          }
-        }
-
-        right_xr += n;
-        l += n;
-        w = (w + 1) % 3;
+    n = sfbwidth[sfbi++];
+
+    for (i = 0; i < n; ++i) {
+      if (right_xr[i]) {
+        max = bound[w] = sfbi;
+        break;
+      }
+    }
+
+    right_xr += n;
+    l += n;
+    w = (w + 1) % 3;
       }
 
       if (max)
-        lower = start;
+    lower = start;
 
       /* long blocks */
 
       for (i = 0; i < lower; ++i)
-        modes[i] = header->mode_extension & ~I_STEREO;
+    modes[i] = header->mode_extension & ~I_STEREO;
 
       /* short blocks */
 
       w = 0;
       for (i = start; i < max; ++i) {
-        if (i < bound[w])
-          modes[i] = header->mode_extension & ~I_STEREO;
+    if (i < bound[w])
+      modes[i] = header->mode_extension & ~I_STEREO;
 
-        w = (w + 1) % 3;
+    w = (w + 1) % 3;
       }
     }
     else {  /* right_ch->block_type != 2 */
@@ -1441,20 +1441,20 @@ enum mad_error III_stereo(mad_fixed_t xr[2][576],
 
       bound = 0;
       for (sfbi = l = 0; l < 576; l += n) {
-        n = sfbwidth[sfbi++];
+    n = sfbwidth[sfbi++];
 
-        for (i = 0; i < n; ++i) {
-          if (right_xr[i]) {
-            bound = sfbi;
-            break;
-          }
-        }
+    for (i = 0; i < n; ++i) {
+      if (right_xr[i]) {
+        bound = sfbi;
+        break;
+      }
+    }
 
-        right_xr += n;
+    right_xr += n;
       }
 
       for (i = 0; i < bound; ++i)
-        modes[i] = header->mode_extension & ~I_STEREO;
+    modes[i] = header->mode_extension & ~I_STEREO;
     }
 
     /* now do the actual processing */
@@ -1467,62 +1467,62 @@ enum mad_error III_stereo(mad_fixed_t xr[2][576],
       lsf_scale = is_lsf_table[right_ch->scalefac_compress & 0x1];
 
       for (sfbi = l = 0; l < 576; ++sfbi, l += n) {
-        n = sfbwidth[sfbi];
+    n = sfbwidth[sfbi];
 
-        if (!(modes[sfbi] & I_STEREO))
-          continue;
+    if (!(modes[sfbi] & I_STEREO))
+      continue;
 
-        if (illegal_pos[sfbi]) {
-          modes[sfbi] &= ~I_STEREO;
-          continue;
-        }
+    if (illegal_pos[sfbi]) {
+      modes[sfbi] &= ~I_STEREO;
+      continue;
+    }
 
-        is_pos = right_ch->scalefac[sfbi];
+    is_pos = right_ch->scalefac[sfbi];
 
-        for (i = 0; i < n; ++i) {
-          register mad_fixed_t left;
+    for (i = 0; i < n; ++i) {
+      register mad_fixed_t left;
 
-          left = xr[0][l + i];
+      left = xr[0][l + i];
 
-          if (is_pos == 0)
-            xr[1][l + i] = left;
-          else {
-            register mad_fixed_t opposite;
+      if (is_pos == 0)
+        xr[1][l + i] = left;
+      else {
+        register mad_fixed_t opposite;
 
-            opposite = mad_f_mul(left, lsf_scale[(is_pos - 1) / 2]);
+        opposite = mad_f_mul(left, lsf_scale[(is_pos - 1) / 2]);
 
-            if (is_pos & 1) {
-              xr[0][l + i] = opposite;
-              xr[1][l + i] = left;
-            }
-            else
-              xr[1][l + i] = opposite;
-          }
-        }
+        if (is_pos & 1) {
+          xr[0][l + i] = opposite;
+          xr[1][l + i] = left;
+        }
+        else
+          xr[1][l + i] = opposite;
+      }
+    }
       }
     }
     else {  /* !(header->flags & MAD_FLAG_LSF_EXT) */
       for (sfbi = l = 0; l < 576; ++sfbi, l += n) {
-        n = sfbwidth[sfbi];
+    n = sfbwidth[sfbi];
 
-        if (!(modes[sfbi] & I_STEREO))
-          continue;
+    if (!(modes[sfbi] & I_STEREO))
+      continue;
 
-        is_pos = right_ch->scalefac[sfbi];
+    is_pos = right_ch->scalefac[sfbi];
 
-        if (is_pos >= 7) {  /* illegal intensity position */
-          modes[sfbi] &= ~I_STEREO;
-          continue;
-        }
+    if (is_pos >= 7) {  /* illegal intensity position */
+      modes[sfbi] &= ~I_STEREO;
+      continue;
+    }
 
-        for (i = 0; i < n; ++i) {
-          register mad_fixed_t left;
+    for (i = 0; i < n; ++i) {
+      register mad_fixed_t left;
 
-          left = xr[0][l + i];
+      left = xr[0][l + i];
 
-          xr[0][l + i] = mad_f_mul(left, is_table[    is_pos]);
-          xr[1][l + i] = mad_f_mul(left, is_table[6 - is_pos]);
-        }
+      xr[0][l + i] = mad_f_mul(left, is_table[    is_pos]);
+      xr[1][l + i] = mad_f_mul(left, is_table[6 - is_pos]);
+    }
       }
     }
   }
@@ -1540,16 +1540,16 @@ enum mad_error III_stereo(mad_fixed_t xr[2][576],
       n = sfbwidth[sfbi];
 
       if (modes[sfbi] != MS_STEREO)
-        continue;
+    continue;
 
       for (i = 0; i < n; ++i) {
-        register mad_fixed_t m, s;
+    register mad_fixed_t m, s;
 
-        m = xr[0][l + i];
-        s = xr[1][l + i];
+    m = xr[0][l + i];
+    s = xr[1][l + i];
 
-        xr[0][l + i] = mad_f_mul(m + s, invsqrt2);  /* l = (m + s) / sqrt(2) */
-        xr[1][l + i] = mad_f_mul(m - s, invsqrt2);  /* r = (m - s) / sqrt(2) */
+    xr[0][l + i] = mad_f_mul(m + s, invsqrt2);  /* l = (m + s) / sqrt(2) */
+    xr[1][l + i] = mad_f_mul(m - s, invsqrt2);  /* r = (m - s) / sqrt(2) */
       }
     }
   }
@@ -1561,8 +1561,8 @@ enum mad_error III_stereo(mad_fixed_t xr[2][576],
 void III_aliasreduce(mad_fixed_t xr[576], int lines);
 #else
 /*
- * NAME:        III_aliasreduce()
- * DESCRIPTION: perform frequency line alias reduction
+ * NAME:    III_aliasreduce()
+ * DESCRIPTION: perform frequency line alias reduction
  */
 static
 void III_aliasreduce(mad_fixed_t xr[576], int lines)
@@ -1598,15 +1598,15 @@ void III_aliasreduce(mad_fixed_t xr[576], int lines)
       xr[-1 - i] = a;
       xr[     i] = b;
 # else
-        MAD_F_ML0(hi, lo,  a, cs[i]);
-        MAD_F_MLA(hi, lo, -b, ca[i]);
+    MAD_F_ML0(hi, lo,  a, cs[i]);
+    MAD_F_MLA(hi, lo, -b, ca[i]);
 
-        xr[-1 - i] = MAD_F_MLZ(hi, lo);
+    xr[-1 - i] = MAD_F_MLZ(hi, lo);
 
-        MAD_F_ML0(hi, lo,  b, cs[i]);
-        MAD_F_MLA(hi, lo,  a, ca[i]);
+    MAD_F_ML0(hi, lo,  b, cs[i]);
+    MAD_F_MLA(hi, lo,  a, ca[i]);
 
-        xr[     i] = MAD_F_MLZ(hi, lo);
+    xr[     i] = MAD_F_MLZ(hi, lo);
 # endif
 # if defined(ASO_ZEROCHECK)
       }
@@ -1774,8 +1774,8 @@ void dctIV(mad_fixed_t const y[18], mad_fixed_t X[18])
 }
 
 /*
- * NAME:        imdct36
- * DESCRIPTION: perform X[18]->x[36] IMDCT using Szu-Wei Lee's fast algorithm
+ * NAME:    imdct36
+ * DESCRIPTION: perform X[18]->x[36] IMDCT using Szu-Wei Lee's fast algorithm
  */
 static inline
 void imdct36(mad_fixed_t const x[18], mad_fixed_t y[36])
@@ -1807,8 +1807,8 @@ void imdct36(mad_fixed_t const x[18], mad_fixed_t y[36])
 }
 #  else
 /*
- * NAME:        imdct36
- * DESCRIPTION: perform X[18]->x[36] IMDCT
+ * NAME:    imdct36
+ * DESCRIPTION: perform X[18]->x[36] IMDCT
  */
 
 # if defined(CPU_COLDFIRE)
@@ -2737,12 +2737,12 @@ void imdct36(mad_fixed_t const X[18], mad_fixed_t x[36])
 #  endif
 
 /*
- * NAME:        III_imdct_l()
- * DESCRIPTION: perform IMDCT and windowing for long blocks
+ * NAME:    III_imdct_l()
+ * DESCRIPTION: perform IMDCT and windowing for long blocks
  */
 static
 void III_imdct_l(mad_fixed_t const X[18], mad_fixed_t z[36],
-                 unsigned int block_type)
+         unsigned int block_type)
 {
   unsigned int i;
 
@@ -2762,10 +2762,10 @@ void III_imdct_l(mad_fixed_t const X[18], mad_fixed_t z[36],
       tmp2 = window_l[1];
 
       for (i = 0; i < 34; i += 2) {
-        z[i + 0] = mad_f_mul(z[i + 0], tmp1);
-        tmp1 = window_l[i + 2];
-        z[i + 1] = mad_f_mul(z[i + 1], tmp2);
-        tmp2 = window_l[i + 3];
+    z[i + 0] = mad_f_mul(z[i + 0], tmp1);
+    tmp1 = window_l[i + 2];
+    z[i + 1] = mad_f_mul(z[i + 1], tmp2);
+    tmp2 = window_l[i + 3];
       }
 
       z[34] = mad_f_mul(z[34], tmp1);
@@ -2779,9 +2779,9 @@ void III_imdct_l(mad_fixed_t const X[18], mad_fixed_t z[36],
       tmp2 = window_l[0];
 
       for (i = 0; i < 35; ++i) {
-        z[i] = mad_f_mul(tmp1, tmp2);
-        tmp1 = z[i + 1];
-        tmp2 = window_l[i + 1];
+    z[i] = mad_f_mul(tmp1, tmp2);
+    tmp1 = z[i + 1];
+    tmp2 = window_l[i + 1];
       }
 
       z[35] = mad_f_mul(tmp1, tmp2);
@@ -2824,8 +2824,8 @@ void III_imdct_l(mad_fixed_t const X[18], mad_fixed_t z[36],
 # endif  /* ASO_IMDCT */
 
 /*
- * NAME:        III_imdct_s()
- * DESCRIPTION: perform IMDCT and windowing for short blocks
+ * NAME:    III_imdct_s()
+ * DESCRIPTION: perform IMDCT and windowing for short blocks
  */
 
 # if defined(CPU_COLDFIRE)
@@ -2911,16 +2911,16 @@ void III_imdct_s(mad_fixed_t const X[18], mad_fixed_t z[36])
 
 #ifdef CPU_ARM
 void III_overlap(mad_fixed_t const output[36], mad_fixed_t overlap[18],
-                 mad_fixed_t sample[18][32], unsigned int sb);
+         mad_fixed_t sample[18][32], unsigned int sb);
 #else
 
 /*
- * NAME:        III_overlap()
- * DESCRIPTION: perform overlap-add of windowed IMDCT outputs
+ * NAME:    III_overlap()
+ * DESCRIPTION: perform overlap-add of windowed IMDCT outputs
  */
 static
 void III_overlap(mad_fixed_t const output[36], mad_fixed_t overlap[18],
-                 mad_fixed_t sample[18][32], unsigned int sb)
+         mad_fixed_t sample[18][32], unsigned int sb)
 {
   unsigned int i;
 
@@ -2964,12 +2964,12 @@ void III_overlap(mad_fixed_t const output[36], mad_fixed_t overlap[18],
 #endif
 
 /*
- * NAME:        III_overlap_z()
- * DESCRIPTION: perform "overlap-add" of zero IMDCT outputs
+ * NAME:    III_overlap_z()
+ * DESCRIPTION: perform "overlap-add" of zero IMDCT outputs
  */
 static inline
 void III_overlap_z(mad_fixed_t overlap[18],
-                   mad_fixed_t sample[18][32], unsigned int sb)
+           mad_fixed_t sample[18][32], unsigned int sb)
 {
   unsigned int i;
 
@@ -3004,8 +3004,8 @@ void III_overlap_z(mad_fixed_t overlap[18],
 }
 
 /*
- * NAME:        III_freqinver()
- * DESCRIPTION: perform subband frequency inversion for odd sample lines
+ * NAME:    III_freqinver()
+ * DESCRIPTION: perform subband frequency inversion for odd sample lines
  */
 static
 void III_freqinver(mad_fixed_t sample[18][32], unsigned int sb)
@@ -3038,12 +3038,12 @@ void III_freqinver(mad_fixed_t sample[18][32], unsigned int sb)
 }
 
 /*
- * NAME:        III_decode()
- * DESCRIPTION: decode frame main_data
+ * NAME:    III_decode()
+ * DESCRIPTION: decode frame main_data
  */
 static
 enum mad_error III_decode(struct mad_bitptr *ptr, struct mad_frame *frame,
-                          struct sideinfo *si, unsigned int nch)
+              struct sideinfo *si, unsigned int nch)
 {
   struct mad_header *header = &frame->header;
   unsigned int sfreqi, ngr, gr;
@@ -3081,23 +3081,23 @@ enum mad_error III_decode(struct mad_bitptr *ptr, struct mad_frame *frame,
 
       sfbwidth[ch] = sfbwidth_table[sfreqi].l;
       if (channel->block_type == 2) {
-        sfbwidth[ch] = (channel->flags & mixed_block_flag) ?
-          sfbwidth_table[sfreqi].m : sfbwidth_table[sfreqi].s;
+    sfbwidth[ch] = (channel->flags & mixed_block_flag) ?
+      sfbwidth_table[sfreqi].m : sfbwidth_table[sfreqi].s;
       }
 
       if (header->flags & MAD_FLAG_LSF_EXT) {
-        part2_length = III_scalefactors_lsf(ptr, channel,
-                                            ch == 0 ? 0 : &si->gr[1].ch[1],
-                                            header->mode_extension);
+    part2_length = III_scalefactors_lsf(ptr, channel,
+                        ch == 0 ? 0 : &si->gr[1].ch[1],
+                        header->mode_extension);
       }
       else {
-        part2_length = III_scalefactors(ptr, channel, &si->gr[0].ch[ch],
-                                        gr == 0 ? 0 : si->scfsi[ch]);
+    part2_length = III_scalefactors(ptr, channel, &si->gr[0].ch[ch],
+                    gr == 0 ? 0 : si->scfsi[ch]);
       }
 
       error = III_huffdecode(ptr, xr[ch], channel, sfbwidth[ch], part2_length);
       if (error)
-        return error;
+    return error;
     }
 
     /* joint stereo processing */
@@ -3105,7 +3105,7 @@ enum mad_error III_decode(struct mad_bitptr *ptr, struct mad_frame *frame,
     if (header->mode == MAD_MODE_JOINT_STEREO && header->mode_extension) {
       error = III_stereo(xr, granule, header, sfbwidth[0]);
       if (error)
-        return error;
+    return error;
     }
 
     /* reordering, alias reduction, IMDCT, overlap-add, frequency inversion */
@@ -3117,46 +3117,46 @@ enum mad_error III_decode(struct mad_bitptr *ptr, struct mad_frame *frame,
       mad_fixed_t output[36];
 
       if (channel->block_type == 2) {
-        III_reorder(xr[ch], channel, sfbwidth[ch]);
+    III_reorder(xr[ch], channel, sfbwidth[ch]);
 
 # if !defined(OPT_STRICT)
-        /*
-         * According to ISO/IEC 11172-3, "Alias reduction is not applied for
-         * granules with block_type == 2 (short block)." However, other
-         * sources suggest alias reduction should indeed be performed on the
-         * lower two subbands of mixed blocks. Most other implementations do
-         * this, so by default we will too.
-         */
-        if (channel->flags & mixed_block_flag)
-          III_aliasreduce(xr[ch], 36);
+    /*
+     * According to ISO/IEC 11172-3, "Alias reduction is not applied for
+     * granules with block_type == 2 (short block)." However, other
+     * sources suggest alias reduction should indeed be performed on the
+     * lower two subbands of mixed blocks. Most other implementations do
+     * this, so by default we will too.
+     */
+    if (channel->flags & mixed_block_flag)
+      III_aliasreduce(xr[ch], 36);
 # endif
       }
       else
-        III_aliasreduce(xr[ch], 576);
+    III_aliasreduce(xr[ch], 576);
 
       l = 0;
 
       /* subbands 0-1 */
 
       if (channel->block_type != 2 || (channel->flags & mixed_block_flag)) {
-        unsigned int block_type;
+    unsigned int block_type;
 
-        block_type = channel->block_type;
-        if (channel->flags & mixed_block_flag)
-          block_type = 0;
+    block_type = channel->block_type;
+    if (channel->flags & mixed_block_flag)
+      block_type = 0;
 
-        /* long blocks */
-        for (sb = 0; sb < 2; ++sb, l += 18) {
-          III_imdct_l(&xr[ch][l], output, block_type);
-          III_overlap(output, (*frame->overlap)[ch][sb], sample, sb);
-        }
+    /* long blocks */
+    for (sb = 0; sb < 2; ++sb, l += 18) {
+      III_imdct_l(&xr[ch][l], output, block_type);
+      III_overlap(output, (*frame->overlap)[ch][sb], sample, sb);
+    }
       }
       else {
-        /* short blocks */
-        for (sb = 0; sb < 2; ++sb, l += 18) {
-          III_imdct_s(&xr[ch][l], output);
-          III_overlap(output, (*frame->overlap)[ch][sb], sample, sb);
-        }
+    /* short blocks */
+    for (sb = 0; sb < 2; ++sb, l += 18) {
+      III_imdct_s(&xr[ch][l], output);
+      III_overlap(output, (*frame->overlap)[ch][sb], sample, sb);
+    }
       }
 
       III_freqinver(sample, 1);
@@ -3166,7 +3166,7 @@ enum mad_error III_decode(struct mad_bitptr *ptr, struct mad_frame *frame,
 /*
       i = 576;
       while (i > 36 && xr[ch][i - 1] == 0)
-        --i;
+    --i;
 */
 
       {
@@ -3181,33 +3181,33 @@ enum mad_error III_decode(struct mad_bitptr *ptr, struct mad_frame *frame,
       sblimit = 32 - (576 - i) / 18;
 
       if (channel->block_type != 2) {
-        /* long blocks */
-        for (sb = 2; sb < sblimit; ++sb, l += 18) {
-          III_imdct_l(&xr[ch][l], output, channel->block_type);
-          III_overlap(output, (*frame->overlap)[ch][sb], sample, sb);
-
-          if (sb & 1)
-            III_freqinver(sample, sb);
-        }
+    /* long blocks */
+    for (sb = 2; sb < sblimit; ++sb, l += 18) {
+      III_imdct_l(&xr[ch][l], output, channel->block_type);
+      III_overlap(output, (*frame->overlap)[ch][sb], sample, sb);
+
+      if (sb & 1)
+        III_freqinver(sample, sb);
+    }
       }
       else {
-        /* short blocks */
-        for (sb = 2; sb < sblimit; ++sb, l += 18) {
-          III_imdct_s(&xr[ch][l], output);
-          III_overlap(output, (*frame->overlap)[ch][sb], sample, sb);
-
-          if (sb & 1)
-            III_freqinver(sample, sb);
-        }
+    /* short blocks */
+    for (sb = 2; sb < sblimit; ++sb, l += 18) {
+      III_imdct_s(&xr[ch][l], output);
+      III_overlap(output, (*frame->overlap)[ch][sb], sample, sb);
+
+      if (sb & 1)
+        III_freqinver(sample, sb);
+    }
       }
 
       /* remaining (zero) subbands */
 
       for (sb = sblimit; sb < 32; ++sb) {
-        III_overlap_z((*frame->overlap)[ch][sb], sample, sb);
+    III_overlap_z((*frame->overlap)[ch][sb], sample, sb);
 
-        if (sb & 1)
-          III_freqinver(sample, sb);
+    if (sb & 1)
+      III_freqinver(sample, sb);
       }
     }
   }
@@ -3216,8 +3216,8 @@ enum mad_error III_decode(struct mad_bitptr *ptr, struct mad_frame *frame,
 }
 
 /*
- * NAME:        layer->III()
- * DESCRIPTION: decode a single Layer III frame
+ * NAME:    layer->III()
+ * DESCRIPTION: decode a single Layer III frame
  */
 int mad_layer_III(struct mad_stream *stream, struct mad_frame *frame)
 {
@@ -3268,7 +3268,7 @@ int mad_layer_III(struct mad_stream *stream, struct mad_frame *frame)
       mad_bit_crc(stream->ptr, si_len * CHAR_BIT, header->crc_check);
 
     if (header->crc_check != header->crc_target &&
-        !(frame->options & MAD_OPTION_IGNORECRC)) {
+    !(frame->options & MAD_OPTION_IGNORECRC)) {
       stream->error = MAD_ERROR_BADCRC;
       result = -1;
     }
@@ -3277,7 +3277,7 @@ int mad_layer_III(struct mad_stream *stream, struct mad_frame *frame)
   /* decode frame side information */
 
   error = III_sideinfo(&stream->ptr, nch, header->flags & MAD_FLAG_LSF_EXT,
-                       &si, &data_bitlen, &priv_bitlen);
+               &si, &data_bitlen, &priv_bitlen);
   if (error && result == 0) {
     stream->error = error;
     result = -1;
@@ -3297,10 +3297,10 @@ int mad_layer_III(struct mad_stream *stream, struct mad_frame *frame)
     header = mad_bit_read(&peek, 32);
     if ((header & 0xffe60000L) /* syncword | layer */ == 0xffe20000L) {
       if (!(header & 0x00010000L))  /* protection_bit */
-        mad_bit_skip(&peek, 16);  /* crc_check */
+    mad_bit_skip(&peek, 16);  /* crc_check */
 
       next_md_begin =
-        mad_bit_read(&peek, (header & 0x00080000L) /* ID */ ? 9 : 8);
+    mad_bit_read(&peek, (header & 0x00080000L) /* ID */ ? 9 : 8);
     }
 
     mad_bit_finish(&peek);
@@ -3326,22 +3326,22 @@ int mad_layer_III(struct mad_stream *stream, struct mad_frame *frame)
   else {
     if (si.main_data_begin > stream->md_len) {
       if (result == 0) {
-        stream->error = MAD_ERROR_BADDATAPTR;
-        result = -1;
+    stream->error = MAD_ERROR_BADDATAPTR;
+    result = -1;
       }
     }
     else {
       mad_bit_init(&ptr,
-                   *stream->main_data + stream->md_len - si.main_data_begin);
+           *stream->main_data + stream->md_len - si.main_data_begin);
 
       if (md_len > si.main_data_begin) {
-        assert(stream->md_len + md_len -
-               si.main_data_begin <= MAD_BUFFER_MDLEN);
+    assert(stream->md_len + md_len -
+           si.main_data_begin <= MAD_BUFFER_MDLEN);
 
-        memcpy(*stream->main_data + stream->md_len,
-               mad_bit_nextbyte(&stream->ptr),
-               frame_used = md_len - si.main_data_begin);
-        stream->md_len += frame_used;
+    memcpy(*stream->main_data + stream->md_len,
+           mad_bit_nextbyte(&stream->ptr),
+           frame_used = md_len - si.main_data_begin);
+    stream->md_len += frame_used;
       }
     }
   }
@@ -3365,17 +3365,17 @@ int mad_layer_III(struct mad_stream *stream, struct mad_frame *frame)
 
 # if 0 && defined(DEBUG)
   fprintf(stderr,
-          "main_data_begin:%u, md_len:%u, frame_free:%u, "
-          "data_bitlen:%u, anc_bitlen: %u\n",
-          si.main_data_begin, md_len, frame_free,
-          data_bitlen, stream->anc_bitlen);
+      "main_data_begin:%u, md_len:%u, frame_free:%u, "
+      "data_bitlen:%u, anc_bitlen: %u\n",
+      si.main_data_begin, md_len, frame_free,
+      data_bitlen, stream->anc_bitlen);
 # endif
 
   /* preload main_data buffer with up to 511 bytes for next frame(s) */
 
   if (frame_free >= next_md_begin) {
     memcpy(*stream->main_data,
-           stream->next_frame - next_md_begin, next_md_begin);
+       stream->next_frame - next_md_begin, next_md_begin);
     stream->md_len = next_md_begin;
   }
   else {
@@ -3384,19 +3384,19 @@ int mad_layer_III(struct mad_stream *stream, struct mad_frame *frame)
 
       extra = si.main_data_begin - md_len;
       if (extra + frame_free > next_md_begin)
-        extra = next_md_begin - frame_free;
+    extra = next_md_begin - frame_free;
 
       if (extra < stream->md_len) {
-        memmove(*stream->main_data,
-                *stream->main_data + stream->md_len - extra, extra);
-        stream->md_len = extra;
+    memmove(*stream->main_data,
+        *stream->main_data + stream->md_len - extra, extra);
+    stream->md_len = extra;
       }
     }
     else
       stream->md_len = 0;
 
     memcpy(*stream->main_data + stream->md_len,
-           stream->next_frame - frame_free, frame_free);
+       stream->next_frame - frame_free, frame_free);
     stream->md_len += frame_free;
   }