Fix -Wshadow warnings.
authorErik de Castro Lopo <erikd@mega-nerd.com>
Sun, 10 Mar 2013 11:03:47 +0000 (22:03 +1100)
committerErik de Castro Lopo <erikd@mega-nerd.com>
Sun, 10 Mar 2013 19:06:34 +0000 (06:06 +1100)
src/flac/encode.c
src/flac/main.c
src/libFLAC/stream_encoder.c
src/metaflac/options.c
src/test_libFLAC++/decoders.cpp
src/test_libFLAC++/encoders.cpp

index 31cebb9..b2ae06a 100644 (file)
@@ -1725,7 +1725,7 @@ FLAC__bool EncoderSession_init_encoder(EncoderSession *e, encode_options_t optio
        FLAC__StreamMetadata padding;
        FLAC__StreamMetadata **metadata = 0;
        static_metadata_t static_metadata;
-       unsigned num_metadata = 0, i;
+       unsigned num_metadata = 0, ic;
        FLAC__StreamEncoderInitStatus init_status;
        const FLAC__bool is_cdda = (channels == 1 || channels == 2) && (bps == 16) && (sample_rate == 44100);
        char apodizations[2000];
@@ -1771,6 +1771,7 @@ FLAC__bool EncoderSession_init_encoder(EncoderSession *e, encode_options_t optio
                 * metadata as the basis for the encoded file
                 */
                {
+                       unsigned i;
                        /*
                         * first handle pictures: simple append any --pictures
                         * specified.
@@ -1992,6 +1993,7 @@ FLAC__bool EncoderSession_init_encoder(EncoderSession *e, encode_options_t optio
                 * from scratch
                 */
                const foreign_metadata_t *foreign_metadata = EncoderSession_format_is_iff(e)? options.format_options.iff.foreign_metadata : 0;
+               unsigned i;
 
                if(e->seek_table_template->data.seek_table.num_points > 0) {
                        e->seek_table_template->is_last = false; /* the encoder will set this for us */
@@ -2046,55 +2048,55 @@ FLAC__bool EncoderSession_init_encoder(EncoderSession *e, encode_options_t optio
        FLAC__stream_encoder_set_channels(e->encoder, channels);
        FLAC__stream_encoder_set_bits_per_sample(e->encoder, bps);
        FLAC__stream_encoder_set_sample_rate(e->encoder, sample_rate);
-       for(i = 0; i < options.num_compression_settings; i++) {
-               switch(options.compression_settings[i].type) {
+       for(ic = 0; ic < options.num_compression_settings; ic++) {
+               switch(options.compression_settings[ic].type) {
                        case CST_BLOCKSIZE:
-                               FLAC__stream_encoder_set_blocksize(e->encoder, options.compression_settings[i].value.t_unsigned);
+                               FLAC__stream_encoder_set_blocksize(e->encoder, options.compression_settings[ic].value.t_unsigned);
                                break;
                        case CST_COMPRESSION_LEVEL:
-                               FLAC__stream_encoder_set_compression_level(e->encoder, options.compression_settings[i].value.t_unsigned);
+                               FLAC__stream_encoder_set_compression_level(e->encoder, options.compression_settings[ic].value.t_unsigned);
                                apodizations[0] = '\0';
                                break;
                        case CST_DO_MID_SIDE:
-                               FLAC__stream_encoder_set_do_mid_side_stereo(e->encoder, options.compression_settings[i].value.t_bool);
+                               FLAC__stream_encoder_set_do_mid_side_stereo(e->encoder, options.compression_settings[ic].value.t_bool);
                                break;
                        case CST_LOOSE_MID_SIDE:
-                               FLAC__stream_encoder_set_loose_mid_side_stereo(e->encoder, options.compression_settings[i].value.t_bool);
+                               FLAC__stream_encoder_set_loose_mid_side_stereo(e->encoder, options.compression_settings[ic].value.t_bool);
                                break;
                        case CST_APODIZATION:
-                               if(strlen(apodizations)+strlen(options.compression_settings[i].value.t_string)+2 >= sizeof(apodizations)) {
+                               if(strlen(apodizations)+strlen(options.compression_settings[ic].value.t_string)+2 >= sizeof(apodizations)) {
                                        flac__utils_printf(stderr, 1, "%s: ERROR: too many apodization functions requested\n", e->inbasefilename);
                                        static_metadata_clear(&static_metadata);
                                        return false;
                                }
                                else {
-                                       strcat(apodizations, options.compression_settings[i].value.t_string);
+                                       strcat(apodizations, options.compression_settings[ic].value.t_string);
                                        strcat(apodizations, ";");
                                }
                                break;
                        case CST_MAX_LPC_ORDER:
-                               FLAC__stream_encoder_set_max_lpc_order(e->encoder, options.compression_settings[i].value.t_unsigned);
+                               FLAC__stream_encoder_set_max_lpc_order(e->encoder, options.compression_settings[ic].value.t_unsigned);
                                break;
                        case CST_QLP_COEFF_PRECISION:
-                               FLAC__stream_encoder_set_qlp_coeff_precision(e->encoder, options.compression_settings[i].value.t_unsigned);
+                               FLAC__stream_encoder_set_qlp_coeff_precision(e->encoder, options.compression_settings[ic].value.t_unsigned);
                                break;
                        case CST_DO_QLP_COEFF_PREC_SEARCH:
-                               FLAC__stream_encoder_set_do_qlp_coeff_prec_search(e->encoder, options.compression_settings[i].value.t_bool);
+                               FLAC__stream_encoder_set_do_qlp_coeff_prec_search(e->encoder, options.compression_settings[ic].value.t_bool);
                                break;
                        case CST_DO_ESCAPE_CODING:
-                               FLAC__stream_encoder_set_do_escape_coding(e->encoder, options.compression_settings[i].value.t_bool);
+                               FLAC__stream_encoder_set_do_escape_coding(e->encoder, options.compression_settings[ic].value.t_bool);
                                break;
                        case CST_DO_EXHAUSTIVE_MODEL_SEARCH:
-                               FLAC__stream_encoder_set_do_exhaustive_model_search(e->encoder, options.compression_settings[i].value.t_bool);
+                               FLAC__stream_encoder_set_do_exhaustive_model_search(e->encoder, options.compression_settings[ic].value.t_bool);
                                break;
                        case CST_MIN_RESIDUAL_PARTITION_ORDER:
-                               FLAC__stream_encoder_set_min_residual_partition_order(e->encoder, options.compression_settings[i].value.t_unsigned);
+                               FLAC__stream_encoder_set_min_residual_partition_order(e->encoder, options.compression_settings[ic].value.t_unsigned);
                                break;
                        case CST_MAX_RESIDUAL_PARTITION_ORDER:
-                               FLAC__stream_encoder_set_max_residual_partition_order(e->encoder, options.compression_settings[i].value.t_unsigned);
+                               FLAC__stream_encoder_set_max_residual_partition_order(e->encoder, options.compression_settings[ic].value.t_unsigned);
                                break;
                        case CST_RICE_PARAMETER_SEARCH_DIST:
-                               FLAC__stream_encoder_set_rice_parameter_search_dist(e->encoder, options.compression_settings[i].value.t_unsigned);
+                               FLAC__stream_encoder_set_rice_parameter_search_dist(e->encoder, options.compression_settings[ic].value.t_unsigned);
                                break;
                }
        }
index 27606e9..c96f93e 100644 (file)
@@ -646,8 +646,6 @@ int parse_options(int argc, char *argv[])
 int parse_option(int short_option, const char *long_option, const char *option_argument)
 {
        const char *violation;
-       char *p;
-       int i;
 
        if(short_option == 0) {
                FLAC__ASSERT(0 != long_option);
@@ -679,12 +677,12 @@ int parse_option(int short_option, const char *long_option, const char *option_a
                        FLAC__ASSERT(0 != option_argument);
                        {
                                char *end;
-                               FLAC__int64 i;
-                               i = strtoll(option_argument, &end, 10);
+                               FLAC__int64 ix;
+                               ix = strtoll(option_argument, &end, 10);
                                if(0 == strlen(option_argument) || *end)
                                        return usage_error("ERROR: --%s must be a number\n", long_option);
-                               option_values.format_input_size = (off_t)i;
-                               if(option_values.format_input_size != i) /* check if off_t is smaller than long long */
+                               option_values.format_input_size = (off_t)ix;
+                               if(option_values.format_input_size != ix) /* check if off_t is smaller than long long */
                                        return usage_error("ERROR: --%s too large; this build of flac does not support filesizes over 2GB\n", long_option);
                                if(option_values.format_input_size <= 0)
                                        return usage_error("ERROR: --%s must be > 0\n", long_option);
@@ -991,11 +989,14 @@ int parse_option(int short_option, const char *long_option, const char *option_a
                                        return usage_error("ERROR: argument to -%c must be >= 0; for no padding use -%c-\n", short_option, short_option);
                                break;
                        case 'b':
-                               FLAC__ASSERT(0 != option_argument);
-                               i = atoi(option_argument);
-                               if((i < (int)FLAC__MIN_BLOCK_SIZE || i > (int)FLAC__MAX_BLOCK_SIZE))
-                                       return usage_error("ERROR: invalid blocksize (-%c) '%d', must be >= %u and <= %u\n", short_option, i, FLAC__MIN_BLOCK_SIZE, FLAC__MAX_BLOCK_SIZE);
-                               add_compression_setting_unsigned(CST_BLOCKSIZE, (unsigned)i);
+                               {
+                                       unsigned i ;
+                                       FLAC__ASSERT(0 != option_argument);
+                                       i = atoi(option_argument);
+                                       if((i < (int)FLAC__MIN_BLOCK_SIZE || i > (int)FLAC__MAX_BLOCK_SIZE))
+                                               return usage_error("ERROR: invalid blocksize (-%c) '%d', must be >= %u and <= %u\n", short_option, i, FLAC__MIN_BLOCK_SIZE, FLAC__MAX_BLOCK_SIZE);
+                                       add_compression_setting_unsigned(CST_BLOCKSIZE, (unsigned)i);
+                               }
                                break;
                        case 'e':
                                add_compression_setting_bool(CST_DO_EXHAUSTIVE_MODEL_SEARCH, true);
@@ -1004,11 +1005,14 @@ int parse_option(int short_option, const char *long_option, const char *option_a
                                add_compression_setting_bool(CST_DO_ESCAPE_CODING, true);
                                break;
                        case 'l':
-                               FLAC__ASSERT(0 != option_argument);
-                               i = atoi(option_argument);
-                               if((i < 0 || i > (int)FLAC__MAX_LPC_ORDER))
-                                       return usage_error("ERROR: invalid LPC order (-%c) '%d', must be >= %u and <= %u\n", short_option, i, 0, FLAC__MAX_LPC_ORDER);
-                               add_compression_setting_unsigned(CST_MAX_LPC_ORDER, (unsigned)i);
+                               {
+                                       unsigned i ;
+                                       FLAC__ASSERT(0 != option_argument);
+                                       i = atoi(option_argument);
+                                       if(i > FLAC__MAX_LPC_ORDER)
+                                               return usage_error("ERROR: invalid LPC order (-%c) '%d', must be >= %u and <= %u\n", short_option, i, 0, FLAC__MAX_LPC_ORDER);
+                                       add_compression_setting_unsigned(CST_MAX_LPC_ORDER, i);
+                               }
                                break;
                        case 'A':
                                FLAC__ASSERT(0 != option_argument);
@@ -1026,38 +1030,46 @@ int parse_option(int short_option, const char *long_option, const char *option_a
                                add_compression_setting_bool(CST_DO_QLP_COEFF_PREC_SEARCH, true);
                                break;
                        case 'q':
-                               FLAC__ASSERT(0 != option_argument);
-                               i = atoi(option_argument);
-                               if(i < 0 || (i > 0 && (i < (int)FLAC__MIN_QLP_COEFF_PRECISION || i > (int)FLAC__MAX_QLP_COEFF_PRECISION)))
-                                       return usage_error("ERROR: invalid value '%d' for qlp coeff precision (-%c), must be 0 or between %u and %u, inclusive\n", i, short_option, FLAC__MIN_QLP_COEFF_PRECISION, FLAC__MAX_QLP_COEFF_PRECISION);
-                               add_compression_setting_unsigned(CST_QLP_COEFF_PRECISION, (unsigned)i);
-                               break;
-                       case 'r':
-                               FLAC__ASSERT(0 != option_argument);
-                               p = strchr(option_argument, ',');
-                               if(0 == p) {
-                                       add_compression_setting_unsigned(CST_MIN_RESIDUAL_PARTITION_ORDER, 0);
+                               {
+                                       unsigned i ;
+                                       FLAC__ASSERT(0 != option_argument);
                                        i = atoi(option_argument);
-                                       if(i < 0)
-                                               return usage_error("ERROR: invalid value '%d' for residual partition order (-%c), must be between 0 and %u, inclusive\n", i, short_option, FLAC__MAX_RICE_PARTITION_ORDER);
-                                       add_compression_setting_unsigned(CST_MAX_RESIDUAL_PARTITION_ORDER, (unsigned)i);
+                                       if((i > 0 && (i < FLAC__MIN_QLP_COEFF_PRECISION || i > FLAC__MAX_QLP_COEFF_PRECISION)))
+                                               return usage_error("ERROR: invalid value '%d' for qlp coeff precision (-%c), must be 0 or between %u and %u, inclusive\n", i, short_option, FLAC__MIN_QLP_COEFF_PRECISION, FLAC__MAX_QLP_COEFF_PRECISION);
+                                       add_compression_setting_unsigned(CST_QLP_COEFF_PRECISION, i);
                                }
-                               else {
-                                       i = atoi(option_argument);
-                                       if(i < 0)
-                                               return usage_error("ERROR: invalid value '%d' for min residual partition order (-%c), must be between 0 and %u, inclusive\n", i, short_option, FLAC__MAX_RICE_PARTITION_ORDER);
-                                       add_compression_setting_unsigned(CST_MIN_RESIDUAL_PARTITION_ORDER, (unsigned)i);
-                                       i = atoi(++p);
-                                       if(i < 0)
-                                               return usage_error("ERROR: invalid value '%d' for max residual partition order (-%c), must be between 0 and %u, inclusive\n", i, short_option, FLAC__MAX_RICE_PARTITION_ORDER);
-                                       add_compression_setting_unsigned(CST_MAX_RESIDUAL_PARTITION_ORDER, (unsigned)i);
+                               break;
+                       case 'r':
+                               {
+                                       unsigned i;
+                                       char * p;
+                                       FLAC__ASSERT(0 != option_argument);
+                                       p = strchr(option_argument, ',');
+                                       if(0 == p) {
+                                               add_compression_setting_unsigned(CST_MIN_RESIDUAL_PARTITION_ORDER, 0);
+                                               i = atoi(option_argument);
+                                               if(i > FLAC__MAX_RICE_PARTITION_ORDER)
+                                                       return usage_error("ERROR: invalid value '%d' for residual partition order (-%c), must be between 0 and %u, inclusive\n", i, short_option, FLAC__MAX_RICE_PARTITION_ORDER);
+                                               add_compression_setting_unsigned(CST_MAX_RESIDUAL_PARTITION_ORDER, i);
+                                       }
+                                       else {
+                                               i = atoi(option_argument);
+                                               if(i > FLAC__MAX_RICE_PARTITION_ORDER)
+                                                       return usage_error("ERROR: invalid value '%d' for min residual partition order (-%c), must be between 0 and %u, inclusive\n", i, short_option, FLAC__MAX_RICE_PARTITION_ORDER);
+                                               add_compression_setting_unsigned(CST_MIN_RESIDUAL_PARTITION_ORDER, i);
+                                               i = atoi(++p);
+                                               if(i > FLAC__MAX_RICE_PARTITION_ORDER)
+                                                       return usage_error("ERROR: invalid value '%d' for max residual partition order (-%c), must be between 0 and %u, inclusive\n", i, short_option, FLAC__MAX_RICE_PARTITION_ORDER);
+                                               add_compression_setting_unsigned(CST_MAX_RESIDUAL_PARTITION_ORDER, i);
+                                       }
                                }
                                break;
                        case 'R':
-                               i = atoi(option_argument);
-                               if(i < 0)
-                                       return usage_error("ERROR: invalid value '%d' for Rice parameter search distance (-%c), must be >= 0\n", i, short_option);
-                               add_compression_setting_unsigned(CST_RICE_PARAMETER_SEARCH_DIST, (unsigned)i);
+                               {
+                                       unsigned i;
+                                       i = atoi(option_argument);
+                                       add_compression_setting_unsigned(CST_RICE_PARAMETER_SEARCH_DIST, i);
+                               }
                                break;
                        default:
                                FLAC__ASSERT(0);
index 000b300..83849d4 100644 (file)
@@ -739,12 +739,12 @@ static FLAC__StreamEncoderInitStatus init_stream_internal_(
 #if FLAC__HAS_OGG
        /* reorder metadata if necessary to ensure that any VORBIS_COMMENT is the first, according to the mapping spec */
        if(is_ogg && 0 != encoder->protected_->metadata && encoder->protected_->num_metadata_blocks > 1) {
-               unsigned i;
-               for(i = 1; i < encoder->protected_->num_metadata_blocks; i++) {
-                       if(0 != encoder->protected_->metadata[i] && encoder->protected_->metadata[i]->type == FLAC__METADATA_TYPE_VORBIS_COMMENT) {
-                               FLAC__StreamMetadata *vc = encoder->protected_->metadata[i];
-                               for( ; i > 0; i--)
-                                       encoder->protected_->metadata[i] = encoder->protected_->metadata[i-1];
+               unsigned i1;
+               for(i1 = 1; i1 < encoder->protected_->num_metadata_blocks; i1++) {
+                       if(0 != encoder->protected_->metadata[i1] && encoder->protected_->metadata[i1]->type == FLAC__METADATA_TYPE_VORBIS_COMMENT) {
+                               FLAC__StreamMetadata *vc = encoder->protected_->metadata[i1];
+                               for( ; i1 > 0; i1--)
+                                       encoder->protected_->metadata[i1] = encoder->protected_->metadata[i1-1];
                                encoder->protected_->metadata[0] = vc;
                                break;
                        }
@@ -753,10 +753,10 @@ static FLAC__StreamEncoderInitStatus init_stream_internal_(
 #endif
        /* keep track of any SEEKTABLE block */
        if(0 != encoder->protected_->metadata && encoder->protected_->num_metadata_blocks > 0) {
-               unsigned i;
-               for(i = 0; i < encoder->protected_->num_metadata_blocks; i++) {
-                       if(0 != encoder->protected_->metadata[i] && encoder->protected_->metadata[i]->type == FLAC__METADATA_TYPE_SEEKTABLE) {
-                               encoder->private_->seek_table = &encoder->protected_->metadata[i]->data.seek_table;
+               unsigned i2;
+               for(i2 = 0; i2 < encoder->protected_->num_metadata_blocks; i2++) {
+                       if(0 != encoder->protected_->metadata[i2] && encoder->protected_->metadata[i2]->type == FLAC__METADATA_TYPE_SEEKTABLE) {
+                               encoder->private_->seek_table = &encoder->protected_->metadata[i2]->data.seek_table;
                                break; /* take only the first one */
                        }
                }
index 0fa5409..2ff4ce4 100644 (file)
@@ -581,7 +581,7 @@ FLAC__bool parse_option(int option_index, const char *option_argument, CommandLi
                }
        }
        else if(0 == strcmp(opt, "export-picture-to")) {
-               const Argument *arg = find_argument(options, ARG__BLOCK_NUMBER);
+               arg = find_argument(options, ARG__BLOCK_NUMBER);
                op = append_shorthand_operation(options, OP__EXPORT_PICTURE_TO);
                FLAC__ASSERT(0 != option_argument);
                if(!parse_string(option_argument, &(op->argument.export_picture_to.filename))) {
index e397af0..938c60b 100644 (file)
@@ -718,7 +718,7 @@ static bool test_stream_decoder(Layer layer, bool is_ogg)
 
        printf("testing finish()... ");
        if(!decoder->finish()) {
-               FLAC::Decoder::Stream::State state = decoder->get_state();
+               state = decoder->get_state();
                printf("FAILED, returned false, state = %u (%s)\n", (unsigned)((::FLAC__StreamDecoderState)state), state.as_cstring());
                return false;
        }
index f16e002..32cf513 100644 (file)
@@ -503,7 +503,7 @@ static bool test_stream_encoder(Layer layer, bool is_ogg)
 
        printf("testing finish()... ");
        if(!encoder->finish()) {
-               FLAC::Encoder::Stream::State state = encoder->get_state();
+               state = encoder->get_state();
                printf("FAILED, returned false, state = %u (%s)\n", (unsigned)((::FLAC__StreamEncoderState)state), state.as_cstring());
                return false;
        }