src/metaflac/options.c

   1 /* metaflac - Command-line FLAC metadata editor
   2  * Copyright (C) 2001,2002,2003,2004,2005,2006,2007  Josh Coalson
   3  *
   4  * This program is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU General Public License
   6  * as published by the Free Software Foundation; either version 2
   7  * of the License, or (at your option) any later version.
   8  *
   9  * This program is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12  * GNU General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU General Public License
  15  * along with this program; if not, write to the Free Software
  16  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
  17  */
  18
  19 #if HAVE_CONFIG_H
  20 #  include <config.h>
  21 #endif
  22
  23 #include "options.h"
  24 #include "usage.h"
  25 #include "utils.h"
  26 #include "FLAC/assert.h"
  27 #include "share/grabbag/replaygain.h"
  28 #include <ctype.h>
  29 #include <stdio.h>
  30 #include <stdlib.h>
  31 #include <string.h>
  32
  33 /*
  34    share__getopt format struct; note we don't use short options so we just
  35    set the 'val' field to 0 everywhere to indicate a valid option.
  36 */
  37 struct share__option long_options_[] = {
  38         /* global options */
  39         { "preserve-modtime", 0, 0, 0 },
  40         { "with-filename", 0, 0, 0 },
  41         { "no-filename", 0, 0, 0 },
  42         { "no-utf8-convert", 0, 0, 0 },
  43         { "dont-use-padding", 0, 0, 0 },
  44         { "no-cued-seekpoints", 0, 0, 0 },
  45         /* shorthand operations */
  46         { "show-md5sum", 0, 0, 0 },
  47         { "show-min-blocksize", 0, 0, 0 },
  48         { "show-max-blocksize", 0, 0, 0 },
  49         { "show-min-framesize", 0, 0, 0 },
  50         { "show-max-framesize", 0, 0, 0 },
  51         { "show-sample-rate", 0, 0, 0 },
  52         { "show-channels", 0, 0, 0 },
  53         { "show-bps", 0, 0, 0 },
  54         { "show-total-samples", 0, 0, 0 },
  55         { "set-md5sum", 1, 0, 0 }, /* undocumented */
  56         { "set-min-blocksize", 1, 0, 0 }, /* undocumented */
  57         { "set-max-blocksize", 1, 0, 0 }, /* undocumented */
  58         { "set-min-framesize", 1, 0, 0 }, /* undocumented */
  59         { "set-max-framesize", 1, 0, 0 }, /* undocumented */
  60         { "set-sample-rate", 1, 0, 0 }, /* undocumented */
  61         { "set-channels", 1, 0, 0 }, /* undocumented */
  62         { "set-bps", 1, 0, 0 }, /* undocumented */
  63         { "set-total-samples", 1, 0, 0 }, /* undocumented */ /* WATCHOUT: used by test/test_flac.sh on windows */
  64         { "show-vendor-tag", 0, 0, 0 },
  65         { "show-tag", 1, 0, 0 },
  66         { "remove-all-tags", 0, 0, 0 },
  67         { "remove-tag", 1, 0, 0 },
  68         { "remove-first-tag", 1, 0, 0 },
  69         { "set-tag", 1, 0, 0 },
  70         { "set-tag-from-file", 1, 0, 0 },
  71         { "import-tags-from", 1, 0, 0 },
  72         { "export-tags-to", 1, 0, 0 },
  73         { "import-cuesheet-from", 1, 0, 0 },
  74         { "export-cuesheet-to", 1, 0, 0 },
  75         { "import-picture-from", 1, 0, 0 },
  76         { "export-picture-to", 1, 0, 0 },
  77         { "add-seekpoint", 1, 0, 0 },
  78         { "add-replay-gain", 0, 0, 0 },
  79         { "remove-replay-gain", 0, 0, 0 },
  80         { "add-padding", 1, 0, 0 },
  81         /* major operations */
  82         { "help", 0, 0, 0 },
  83         { "version", 0, 0, 0 },
  84         { "list", 0, 0, 0 },
  85         { "append", 0, 0, 0 },
  86         { "remove", 0, 0, 0 },
  87         { "remove-all", 0, 0, 0 },
  88         { "merge-padding", 0, 0, 0 },
  89         { "sort-padding", 0, 0, 0 },
  90         /* major operation arguments */
  91         { "block-number", 1, 0, 0 },
  92         { "block-type", 1, 0, 0 },
  93         { "except-block-type", 1, 0, 0 },
  94         { "data-format", 1, 0, 0 },
  95         { "application-data-format", 1, 0, 0 },
  96         { "from-file", 1, 0, 0 },
  97         {0, 0, 0, 0}
  98 };
  99
 100 static FLAC__bool parse_option(int option_index, const char *option_argument, CommandLineOptions *options);
 101 static void append_new_operation(CommandLineOptions *options, Operation operation);
 102 static void append_new_argument(CommandLineOptions *options, Argument argument);
 103 static Operation *append_major_operation(CommandLineOptions *options, OperationType type);
 104 static Operation *append_shorthand_operation(CommandLineOptions *options, OperationType type);
 105 static Argument *find_argument(CommandLineOptions *options, ArgumentType type);
 106 static Operation *find_shorthand_operation(CommandLineOptions *options, OperationType type);
 107 static Argument *append_argument(CommandLineOptions *options, ArgumentType type);
 108 static FLAC__bool parse_md5(const char *src, FLAC__byte dest[16]);
 109 static FLAC__bool parse_uint32(const char *src, FLAC__uint32 *dest);
 110 static FLAC__bool parse_uint64(const char *src, FLAC__uint64 *dest);
 111 static FLAC__bool parse_string(const char *src, char **dest);
 112 static FLAC__bool parse_vorbis_comment_field_name(const char *field_ref, char **name, const char **violation);
 113 static FLAC__bool parse_add_seekpoint(const char *in, char **out, const char **violation);
 114 static FLAC__bool parse_add_padding(const char *in, unsigned *out);
 115 static FLAC__bool parse_block_number(const char *in, Argument_BlockNumber *out);
 116 static FLAC__bool parse_block_type(const char *in, Argument_BlockType *out);
 117 static FLAC__bool parse_data_format(const char *in, Argument_DataFormat *out);
 118 static FLAC__bool parse_application_data_format(const char *in, FLAC__bool *out);
 119 static void undocumented_warning(const char *opt);
 120
 121
 122 void init_options(CommandLineOptions *options)
 123 {
 124         options->preserve_modtime = false;
 125
 126         /* '2' is a hack to mean "use default if not forced on command line" */
 127         FLAC__ASSERT(true != 2);
 128         options->prefix_with_filename = 2;
 129
 130         options->utf8_convert = true;
 131         options->use_padding = true;
 132         options->cued_seekpoints = true;
 133         options->show_long_help = false;
 134         options->show_version = false;
 135         options->application_data_format_is_hexdump = false;
 136
 137         options->ops.operations = 0;
 138         options->ops.num_operations = 0;
 139         options->ops.capacity = 0;
 140
 141         options->args.arguments = 0;
 142         options->args.num_arguments = 0;
 143         options->args.capacity = 0;
 144
 145         options->args.checks.num_shorthand_ops = 0;
 146         options->args.checks.num_major_ops = 0;
 147         options->args.checks.has_block_type = false;
 148         options->args.checks.has_except_block_type = false;
 149
 150         options->num_files = 0;
 151         options->filenames = 0;
 152 }
 153
 154 FLAC__bool parse_options(int argc, char *argv[], CommandLineOptions *options)
 155 {
 156         int ret;
 157         int option_index = 1;
 158         FLAC__bool had_error = false;
 159
 160         while ((ret = share__getopt_long(argc, argv, "", long_options_, &option_index)) != -1) {
 161                 switch (ret) {
 162                         case 0:
 163                                 had_error |= !parse_option(option_index, share__optarg, options);
 164                                 break;
 165                         case '?':
 166                         case ':':
 167                                 had_error = true;
 168                                 break;
 169                         default:
 170                                 FLAC__ASSERT(0);
 171                                 break;
 172                 }
 173         }
 174
 175         if(options->prefix_with_filename == 2)
 176                 options->prefix_with_filename = (argc - share__optind > 1);
 177
 178         if(share__optind >= argc && !options->show_long_help && !options->show_version) {
 179                 fprintf(stderr,"ERROR: you must specify at least one FLAC file;\n");
 180                 fprintf(stderr,"       metaflac cannot be used as a pipe\n");
 181                 had_error = true;
 182         }
 183
 184         options->num_files = argc - share__optind;
 185
 186         if(options->num_files > 0) {
 187                 unsigned i = 0;
 188                 if(0 == (options->filenames = (char**)malloc(sizeof(char*) * options->num_files)))
 189                         die("out of memory allocating space for file names list");
 190                 while(share__optind < argc)
 191                         options->filenames[i++] = local_strdup(argv[share__optind++]);
 192         }
 193
 194         if(options->args.checks.num_major_ops > 0) {
 195                 if(options->args.checks.num_major_ops > 1) {
 196                         fprintf(stderr, "ERROR: you may only specify one major operation at a time\n");
 197                         had_error = true;
 198                 }
 199                 else if(options->args.checks.num_shorthand_ops > 0) {
 200                         fprintf(stderr, "ERROR: you may not mix shorthand and major operations\n");
 201                         had_error = true;
 202                 }
 203         }
 204
 205         /* check for only one FLAC file used with certain options */
 206         if(options->num_files > 1) {
 207                 if(0 != find_shorthand_operation(options, OP__IMPORT_CUESHEET_FROM)) {
 208                         fprintf(stderr, "ERROR: you may only specify one FLAC file when using '--import-cuesheet-from'\n");
 209                         had_error = true;
 210                 }
 211                 if(0 != find_shorthand_operation(options, OP__EXPORT_CUESHEET_TO)) {
 212                         fprintf(stderr, "ERROR: you may only specify one FLAC file when using '--export-cuesheet-to'\n");
 213                         had_error = true;
 214                 }
 215                 if(0 != find_shorthand_operation(options, OP__EXPORT_PICTURE_TO)) {
 216                         fprintf(stderr, "ERROR: you may only specify one FLAC file when using '--export-picture-to'\n");
 217                         had_error = true;
 218                 }
 219                 if(
 220                         0 != find_shorthand_operation(options, OP__IMPORT_VC_FROM) &&
 221                         0 == strcmp(find_shorthand_operation(options, OP__IMPORT_VC_FROM)->argument.filename.value, "-")
 222                 ) {
 223                         fprintf(stderr, "ERROR: you may only specify one FLAC file when using '--import-tags-from=-'\n");
 224                         had_error = true;
 225                 }
 226         }
 227
 228         if(options->args.checks.has_block_type && options->args.checks.has_except_block_type) {
 229                 fprintf(stderr, "ERROR: you may not specify both '--block-type' and '--except-block-type'\n");
 230                 had_error = true;
 231         }
 232
 233         if(had_error)
 234                 short_usage(0);
 235
 236         /*
 237          * We need to create an OP__ADD_SEEKPOINT operation if there is
 238          * not one already,  and --import-cuesheet-from was specified but
 239          * --no-cued-seekpoints was not:
 240          */
 241         if(options->cued_seekpoints) {
 242                 Operation *op = find_shorthand_operation(options, OP__IMPORT_CUESHEET_FROM);
 243                 if(0 != op) {
 244                         Operation *op2 = find_shorthand_operation(options, OP__ADD_SEEKPOINT);
 245                         if(0 == op2)
 246                                 op2 = append_shorthand_operation(options, OP__ADD_SEEKPOINT);
 247                         op->argument.import_cuesheet_from.add_seekpoint_link = &(op2->argument.add_seekpoint);
 248                 }
 249         }
 250
 251         return !had_error;
 252 }
 253
 254 void free_options(CommandLineOptions *options)
 255 {
 256         unsigned i;
 257         Operation *op;
 258         Argument *arg;
 259
 260         FLAC__ASSERT(0 == options->ops.operations || options->ops.num_operations > 0);
 261         FLAC__ASSERT(0 == options->args.arguments || options->args.num_arguments > 0);
 262
 263         for(i = 0, op = options->ops.operations; i < options->ops.num_operations; i++, op++) {
 264                 switch(op->type) {
 265                         case OP__SHOW_VC_FIELD:
 266                         case OP__REMOVE_VC_FIELD:
 267                         case OP__REMOVE_VC_FIRSTFIELD:
 268                                 if(0 != op->argument.vc_field_name.value)
 269                                         free(op->argument.vc_field_name.value);
 270                                 break;
 271                         case OP__SET_VC_FIELD:
 272                                 if(0 != op->argument.vc_field.field)
 273                                         free(op->argument.vc_field.field);
 274                                 if(0 != op->argument.vc_field.field_name)
 275                                         free(op->argument.vc_field.field_name);
 276                                 if(0 != op->argument.vc_field.field_value)
 277                                         free(op->argument.vc_field.field_value);
 278                                 break;
 279                         case OP__IMPORT_VC_FROM:
 280                         case OP__EXPORT_VC_TO:
 281                         case OP__EXPORT_CUESHEET_TO:
 282                                 if(0 != op->argument.filename.value)
 283                                         free(op->argument.filename.value);
 284                                 break;
 285                         case OP__IMPORT_CUESHEET_FROM:
 286                                 if(0 != op->argument.import_cuesheet_from.filename)
 287                                         free(op->argument.import_cuesheet_from.filename);
 288                                 break;
 289                         case OP__IMPORT_PICTURE_FROM:
 290                                 if(0 != op->argument.specification.value)
 291                                         free(op->argument.specification.value);
 292                                 break;
 293                         case OP__EXPORT_PICTURE_TO:
 294                                 if(0 != op->argument.export_picture_to.filename)
 295                                         free(op->argument.export_picture_to.filename);
 296                                 break;
 297                         case OP__ADD_SEEKPOINT:
 298                                 if(0 != op->argument.add_seekpoint.specification)
 299                                         free(op->argument.add_seekpoint.specification);
 300                                 break;
 301                         default:
 302                                 break;
 303                 }
 304         }
 305
 306         for(i = 0, arg = options->args.arguments; i < options->args.num_arguments; i++, arg++) {
 307                 switch(arg->type) {
 308                         case ARG__BLOCK_NUMBER:
 309                                 if(0 != arg->value.block_number.entries)
 310                                         free(arg->value.block_number.entries);
 311                                 break;
 312                         case ARG__BLOCK_TYPE:
 313                         case ARG__EXCEPT_BLOCK_TYPE:
 314                                 if(0 != arg->value.block_type.entries)
 315                                         free(arg->value.block_type.entries);
 316                                 break;
 317                         case ARG__FROM_FILE:
 318                                 if(0 != arg->value.from_file.file_name)
 319                                         free(arg->value.from_file.file_name);
 320                                 break;
 321                         default:
 322                                 break;
 323                 }
 324         }
 325
 326         if(0 != options->ops.operations)
 327                 free(options->ops.operations);
 328
 329         if(0 != options->args.arguments)
 330                 free(options->args.arguments);
 331
 332         if(0 != options->filenames) {
 333                 for(i = 0; i < options->num_files; i++) {
 334                         if(0 != options->filenames[i])
 335                                 free(options->filenames[i]);
 336                 }
 337                 free(options->filenames);
 338         }
 339 }
 340
 341 /*
 342  * local routines
 343  */
 344
 345 FLAC__bool parse_option(int option_index, const char *option_argument, CommandLineOptions *options)
 346 {
 347         const char *opt = long_options_[option_index].name;
 348         Operation *op;
 349         Argument *arg;
 350         FLAC__bool ok = true;
 351
 352         if(0 == strcmp(opt, "preserve-modtime")) {
 353                 options->preserve_modtime = true;
 354         }
 355         else if(0 == strcmp(opt, "with-filename")) {
 356                 options->prefix_with_filename = true;
 357         }
 358         else if(0 == strcmp(opt, "no-filename")) {
 359                 options->prefix_with_filename = false;
 360         }
 361         else if(0 == strcmp(opt, "no-utf8-convert")) {
 362                 options->utf8_convert = false;
 363         }
 364         else if(0 == strcmp(opt, "dont-use-padding")) {
 365                 options->use_padding = false;
 366         }
 367         else if(0 == strcmp(opt, "no-cued-seekpoints")) {
 368                 options->cued_seekpoints = false;
 369         }
 370         else if(0 == strcmp(opt, "show-md5sum")) {
 371                 (void) append_shorthand_operation(options, OP__SHOW_MD5SUM);
 372         }
 373         else if(0 == strcmp(opt, "show-min-blocksize")) {
 374                 (void) append_shorthand_operation(options, OP__SHOW_MIN_BLOCKSIZE);
 375         }
 376         else if(0 == strcmp(opt, "show-max-blocksize")) {
 377                 (void) append_shorthand_operation(options, OP__SHOW_MAX_BLOCKSIZE);
 378         }
 379         else if(0 == strcmp(opt, "show-min-framesize")) {
 380                 (void) append_shorthand_operation(options, OP__SHOW_MIN_FRAMESIZE);
 381         }
 382         else if(0 == strcmp(opt, "show-max-framesize")) {
 383                 (void) append_shorthand_operation(options, OP__SHOW_MAX_FRAMESIZE);
 384         }
 385         else if(0 == strcmp(opt, "show-sample-rate")) {
 386                 (void) append_shorthand_operation(options, OP__SHOW_SAMPLE_RATE);
 387         }
 388         else if(0 == strcmp(opt, "show-channels")) {
 389                 (void) append_shorthand_operation(options, OP__SHOW_CHANNELS);
 390         }
 391         else if(0 == strcmp(opt, "show-bps")) {
 392                 (void) append_shorthand_operation(options, OP__SHOW_BPS);
 393         }
 394         else if(0 == strcmp(opt, "show-total-samples")) {
 395                 (void) append_shorthand_operation(options, OP__SHOW_TOTAL_SAMPLES);
 396         }
 397         else if(0 == strcmp(opt, "set-md5sum")) {
 398                 op = append_shorthand_operation(options, OP__SET_MD5SUM);
 399                 FLAC__ASSERT(0 != option_argument);
 400                 if(!parse_md5(option_argument, op->argument.streaminfo_md5.value)) {
 401                         fprintf(stderr, "ERROR (--%s): bad MD5 sum\n", opt);
 402                         ok = false;
 403                 }
 404                 else
 405                         undocumented_warning(opt);
 406         }
 407         else if(0 == strcmp(opt, "set-min-blocksize")) {
 408                 op = append_shorthand_operation(options, OP__SET_MIN_BLOCKSIZE);
 409                 if(!parse_uint32(option_argument, &(op->argument.streaminfo_uint32.value)) || op->argument.streaminfo_uint32.value < FLAC__MIN_BLOCK_SIZE || op->argument.streaminfo_uint32.value > FLAC__MAX_BLOCK_SIZE) {
 410                         fprintf(stderr, "ERROR (--%s): value must be >= %u and <= %u\n", opt, FLAC__MIN_BLOCK_SIZE, FLAC__MAX_BLOCK_SIZE);
 411                         ok = false;
 412                 }
 413                 else
 414                         undocumented_warning(opt);
 415         }
 416         else if(0 == strcmp(opt, "set-max-blocksize")) {
 417                 op = append_shorthand_operation(options, OP__SET_MAX_BLOCKSIZE);
 418                 if(!parse_uint32(option_argument, &(op->argument.streaminfo_uint32.value)) || op->argument.streaminfo_uint32.value < FLAC__MIN_BLOCK_SIZE || op->argument.streaminfo_uint32.value > FLAC__MAX_BLOCK_SIZE) {
 419                         fprintf(stderr, "ERROR (--%s): value must be >= %u and <= %u\n", opt, FLAC__MIN_BLOCK_SIZE, FLAC__MAX_BLOCK_SIZE);
 420                         ok = false;
 421                 }
 422                 else
 423                         undocumented_warning(opt);
 424         }
 425         else if(0 == strcmp(opt, "set-min-framesize")) {
 426                 op = append_shorthand_operation(options, OP__SET_MIN_FRAMESIZE);
 427                 if(!parse_uint32(option_argument, &(op->argument.streaminfo_uint32.value)) || op->argument.streaminfo_uint32.value >= (1u<<FLAC__STREAM_METADATA_STREAMINFO_MIN_FRAME_SIZE_LEN)) {
 428                         fprintf(stderr, "ERROR (--%s): value must be a %u-bit unsigned integer\n", opt, FLAC__STREAM_METADATA_STREAMINFO_MIN_FRAME_SIZE_LEN);
 429                         ok = false;
 430                 }
 431                 else
 432                         undocumented_warning(opt);
 433         }
 434         else if(0 == strcmp(opt, "set-max-framesize")) {
 435                 op = append_shorthand_operation(options, OP__SET_MAX_FRAMESIZE);
 436                 if(!parse_uint32(option_argument, &(op->argument.streaminfo_uint32.value)) || op->argument.streaminfo_uint32.value >= (1u<<FLAC__STREAM_METADATA_STREAMINFO_MAX_FRAME_SIZE_LEN)) {
 437                         fprintf(stderr, "ERROR (--%s): value must be a %u-bit unsigned integer\n", opt, FLAC__STREAM_METADATA_STREAMINFO_MAX_FRAME_SIZE_LEN);
 438                         ok = false;
 439                 }
 440                 else
 441                         undocumented_warning(opt);
 442         }
 443         else if(0 == strcmp(opt, "set-sample-rate")) {
 444                 op = append_shorthand_operation(options, OP__SET_SAMPLE_RATE);
 445                 if(!parse_uint32(option_argument, &(op->argument.streaminfo_uint32.value)) || !FLAC__format_sample_rate_is_valid(op->argument.streaminfo_uint32.value)) {
 446                         fprintf(stderr, "ERROR (--%s): invalid sample rate\n", opt);
 447                         ok = false;
 448                 }
 449                 else
 450                         undocumented_warning(opt);
 451         }
 452         else if(0 == strcmp(opt, "set-channels")) {
 453                 op = append_shorthand_operation(options, OP__SET_CHANNELS);
 454                 if(!parse_uint32(option_argument, &(op->argument.streaminfo_uint32.value)) || op->argument.streaminfo_uint32.value > FLAC__MAX_CHANNELS) {
 455                         fprintf(stderr, "ERROR (--%s): value must be > 0 and <= %u\n", opt, FLAC__MAX_CHANNELS);
 456                         ok = false;
 457                 }
 458                 else
 459                         undocumented_warning(opt);
 460         }
 461         else if(0 == strcmp(opt, "set-bps")) {
 462                 op = append_shorthand_operation(options, OP__SET_BPS);
 463                 if(!parse_uint32(option_argument, &(op->argument.streaminfo_uint32.value)) || op->argument.streaminfo_uint32.value < FLAC__MIN_BITS_PER_SAMPLE || op->argument.streaminfo_uint32.value > FLAC__MAX_BITS_PER_SAMPLE) {
 464                         fprintf(stderr, "ERROR (--%s): value must be >= %u and <= %u\n", opt, FLAC__MIN_BITS_PER_SAMPLE, FLAC__MAX_BITS_PER_SAMPLE);
 465                         ok = false;
 466                 }
 467                 else
 468                         undocumented_warning(opt);
 469         }
 470         else if(0 == strcmp(opt, "set-total-samples")) {
 471                 op = append_shorthand_operation(options, OP__SET_TOTAL_SAMPLES);
 472                 if(!parse_uint64(option_argument, &(op->argument.streaminfo_uint64.value)) || op->argument.streaminfo_uint64.value >= (((FLAC__uint64)1)<<FLAC__STREAM_METADATA_STREAMINFO_TOTAL_SAMPLES_LEN)) {
 473                         fprintf(stderr, "ERROR (--%s): value must be a %u-bit unsigned integer\n", opt, FLAC__STREAM_METADATA_STREAMINFO_TOTAL_SAMPLES_LEN);
 474                         ok = false;
 475                 }
 476                 else
 477                         undocumented_warning(opt);
 478         }
 479         else if(0 == strcmp(opt, "show-vendor-tag")) {
 480                 (void) append_shorthand_operation(options, OP__SHOW_VC_VENDOR);
 481         }
 482         else if(0 == strcmp(opt, "show-tag")) {
 483                 const char *violation;
 484                 op = append_shorthand_operation(options, OP__SHOW_VC_FIELD);
 485                 FLAC__ASSERT(0 != option_argument);
 486                 if(!parse_vorbis_comment_field_name(option_argument, &(op->argument.vc_field_name.value), &violation)) {
 487                         FLAC__ASSERT(0 != violation);
 488                         fprintf(stderr, "ERROR (--%s): malformed vorbis comment field name \"%s\",\n       %s\n", opt, option_argument, violation);
 489                         ok = false;
 490                 }
 491         }
 492         else if(0 == strcmp(opt, "remove-all-tags")) {
 493                 (void) append_shorthand_operation(options, OP__REMOVE_VC_ALL);
 494         }
 495         else if(0 == strcmp(opt, "remove-tag")) {
 496                 const char *violation;
 497                 op = append_shorthand_operation(options, OP__REMOVE_VC_FIELD);
 498                 FLAC__ASSERT(0 != option_argument);
 499                 if(!parse_vorbis_comment_field_name(option_argument, &(op->argument.vc_field_name.value), &violation)) {
 500                         FLAC__ASSERT(0 != violation);
 501                         fprintf(stderr, "ERROR (--%s): malformed vorbis comment field name \"%s\",\n       %s\n", opt, option_argument, violation);
 502                         ok = false;
 503                 }
 504         }
 505         else if(0 == strcmp(opt, "remove-first-tag")) {
 506                 const char *violation;
 507                 op = append_shorthand_operation(options, OP__REMOVE_VC_FIRSTFIELD);
 508                 FLAC__ASSERT(0 != option_argument);
 509                 if(!parse_vorbis_comment_field_name(option_argument, &(op->argument.vc_field_name.value), &violation)) {
 510                         FLAC__ASSERT(0 != violation);
 511                         fprintf(stderr, "ERROR (--%s): malformed vorbis comment field name \"%s\",\n       %s\n", opt, option_argument, violation);
 512                         ok = false;
 513                 }
 514         }
 515         else if(0 == strcmp(opt, "set-tag")) {
 516                 const char *violation;
 517                 op = append_shorthand_operation(options, OP__SET_VC_FIELD);
 518                 FLAC__ASSERT(0 != option_argument);
 519                 op->argument.vc_field.field_value_from_file = false;
 520                 if(!parse_vorbis_comment_field(option_argument, &(op->argument.vc_field.field), &(op->argument.vc_field.field_name), &(op->argument.vc_field.field_value), &(op->argument.vc_field.field_value_length), &violation)) {
 521                         FLAC__ASSERT(0 != violation);
 522                         fprintf(stderr, "ERROR (--%s): malformed vorbis comment field \"%s\",\n       %s\n", opt, option_argument, violation);
 523                         ok = false;
 524                 }
 525         }
 526         else if(0 == strcmp(opt, "set-tag-from-file")) {
 527                 const char *violation;
 528                 op = append_shorthand_operation(options, OP__SET_VC_FIELD);
 529                 FLAC__ASSERT(0 != option_argument);
 530                 op->argument.vc_field.field_value_from_file = true;
 531                 if(!parse_vorbis_comment_field(option_argument, &(op->argument.vc_field.field), &(op->argument.vc_field.field_name), &(op->argument.vc_field.field_value), &(op->argument.vc_field.field_value_length), &violation)) {
 532                         FLAC__ASSERT(0 != violation);
 533                         fprintf(stderr, "ERROR (--%s): malformed vorbis comment field \"%s\",\n       %s\n", opt, option_argument, violation);
 534                         ok = false;
 535                 }
 536         }
 537         else if(0 == strcmp(opt, "import-tags-from")) {
 538                 op = append_shorthand_operation(options, OP__IMPORT_VC_FROM);
 539                 FLAC__ASSERT(0 != option_argument);
 540                 if(!parse_string(option_argument, &(op->argument.filename.value))) {
 541                         fprintf(stderr, "ERROR (--%s): missing filename\n", opt);
 542                         ok = false;
 543                 }
 544         }
 545         else if(0 == strcmp(opt, "export-tags-to")) {
 546                 op = append_shorthand_operation(options, OP__EXPORT_VC_TO);
 547                 FLAC__ASSERT(0 != option_argument);
 548                 if(!parse_string(option_argument, &(op->argument.filename.value))) {
 549                         fprintf(stderr, "ERROR (--%s): missing filename\n", opt);
 550                         ok = false;
 551                 }
 552         }
 553         else if(0 == strcmp(opt, "import-cuesheet-from")) {
 554                 if(0 != find_shorthand_operation(options, OP__IMPORT_CUESHEET_FROM)) {
 555                         fprintf(stderr, "ERROR (--%s): may be specified only once\n", opt);
 556                         ok = false;
 557                 }
 558                 op = append_shorthand_operation(options, OP__IMPORT_CUESHEET_FROM);
 559                 FLAC__ASSERT(0 != option_argument);
 560                 if(!parse_string(option_argument, &(op->argument.import_cuesheet_from.filename))) {
 561                         fprintf(stderr, "ERROR (--%s): missing filename\n", opt);
 562                         ok = false;
 563                 }
 564         }
 565         else if(0 == strcmp(opt, "export-cuesheet-to")) {
 566                 op = append_shorthand_operation(options, OP__EXPORT_CUESHEET_TO);
 567                 FLAC__ASSERT(0 != option_argument);
 568                 if(!parse_string(option_argument, &(op->argument.filename.value))) {
 569                         fprintf(stderr, "ERROR (--%s): missing filename\n", opt);
 570                         ok = false;
 571                 }
 572         }
 573         else if(0 == strcmp(opt, "import-picture-from")) {
 574                 op = append_shorthand_operation(options, OP__IMPORT_PICTURE_FROM);
 575                 FLAC__ASSERT(0 != option_argument);
 576                 if(!parse_string(option_argument, &(op->argument.specification.value))) {
 577                         fprintf(stderr, "ERROR (--%s): missing specification\n", opt);
 578                         ok = false;
 579                 }
 580         }
 581         else if(0 == strcmp(opt, "export-picture-to")) {
 582                 const Argument *arg = find_argument(options, ARG__BLOCK_NUMBER);
 583                 op = append_shorthand_operation(options, OP__EXPORT_PICTURE_TO);
 584                 FLAC__ASSERT(0 != option_argument);
 585                 if(!parse_string(option_argument, &(op->argument.export_picture_to.filename))) {
 586                         fprintf(stderr, "ERROR (--%s): missing filename\n", opt);
 587                         ok = false;
 588                 }
 589                 op->argument.export_picture_to.block_number_link = arg? &(arg->value.block_number) : 0;
 590         }
 591         else if(0 == strcmp(opt, "add-seekpoint")) {
 592                 const char *violation;
 593                 char *spec;
 594                 FLAC__ASSERT(0 != option_argument);
 595                 if(!parse_add_seekpoint(option_argument, &spec, &violation)) {
 596                         FLAC__ASSERT(0 != violation);
 597                         fprintf(stderr, "ERROR (--%s): malformed seekpoint specification \"%s\",\n       %s\n", opt, option_argument, violation);
 598                         ok = false;
 599                 }
 600                 else {
 601                         op = find_shorthand_operation(options, OP__ADD_SEEKPOINT);
 602                         if(0 == op)
 603                                 op = append_shorthand_operation(options, OP__ADD_SEEKPOINT);
 604                         local_strcat(&(op->argument.add_seekpoint.specification), spec);
 605                         local_strcat(&(op->argument.add_seekpoint.specification), ";");
 606                         free(spec);
 607                 }
 608         }
 609         else if(0 == strcmp(opt, "add-replay-gain")) {
 610                 (void) append_shorthand_operation(options, OP__ADD_REPLAY_GAIN);
 611         }
 612         else if(0 == strcmp(opt, "remove-replay-gain")) {
 613                 const FLAC__byte * const tags[5] = {
 614                         GRABBAG__REPLAYGAIN_TAG_REFERENCE_LOUDNESS,
 615                         GRABBAG__REPLAYGAIN_TAG_TITLE_GAIN,
 616                         GRABBAG__REPLAYGAIN_TAG_TITLE_PEAK,
 617                         GRABBAG__REPLAYGAIN_TAG_ALBUM_GAIN,
 618                         GRABBAG__REPLAYGAIN_TAG_ALBUM_PEAK
 619                 };
 620                 size_t i;
 621                 for(i = 0; i < sizeof(tags)/sizeof(tags[0]); i++) {
 622                         op = append_shorthand_operation(options, OP__REMOVE_VC_FIELD);
 623                         op->argument.vc_field_name.value = local_strdup((const char *)tags[i]);
 624                 }
 625         }
 626         else if(0 == strcmp(opt, "add-padding")) {
 627                 op = append_shorthand_operation(options, OP__ADD_PADDING);
 628                 FLAC__ASSERT(0 != option_argument);
 629                 if(!parse_add_padding(option_argument, &(op->argument.add_padding.length))) {
 630                         fprintf(stderr, "ERROR (--%s): illegal length \"%s\", length must be >= 0 and < 2^%u\n", opt, option_argument, FLAC__STREAM_METADATA_LENGTH_LEN);
 631                         ok = false;
 632                 }
 633         }
 634         else if(0 == strcmp(opt, "help")) {
 635                 options->show_long_help = true;
 636         }
 637         else if(0 == strcmp(opt, "version")) {
 638                 options->show_version = true;
 639         }
 640         else if(0 == strcmp(opt, "list")) {
 641                 (void) append_major_operation(options, OP__LIST);
 642         }
 643         else if(0 == strcmp(opt, "append")) {
 644                 (void) append_major_operation(options, OP__APPEND);
 645         }
 646         else if(0 == strcmp(opt, "remove")) {
 647                 (void) append_major_operation(options, OP__REMOVE);
 648         }
 649         else if(0 == strcmp(opt, "remove-all")) {
 650                 (void) append_major_operation(options, OP__REMOVE_ALL);
 651         }
 652         else if(0 == strcmp(opt, "merge-padding")) {
 653                 (void) append_major_operation(options, OP__MERGE_PADDING);
 654         }
 655         else if(0 == strcmp(opt, "sort-padding")) {
 656                 (void) append_major_operation(options, OP__SORT_PADDING);
 657         }
 658         else if(0 == strcmp(opt, "block-number")) {
 659                 arg = append_argument(options, ARG__BLOCK_NUMBER);
 660                 FLAC__ASSERT(0 != option_argument);
 661                 if(!parse_block_number(option_argument, &(arg->value.block_number))) {
 662                         fprintf(stderr, "ERROR: malformed block number specification \"%s\"\n", option_argument);
 663                         ok = false;
 664                 }
 665         }
 666         else if(0 == strcmp(opt, "block-type")) {
 667                 arg = append_argument(options, ARG__BLOCK_TYPE);
 668                 FLAC__ASSERT(0 != option_argument);
 669                 if(!parse_block_type(option_argument, &(arg->value.block_type))) {
 670                         fprintf(stderr, "ERROR (--%s): malformed block type specification \"%s\"\n", opt, option_argument);
 671                         ok = false;
 672                 }
 673                 options->args.checks.has_block_type = true;
 674         }
 675         else if(0 == strcmp(opt, "except-block-type")) {
 676                 arg = append_argument(options, ARG__EXCEPT_BLOCK_TYPE);
 677                 FLAC__ASSERT(0 != option_argument);
 678                 if(!parse_block_type(option_argument, &(arg->value.block_type))) {
 679                         fprintf(stderr, "ERROR (--%s): malformed block type specification \"%s\"\n", opt, option_argument);
 680                         ok = false;
 681                 }
 682                 options->args.checks.has_except_block_type = true;
 683         }
 684         else if(0 == strcmp(opt, "data-format")) {
 685                 arg = append_argument(options, ARG__DATA_FORMAT);
 686                 FLAC__ASSERT(0 != option_argument);
 687                 if(!parse_data_format(option_argument, &(arg->value.data_format))) {
 688                         fprintf(stderr, "ERROR (--%s): illegal data format \"%s\"\n", opt, option_argument);
 689                         ok = false;
 690                 }
 691         }
 692         else if(0 == strcmp(opt, "application-data-format")) {
 693                 FLAC__ASSERT(0 != option_argument);
 694                 if(!parse_application_data_format(option_argument, &(options->application_data_format_is_hexdump))) {
 695                         fprintf(stderr, "ERROR (--%s): illegal application data format \"%s\"\n", opt, option_argument);
 696                         ok = false;
 697                 }
 698         }
 699         else if(0 == strcmp(opt, "from-file")) {
 700                 arg = append_argument(options, ARG__FROM_FILE);
 701                 FLAC__ASSERT(0 != option_argument);
 702                 arg->value.from_file.file_name = local_strdup(option_argument);
 703         }
 704         else {
 705                 FLAC__ASSERT(0);
 706         }
 707
 708         return ok;
 709 }
 710
 711 void append_new_operation(CommandLineOptions *options, Operation operation)
 712 {
 713         if(options->ops.capacity == 0) {
 714                 options->ops.capacity = 50;
 715                 if(0 == (options->ops.operations = (Operation*)malloc(sizeof(Operation) * options->ops.capacity)))
 716                         die("out of memory allocating space for option list");
 717                 memset(options->ops.operations, 0, sizeof(Operation) * options->ops.capacity);
 718         }
 719         if(options->ops.capacity <= options->ops.num_operations) {
 720                 unsigned original_capacity = options->ops.capacity;
 721                 options->ops.capacity *= 4;
 722                 if(0 == (options->ops.operations = (Operation*)realloc(options->ops.operations, sizeof(Operation) * options->ops.capacity)))
 723                         die("out of memory allocating space for option list");
 724                 memset(options->ops.operations + original_capacity, 0, sizeof(Operation) * (options->ops.capacity - original_capacity));
 725         }
 726
 727         options->ops.operations[options->ops.num_operations++] = operation;
 728 }
 729
 730 void append_new_argument(CommandLineOptions *options, Argument argument)
 731 {
 732         if(options->args.capacity == 0) {
 733                 options->args.capacity = 50;
 734                 if(0 == (options->args.arguments = (Argument*)malloc(sizeof(Argument) * options->args.capacity)))
 735                         die("out of memory allocating space for option list");
 736                 memset(options->args.arguments, 0, sizeof(Argument) * options->args.capacity);
 737         }
 738         if(options->args.capacity <= options->args.num_arguments) {
 739                 unsigned original_capacity = options->args.capacity;
 740                 options->args.capacity *= 4;
 741                 if(0 == (options->args.arguments = (Argument*)realloc(options->args.arguments, sizeof(Argument) * options->args.capacity)))
 742                         die("out of memory allocating space for option list");
 743                 memset(options->args.arguments + original_capacity, 0, sizeof(Argument) * (options->args.capacity - original_capacity));
 744         }
 745
 746         options->args.arguments[options->args.num_arguments++] = argument;
 747 }
 748
 749 Operation *append_major_operation(CommandLineOptions *options, OperationType type)
 750 {
 751         Operation op;
 752         memset(&op, 0, sizeof(op));
 753         op.type = type;
 754         append_new_operation(options, op);
 755         options->args.checks.num_major_ops++;
 756         return options->ops.operations + (options->ops.num_operations - 1);
 757 }
 758
 759 Operation *append_shorthand_operation(CommandLineOptions *options, OperationType type)
 760 {
 761         Operation op;
 762         memset(&op, 0, sizeof(op));
 763         op.type = type;
 764         append_new_operation(options, op);
 765         options->args.checks.num_shorthand_ops++;
 766         return options->ops.operations + (options->ops.num_operations - 1);
 767 }
 768
 769 Argument *find_argument(CommandLineOptions *options, ArgumentType type)
 770 {
 771         unsigned i;
 772         for(i = 0; i < options->args.num_arguments; i++)
 773                 if(options->args.arguments[i].type == type)
 774                         return &options->args.arguments[i];
 775         return 0;
 776 }
 777
 778 Operation *find_shorthand_operation(CommandLineOptions *options, OperationType type)
 779 {
 780         unsigned i;
 781         for(i = 0; i < options->ops.num_operations; i++)
 782                 if(options->ops.operations[i].type == type)
 783                         return &options->ops.operations[i];
 784         return 0;
 785 }
 786
 787 Argument *append_argument(CommandLineOptions *options, ArgumentType type)
 788 {
 789         Argument arg;
 790         memset(&arg, 0, sizeof(arg));
 791         arg.type = type;
 792         append_new_argument(options, arg);
 793         return options->args.arguments + (options->args.num_arguments - 1);
 794 }
 795
 796 FLAC__bool parse_md5(const char *src, FLAC__byte dest[16])
 797 {
 798         unsigned i, d;
 799         int c;
 800         FLAC__ASSERT(0 != src);
 801         if(strlen(src) != 32)
 802                 return false;
 803         /* strtoul() accepts negative numbers which we do not want, so we do it the hard way */
 804         for(i = 0; i < 16; i++) {
 805                 c = (int)(*src++);
 806                 if(isdigit(c))
 807                         d = (unsigned)(c - '0');
 808                 else if(c >= 'a' && c <= 'f')
 809                         d = (unsigned)(c - 'a') + 10u;
 810                 else if(c >= 'A' && c <= 'F')
 811                         d = (unsigned)(c - 'A') + 10u;
 812                 else
 813                         return false;
 814                 d <<= 4;
 815                 c = (int)(*src++);
 816                 if(isdigit(c))
 817                         d |= (unsigned)(c - '0');
 818                 else if(c >= 'a' && c <= 'f')
 819                         d |= (unsigned)(c - 'a') + 10u;
 820                 else if(c >= 'A' && c <= 'F')
 821                         d |= (unsigned)(c - 'A') + 10u;
 822                 else
 823                         return false;
 824                 dest[i] = (FLAC__byte)d;
 825         }
 826         return true;
 827 }
 828
 829 FLAC__bool parse_uint32(const char *src, FLAC__uint32 *dest)
 830 {
 831         FLAC__ASSERT(0 != src);
 832         if(strlen(src) == 0 || strspn(src, "0123456789") != strlen(src))
 833                 return false;
 834         *dest = strtoul(src, 0, 10);
 835         return true;
 836 }
 837
 838 #ifdef _MSC_VER
 839 /* There's no strtoull() in MSVC6 so we just write a specialized one */
 840 static FLAC__uint64 local__strtoull(const char *src)
 841 {
 842         FLAC__uint64 ret = 0;
 843         int c;
 844         FLAC__ASSERT(0 != src);
 845         while(0 != (c = *src++)) {
 846                 c -= '0';
 847                 if(c >= 0 && c <= 9)
 848                         ret = (ret * 10) + c;
 849                 else
 850                         break;
 851         }
 852         return ret;
 853 }
 854 #endif
 855
 856 FLAC__bool parse_uint64(const char *src, FLAC__uint64 *dest)
 857 {
 858         FLAC__ASSERT(0 != src);
 859         if(strlen(src) == 0 || strspn(src, "0123456789") != strlen(src))
 860                 return false;
 861 #ifdef _MSC_VER
 862         *dest = local__strtoull(src);
 863 #else
 864         *dest = strtoull(src, 0, 10);
 865 #endif
 866         return true;
 867 }
 868
 869 FLAC__bool parse_string(const char *src, char **dest)
 870 {
 871         if(0 == src || strlen(src) == 0)
 872                 return false;
 873         *dest = strdup(src);
 874         return true;
 875 }
 876
 877 FLAC__bool parse_vorbis_comment_field_name(const char *field_ref, char **name, const char **violation)
 878 {
 879         static const char * const violations[] = {
 880                 "field name contains invalid character"
 881         };
 882
 883         char *q, *s;
 884
 885         s = local_strdup(field_ref);
 886
 887         for(q = s; *q; q++) {
 888                 if(*q < 0x20 || *q > 0x7d || *q == 0x3d) {
 889                         free(s);
 890                         *violation = violations[0];
 891                         return false;
 892                 }
 893         }
 894
 895         *name = s;
 896
 897         return true;
 898 }
 899
 900 FLAC__bool parse_add_seekpoint(const char *in, char **out, const char **violation)
 901 {
 902         static const char *garbled_ = "garbled specification";
 903         const unsigned n = strlen(in);
 904
 905         FLAC__ASSERT(0 != in);
 906         FLAC__ASSERT(0 != out);
 907
 908         if(n == 0) {
 909                 *violation = "specification is empty";
 910                 return false;
 911         }
 912
 913         if(n > strspn(in, "0123456789.Xsx")) {
 914                 *violation = "specification contains invalid character";
 915                 return false;
 916         }
 917
 918         if(in[n-1] == 'X') {
 919                 if(n > 1) {
 920                         *violation = garbled_;
 921                         return false;
 922                 }
 923         }
 924         else if(in[n-1] == 's') {
 925                 if(n-1 > strspn(in, "0123456789.")) {
 926                         *violation = garbled_;
 927                         return false;
 928                 }
 929         }
 930         else if(in[n-1] == 'x') {
 931                 if(n-1 > strspn(in, "0123456789")) {
 932                         *violation = garbled_;
 933                         return false;
 934                 }
 935         }
 936         else {
 937                 if(n > strspn(in, "0123456789")) {
 938                         *violation = garbled_;
 939                         return false;
 940                 }
 941         }
 942
 943         *out = local_strdup(in);
 944         return true;
 945 }
 946
 947 FLAC__bool parse_add_padding(const char *in, unsigned *out)
 948 {
 949         FLAC__ASSERT(0 != in);
 950         FLAC__ASSERT(0 != out);
 951         *out = (unsigned)strtoul(in, 0, 10);
 952         return *out < (1u << FLAC__STREAM_METADATA_LENGTH_LEN);
 953 }
 954
 955 FLAC__bool parse_block_number(const char *in, Argument_BlockNumber *out)
 956 {
 957         char *p, *q, *s, *end;
 958         long i;
 959         unsigned entry;
 960
 961         if(*in == '\0')
 962                 return false;
 963
 964         s = local_strdup(in);
 965
 966         /* first count the entries */
 967         for(out->num_entries = 1, p = strchr(s, ','); p; out->num_entries++, p = strchr(++p, ','))
 968                 ;
 969
 970         /* make space */
 971         FLAC__ASSERT(out->num_entries > 0);
 972         if(0 == (out->entries = (unsigned*)malloc(sizeof(unsigned) * out->num_entries)))
 973                 die("out of memory allocating space for option list");
 974
 975         /* load 'em up */
 976         entry = 0;
 977         q = s;
 978         while(q) {
 979                 FLAC__ASSERT(entry < out->num_entries);
 980                 if(0 != (p = strchr(q, ',')))
 981                         *p++ = '\0';
 982                 if(!isdigit((int)(*q)) || (i = strtol(q, &end, 10)) < 0 || *end) {
 983                         free(s);
 984                         return false;
 985                 }
 986                 out->entries[entry++] = (unsigned)i;
 987                 q = p;
 988         }
 989         FLAC__ASSERT(entry == out->num_entries);
 990
 991         free(s);
 992         return true;
 993 }
 994
 995 FLAC__bool parse_block_type(const char *in, Argument_BlockType *out)
 996 {
 997         char *p, *q, *r, *s;
 998         unsigned entry;
 999
1000         if(*in == '\0')
1001                 return false;
1002
1003         s = local_strdup(in);
1004
1005         /* first count the entries */
1006         for(out->num_entries = 1, p = strchr(s, ','); p; out->num_entries++, p = strchr(++p, ','))
1007                 ;
1008
1009         /* make space */
1010         FLAC__ASSERT(out->num_entries > 0);
1011         if(0 == (out->entries = (Argument_BlockTypeEntry*)malloc(sizeof(Argument_BlockTypeEntry) * out->num_entries)))
1012                 die("out of memory allocating space for option list");
1013
1014         /* load 'em up */
1015         entry = 0;
1016         q = s;
1017         while(q) {
1018                 FLAC__ASSERT(entry < out->num_entries);
1019                 if(0 != (p = strchr(q, ',')))
1020                         *p++ = 0;
1021                 r = strchr(q, ':');
1022                 if(r)
1023                         *r++ = '\0';
1024                 if(0 != r && 0 != strcmp(q, "APPLICATION")) {
1025                         free(s);
1026                         return false;
1027                 }
1028                 if(0 == strcmp(q, "STREAMINFO")) {
1029                         out->entries[entry++].type = FLAC__METADATA_TYPE_STREAMINFO;
1030                 }
1031                 else if(0 == strcmp(q, "PADDING")) {
1032                         out->entries[entry++].type = FLAC__METADATA_TYPE_PADDING;
1033                 }
1034                 else if(0 == strcmp(q, "APPLICATION")) {
1035                         out->entries[entry].type = FLAC__METADATA_TYPE_APPLICATION;
1036                         out->entries[entry].filter_application_by_id = (0 != r);
1037                         if(0 != r) {
1038                                 if(strlen(r) == 4) {
1039                                         strcpy(out->entries[entry].application_id, r);
1040                                 }
1041                                 else if(strlen(r) == 10 && strncmp(r, "0x", 2) == 0 && strspn(r+2, "0123456789ABCDEFabcdef") == 8) {
1042                                         FLAC__uint32 x = strtoul(r+2, 0, 16);
1043                                         out->entries[entry].application_id[3] = (FLAC__byte)(x & 0xff);
1044                                         out->entries[entry].application_id[2] = (FLAC__byte)((x>>=8) & 0xff);
1045                                         out->entries[entry].application_id[1] = (FLAC__byte)((x>>=8) & 0xff);
1046                                         out->entries[entry].application_id[0] = (FLAC__byte)((x>>=8) & 0xff);
1047                                 }
1048                                 else {
1049                                         free(s);
1050                                         return false;
1051                                 }
1052                         }
1053                         entry++;
1054                 }
1055                 else if(0 == strcmp(q, "SEEKTABLE")) {
1056                         out->entries[entry++].type = FLAC__METADATA_TYPE_SEEKTABLE;
1057                 }
1058                 else if(0 == strcmp(q, "VORBIS_COMMENT")) {
1059                         out->entries[entry++].type = FLAC__METADATA_TYPE_VORBIS_COMMENT;
1060                 }
1061                 else if(0 == strcmp(q, "CUESHEET")) {
1062                         out->entries[entry++].type = FLAC__METADATA_TYPE_CUESHEET;
1063                 }
1064                 else if(0 == strcmp(q, "PICTURE")) {
1065                         out->entries[entry++].type = FLAC__METADATA_TYPE_PICTURE;
1066                 }
1067                 else {
1068                         free(s);
1069                         return false;
1070                 }
1071                 q = p;
1072         }
1073         FLAC__ASSERT(entry == out->num_entries);
1074
1075         free(s);
1076         return true;
1077 }
1078
1079 FLAC__bool parse_data_format(const char *in, Argument_DataFormat *out)
1080 {
1081         if(0 == strcmp(in, "binary"))
1082                 out->is_binary = true;
1083         else if(0 == strcmp(in, "text"))
1084                 out->is_binary = false;
1085         else
1086                 return false;
1087         return true;
1088 }
1089
1090 FLAC__bool parse_application_data_format(const char *in, FLAC__bool *out)
1091 {
1092         if(0 == strcmp(in, "hexdump"))
1093                 *out = true;
1094         else if(0 == strcmp(in, "text"))
1095                 *out = false;
1096         else
1097                 return false;
1098         return true;
1099 }
1100
1101 void undocumented_warning(const char *opt)
1102 {
1103         fprintf(stderr, "WARNING: undocmented option --%s should be used with caution,\n         only for repairing a damaged STREAMINFO block\n", opt);
1104 }