avcodec/mlpenc: use variables local to for loops

libavcodec/mlpenc.c

@@ -236,7 +236,6 @@ static int compare_filter_params(const ChannelParams *prev_cp, const ChannelPara
 {
     const FilterParams *prev = &prev_cp->filter_params[filter];
     const FilterParams *fp = &cp->filter_params[filter];
-    int i;
 
     if (prev->order != fp->order)
         return 1;
@@ -247,7 +246,7 @@ static int compare_filter_params(const ChannelParams *prev_cp, const ChannelPara
     if (prev->shift != fp->shift)
         return 1;
 
-    for (i = 0; i < fp->order; i++)
+    for (int i = 0; i < fp->order; i++)
         if (prev_cp->coeff[filter][i] != cp->coeff[filter][i])
             return 1;
 
@@ -260,7 +259,6 @@ static int compare_filter_params(const ChannelParams *prev_cp, const ChannelPara
 static int compare_matrix_params(MLPEncodeContext *ctx, const MatrixParams *prev, const MatrixParams *mp)
 {
     RestartHeader *rh = ctx->cur_restart_header;
-    unsigned int channel, mat;
 
     if (prev->count != mp->count)
         return 1;
@@ -268,15 +266,15 @@ static int compare_matrix_params(MLPEncodeContext *ctx, const MatrixParams *prev
     if (!prev->count)
         return 0;
 
-    for (channel = rh->min_channel; channel <= rh->max_channel; channel++)
+    for (unsigned int channel = rh->min_channel; channel <= rh->max_channel; channel++)
         if (prev->fbits[channel] != mp->fbits[channel])
             return 1;
 
-    for (mat = 0; mat < mp->count; mat++) {
+    for (unsigned int mat = 0; mat < mp->count; mat++) {
         if (prev->outch[mat] != mp->outch[mat])
             return 1;
 
-        for (channel = 0; channel < ctx->num_channels; channel++)
+        for (unsigned int channel = 0; channel < ctx->num_channels; channel++)
             if (prev->coeff[mat][channel] != mp->coeff[mat][channel])
                 return 1;
     }
@@ -294,7 +292,6 @@ static int compare_decoding_params(MLPEncodeContext *ctx)
     const MatrixParams *prev_mp = &prev->matrix_params;
     MatrixParams *mp = &dp->matrix_params;
     RestartHeader  *rh = ctx->cur_restart_header;
-    unsigned int ch;
     int retval = 0;
 
     if (prev->param_presence_flags != dp->param_presence_flags)
@@ -306,19 +303,19 @@ static int compare_decoding_params(MLPEncodeContext *ctx)
     if (compare_matrix_params(ctx, prev_mp, mp))
         retval |= PARAM_MATRIX;
 
-    for (ch = 0; ch <= rh->max_matrix_channel; ch++)
+    for (unsigned int ch = 0; ch <= rh->max_matrix_channel; ch++)
         if (prev_mp->shift[ch] != mp->shift[ch]) {
             retval |= PARAM_OUTSHIFT;
             break;
         }
 
-    for (ch = 0; ch <= rh->max_channel; ch++)
+    for (unsigned int ch = 0; ch <= rh->max_channel; ch++)
         if (prev->quant_step_size[ch] != dp->quant_step_size[ch]) {
             retval |= PARAM_QUANTSTEP;
             break;
         }
 
-    for (ch = rh->min_channel; ch <= rh->max_channel; ch++) {
+    for (unsigned int ch = rh->min_channel; ch <= rh->max_channel; ch++) {
         const ChannelParams *prev_cp = &ctx->prev_channel_params[ch];
         ChannelParams *cp = &ctx->cur_channel_params[ch];
 
@@ -345,7 +342,6 @@ static void copy_filter_params(ChannelParams *dst_cp, ChannelParams *src_cp, int
 {
     FilterParams *dst = &dst_cp->filter_params[filter];
     FilterParams *src = &src_cp->filter_params[filter];
-    unsigned int order;
 
     dst->order = src->order;
 
@@ -356,7 +352,7 @@ static void copy_filter_params(ChannelParams *dst_cp, ChannelParams *src_cp, int
         dst->coeff_bits = src->coeff_bits;
     }
 
-    for (order = 0; order < dst->order; order++)
+    for (unsigned int order = 0; order < dst->order; order++)
         dst_cp->coeff[filter][order] = src_cp->coeff[filter][order];
 }
 
@@ -365,18 +361,16 @@ static void copy_matrix_params(MatrixParams *dst, MatrixParams *src)
     dst->count = src->count;
 
     if (dst->count) {
-        unsigned int channel, count;
+        for (unsigned int channel = 0; channel < MAX_CHANNELS; channel++) {
-
-        for (channel = 0; channel < MAX_CHANNELS; channel++) {
 
             dst->fbits[channel] = src->fbits[channel];
             dst->shift[channel] = src->shift[channel];
 
-            for (count = 0; count < MAX_MATRICES; count++)
+            for (unsigned int count = 0; count < MAX_MATRICES; count++)
                 dst->coeff[count][channel] = src->coeff[count][channel];
         }
 
-        for (count = 0; count < MAX_MATRICES; count++)
+        for (unsigned int count = 0; count < MAX_MATRICES; count++)
             dst->outch[count] = src->outch[count];
     }
 }
@@ -384,23 +378,19 @@ static void copy_matrix_params(MatrixParams *dst, MatrixParams *src)
 static void copy_restart_frame_params(MLPEncodeContext *ctx,
                                       unsigned int substr)
 {
-    unsigned int index;
+    for (unsigned int index = 0; index < ctx->number_of_subblocks; index++) {
-
-    for (index = 0; index < ctx->number_of_subblocks; index++) {
         DecodingParams *dp = ctx->seq_decoding_params + index*(ctx->num_substreams) + substr;
-        unsigned int channel;
 
         copy_matrix_params(&dp->matrix_params, &ctx->cur_decoding_params->matrix_params);
 
-        for (channel = 0; channel < ctx->avctx->channels; channel++) {
+        for (unsigned int channel = 0; channel < ctx->avctx->channels; channel++) {
             ChannelParams *cp = ctx->seq_channel_params + index*(ctx->avctx->channels) + channel;
-            unsigned int filter;
 
             dp->quant_step_size[channel] = ctx->cur_decoding_params->quant_step_size[channel];
             dp->matrix_params.shift[channel] = ctx->cur_decoding_params->matrix_params.shift[channel];
 
             if (index)
-                for (filter = 0; filter < NUM_FILTERS; filter++)
+                for (unsigned int filter = 0; filter < NUM_FILTERS; filter++)
                     copy_filter_params(cp, &ctx->cur_channel_params[channel], filter);
         }
     }
@@ -439,11 +429,9 @@ static void clear_channel_params(ChannelParams channel_params[MAX_CHANNELS], int
 static void default_decoding_params(MLPEncodeContext *ctx,
      DecodingParams decoding_params[MAX_SUBSTREAMS])
 {
-    unsigned int substr;
-
     clear_decoding_params(decoding_params, ctx->num_substreams);
 
-    for (substr = 0; substr < ctx->num_substreams; substr++) {
+    for (unsigned int substr = 0; substr < ctx->num_substreams; substr++) {
         DecodingParams *dp = &decoding_params[substr];
         uint8_t param_presence_flags = 0;
 
@@ -495,7 +483,6 @@ static av_cold int mlp_encode_init(AVCodecContext *avctx)
 {
     static AVOnce init_static_once = AV_ONCE_INIT;
     MLPEncodeContext *ctx = avctx->priv_data;
-    unsigned int substr, index;
     unsigned int sum = 0;
     size_t size;
     int ret;
@@ -678,7 +665,7 @@ static av_cold int mlp_encode_init(AVCodecContext *avctx)
     if (!ctx->lossless_check_data)
         return AVERROR(ENOMEM);
 
-    for (index = 0; index < ctx->restart_intervals; index++) {
+    for (unsigned int index = 0; index < ctx->restart_intervals; index++) {
         ctx->seq_offset[index] = sum;
         ctx->seq_size  [index] = ((index + 1) * ctx->min_restart_interval) + 1;
         sum += ctx->seq_size[index];
@@ -694,7 +681,7 @@ static av_cold int mlp_encode_init(AVCodecContext *avctx)
     if (!ctx->decoding_params)
         return AVERROR(ENOMEM);
 
-    for (substr = 0; substr < ctx->num_substreams; substr++) {
+    for (unsigned int substr = 0; substr < ctx->num_substreams; substr++) {
         RestartHeader  *rh = &ctx->restart_header [substr];
 
         /* TODO see if noisegen_seed is really worth it. */
@@ -795,7 +782,6 @@ static void write_restart_header(MLPEncodeContext *ctx, PutBitContext *pb)
     unsigned int start_count = put_bits_count(pb);
     PutBitContext tmpb;
     uint8_t checksum;
-    unsigned int ch;
 
     put_bits(pb, 14, 0x31ea                ); /* TODO 0x31eb */
     put_bits(pb, 16, ctx->timestamp        );
@@ -812,7 +798,7 @@ static void write_restart_header(MLPEncodeContext *ctx, PutBitContext *pb)
     put_bits(pb,  8, lossless_check        );
     put_bits(pb, 16, 0                     ); /* ignored */
 
-    for (ch = 0; ch <= rh->max_matrix_channel; ch++)
+    for (unsigned int ch = 0; ch <= rh->max_matrix_channel; ch++)
         put_bits(pb, 6, ch);
 
     /* Data must be flushed for the checksum to be correct. */
@@ -829,18 +815,15 @@ static void write_matrix_params(MLPEncodeContext *ctx, PutBitContext *pb)
 {
     DecodingParams *dp = ctx->cur_decoding_params;
     MatrixParams *mp = &dp->matrix_params;
-    unsigned int mat;
 
     put_bits(pb, 4, mp->count);
 
-    for (mat = 0; mat < mp->count; mat++) {
+    for (unsigned int mat = 0; mat < mp->count; mat++) {
-        unsigned int channel;
-
         put_bits(pb, 4, mp->outch[mat]); /* matrix_out_ch */
         put_bits(pb, 4, mp->fbits[mat]);
         put_bits(pb, 1, 0             ); /* lsb_bypass */
 
-        for (channel = 0; channel < ctx->num_channels; channel++) {
+        for (unsigned int channel = 0; channel < ctx->num_channels; channel++) {
             int32_t coeff = mp->coeff[mat][channel];
 
             if (coeff) {
@@ -865,14 +848,13 @@ static void write_filter_params(MLPEncodeContext *ctx, PutBitContext *pb,
     put_bits(pb, 4, fp->order);
 
     if (fp->order > 0) {
-        int i;
         int32_t *fcoeff = ctx->cur_channel_params[channel].coeff[filter];
 
         put_bits(pb, 4, fp->shift      );
         put_bits(pb, 5, fp->coeff_bits );
         put_bits(pb, 3, fp->coeff_shift);
 
-        for (i = 0; i < fp->order; i++) {
+        for (int i = 0; i < fp->order; i++) {
             put_sbits(pb, fp->coeff_bits, fcoeff[i] >> fp->coeff_shift);
         }
 
@@ -890,7 +872,6 @@ static void write_decoding_params(MLPEncodeContext *ctx, PutBitContext *pb,
     DecodingParams *dp = ctx->cur_decoding_params;
     RestartHeader  *rh = ctx->cur_restart_header;
     MatrixParams *mp = &dp->matrix_params;
-    unsigned int ch;
 
     if (dp->param_presence_flags != PARAMS_DEFAULT &&
         params_changed & PARAM_PRESENCE_FLAGS) {
@@ -921,7 +902,7 @@ static void write_decoding_params(MLPEncodeContext *ctx, PutBitContext *pb,
     if (dp->param_presence_flags & PARAM_OUTSHIFT) {
         if (params_changed       & PARAM_OUTSHIFT) {
             put_bits(pb, 1, 1);
-            for (ch = 0; ch <= rh->max_matrix_channel; ch++)
+            for (unsigned int ch = 0; ch <= rh->max_matrix_channel; ch++)
                 put_sbits(pb, 4, mp->shift[ch]);
         } else {
             put_bits(pb, 1, 0);
@@ -931,14 +912,14 @@ static void write_decoding_params(MLPEncodeContext *ctx, PutBitContext *pb,
     if (dp->param_presence_flags & PARAM_QUANTSTEP) {
         if (params_changed       & PARAM_QUANTSTEP) {
             put_bits(pb, 1, 1);
-            for (ch = 0; ch <= rh->max_channel; ch++)
+            for (unsigned int ch = 0; ch <= rh->max_channel; ch++)
                 put_bits(pb, 4, dp->quant_step_size[ch]);
         } else {
             put_bits(pb, 1, 0);
         }
     }
 
-    for (ch = rh->min_channel; ch <= rh->max_channel; ch++) {
+    for (unsigned int ch = rh->min_channel; ch <= rh->max_channel; ch++) {
         ChannelParams *cp = &ctx->cur_channel_params[ch];
 
         if (dp->param_presence_flags & 0xF) {
@@ -993,9 +974,8 @@ static void write_block_data(MLPEncodeContext *ctx, PutBitContext *pb)
     int32_t sign_huff_offset[MAX_CHANNELS];
     int codebook_index      [MAX_CHANNELS];
     int lsb_bits            [MAX_CHANNELS];
-    unsigned int i, ch;
 
-    for (ch = rh->min_channel; ch <= rh->max_channel; ch++) {
+    for (unsigned int ch = rh->min_channel; ch <= rh->max_channel; ch++) {
         ChannelParams *cp = &ctx->cur_channel_params[ch];
         int sign_shift;
 
@@ -1013,8 +993,8 @@ static void write_block_data(MLPEncodeContext *ctx, PutBitContext *pb)
             sign_huff_offset[ch] -= 1 << sign_shift;
     }
 
-    for (i = 0; i < dp->blocksize; i++) {
+    for (unsigned int i = 0; i < dp->blocksize; i++) {
-        for (ch = rh->min_channel; ch <= rh->max_channel; ch++) {
+        for (unsigned int ch = rh->min_channel; ch <= rh->max_channel; ch++) {
             int32_t sample = *sample_buffer++ >> dp->quant_step_size[ch];
             sample -= sign_huff_offset[ch];
 
@@ -1038,15 +1018,13 @@ static uint8_t *write_substrs(MLPEncodeContext *ctx, uint8_t *buf, int buf_size,
                               uint16_t substream_data_len[MAX_SUBSTREAMS])
 {
     int32_t *lossless_check_data = ctx->lossless_check_data;
-    unsigned int substr;
     int end = 0;
 
     lossless_check_data += ctx->frame_index * ctx->num_substreams;
 
-    for (substr = 0; substr < ctx->num_substreams; substr++) {
+    for (unsigned int substr = 0; substr < ctx->num_substreams; substr++) {
         unsigned int cur_subblock_index = ctx->major_cur_subblock_index;
         unsigned int num_subblocks = ctx->major_filter_state_subblock;
-        unsigned int subblock;
         RestartHeader  *rh = &ctx->restart_header [substr];
         int substr_restart_frame = restart_frame;
         uint8_t parity, checksum;
@@ -1057,7 +1035,7 @@ static uint8_t *write_substrs(MLPEncodeContext *ctx, uint8_t *buf, int buf_size,
 
         init_put_bits(&pb, buf, buf_size);
 
-        for (subblock = 0; subblock <= num_subblocks; subblock++) {
+        for (unsigned int subblock = 0; subblock <= num_subblocks; subblock++) {
             unsigned int subblock_index;
 
             subblock_index = cur_subblock_index++;
@@ -1136,12 +1114,11 @@ static void write_frame_headers(MLPEncodeContext *ctx, uint8_t *frame_header,
 {
     uint16_t access_unit_header = 0;
     uint16_t parity_nibble = 0;
-    unsigned int substr;
 
     parity_nibble  = ctx->dts;
     parity_nibble ^= length;
 
-    for (substr = 0; substr < ctx->num_substreams; substr++) {
+    for (unsigned int substr = 0; substr < ctx->num_substreams; substr++) {
         uint16_t substr_hdr = 0;
 
         substr_hdr |= (0 << 15); /* extraword */
@@ -1173,7 +1150,6 @@ static int write_access_unit(MLPEncodeContext *ctx, uint8_t *buf,
 {
     uint16_t substream_data_len[MAX_SUBSTREAMS];
     uint8_t *buf1, *buf0 = buf;
-    unsigned int substr;
     int total_length;
 
     /* Frame header will be written at the end. */
@@ -1189,7 +1165,7 @@ static int write_access_unit(MLPEncodeContext *ctx, uint8_t *buf,
     buf1 = buf;
 
     /* Substream headers will be written at the end. */
-    for (substr = 0; substr < ctx->num_substreams; substr++) {
+    for (unsigned int substr = 0; substr < ctx->num_substreams; substr++) {
         buf      += 2;
         buf_size -= 2;
     }
@@ -1217,20 +1193,17 @@ static void input_data_internal(MLPEncodeContext *ctx, const uint8_t *samples,
     int32_t *lossless_check_data = ctx->lossless_check_data;
     const int32_t *samples_32 = (const int32_t *) samples;
     const int16_t *samples_16 = (const int16_t *) samples;
-    unsigned int substr;
 
     lossless_check_data += ctx->frame_index * ctx->num_substreams;
 
-    for (substr = 0; substr < ctx->num_substreams; substr++) {
+    for (unsigned int substr = 0; substr < ctx->num_substreams; substr++) {
         RestartHeader  *rh = &ctx->restart_header [substr];
         int32_t *sample_buffer = ctx->inout_buffer;
         int32_t temp_lossless_check_data = 0;
         uint32_t greatest = 0;
-        unsigned int channel;
-        int i;
 
-        for (i = 0; i < ctx->avctx->frame_size; i++) {
+        for (int i = 0; i < ctx->avctx->frame_size; i++) {
-            for (channel = 0; channel <= rh->max_channel; channel++) {
+            for (unsigned int channel = 0; channel <= rh->max_channel; channel++) {
                 uint32_t abs_sample;
                 int32_t sample;
 
@@ -1266,15 +1239,13 @@ static void input_data(MLPEncodeContext *ctx, void *samples)
 static void input_to_sample_buffer(MLPEncodeContext *ctx)
 {
     int32_t *sample_buffer = ctx->sample_buffer;
-    unsigned int index;
 
-    for (index = 0; index < ctx->number_of_frames; index++) {
+    for (unsigned int index = 0; index < ctx->number_of_frames; index++) {
         unsigned int cur_index = (ctx->starting_frame_index + index) % ctx->max_restart_interval;
         int32_t *input_buffer = ctx->inout_buffer + cur_index * ctx->one_sample_buffer_size;
-        unsigned int i, channel;
 
-        for (i = 0; i < ctx->avctx->frame_size; i++) {
+        for (unsigned int i = 0; i < ctx->avctx->frame_size; i++) {
-            for (channel = 0; channel < ctx->avctx->channels; channel++)
+            for (unsigned int channel = 0; channel < ctx->avctx->channels; channel++)
                 *sample_buffer++ = *input_buffer++;
             sample_buffer += 2; /* noise_channels */
             input_buffer += 2; /* noise_channels */
@@ -1309,19 +1280,17 @@ static void determine_quant_step_size(MLPEncodeContext *ctx)
     MatrixParams *mp = &dp->matrix_params;
     int32_t *sample_buffer = ctx->sample_buffer;
     int32_t sample_mask[MAX_CHANNELS];
-    unsigned int channel;
-    int i;
 
     memset(sample_mask, 0x00, sizeof(sample_mask));
 
-    for (i = 0; i < ctx->number_of_samples; i++) {
+    for (unsigned int i = 0; i < ctx->number_of_samples; i++) {
-        for (channel = 0; channel <= rh->max_channel; channel++)
+        for (unsigned int channel = 0; channel <= rh->max_channel; channel++)
             sample_mask[channel] |= *sample_buffer++;
 
         sample_buffer += 2; /* noise channels */
     }
 
-    for (channel = 0; channel <= rh->max_channel; channel++)
+    for (unsigned int channel = 0; channel <= rh->max_channel; channel++)
         dp->quant_step_size[channel] = number_trailing_zeroes(sample_mask[channel]) - mp->shift[channel];
 }
 
@@ -1334,9 +1303,8 @@ static void code_filter_coeffs(MLPEncodeContext *ctx, FilterParams *fp, int32_t
     int min = INT_MAX, max = INT_MIN;
     int bits, shift;
     int coeff_mask = 0;
-    int order;
 
-    for (order = 0; order < fp->order; order++) {
+    for (int order = 0; order < fp->order; order++) {
         int coeff = fcoeff[order];
 
         if (coeff < min)
@@ -1379,10 +1347,9 @@ static void set_filter_params(MLPEncodeContext *ctx,
         int32_t *lpc_samples = ctx->lpc_sample_buffer;
         int32_t *fcoeff = ctx->cur_channel_params[channel].coeff[filter];
         int shift[MLP_MAX_LPC_ORDER];
-        unsigned int i;
         int order;
 
-        for (i = 0; i < ctx->number_of_samples; i++) {
+        for (unsigned int i = 0; i < ctx->number_of_samples; i++) {
             *lpc_samples++ = *sample_buffer;
             sample_buffer += ctx->num_channels;
         }
@@ -1396,7 +1363,7 @@ static void set_filter_params(MLPEncodeContext *ctx,
         fp->order = order;
         fp->shift = shift[order-1];
 
-        for (i = 0; i < order; i++)
+        for (unsigned int i = 0; i < order; i++)
             fcoeff[i] = coefs[order-1][i];
 
         code_filter_coeffs(ctx, fp, fcoeff);
@@ -1410,10 +1377,9 @@ static void set_filter_params(MLPEncodeContext *ctx,
 static void determine_filters(MLPEncodeContext *ctx)
 {
     RestartHeader *rh = ctx->cur_restart_header;
-    int channel, filter;
 
-    for (channel = rh->min_channel; channel <= rh->max_channel; channel++) {
+    for (int channel = rh->min_channel; channel <= rh->max_channel; channel++) {
-        for (filter = 0; filter < NUM_FILTERS; filter++)
+        for (int filter = 0; filter < NUM_FILTERS; filter++)
             set_filter_params(ctx, channel, filter, 0);
     }
 }
@@ -1463,10 +1429,9 @@ static void code_matrix_coeffs(MLPEncodeContext *ctx, unsigned int mat)
     DecodingParams *dp = ctx->cur_decoding_params;
     MatrixParams *mp = &dp->matrix_params;
     int32_t coeff_mask = 0;
-    unsigned int channel;
     unsigned int bits;
 
-    for (channel = 0; channel < ctx->num_channels; channel++) {
+    for (unsigned int channel = 0; channel < ctx->num_channels; channel++) {
         int32_t coeff = mp->coeff[mat][channel];
         coeff_mask |= coeff;
     }
@@ -1482,8 +1447,6 @@ static void lossless_matrix_coeffs(MLPEncodeContext *ctx)
     DecodingParams *dp = ctx->cur_decoding_params;
     MatrixParams *mp = &dp->matrix_params;
     unsigned int shift = 0;
-    unsigned int channel;
-    int mat;
     enum MLPChMode mode;
 
     /* No decorrelation for non-stereo. */
@@ -1518,10 +1481,10 @@ static void lossless_matrix_coeffs(MLPEncodeContext *ctx)
         break;
     }
 
-    for (mat = 0; mat < mp->count; mat++)
+    for (int mat = 0; mat < mp->count; mat++)
         code_matrix_coeffs(ctx, mat);
 
-    for (channel = 0; channel < ctx->num_channels; channel++)
+    for (unsigned int channel = 0; channel < ctx->num_channels; channel++)
         mp->shift[channel] = shift;
 }
 
@@ -1620,7 +1583,6 @@ static inline void codebook_bits_offset(MLPEncodeContext *ctx,
     int lsb_bits = 0, bitcount = 0;
     int offset_min = INT_MAX, offset_max = INT_MAX;
     int unsign, mask;
-    int i;
 
     sample_min -= offset;
     sample_max -= offset;
@@ -1639,7 +1601,7 @@ static inline void codebook_bits_offset(MLPEncodeContext *ctx,
         lsb_bits++;
     }
 
-    for (i = 0; i < dp->blocksize; i++) {
+    for (int i = 0; i < dp->blocksize; i++) {
         int32_t sample = *sample_buffer >> dp->quant_step_size[channel];
         int temp_min, temp_max;
 
@@ -1714,19 +1676,17 @@ static void determine_bits(MLPEncodeContext *ctx)
 {
     DecodingParams *dp = ctx->cur_decoding_params;
     RestartHeader  *rh = ctx->cur_restart_header;
-    unsigned int channel;
 
-    for (channel = 0; channel <= rh->max_channel; channel++) {
+    for (unsigned int channel = 0; channel <= rh->max_channel; channel++) {
         ChannelParams *cp = &ctx->cur_channel_params[channel];
         int32_t *sample_buffer = ctx->sample_buffer + channel;
         int32_t min = INT32_MAX, max = INT32_MIN;
         int no_filters_used = !cp->filter_params[FIR].order;
         int average = 0;
         int offset = 0;
-        int i;
 
         /* Determine extremes and average. */
-        for (i = 0; i < dp->blocksize; i++) {
+        for (int i = 0; i < dp->blocksize; i++) {
             int32_t sample = *sample_buffer >> dp->quant_step_size[channel];
             if (sample < min)
                 min = sample;
@@ -1746,7 +1706,7 @@ static void determine_bits(MLPEncodeContext *ctx)
             no_codebook_bits_offset(ctx, channel, offset, min, max, &ctx->cur_best_offset[channel][0]);
         }
 
-        for (i = 1; i < NUM_CODEBOOKS; i++) {
+        for (int i = 1; i < NUM_CODEBOOKS; i++) {
             BestOffset temp_bo = { 0, INT_MAX, 0, 0, 0, };
             int16_t offset_max;
 
@@ -1790,25 +1750,23 @@ static int apply_filter(MLPEncodeContext *ctx, unsigned int channel)
     int32_t *sample_buffer = ctx->sample_buffer + channel;
     unsigned int number_of_samples = ctx->number_of_samples;
     unsigned int filter_shift = fp[FIR]->shift;
-    int filter;
+    int ret = 0;
-    int i, ret = 0;
 
-    for (i = 0; i < 8; i++) {
+    for (int i = 0; i < 8; i++) {
         ctx->filter_state_buffer[FIR][i] = *sample_buffer;
         ctx->filter_state_buffer[IIR][i] = *sample_buffer;
 
         sample_buffer += ctx->num_channels;
     }
 
-    for (i = 8; i < number_of_samples; i++) {
+    for (int i = 8; i < number_of_samples; i++) {
         int32_t sample = *sample_buffer;
-        unsigned int order;
         int64_t accum = 0;
         int64_t residual;
 
-        for (filter = 0; filter < NUM_FILTERS; filter++) {
+        for (int filter = 0; filter < NUM_FILTERS; filter++) {
             int32_t *fcoeff = ctx->cur_channel_params[channel].coeff[filter];
-            for (order = 0; order < fp[filter]->order; order++)
+            for (unsigned int order = 0; order < fp[filter]->order; order++)
                 accum += (int64_t)ctx->filter_state_buffer[filter][i - 1 - order] *
                          fcoeff[order];
         }
@@ -1828,7 +1786,7 @@ static int apply_filter(MLPEncodeContext *ctx, unsigned int channel)
     }
 
     sample_buffer = ctx->sample_buffer + channel;
-    for (i = 0; i < number_of_samples; i++) {
+    for (int i = 0; i < number_of_samples; i++) {
         *sample_buffer = ctx->filter_state_buffer[IIR][i];
 
         sample_buffer += ctx->num_channels;
@@ -1840,9 +1798,8 @@ static int apply_filter(MLPEncodeContext *ctx, unsigned int channel)
 static void apply_filters(MLPEncodeContext *ctx)
 {
     RestartHeader *rh = ctx->cur_restart_header;
-    int channel;
 
-    for (channel = rh->min_channel; channel <= rh->max_channel; channel++) {
+    for (int channel = rh->min_channel; channel <= rh->max_channel; channel++) {
         if (apply_filter(ctx, channel) < 0) {
             /* Filter is horribly wrong.
              * Clear filter params and update state. */
@@ -1858,10 +1815,9 @@ static void generate_2_noise_channels(MLPEncodeContext *ctx)
 {
     int32_t *sample_buffer = ctx->sample_buffer + ctx->num_channels - 2;
     RestartHeader *rh = ctx->cur_restart_header;
-    unsigned int i;
     uint32_t seed = rh->noisegen_seed;
 
-    for (i = 0; i < ctx->number_of_samples; i++) {
+    for (unsigned int i = 0; i < ctx->number_of_samples; i++) {
         uint16_t seed_shr7 = seed >> 7;
         *sample_buffer++ = ((int8_t)(seed >> 15)) * (1 << rh->noise_shift);
         *sample_buffer++ = ((int8_t) seed_shr7)   * (1 << rh->noise_shift);
@@ -1880,21 +1836,18 @@ static void rematrix_channels(MLPEncodeContext *ctx)
     DecodingParams *dp = ctx->cur_decoding_params;
     MatrixParams *mp = &dp->matrix_params;
     int32_t *sample_buffer = ctx->sample_buffer;
-    unsigned int mat, i, maxchan;
+    unsigned int maxchan = ctx->num_channels;
 
-    maxchan = ctx->num_channels;
+    for (unsigned int mat = 0; mat < mp->count; mat++) {
-
-    for (mat = 0; mat < mp->count; mat++) {
         unsigned int msb_mask_bits = (ctx->avctx->sample_fmt == AV_SAMPLE_FMT_S16 ? 8 : 0) - mp->shift[mat];
         int32_t mask = MSB_MASK(msb_mask_bits);
         unsigned int outch = mp->outch[mat];
 
         sample_buffer = ctx->sample_buffer;
-        for (i = 0; i < ctx->number_of_samples; i++) {
+        for (unsigned int i = 0; i < ctx->number_of_samples; i++) {
-            unsigned int src_ch;
             int64_t accum = 0;
 
-            for (src_ch = 0; src_ch < maxchan; src_ch++) {
+            for (unsigned int src_ch = 0; src_ch < maxchan; src_ch++) {
                 int32_t sample = *(sample_buffer + src_ch);
                 accum += (int64_t) sample * mp->forco[mat][src_ch];
             }
@@ -1950,29 +1903,25 @@ static void set_best_codebook(MLPEncodeContext *ctx)
 {
     DecodingParams *dp = ctx->cur_decoding_params;
     RestartHeader *rh = ctx->cur_restart_header;
-    unsigned int channel;
 
-    for (channel = rh->min_channel; channel <= rh->max_channel; channel++) {
+    for (unsigned int channel = rh->min_channel; channel <= rh->max_channel; channel++) {
         const BestOffset *prev_bo = restart_best_offset;
         BestOffset *cur_bo;
         PathCounter path_counter[NUM_CODEBOOKS + 1];
         unsigned int best_codebook;
-        unsigned int index;
         char *best_path;
 
         clear_path_counter(path_counter);
 
-        for (index = 0; index < ctx->number_of_subblocks; index++) {
+        for (unsigned int index = 0; index < ctx->number_of_subblocks; index++) {
             unsigned int best_bitcount = INT_MAX;
-            unsigned int codebook;
 
             cur_bo = ctx->best_offset[index][channel];
 
-            for (codebook = 0; codebook < NUM_CODEBOOKS; codebook++) {
+            for (unsigned int codebook = 0; codebook < NUM_CODEBOOKS; codebook++) {
                 int prev_best_bitcount = INT_MAX;
-                int last_best;
 
-                for (last_best = 0; last_best < 2; last_best++) {
+                for (unsigned int last_best = 0; last_best < 2; last_best++) {
                     PathCounter *dst_path = &path_counter[codebook];
                     PathCounter *src_path;
                     int  temp_bitcount;
@@ -2014,7 +1963,7 @@ static void set_best_codebook(MLPEncodeContext *ctx)
         best_path = path_counter[NUM_CODEBOOKS].path + 1;
 
         /* Update context. */
-        for (index = 0; index < ctx->number_of_subblocks; index++) {
+        for (unsigned int index = 0; index < ctx->number_of_subblocks; index++) {
             ChannelParams *cp = ctx->seq_channel_params + index*(ctx->avctx->channels) + channel;
 
             best_codebook = *best_path++;
@@ -2034,12 +1983,10 @@ static void set_best_codebook(MLPEncodeContext *ctx)
 static void set_major_params(MLPEncodeContext *ctx)
 {
     RestartHeader *rh = ctx->cur_restart_header;
-    unsigned int index;
-    unsigned int substr;
     uint8_t max_huff_lsbs = 0;
     uint8_t max_output_bits = 0;
 
-    for (substr = 0; substr < ctx->num_substreams; substr++) {
+    for (unsigned int substr = 0; substr < ctx->num_substreams; substr++) {
         DecodingParams *seq_dp = (DecodingParams *) ctx->decoding_params+
                                  (ctx->restart_intervals - 1)*(ctx->sequence_size)*(ctx->avctx->channels) +
                                  (ctx->seq_offset[ctx->restart_intervals - 1])*(ctx->avctx->channels);
@@ -2047,10 +1994,9 @@ static void set_major_params(MLPEncodeContext *ctx)
         ChannelParams *seq_cp = (ChannelParams *) ctx->channel_params +
                                 (ctx->restart_intervals - 1)*(ctx->sequence_size)*(ctx->avctx->channels) +
                                 (ctx->seq_offset[ctx->restart_intervals - 1])*(ctx->avctx->channels);
-        unsigned int channel;
+        for (unsigned int index = 0; index < ctx->seq_size[ctx->restart_intervals-1]; index++) {
-        for (index = 0; index < ctx->seq_size[ctx->restart_intervals-1]; index++) {
             memcpy(&ctx->major_decoding_params[index][substr], seq_dp + index*(ctx->num_substreams) + substr, sizeof(DecodingParams));
-            for (channel = 0; channel < ctx->avctx->channels; channel++) {
+            for (unsigned int channel = 0; channel < ctx->avctx->channels; channel++) {
                 uint8_t huff_lsbs = (seq_cp + index*(ctx->avctx->channels) + channel)->huff_lsbs;
                 if (max_huff_lsbs < huff_lsbs)
                     max_huff_lsbs = huff_lsbs;
@@ -2063,19 +2009,19 @@ static void set_major_params(MLPEncodeContext *ctx)
 
     rh->max_huff_lsbs = max_huff_lsbs;
 
-    for (index = 0; index < ctx->number_of_frames; index++)
+    for (unsigned int index = 0; index < ctx->number_of_frames; index++)
         if (max_output_bits < ctx->max_output_bits[index])
             max_output_bits = ctx->max_output_bits[index];
     rh->max_output_bits = max_output_bits;
 
-    for (substr = 0; substr < ctx->num_substreams; substr++) {
+    for (unsigned int substr = 0; substr < ctx->num_substreams; substr++) {
 
         ctx->cur_restart_header = &ctx->restart_header[substr];
 
         ctx->prev_decoding_params = &restart_decoding_params[substr];
         ctx->prev_channel_params = restart_channel_params;
 
-        for (index = 0; index < MAJOR_HEADER_INTERVAL + 1; index++) {
+        for (unsigned int index = 0; index < MAJOR_HEADER_INTERVAL + 1; index++) {
             ctx->cur_decoding_params = &ctx->major_decoding_params[index][substr];
             ctx->cur_channel_params = ctx->major_channel_params[index];
 
@@ -2095,10 +2041,8 @@ static void analyze_sample_buffer(MLPEncodeContext *ctx)
 {
     ChannelParams *seq_cp = ctx->seq_channel_params;
     DecodingParams *seq_dp = ctx->seq_decoding_params;
-    unsigned int index;
-    unsigned int substr;
 
-    for (substr = 0; substr < ctx->num_substreams; substr++) {
+    for (unsigned int substr = 0; substr < ctx->num_substreams; substr++) {
         ctx->cur_restart_header = &ctx->restart_header[substr];
         ctx->cur_decoding_params = seq_dp + 1*(ctx->num_substreams) + substr;
         ctx->cur_channel_params = seq_cp + 1*(ctx->avctx->channels);
@@ -2115,7 +2059,7 @@ static void analyze_sample_buffer(MLPEncodeContext *ctx)
         /* Copy frame_size from frames 0...max to decoding_params 1...max + 1
          * decoding_params[0] is for the filter state subblock.
          */
-        for (index = 0; index < ctx->number_of_frames; index++) {
+        for (unsigned int index = 0; index < ctx->number_of_frames; index++) {
             DecodingParams *dp = seq_dp + (index + 1)*(ctx->num_substreams) + substr;
             dp->blocksize = ctx->avctx->frame_size;
         }
@@ -2126,7 +2070,7 @@ static void analyze_sample_buffer(MLPEncodeContext *ctx)
         (seq_dp + substr)->blocksize  = 8;
         (seq_dp + 1*(ctx->num_substreams) + substr)->blocksize -= 8;
 
-        for (index = 0; index < ctx->number_of_subblocks; index++) {
+        for (unsigned int index = 0; index < ctx->number_of_subblocks; index++) {
                 ctx->cur_decoding_params = seq_dp + index*(ctx->num_substreams) + substr;
                 ctx->cur_channel_params = seq_cp + index*(ctx->avctx->channels);
                 ctx->cur_best_offset = ctx->best_offset[index];
@@ -2140,15 +2084,13 @@ static void analyze_sample_buffer(MLPEncodeContext *ctx)
 
 static void process_major_frame(MLPEncodeContext *ctx)
 {
-    unsigned int substr;
-
     ctx->sample_buffer = ctx->major_inout_buffer;
 
     ctx->starting_frame_index = 0;
     ctx->number_of_frames = ctx->major_number_of_frames;
     ctx->number_of_samples = ctx->major_frame_size;
 
-    for (substr = 0; substr < ctx->num_substreams; substr++) {
+    for (unsigned int substr = 0; substr < ctx->num_substreams; substr++) {
         ctx->cur_restart_header = &ctx->restart_header[substr];
 
         ctx->cur_decoding_params = &ctx->major_decoding_params[1][substr];
@@ -2229,13 +2171,10 @@ input_and_return:
     restart_frame = (ctx->frame_index + 1) % ctx->min_restart_interval;
 
     if (!restart_frame) {
-        int seq_index;
+        for (unsigned int seq_index = 0;
-
-        for (seq_index = 0;
              seq_index < ctx->restart_intervals && (seq_index * ctx->min_restart_interval) <= ctx->avctx->frame_number;
              seq_index++) {
             unsigned int number_of_samples;
-            unsigned int index;
 
             ctx->sample_buffer = ctx->major_scratch_buffer;
             ctx->inout_buffer = ctx->major_inout_buffer;
@@ -2257,7 +2196,7 @@ input_and_return:
             number_of_samples = avctx->frame_size * ctx->number_of_frames;
             ctx->number_of_samples = number_of_samples;
 
-            for (index = 0; index < ctx->seq_size[seq_index]; index++) {
+            for (unsigned int index = 0; index < ctx->seq_size[seq_index]; index++) {
                 clear_channel_params(ctx->seq_channel_params + index * ctx->avctx->channels, ctx->avctx->channels);
                 default_decoding_params(ctx, ctx->seq_decoding_params + index*(ctx->num_substreams));
             }