src/metaflac/main.c

   1 /* metaflac - Command-line FLAC metadata editor
   2  * Copyright (C) 2001,2002  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 /*@@@
  20 more powerful operations yet to add:
  21         add a seektable, using same args as flac
  22 */
  23
  24 #if HAVE_CONFIG_H
  25 #  include <config.h>
  26 #endif
  27
  28 #include "FLAC/assert.h"
  29 #include "FLAC/metadata.h"
  30 #include <ctype.h>
  31 #include <stdarg.h>
  32 #include <stdio.h>
  33 #include <stdlib.h>
  34 #include <string.h>
  35
  36 #if 0
  37 /*[JEC] was:#if HAVE_GETOPT_LONG*/
  38 /*[JEC] see flac/include/share/getopt.h as to why the change */
  39 #  include <getopt.h>
  40 #else
  41 #  include "share/getopt.h"
  42 #endif
  43
  44 /*
  45    FLAC__share__getopt format struct; note we don't use short options so we just
  46    set the 'val' field to 0 everywhere to indicate a valid option.
  47 */
  48 static struct FLAC__share__option long_options_[] = {
  49         /* global options */
  50     { "preserve-modtime", 0, 0, 0 },
  51     { "with-filename", 0, 0, 0 },
  52     { "no-filename", 0, 0, 0 },
  53     { "dont-use-padding", 0, 0, 0 },
  54         /* shorthand operations */
  55     { "show-md5sum", 0, 0, 0 },
  56     { "show-min-blocksize", 0, 0, 0 },
  57     { "show-max-blocksize", 0, 0, 0 },
  58     { "show-min-framesize", 0, 0, 0 },
  59     { "show-max-framesize", 0, 0, 0 },
  60     { "show-sample-rate", 0, 0, 0 },
  61     { "show-channels", 0, 0, 0 },
  62     { "show-bps", 0, 0, 0 },
  63     { "show-total-samples", 0, 0, 0 },
  64     { "show-vc-vendor", 0, 0, 0 },
  65     { "show-vc-field", 1, 0, 0 },
  66     { "remove-vc-all", 0, 0, 0 },
  67     { "remove-vc-field", 1, 0, 0 },
  68     { "remove-vc-firstfield", 1, 0, 0 },
  69     { "set-vc-field", 1, 0, 0 },
  70     { "add-padding", 1, 0, 0 },
  71         /* major operations */
  72     { "help", 0, 0, 0 },
  73     { "list", 0, 0, 0 },
  74     { "append", 0, 0, 0 },
  75     { "remove", 0, 0, 0 },
  76     { "remove-all", 0, 0, 0 },
  77     { "merge-padding", 0, 0, 0 },
  78     { "sort-padding", 0, 0, 0 },
  79         /* major operation arguments */
  80     { "block-number", 1, 0, 0 },
  81     { "block-type", 1, 0, 0 },
  82     { "except-block-type", 1, 0, 0 },
  83     { "data-format", 1, 0, 0 },
  84     { "application-data-format", 1, 0, 0 },
  85     { "from-file", 1, 0, 0 },
  86     {0, 0, 0, 0}
  87 };
  88
  89 typedef enum {
  90         OP__SHOW_MD5SUM,
  91         OP__SHOW_MIN_BLOCKSIZE,
  92         OP__SHOW_MAX_BLOCKSIZE,
  93         OP__SHOW_MIN_FRAMESIZE,
  94         OP__SHOW_MAX_FRAMESIZE,
  95         OP__SHOW_SAMPLE_RATE,
  96         OP__SHOW_CHANNELS,
  97         OP__SHOW_BPS,
  98         OP__SHOW_TOTAL_SAMPLES,
  99         OP__SHOW_VC_VENDOR,
 100         OP__SHOW_VC_FIELD,
 101         OP__REMOVE_VC_ALL,
 102         OP__REMOVE_VC_FIELD,
 103         OP__REMOVE_VC_FIRSTFIELD,
 104         OP__SET_VC_FIELD,
 105         OP__ADD_PADDING,
 106         OP__LIST,
 107         OP__APPEND,
 108         OP__REMOVE,
 109         OP__REMOVE_ALL,
 110         OP__MERGE_PADDING,
 111         OP__SORT_PADDING
 112 } OperationType;
 113
 114 typedef enum {
 115         ARG__BLOCK_NUMBER,
 116         ARG__BLOCK_TYPE,
 117         ARG__EXCEPT_BLOCK_TYPE,
 118         ARG__DATA_FORMAT,
 119         ARG__FROM_FILE
 120 } ArgumentType;
 121
 122 typedef struct {
 123         char *field_name;
 124 } Argument_VcFieldName;
 125
 126 typedef struct {
 127         char *field; /* the whole field as passed on the command line, i.e. "NAME=VALUE" */
 128         char *field_name;
 129         /* according to the vorbis spec, field values can contain \0 so simple C strings are not enough here */
 130         unsigned field_value_length;
 131         char *field_value;
 132 } Argument_VcField;
 133
 134 typedef struct {
 135         unsigned num_entries;
 136         unsigned *entries;
 137 } Argument_BlockNumber;
 138
 139 typedef struct {
 140         FLAC__MetadataType type;
 141         char application_id[4]; /* only relevant if type == FLAC__STREAM_METADATA_TYPE_APPLICATION */
 142         FLAC__bool filter_application_by_id;
 143 } Argument_BlockTypeEntry;
 144
 145 typedef struct {
 146         unsigned num_entries;
 147         Argument_BlockTypeEntry *entries;
 148 } Argument_BlockType;
 149
 150 typedef struct {
 151         FLAC__bool is_binary;
 152 } Argument_DataFormat;
 153
 154 typedef struct {
 155         char *file_name;
 156 } Argument_FromFile;
 157
 158 typedef struct {
 159         unsigned length;
 160 } Argument_AddPadding;
 161
 162 typedef struct {
 163         OperationType type;
 164         union {
 165                 Argument_VcFieldName show_vc_field;
 166                 Argument_VcFieldName remove_vc_field;
 167                 Argument_VcFieldName remove_vc_firstfield;
 168                 Argument_VcField set_vc_field;
 169                 Argument_AddPadding add_padding;
 170         } argument;
 171 } Operation;
 172
 173 typedef struct {
 174         ArgumentType type;
 175         union {
 176                 Argument_BlockNumber block_number;
 177                 Argument_BlockType block_type;
 178                 Argument_DataFormat data_format;
 179                 Argument_FromFile from_file;
 180         } value;
 181 } Argument;
 182
 183 typedef struct {
 184         FLAC__bool preserve_modtime;
 185         FLAC__bool prefix_with_filename;
 186         FLAC__bool use_padding;
 187         FLAC__bool show_long_help;
 188         FLAC__bool application_data_format_is_hexdump;
 189         struct {
 190                 Operation *operations;
 191                 unsigned num_operations;
 192                 unsigned capacity;
 193         } ops;
 194         struct {
 195                 struct {
 196                         unsigned num_shorthand_ops;
 197                         unsigned num_major_ops;
 198                         FLAC__bool has_block_type;
 199                         FLAC__bool has_except_block_type;
 200                 } checks;
 201                 Argument *arguments;
 202                 unsigned num_arguments;
 203                 unsigned capacity;
 204         } args;
 205         unsigned num_files;
 206         char **filenames;
 207 } CommandLineOptions;
 208
 209 static void die(const char *message);
 210 static void init_options(CommandLineOptions *options);
 211 static FLAC__bool parse_options(int argc, char *argv[], CommandLineOptions *options);
 212 static FLAC__bool parse_option(int option_index, const char *option_argument, CommandLineOptions *options);
 213 static void free_options(CommandLineOptions *options);
 214 static void append_new_operation(CommandLineOptions *options, Operation operation);
 215 static void append_new_argument(CommandLineOptions *options, Argument argument);
 216 static Operation *append_major_operation(CommandLineOptions *options, OperationType type);
 217 static Operation *append_shorthand_operation(CommandLineOptions *options, OperationType type);
 218 static Argument *append_argument(CommandLineOptions *options, ArgumentType type);
 219 static int short_usage(const char *message, ...);
 220 static int long_usage(const char *message, ...);
 221 static char *local_strdup(const char *source);
 222 static FLAC__bool parse_vorbis_comment_field(const char *field_ref, char **field, char **name, char **value, unsigned *length);
 223 static FLAC__bool parse_add_padding(const char *in, unsigned *out);
 224 static FLAC__bool parse_block_number(const char *in, Argument_BlockNumber *out);
 225 static FLAC__bool parse_block_type(const char *in, Argument_BlockType *out);
 226 static FLAC__bool parse_data_format(const char *in, Argument_DataFormat *out);
 227 static FLAC__bool parse_application_data_format(const char *in, FLAC__bool *out);
 228 static FLAC__bool do_operations(const CommandLineOptions *options);
 229 static FLAC__bool do_major_operation(const CommandLineOptions *options);
 230 static FLAC__bool do_major_operation_on_file(const char *filename, const CommandLineOptions *options);
 231 static FLAC__bool do_major_operation__list(const char *filename, FLAC__Metadata_Chain *chain, const CommandLineOptions *options);
 232 static FLAC__bool do_major_operation__append(FLAC__Metadata_Chain *chain, const CommandLineOptions *options);
 233 static FLAC__bool do_major_operation__remove(FLAC__Metadata_Chain *chain, const CommandLineOptions *options);
 234 static FLAC__bool do_major_operation__remove_all(FLAC__Metadata_Chain *chain, const CommandLineOptions *options);
 235 static FLAC__bool do_shorthand_operations(const CommandLineOptions *options);
 236 static FLAC__bool do_shorthand_operations_on_file(const char *fielname, const CommandLineOptions *options);
 237 static FLAC__bool do_shorthand_operation(const char *filename, FLAC__Metadata_Chain *chain, const Operation *operation, FLAC__bool *needs_write);
 238 static FLAC__bool do_shorthand_operation__add_padding(const char *filename, FLAC__Metadata_Chain *chain, unsigned length, FLAC__bool *needs_write);
 239 static FLAC__bool do_shorthand_operation__streaminfo(const char *filename, FLAC__Metadata_Chain *chain, OperationType op);
 240 static FLAC__bool do_shorthand_operation__vorbis_comment(const char *filename, FLAC__Metadata_Chain *chain, const Operation *operation, FLAC__bool *needs_write);
 241 static FLAC__bool passes_filter(const CommandLineOptions *options, const FLAC__StreamMetadata *block, unsigned block_number);
 242 static void write_metadata(const char *filename, FLAC__StreamMetadata *block, unsigned block_number, FLAC__bool hexdump_application);
 243 static void write_vc_field(const char *filename, const FLAC__StreamMetadata_VorbisComment_Entry *entry);
 244 static void write_vc_fields(const char *filename, const char *field_name, const FLAC__StreamMetadata_VorbisComment_Entry entry[], unsigned num_entries);
 245 static FLAC__bool remove_vc_all(FLAC__StreamMetadata *block, FLAC__bool *needs_write);
 246 static FLAC__bool remove_vc_field(FLAC__StreamMetadata *block, const char *field_name, FLAC__bool *needs_write);
 247 static FLAC__bool remove_vc_firstfield(FLAC__StreamMetadata *block, const char *field_name, FLAC__bool *needs_write);
 248 static FLAC__bool set_vc_field(FLAC__StreamMetadata *block, const Argument_VcField *field, FLAC__bool *needs_write);
 249 static FLAC__bool field_name_matches_entry(const char *field_name, unsigned field_name_length, const FLAC__StreamMetadata_VorbisComment_Entry *entry);
 250 static void hexdump(const char *filename, const FLAC__byte *buf, unsigned bytes, const char *indent);
 251
 252 int main(int argc, char *argv[])
 253 {
 254         CommandLineOptions options;
 255         int ret = 0;
 256
 257         init_options(&options);
 258
 259         if(parse_options(argc, argv, &options))
 260                 ret = !do_operations(&options);
 261
 262         free_options(&options);
 263
 264         return ret;
 265 }
 266
 267 void die(const char *message)
 268 {
 269         FLAC__ASSERT(0 != message);
 270         fprintf(stderr, "ERROR: %s\n", message);
 271         exit(1);
 272 }
 273
 274 void init_options(CommandLineOptions *options)
 275 {
 276         options->preserve_modtime = false;
 277
 278         /* '2' is hack to mean "use default if not forced on command line" */
 279         FLAC__ASSERT(true != 2);
 280         options->prefix_with_filename = 2;
 281
 282         options->use_padding = true;
 283         options->show_long_help = false;
 284         options->application_data_format_is_hexdump = false;
 285
 286         options->ops.operations = 0;
 287         options->ops.num_operations = 0;
 288         options->ops.capacity = 0;
 289
 290         options->args.arguments = 0;
 291         options->args.num_arguments = 0;
 292         options->args.capacity = 0;
 293
 294         options->args.checks.num_shorthand_ops = 0;
 295         options->args.checks.num_major_ops = 0;
 296         options->args.checks.has_block_type = false;
 297         options->args.checks.has_except_block_type = false;
 298
 299         options->num_files = 0;
 300         options->filenames = 0;
 301 }
 302
 303 FLAC__bool parse_options(int argc, char *argv[], CommandLineOptions *options)
 304 {
 305     int ret;
 306     int option_index = 1;
 307         FLAC__bool had_error = false;
 308
 309     while ((ret = FLAC__share__getopt_long(argc, argv, "", long_options_, &option_index)) != -1) {
 310         switch (ret) {
 311             case 0:
 312                                 had_error |= !parse_option(option_index, FLAC__share__optarg, options);
 313                 break;
 314                         case '?':
 315                         case ':':
 316                 had_error = true;
 317                 break;
 318             default:
 319                                 FLAC__ASSERT(0);
 320                                 break;
 321         }
 322     }
 323
 324         if(options->prefix_with_filename == 2)
 325                 options->prefix_with_filename = (argc - FLAC__share__optind > 1);
 326
 327         if(FLAC__share__optind >= argc && !options->show_long_help) {
 328                 fprintf(stderr,"ERROR: you must specify at least one FLAC file;\n");
 329                 fprintf(stderr,"       metaflac cannot be used as a pipe\n");
 330                 had_error = true;
 331         }
 332
 333         options->num_files = argc - FLAC__share__optind;
 334
 335         if(options->num_files > 0) {
 336                 unsigned i = 0;
 337                 if(0 == (options->filenames = malloc(sizeof(char *) * options->num_files)))
 338                         die("out of memory allocating space for file names list");
 339                 while(FLAC__share__optind < argc)
 340                         options->filenames[i++] = local_strdup(argv[FLAC__share__optind++]);
 341         }
 342
 343         if(options->args.checks.num_major_ops > 0) {
 344                 if(options->args.checks.num_major_ops > 1) {
 345                         fprintf(stderr, "ERROR: you may only specify one major operation at a time\n");
 346                         had_error = true;
 347                 }
 348                 else if(options->args.checks.num_shorthand_ops > 0) {
 349                         fprintf(stderr, "ERROR: you may not mix shorthand and major operations\n");
 350                         had_error = true;
 351                 }
 352         }
 353
 354         if(options->args.checks.has_block_type && options->args.checks.has_except_block_type) {
 355                 fprintf(stderr, "ERROR: you may not specify both '--block-type' and '--except-block-type'\n");
 356                 had_error = true;
 357         }
 358
 359         if(had_error)
 360                 short_usage(0);
 361
 362         return !had_error;
 363 }
 364
 365 FLAC__bool parse_option(int option_index, const char *option_argument, CommandLineOptions *options)
 366 {
 367         const char *opt = long_options_[option_index].name;
 368         Operation *op;
 369         Argument *arg;
 370         FLAC__bool ok = true;
 371
 372     if(0 == strcmp(opt, "preserve-modtime")) {
 373                 options->preserve_modtime = true;
 374         }
 375     else if(0 == strcmp(opt, "with-filename")) {
 376                 options->prefix_with_filename = true;
 377         }
 378     else if(0 == strcmp(opt, "no-filename")) {
 379                 options->prefix_with_filename = false;
 380         }
 381     else if(0 == strcmp(opt, "dont-use-padding")) {
 382                 options->use_padding = false;
 383         }
 384     else if(0 == strcmp(opt, "show-md5sum")) {
 385                 (void) append_shorthand_operation(options, OP__SHOW_MD5SUM);
 386         }
 387     else if(0 == strcmp(opt, "show-min-blocksize")) {
 388                 (void) append_shorthand_operation(options, OP__SHOW_MIN_BLOCKSIZE);
 389         }
 390     else if(0 == strcmp(opt, "show-max-blocksize")) {
 391                 (void) append_shorthand_operation(options, OP__SHOW_MAX_BLOCKSIZE);
 392         }
 393     else if(0 == strcmp(opt, "show-min-framesize")) {
 394                 (void) append_shorthand_operation(options, OP__SHOW_MIN_FRAMESIZE);
 395         }
 396     else if(0 == strcmp(opt, "show-max-framesize")) {
 397                 (void) append_shorthand_operation(options, OP__SHOW_MAX_FRAMESIZE);
 398         }
 399     else if(0 == strcmp(opt, "show-sample-rate")) {
 400                 (void) append_shorthand_operation(options, OP__SHOW_SAMPLE_RATE);
 401         }
 402     else if(0 == strcmp(opt, "show-channels")) {
 403                 (void) append_shorthand_operation(options, OP__SHOW_CHANNELS);
 404         }
 405     else if(0 == strcmp(opt, "show-bps")) {
 406                 (void) append_shorthand_operation(options, OP__SHOW_BPS);
 407         }
 408     else if(0 == strcmp(opt, "show-total-samples")) {
 409                 (void) append_shorthand_operation(options, OP__SHOW_TOTAL_SAMPLES);
 410         }
 411     else if(0 == strcmp(opt, "show-vc-vendor")) {
 412                 (void) append_shorthand_operation(options, OP__SHOW_VC_VENDOR);
 413         }
 414     else if(0 == strcmp(opt, "show-vc-field")) {
 415                 op = append_shorthand_operation(options, OP__SHOW_VC_FIELD);
 416                 FLAC__ASSERT(0 != option_argument);
 417                 op->argument.show_vc_field.field_name = local_strdup(option_argument);
 418         }
 419     else if(0 == strcmp(opt, "remove-vc-all")) {
 420                 (void) append_shorthand_operation(options, OP__REMOVE_VC_ALL);
 421         }
 422     else if(0 == strcmp(opt, "remove-vc-field")) {
 423                 op = append_shorthand_operation(options, OP__REMOVE_VC_FIELD);
 424                 FLAC__ASSERT(0 != option_argument);
 425                 op->argument.remove_vc_field.field_name = local_strdup(option_argument);
 426         }
 427     else if(0 == strcmp(opt, "remove-vc-firstfield")) {
 428                 op = append_shorthand_operation(options, OP__REMOVE_VC_FIRSTFIELD);
 429                 FLAC__ASSERT(0 != option_argument);
 430                 op->argument.remove_vc_firstfield.field_name = local_strdup(option_argument);
 431         }
 432     else if(0 == strcmp(opt, "set-vc-field")) {
 433                 op = append_shorthand_operation(options, OP__SET_VC_FIELD);
 434                 FLAC__ASSERT(0 != option_argument);
 435                 if(!parse_vorbis_comment_field(option_argument, &(op->argument.set_vc_field.field), &(op->argument.set_vc_field.field_name), &(op->argument.set_vc_field.field_value), &(op->argument.set_vc_field.field_value_length))) {
 436                         fprintf(stderr, "ERROR: malformed vorbis comment field \"%s\"\n", option_argument);
 437                         ok = false;
 438                 }
 439         }
 440     else if(0 == strcmp(opt, "add-padding")) {
 441                 op = append_shorthand_operation(options, OP__ADD_PADDING);
 442                 FLAC__ASSERT(0 != option_argument);
 443                 if(!parse_add_padding(option_argument, &(op->argument.add_padding.length))) {
 444                         fprintf(stderr, "ERROR: illegal length \"%s\", length must be >= 0 and < 2^%u\n", option_argument, FLAC__STREAM_METADATA_LENGTH_LEN);
 445                         ok = false;
 446                 }
 447         }
 448     else if(0 == strcmp(opt, "help")) {
 449                 options->show_long_help = true;
 450         }
 451     else if(0 == strcmp(opt, "list")) {
 452                 (void) append_major_operation(options, OP__LIST);
 453         }
 454     else if(0 == strcmp(opt, "append")) {
 455                 (void) append_major_operation(options, OP__APPEND);
 456         }
 457     else if(0 == strcmp(opt, "remove")) {
 458                 (void) append_major_operation(options, OP__REMOVE);
 459         }
 460     else if(0 == strcmp(opt, "remove-all")) {
 461                 (void) append_major_operation(options, OP__REMOVE_ALL);
 462         }
 463     else if(0 == strcmp(opt, "merge-padding")) {
 464                 (void) append_major_operation(options, OP__MERGE_PADDING);
 465         }
 466     else if(0 == strcmp(opt, "sort-padding")) {
 467                 (void) append_major_operation(options, OP__SORT_PADDING);
 468         }
 469     else if(0 == strcmp(opt, "block-number")) {
 470                 arg = append_argument(options, ARG__BLOCK_NUMBER);
 471                 FLAC__ASSERT(0 != option_argument);
 472                 if(!parse_block_number(option_argument, &(arg->value.block_number))) {
 473                         fprintf(stderr, "ERROR: malformed block number specification \"%s\"\n", option_argument);
 474                         ok = false;
 475                 }
 476         }
 477     else if(0 == strcmp(opt, "block-type")) {
 478                 arg = append_argument(options, ARG__BLOCK_TYPE);
 479                 FLAC__ASSERT(0 != option_argument);
 480                 if(!parse_block_type(option_argument, &(arg->value.block_type))) {
 481                         fprintf(stderr, "ERROR: malformed block type specification \"%s\"\n", option_argument);
 482                         ok = false;
 483                 }
 484                 options->args.checks.has_block_type = true;
 485         }
 486     else if(0 == strcmp(opt, "except-block-type")) {
 487                 arg = append_argument(options, ARG__EXCEPT_BLOCK_TYPE);
 488                 FLAC__ASSERT(0 != option_argument);
 489                 if(!parse_block_type(option_argument, &(arg->value.block_type))) {
 490                         fprintf(stderr, "ERROR: malformed block type specification \"%s\"\n", option_argument);
 491                         ok = false;
 492                 }
 493                 options->args.checks.has_except_block_type = true;
 494         }
 495     else if(0 == strcmp(opt, "data-format")) {
 496                 arg = append_argument(options, ARG__DATA_FORMAT);
 497                 FLAC__ASSERT(0 != option_argument);
 498                 if(!parse_data_format(option_argument, &(arg->value.data_format))) {
 499                         fprintf(stderr, "ERROR: illegal data format \"%s\"\n", option_argument);
 500                         ok = false;
 501                 }
 502         }
 503     else if(0 == strcmp(opt, "application-data-format")) {
 504                 FLAC__ASSERT(0 != option_argument);
 505                 if(!parse_application_data_format(option_argument, &(options->application_data_format_is_hexdump))) {
 506                         fprintf(stderr, "ERROR: illegal application data format \"%s\"\n", option_argument);
 507                         ok = false;
 508                 }
 509         }
 510     else if(0 == strcmp(opt, "from-file")) {
 511                 arg = append_argument(options, ARG__FROM_FILE);
 512                 FLAC__ASSERT(0 != option_argument);
 513                 arg->value.from_file.file_name = local_strdup(option_argument);
 514         }
 515         else {
 516                 FLAC__ASSERT(0);
 517         }
 518
 519         return ok;
 520 }
 521
 522 void free_options(CommandLineOptions *options)
 523 {
 524         unsigned i;
 525         Operation *op;
 526         Argument *arg;
 527
 528         FLAC__ASSERT(0 == options->ops.operations || options->ops.num_operations > 0);
 529         FLAC__ASSERT(0 == options->args.arguments || options->args.num_arguments > 0);
 530
 531         for(i = 0, op = options->ops.operations; i < options->ops.num_operations; i++, op++) {
 532                 switch(op->type) {
 533                         case OP__SHOW_VC_FIELD:
 534                         case OP__REMOVE_VC_FIELD:
 535                         case OP__REMOVE_VC_FIRSTFIELD:
 536                                 if(0 != op->argument.show_vc_field.field_name)
 537                                         free(op->argument.show_vc_field.field_name);
 538                                 break;
 539                         case OP__SET_VC_FIELD:
 540                                 if(0 != op->argument.set_vc_field.field)
 541                                         free(op->argument.set_vc_field.field);
 542                                 if(0 != op->argument.set_vc_field.field_name)
 543                                         free(op->argument.set_vc_field.field_name);
 544                                 if(0 != op->argument.set_vc_field.field_value)
 545                                         free(op->argument.set_vc_field.field_value);
 546                                 break;
 547                         default:
 548                                 break;
 549                 }
 550         }
 551
 552         for(i = 0, arg = options->args.arguments; i < options->args.num_arguments; i++, arg++) {
 553                 switch(arg->type) {
 554                         case ARG__BLOCK_NUMBER:
 555                                 if(0 != arg->value.block_number.entries)
 556                                         free(arg->value.block_number.entries);
 557                                 break;
 558                         case ARG__BLOCK_TYPE:
 559                         case ARG__EXCEPT_BLOCK_TYPE:
 560                                 if(0 != arg->value.block_type.entries)
 561                                         free(arg->value.block_type.entries);
 562                                 break;
 563                         case ARG__FROM_FILE:
 564                                 if(0 != arg->value.from_file.file_name)
 565                                         free(arg->value.from_file.file_name);
 566                                 break;
 567                         default:
 568                                 break;
 569                 }
 570         }
 571
 572         if(0 != options->ops.operations)
 573                 free(options->ops.operations);
 574
 575         if(0 != options->args.arguments)
 576                 free(options->args.arguments);
 577
 578         if(0 != options->filenames)
 579                 free(options->filenames);
 580 }
 581
 582 void append_new_operation(CommandLineOptions *options, Operation operation)
 583 {
 584         if(options->ops.capacity == 0) {
 585                 options->ops.capacity = 50;
 586                 if(0 == (options->ops.operations = malloc(sizeof(Operation) * options->ops.capacity)))
 587                         die("out of memory allocating space for option list");
 588                 memset(options->ops.operations, 0, sizeof(Operation) * options->ops.capacity);
 589         }
 590         if(options->ops.capacity <= options->ops.num_operations) {
 591                 unsigned original_capacity = options->ops.capacity;
 592                 options->ops.capacity *= 4;
 593                 if(0 == (options->ops.operations = realloc(options->ops.operations, sizeof(Operation) * options->ops.capacity)))
 594                         die("out of memory allocating space for option list");
 595                 memset(options->ops.operations + original_capacity, 0, sizeof(Operation) * (options->ops.capacity - original_capacity));
 596         }
 597
 598         options->ops.operations[options->ops.num_operations++] = operation;
 599 }
 600
 601 void append_new_argument(CommandLineOptions *options, Argument argument)
 602 {
 603         if(options->args.capacity == 0) {
 604                 options->args.capacity = 50;
 605                 if(0 == (options->args.arguments = malloc(sizeof(Argument) * options->args.capacity)))
 606                         die("out of memory allocating space for option list");
 607                 memset(options->args.arguments, 0, sizeof(Argument) * options->args.capacity);
 608         }
 609         if(options->args.capacity <= options->args.num_arguments) {
 610                 unsigned original_capacity = options->args.capacity;
 611                 options->args.capacity *= 4;
 612                 if(0 == (options->args.arguments = realloc(options->args.arguments, sizeof(Argument) * options->args.capacity)))
 613                         die("out of memory allocating space for option list");
 614                 memset(options->args.arguments + original_capacity, 0, sizeof(Argument) * (options->args.capacity - original_capacity));
 615         }
 616
 617         options->args.arguments[options->args.num_arguments++] = argument;
 618 }
 619
 620 Operation *append_major_operation(CommandLineOptions *options, OperationType type)
 621 {
 622         Operation op;
 623         memset(&op, 0, sizeof(op));
 624         op.type = type;
 625         append_new_operation(options, op);
 626         options->args.checks.num_major_ops++;
 627         return options->ops.operations + (options->ops.num_operations - 1);
 628 }
 629
 630 Operation *append_shorthand_operation(CommandLineOptions *options, OperationType type)
 631 {
 632         Operation op;
 633         memset(&op, 0, sizeof(op));
 634         op.type = type;
 635         append_new_operation(options, op);
 636         options->args.checks.num_shorthand_ops++;
 637         return options->ops.operations + (options->ops.num_operations - 1);
 638 }
 639
 640 Argument *append_argument(CommandLineOptions *options, ArgumentType type)
 641 {
 642         Argument arg;
 643         memset(&arg, 0, sizeof(arg));
 644         arg.type = type;
 645         append_new_argument(options, arg);
 646         return options->args.arguments + (options->args.num_arguments - 1);
 647 }
 648
 649 static void usage_header(FILE *out)
 650 {
 651         fprintf(out, "==============================================================================\n");
 652         fprintf(out, "metaflac - Command-line FLAC metadata editor version %s\n", FLAC__VERSION_STRING);
 653         fprintf(out, "Copyright (C) 2001,2002  Josh Coalson\n");
 654         fprintf(out, "\n");
 655         fprintf(out, "This program is free software; you can redistribute it and/or\n");
 656         fprintf(out, "modify it under the terms of the GNU General Public License\n");
 657         fprintf(out, "as published by the Free Software Foundation; either version 2\n");
 658         fprintf(out, "of the License, or (at your option) any later version.\n");
 659         fprintf(out, "\n");
 660         fprintf(out, "This program is distributed in the hope that it will be useful,\n");
 661         fprintf(out, "but WITHOUT ANY WARRANTY; without even the implied warranty of\n");
 662         fprintf(out, "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n");
 663         fprintf(out, "GNU General Public License for more details.\n");
 664         fprintf(out, "\n");
 665         fprintf(out, "You should have received a copy of the GNU General Public License\n");
 666         fprintf(out, "along with this program; if not, write to the Free Software\n");
 667         fprintf(out, "Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.\n");
 668         fprintf(out, "==============================================================================\n");
 669 }
 670
 671 static void usage_summary(FILE *out)
 672 {
 673     fprintf(out, "Usage:\n");
 674     fprintf(out, "  metaflac [options] [operations] FLACfile [FLACfile ...]\n");
 675     fprintf(out, "\n");
 676     fprintf(out, "Use metaflac to list, add, remove, or edit metadata in one or more FLAC files.\n");
 677     fprintf(out, "You may perform one major operation, or many shorthand operations at a time.\n");
 678     fprintf(out, "\n");
 679     fprintf(out, "Options:\n");
 680     fprintf(out, "--preserve-modtime    Preserve the original modification time in spite of edits\n");
 681     fprintf(out, "--with-filename       Prefix each output line with the FLAC file name\n");
 682     fprintf(out, "                      (the default if more than one FLAC file is specified)\n");
 683     fprintf(out, "--no-filename         Do not prefix each output line with the FLAC file name\n");
 684     fprintf(out, "                      (the default if only one FLAC file is specified)\n");
 685     fprintf(out, "--dont-use-padding    By default metaflac tries to use padding where possible\n");
 686     fprintf(out, "                      to avoid rewriting the entire file if the metadata size\n");
 687     fprintf(out, "                      changes.  Use this option to tell metaflac to not take\n");
 688     fprintf(out, "                      advantage of padding this way.\n");
 689 }
 690
 691 int short_usage(const char *message, ...)
 692 {
 693         va_list args;
 694
 695         if(message) {
 696                 va_start(args, message);
 697
 698                 (void) vfprintf(stderr, message, args);
 699
 700                 va_end(args);
 701
 702         }
 703         usage_header(stderr);
 704         fprintf(stderr, "\n");
 705         fprintf(stderr, "This is the short help; for full help use 'metaflac --help'\n");
 706         fprintf(stderr, "\n");
 707         usage_summary(stderr);
 708
 709         return message? 1 : 0;
 710 }
 711
 712 int long_usage(const char *message, ...)
 713 {
 714         FILE *out = (message? stderr : stdout);
 715         va_list args;
 716
 717         if(message) {
 718                 va_start(args, message);
 719
 720                 (void) vfprintf(stderr, message, args);
 721
 722                 va_end(args);
 723
 724         }
 725         usage_header(out);
 726     fprintf(out, "\n");
 727         usage_summary(out);
 728     fprintf(out, "\n");
 729     fprintf(out, "Shorthand operations:\n");
 730     fprintf(out, "--show-md5sum         Show the MD5 signature from the STREAMINFO block.\n");
 731     fprintf(out, "--show-min-blocksize  Show the minimum block size from the STREAMINFO block.\n");
 732     fprintf(out, "--show-max-blocksize  Show the maximum block size from the STREAMINFO block.\n");
 733     fprintf(out, "--show-min-framesize  Show the minimum frame size from the STREAMINFO block.\n");
 734     fprintf(out, "--show-max-framesize  Show the maximum frame size from the STREAMINFO block.\n");
 735     fprintf(out, "--show-sample-rate    Show the sample rate from the STREAMINFO block.\n");
 736     fprintf(out, "--show-channels       Show the number of channels from the STREAMINFO block.\n");
 737     fprintf(out, "--show-bps            Show the # of bits per sample from the STREAMINFO block.\n");
 738     fprintf(out, "--show-total-samples  Show the total # of samples from the STREAMINFO block.\n");
 739     fprintf(out, "\n");
 740     fprintf(out, "--show-vc-vendor      Show the vendor string from the VORBIS_COMMENT block.\n");
 741     fprintf(out, "--show-vc-field=name  Show all Vorbis comment fields where the the field name\n");
 742     fprintf(out, "                      matches 'name'.\n");
 743     fprintf(out, "--remove-vc-field=name\n");
 744     fprintf(out, "                      Remove all Vorbis comment fields whose field name is\n");
 745     fprintf(out, "                      'name'.\n");
 746     fprintf(out, "--remove-vc-firstfield=name\n");
 747     fprintf(out, "                      Remove first Vorbis comment field whose field name is\n");
 748     fprintf(out, "                      'name'.\n");
 749     fprintf(out, "--remove-vc-all       Remove all Vorbis comment fields, leaving only the\n");
 750     fprintf(out, "                      vendor string in the VORBIS_COMMENT block.\n");
 751     fprintf(out, "--set-vc-field=field  Add a Vorbis comment field.  The field must comply with\n");
 752     fprintf(out, "                      the Vorbis comment spec, of the form \"NAME=VALUE\".  If\n");
 753     fprintf(out, "                      there is currently no VORBIS_COMMENT block, one will be\n");
 754     fprintf(out, "                      created.\n");
 755     fprintf(out, "--add-padding=length  Add a padding block of the given length (in bytes).\n");
 756     fprintf(out, "                      The overall length of the new block will be 4 + length;\n");
 757     fprintf(out, "                      the extra 4 bytes is for the metadata block header.\n");
 758     fprintf(out, "\n");
 759     fprintf(out, "Major operations:\n");
 760     fprintf(out, "--list\n");
 761     fprintf(out, "    List the contents of one or more metadata blocks to stdout.  By default,\n");
 762     fprintf(out, "    all metadata blocks are listed in text format.  Use the following options\n");
 763     fprintf(out, "    to change this behavior:\n");
 764     fprintf(out, "\n");
 765     fprintf(out, "    --block-number=#[,#[...]]\n");
 766     fprintf(out, "    An optional comma-separated list of block numbers to display.  The first\n");
 767     fprintf(out, "    block, the STREAMINFO block, is block 0.\n");
 768     fprintf(out, "\n");
 769     fprintf(out, "    --block-type=type[,type[...]]\n");
 770     fprintf(out, "    --except-block-type=type[,type[...]]\n");
 771     fprintf(out, "    An optional comma-separated list of block types to included or ignored\n");
 772     fprintf(out, "    with this option.  Use only one of --block-type or --except-block-type.\n");
 773     fprintf(out, "    The valid block types are: STREAMINFO, PADDING, APPLICATION, SEEKTABLE,\n");
 774     fprintf(out, "    VORBIS_COMMENT.  You may narrow down the types of APPLICATION blocks\n");
 775     fprintf(out, "    displayed as follows:\n");
 776     fprintf(out, "        APPLICATION:abcd        The APPLICATION block(s) whose textual repre-\n");
 777     fprintf(out, "                                sentation of the 4-byte ID is \"abcd\"\n");
 778     fprintf(out, "        APPLICATION:0xXXXXXXXX  The APPLICATION block(s) whose hexadecimal big-\n");
 779     fprintf(out, "                                endian representation of the 4-byte ID is\n");
 780     fprintf(out, "                                \"0xXXXXXXXX\".  For the example \"abcd\" above the\n");
 781     fprintf(out, "                                hexadecimal equivalalent is 0x61626364\n");
 782     fprintf(out, "\n");
 783     fprintf(out, "    NOTE: if both --block-number and --[except-]block-type are specified,\n");
 784     fprintf(out, "          the result is the logical AND of both arguments.\n");
 785     fprintf(out, "\n");
 786 #if 0
 787         /*@@@ not implemented yet */
 788     fprintf(out, "    --data-format=binary|text\n");
 789     fprintf(out, "    By default a human-readable text representation of the data is displayed.\n");
 790     fprintf(out, "    You may specify --data-format=binary to dump the raw binary form of each\n");
 791     fprintf(out, "    metadata block.  The output can be read in using a subsequent call to\n");
 792     fprintf(out, "    "metaflac --append --from-file=..."\n");
 793     fprintf(out, "\n");
 794 #endif
 795     fprintf(out, "    --application-data-format=hexdump|text\n");
 796     fprintf(out, "    If the application block you are displaying contains binary data but your\n");
 797     fprintf(out, "    --data-format=text, you can display a hex dump of the application data\n");
 798     fprintf(out, "    contents instead using --application-data-format=hexdump\n");
 799     fprintf(out, "\n");
 800 #if 0
 801         /*@@@ not implemented yet */
 802     fprintf(out, "--append\n");
 803     fprintf(out, "    Insert a metadata block from a file.  The input file must be in the same\n");
 804     fprintf(out, "    format as generated with --list.\n");
 805     fprintf(out, "\n");
 806     fprintf(out, "    --block-number=#\n");
 807     fprintf(out, "    Specify the insertion point (defaults to last block).  The new block will\n");
 808     fprintf(out, "    be added after the given block number.  This prevents the illegal insertion\n");
 809     fprintf(out, "    of a block before the first STREAMINFO block.  You may not --append another\n");
 810     fprintf(out, "    STREAMINFO block.\n");
 811     fprintf(out, "\n");
 812     fprintf(out, "    --from-file=filename\n");
 813     fprintf(out, "    Mandatory 'option' to specify the input file containing the block contents.\n");
 814     fprintf(out, "\n");
 815     fprintf(out, "    --data-format=binary|text\n");
 816     fprintf(out, "    By default the block contents are assumed to be in binary format.  You can\n");
 817     fprintf(out, "    override this by specifying --data-format=text\n");
 818     fprintf(out, "\n");
 819 #endif
 820     fprintf(out, "--remove\n");
 821     fprintf(out, "    Remove one or more metadata blocks from the metadata.  Unless\n");
 822     fprintf(out, "    --dont-use-padding is specified, the blocks will be replaced with padding.\n");
 823     fprintf(out, "    You may not remove the STREAMINFO block.\n");
 824     fprintf(out, "\n");
 825     fprintf(out, "    --block-number=#[,#[...]]\n");
 826     fprintf(out, "    --block-type=type[,type[...]]\n");
 827     fprintf(out, "    --except-block-type=type[,type[...]]\n");
 828     fprintf(out, "    See --list above for usage.\n");
 829     fprintf(out, "\n");
 830     fprintf(out, "    NOTE: if both --block-number and --[except-]block-type are specified,\n");
 831     fprintf(out, "          the result is the logical AND of both arguments.\n");
 832     fprintf(out, "\n");
 833     fprintf(out, "--remove-all\n");
 834     fprintf(out, "    Remove all metadata blocks (except the STREAMINFO block) from the\n");
 835     fprintf(out, "    metadata.  Unless --dont-use-padding is specified, the blocks will be\n");
 836     fprintf(out, "    replaced with padding.\n");
 837     fprintf(out, "\n");
 838     fprintf(out, "--merge-padding\n");
 839     fprintf(out, "    Merge adjacent PADDING blocks into single blocks.\n");
 840     fprintf(out, "\n");
 841     fprintf(out, "--sort-padding\n");
 842     fprintf(out, "    Move all PADDING blocks to the end of the metadata and merge them into a\n");
 843     fprintf(out, "    single block.\n");
 844
 845         return message? 1 : 0;
 846 }
 847
 848 char *local_strdup(const char *source)
 849 {
 850         char *ret;
 851         FLAC__ASSERT(0 != source);
 852         if(0 == (ret = strdup(source)))
 853                 die("out of memory during strdup()");
 854         return ret;
 855 }
 856
 857 FLAC__bool parse_vorbis_comment_field(const char *field_ref, char **field, char **name, char **value, unsigned *length)
 858 {
 859         char *p, *s;
 860
 861         if(0 != field)
 862                 *field = local_strdup(field_ref);
 863
 864         s = local_strdup(field_ref);
 865
 866         if(0 == (p = strchr(s, '='))) {
 867                 free(s);
 868                 return false;
 869         }
 870         *p++ = '\0';
 871         *name = local_strdup(s);
 872         *value = local_strdup(p);
 873         *length = strlen(p);
 874
 875         free(s);
 876         return true;
 877 }
 878
 879 FLAC__bool parse_add_padding(const char *in, unsigned *out)
 880 {
 881         *out = (unsigned)strtoul(in, 0, 10);
 882         return *out < (1u << FLAC__STREAM_METADATA_LENGTH_LEN);
 883 }
 884
 885 FLAC__bool parse_block_number(const char *in, Argument_BlockNumber *out)
 886 {
 887         char *p, *q, *s, *end;
 888         long i;
 889         unsigned entry;
 890
 891         if(*in == '\0')
 892                 return false;
 893
 894         s = local_strdup(in);
 895
 896         /* first count the entries */
 897         for(out->num_entries = 1, p = strchr(s, ','); p; out->num_entries++, p = strchr(++p, ','))
 898                 ;
 899
 900         /* make space */
 901         FLAC__ASSERT(out->num_entries > 0);
 902         if(0 == (out->entries = malloc(sizeof(unsigned) * out->num_entries)))
 903                 die("out of memory allocating space for option list");
 904
 905         /* load 'em up */
 906         entry = 0;
 907         q = s;
 908         while(q) {
 909                 FLAC__ASSERT(entry < out->num_entries);
 910                 if(0 != (p = strchr(q, ',')))
 911                         *p++ = '\0';
 912                 if(!isdigit((int)(*q)) || (i = strtol(q, &end, 10)) < 0 || *end) {
 913                         free(s);
 914                         return false;
 915                 }
 916                 out->entries[entry++] = (unsigned)i;
 917                 q = p;
 918         }
 919         FLAC__ASSERT(entry == out->num_entries);
 920
 921         free(s);
 922         return true;
 923 }
 924
 925 FLAC__bool parse_block_type(const char *in, Argument_BlockType *out)
 926 {
 927         char *p, *q, *r, *s;
 928         unsigned entry;
 929
 930         if(*in == '\0')
 931                 return false;
 932
 933         s = local_strdup(in);
 934
 935         /* first count the entries */
 936         for(out->num_entries = 1, p = strchr(s, ','); p; out->num_entries++, p = strchr(++p, ','))
 937                 ;
 938
 939         /* make space */
 940         FLAC__ASSERT(out->num_entries > 0);
 941         if(0 == (out->entries = malloc(sizeof(Argument_BlockTypeEntry) * out->num_entries)))
 942                 die("out of memory allocating space for option list");
 943
 944         /* load 'em up */
 945         entry = 0;
 946         q = s;
 947         while(q) {
 948                 FLAC__ASSERT(entry < out->num_entries);
 949                 if(0 != (p = strchr(q, ',')))
 950                         *p++ = 0;
 951                 r = strchr(q, ':');
 952                 if(r)
 953                         *r++ = '\0';
 954                 if(0 != r && 0 != strcmp(q, "APPLICATION")) {
 955                         free(s);
 956                         return false;
 957                 }
 958                 if(0 == strcmp(q, "STREAMINFO")) {
 959                         out->entries[entry++].type = FLAC__METADATA_TYPE_STREAMINFO;
 960                 }
 961                 else if(0 == strcmp(q, "PADDING")) {
 962                         out->entries[entry++].type = FLAC__METADATA_TYPE_PADDING;
 963                 }
 964                 else if(0 == strcmp(q, "APPLICATION")) {
 965                         out->entries[entry].type = FLAC__METADATA_TYPE_APPLICATION;
 966                         out->entries[entry].filter_application_by_id = (0 != r);
 967                         if(0 != r) {
 968                                 if(strlen(r) == 4) {
 969                                         strcpy(out->entries[entry].application_id, r);
 970                                 }
 971                                 else if(strlen(r) == 10 && strncmp(r, "0x", 2) == 0 && strspn(r+2, "0123456789ABCDEFabcdef") == 8) {
 972                                         FLAC__uint32 x = strtoul(r+2, 0, 16);
 973                                         out->entries[entry].application_id[3] = (FLAC__byte)(x & 0xff);
 974                                         out->entries[entry].application_id[2] = (FLAC__byte)((x>>=8) & 0xff);
 975                                         out->entries[entry].application_id[1] = (FLAC__byte)((x>>=8) & 0xff);
 976                                         out->entries[entry].application_id[0] = (FLAC__byte)((x>>=8) & 0xff);
 977                                 }
 978                                 else {
 979                                         free(s);
 980                                         return false;
 981                                 }
 982                         }
 983                         entry++;
 984                 }
 985                 else if(0 == strcmp(q, "SEEKTABLE")) {
 986                         out->entries[entry++].type = FLAC__METADATA_TYPE_SEEKTABLE;
 987                 }
 988                 else if(0 == strcmp(q, "VORBIS_COMMENT")) {
 989                         out->entries[entry++].type = FLAC__METADATA_TYPE_VORBIS_COMMENT;
 990                 }
 991                 else {
 992                         free(s);
 993                         return false;
 994                 }
 995                 q = p;
 996         }
 997         FLAC__ASSERT(entry == out->num_entries);
 998
 999         free(s);
1000         return true;
1001 }
1002
1003 FLAC__bool parse_data_format(const char *in, Argument_DataFormat *out)
1004 {
1005         if(0 == strcmp(in, "binary"))
1006                 out->is_binary = true;
1007         else if(0 == strcmp(in, "text"))
1008                 out->is_binary = false;
1009         else
1010                 return false;
1011         return true;
1012 }
1013
1014 FLAC__bool parse_application_data_format(const char *in, FLAC__bool *out)
1015 {
1016         if(0 == strcmp(in, "hexdump"))
1017                 *out = true;
1018         else if(0 == strcmp(in, "text"))
1019                 *out = false;
1020         else
1021                 return false;
1022         return true;
1023 }
1024
1025 FLAC__bool do_operations(const CommandLineOptions *options)
1026 {
1027         FLAC__bool ok = true;
1028
1029         if(options->show_long_help) {
1030                 long_usage(0);
1031         }
1032         else if(options->args.checks.num_major_ops > 0) {
1033                 FLAC__ASSERT(options->args.checks.num_shorthand_ops == 0);
1034                 FLAC__ASSERT(options->args.checks.num_major_ops == 1);
1035                 FLAC__ASSERT(options->args.checks.num_major_ops == options->ops.num_operations);
1036                 ok = do_major_operation(options);
1037         }
1038         else if(options->args.checks.num_shorthand_ops > 0) {
1039                 FLAC__ASSERT(options->args.checks.num_shorthand_ops == options->ops.num_operations);
1040                 ok = do_shorthand_operations(options);
1041         }
1042
1043         return ok;
1044 }
1045
1046 FLAC__bool do_major_operation(const CommandLineOptions *options)
1047 {
1048         unsigned i;
1049         FLAC__bool ok = true;
1050
1051         /*@@@ to die after first error,  v---  add '&& ok' here */
1052         for(i = 0; i < options->num_files; i++)
1053                 ok &= do_major_operation_on_file(options->filenames[i], options);
1054
1055         return ok;
1056 }
1057
1058 FLAC__bool do_major_operation_on_file(const char *filename, const CommandLineOptions *options)
1059 {
1060         FLAC__bool ok = true, needs_write = false;
1061         FLAC__Metadata_Chain *chain = FLAC__metadata_chain_new();
1062
1063         if(0 == chain)
1064                 die("out of memory allocating chain");
1065
1066         if(!FLAC__metadata_chain_read(chain, filename)) {
1067                 fprintf(stderr, "%s: ERROR: reading metadata, status = \"%s\"\n", filename, FLAC__Metadata_ChainStatusString[FLAC__metadata_chain_status(chain)]);
1068                 return false;
1069         }
1070
1071         switch(options->ops.operations[0].type) {
1072                 case OP__LIST:
1073                         ok = do_major_operation__list(options->prefix_with_filename? filename : 0, chain, options);
1074                         break;
1075                 case OP__APPEND:
1076                         ok = do_major_operation__append(chain, options);
1077                         needs_write = true;
1078                         break;
1079                 case OP__REMOVE:
1080                         ok = do_major_operation__remove(chain, options);
1081                         needs_write = true;
1082                         break;
1083                 case OP__REMOVE_ALL:
1084                         ok = do_major_operation__remove_all(chain, options);
1085                         needs_write = true;
1086                         break;
1087                 case OP__MERGE_PADDING:
1088                         FLAC__metadata_chain_merge_padding(chain);
1089                         needs_write = true;
1090                         break;
1091                 case OP__SORT_PADDING:
1092                         FLAC__metadata_chain_sort_padding(chain);
1093                         needs_write = true;
1094                         break;
1095                 default:
1096                         FLAC__ASSERT(0);
1097                         return false;
1098         }
1099
1100         if(ok && needs_write) {
1101                 if(options->use_padding)
1102                         FLAC__metadata_chain_sort_padding(chain);
1103                 ok = FLAC__metadata_chain_write(chain, options->use_padding, options->preserve_modtime);
1104                 if(!ok)
1105                         fprintf(stderr, "%s: ERROR: writing FLAC file, error = %s\n", filename, FLAC__Metadata_ChainStatusString[FLAC__metadata_chain_status(chain)]);
1106         }
1107
1108         FLAC__metadata_chain_delete(chain);
1109
1110         return ok;
1111 }
1112
1113 FLAC__bool do_major_operation__list(const char *filename, FLAC__Metadata_Chain *chain, const CommandLineOptions *options)
1114 {
1115         FLAC__Metadata_Iterator *iterator = FLAC__metadata_iterator_new();
1116         FLAC__StreamMetadata *block;
1117         FLAC__bool ok = true;
1118         unsigned block_number;
1119
1120         if(0 == iterator)
1121                 die("out of memory allocating iterator");
1122
1123         FLAC__metadata_iterator_init(iterator, chain);
1124
1125         block_number = 0;
1126         do {
1127                 block = FLAC__metadata_iterator_get_block(iterator);
1128                 ok &= (0 != block);
1129                 if(!ok)
1130                         fprintf(stderr, "%s: ERROR: couldn't get block from chain\n", filename);
1131                 else if(passes_filter(options, FLAC__metadata_iterator_get_block(iterator), block_number))
1132                         write_metadata(filename, block, block_number, options->application_data_format_is_hexdump);
1133                 block_number++;
1134         } while(ok && FLAC__metadata_iterator_next(iterator));
1135
1136         FLAC__metadata_iterator_delete(iterator);
1137
1138         return ok;
1139 }
1140
1141 FLAC__bool do_major_operation__append(FLAC__Metadata_Chain *chain, const CommandLineOptions *options)
1142 {
1143         (void) chain, (void) options;
1144         fprintf(stderr, "ERROR: --append not implemented yet\n"); /*@@@*/
1145         return false;
1146 }
1147
1148 FLAC__bool do_major_operation__remove(FLAC__Metadata_Chain *chain, const CommandLineOptions *options)
1149 {
1150         FLAC__Metadata_Iterator *iterator = FLAC__metadata_iterator_new();
1151         FLAC__bool ok = true;
1152         unsigned block_number;
1153
1154         if(0 == iterator)
1155                 die("out of memory allocating iterator");
1156
1157         FLAC__metadata_iterator_init(iterator, chain);
1158
1159         block_number = 0;
1160         while(ok && FLAC__metadata_iterator_next(iterator)) {
1161                 block_number++;
1162                 if(passes_filter(options, FLAC__metadata_iterator_get_block(iterator), block_number)) {
1163                         ok &= FLAC__metadata_iterator_delete_block(iterator, options->use_padding);
1164                         if(options->use_padding)
1165                                 ok &= FLAC__metadata_iterator_next(iterator);
1166                 }
1167         }
1168
1169         FLAC__metadata_iterator_delete(iterator);
1170
1171         return ok;
1172 }
1173
1174 FLAC__bool do_major_operation__remove_all(FLAC__Metadata_Chain *chain, const CommandLineOptions *options)
1175 {
1176         FLAC__Metadata_Iterator *iterator = FLAC__metadata_iterator_new();
1177         FLAC__bool ok = true;
1178
1179         if(0 == iterator)
1180                 die("out of memory allocating iterator");
1181
1182         FLAC__metadata_iterator_init(iterator, chain);
1183
1184         while(ok && FLAC__metadata_iterator_next(iterator)) {
1185                 ok &= FLAC__metadata_iterator_delete_block(iterator, options->use_padding);
1186                 if(options->use_padding)
1187                         ok &= FLAC__metadata_iterator_next(iterator);
1188         }
1189
1190         FLAC__metadata_iterator_delete(iterator);
1191
1192         return ok;
1193 }
1194
1195 FLAC__bool do_shorthand_operations(const CommandLineOptions *options)
1196 {
1197         unsigned i;
1198         FLAC__bool ok = true;
1199
1200         /*@@@ to die after first error,  v---  add '&& ok' here */
1201         for(i = 0; i < options->num_files; i++)
1202                 ok &= do_shorthand_operations_on_file(options->filenames[i], options);
1203
1204         return ok;
1205 }
1206
1207 FLAC__bool do_shorthand_operations_on_file(const char *filename, const CommandLineOptions *options)
1208 {
1209         unsigned i;
1210         FLAC__bool ok = true, needs_write = false;
1211         FLAC__Metadata_Chain *chain = FLAC__metadata_chain_new();
1212
1213         if(0 == chain)
1214                 die("out of memory allocating chain");
1215
1216         if(!FLAC__metadata_chain_read(chain, filename)) {
1217                 fprintf(stderr, "%s: ERROR: reading metadata, status = \"%s\"\n", filename, FLAC__Metadata_ChainStatusString[FLAC__metadata_chain_status(chain)]);
1218                 return false;
1219         }
1220
1221         for(i = 0; i < options->ops.num_operations && ok; i++)
1222                 ok &= do_shorthand_operation(options->prefix_with_filename? filename : 0, chain, &options->ops.operations[i], &needs_write);
1223
1224         if(ok) {
1225                 if(options->use_padding)
1226                         FLAC__metadata_chain_sort_padding(chain);
1227                 ok = FLAC__metadata_chain_write(chain, options->use_padding, options->preserve_modtime);
1228                 if(!ok)
1229                         fprintf(stderr, "%s: ERROR: writing FLAC file, error = %s\n", filename, FLAC__Metadata_ChainStatusString[FLAC__metadata_chain_status(chain)]);
1230         }
1231
1232         FLAC__metadata_chain_delete(chain);
1233
1234         return ok;
1235 }
1236
1237 FLAC__bool do_shorthand_operation(const char *filename, FLAC__Metadata_Chain *chain, const Operation *operation, FLAC__bool *needs_write)
1238 {
1239         FLAC__bool ok = true;
1240
1241         switch(operation->type) {
1242                 case OP__SHOW_MD5SUM:
1243                 case OP__SHOW_MIN_BLOCKSIZE:
1244                 case OP__SHOW_MAX_BLOCKSIZE:
1245                 case OP__SHOW_MIN_FRAMESIZE:
1246                 case OP__SHOW_MAX_FRAMESIZE:
1247                 case OP__SHOW_SAMPLE_RATE:
1248                 case OP__SHOW_CHANNELS:
1249                 case OP__SHOW_BPS:
1250                 case OP__SHOW_TOTAL_SAMPLES:
1251                         ok = do_shorthand_operation__streaminfo(filename, chain, operation->type);
1252                         break;
1253                 case OP__SHOW_VC_VENDOR:
1254                 case OP__SHOW_VC_FIELD:
1255                 case OP__REMOVE_VC_ALL:
1256                 case OP__REMOVE_VC_FIELD:
1257                 case OP__REMOVE_VC_FIRSTFIELD:
1258                 case OP__SET_VC_FIELD:
1259                         ok = do_shorthand_operation__vorbis_comment(filename, chain, operation, needs_write);
1260                         break;
1261                 case OP__ADD_PADDING:
1262                         ok = do_shorthand_operation__add_padding(filename, chain, operation->argument.add_padding.length, needs_write);
1263                         break;
1264                 default:
1265                         ok = false;
1266                         FLAC__ASSERT(0);
1267                         break;
1268         };
1269
1270         return ok;
1271 }
1272
1273 FLAC__bool do_shorthand_operation__add_padding(const char *filename, FLAC__Metadata_Chain *chain, unsigned length, FLAC__bool *needs_write)
1274 {
1275         FLAC__StreamMetadata *padding = 0;
1276         FLAC__Metadata_Iterator *iterator = FLAC__metadata_iterator_new();
1277
1278         if(0 == iterator)
1279                 die("out of memory allocating iterator");
1280
1281         FLAC__metadata_iterator_init(iterator, chain);
1282
1283         while(FLAC__metadata_iterator_next(iterator))
1284                 ;
1285
1286         padding = FLAC__metadata_object_new(FLAC__METADATA_TYPE_PADDING);
1287         if(0 == padding)
1288                 die("out of memory allocating PADDING block");
1289
1290         padding->length = length;
1291
1292         if(!FLAC__metadata_iterator_insert_block_after(iterator, padding)) {
1293                 fprintf(stderr, "%s: ERROR: adding new PADDING block to metadata, status =\"%s\"\n", filename, FLAC__Metadata_ChainStatusString[FLAC__metadata_chain_status(chain)]);
1294                 FLAC__metadata_object_delete(padding);
1295                 return false;
1296         }
1297
1298         *needs_write = true;
1299         return true;
1300 }
1301
1302 FLAC__bool do_shorthand_operation__streaminfo(const char *filename, FLAC__Metadata_Chain *chain, OperationType op)
1303 {
1304         unsigned i;
1305         FLAC__bool ok = true;
1306         FLAC__StreamMetadata *block;
1307         FLAC__Metadata_Iterator *iterator = FLAC__metadata_iterator_new();
1308
1309         if(0 == iterator)
1310                 die("out of memory allocating iterator");
1311
1312         FLAC__metadata_iterator_init(iterator, chain);
1313
1314         block = FLAC__metadata_iterator_get_block(iterator);
1315
1316         FLAC__ASSERT(0 != block);
1317         FLAC__ASSERT(block->type == FLAC__METADATA_TYPE_STREAMINFO);
1318
1319         if(0 != filename)
1320                 printf("%s:", filename);
1321
1322         switch(op) {
1323                 case OP__SHOW_MD5SUM:
1324                         for(i = 0; i < 16; i++)
1325                                 printf("%02x", block->data.stream_info.md5sum[i]);
1326                         printf("\n");
1327                         break;
1328                 case OP__SHOW_MIN_BLOCKSIZE:
1329                         printf("%u\n", block->data.stream_info.min_blocksize);
1330                         break;
1331                 case OP__SHOW_MAX_BLOCKSIZE:
1332                         printf("%u\n", block->data.stream_info.max_blocksize);
1333                         break;
1334                 case OP__SHOW_MIN_FRAMESIZE:
1335                         printf("%u\n", block->data.stream_info.min_framesize);
1336                         break;
1337                 case OP__SHOW_MAX_FRAMESIZE:
1338                         printf("%u\n", block->data.stream_info.max_framesize);
1339                         break;
1340                 case OP__SHOW_SAMPLE_RATE:
1341                         printf("%u\n", block->data.stream_info.sample_rate);
1342                         break;
1343                 case OP__SHOW_CHANNELS:
1344                         printf("%u\n", block->data.stream_info.channels);
1345                         break;
1346                 case OP__SHOW_BPS:
1347                         printf("%u\n", block->data.stream_info.bits_per_sample);
1348                         break;
1349                 case OP__SHOW_TOTAL_SAMPLES:
1350                         printf("%llu\n", block->data.stream_info.total_samples);
1351                         break;
1352                 default:
1353                         ok = false;
1354                         FLAC__ASSERT(0);
1355                         break;
1356         };
1357
1358         FLAC__metadata_iterator_delete(iterator);
1359
1360         return ok;
1361 }
1362
1363 FLAC__bool do_shorthand_operation__vorbis_comment(const char *filename, FLAC__Metadata_Chain *chain, const Operation *operation, FLAC__bool *needs_write)
1364 {
1365         FLAC__bool ok = true, found_vc_block = false;
1366         FLAC__StreamMetadata *block = 0;
1367         FLAC__Metadata_Iterator *iterator = FLAC__metadata_iterator_new();
1368
1369         if(0 == iterator)
1370                 die("out of memory allocating iterator");
1371
1372         FLAC__metadata_iterator_init(iterator, chain);
1373
1374         do {
1375                 block = FLAC__metadata_iterator_get_block(iterator);
1376                 if(block->type == FLAC__METADATA_TYPE_VORBIS_COMMENT)
1377                         found_vc_block = true;
1378         } while(!found_vc_block && FLAC__metadata_iterator_next(iterator));
1379
1380         /* create a new block if necessary */
1381         if(!found_vc_block && operation->type == OP__SET_VC_FIELD) {
1382                 block = FLAC__metadata_object_new(FLAC__METADATA_TYPE_VORBIS_COMMENT);
1383                 if(0 == block)
1384                         die("out of memory allocating VORBIS_COMMENT block");
1385                 while(FLAC__metadata_iterator_next(iterator))
1386                         ;
1387                 if(!FLAC__metadata_iterator_insert_block_after(iterator, block)) {
1388                         fprintf(stderr, "%s: ERROR: adding new VORBIS_COMMENT block to metadata, status =\"%s\"\n", filename, FLAC__Metadata_ChainStatusString[FLAC__metadata_chain_status(chain)]);
1389                         return false;
1390                 }
1391                 /* iterator is left pointing to new block */
1392                 FLAC__ASSERT(FLAC__metadata_iterator_get_block(iterator) == block);
1393         }
1394
1395         FLAC__ASSERT(0 != block);
1396         FLAC__ASSERT(block->type == FLAC__METADATA_TYPE_VORBIS_COMMENT);
1397
1398         switch(operation->type) {
1399                 case OP__SHOW_VC_VENDOR:
1400                         write_vc_field(filename, &block->data.vorbis_comment.vendor_string);
1401                         break;
1402                 case OP__SHOW_VC_FIELD:
1403                         write_vc_fields(filename, operation->argument.show_vc_field.field_name, block->data.vorbis_comment.comments, block->data.vorbis_comment.num_comments);
1404                         break;
1405                 case OP__REMOVE_VC_ALL:
1406                         ok = remove_vc_all(block, needs_write);
1407                         break;
1408                 case OP__REMOVE_VC_FIELD:
1409                         ok = remove_vc_field(block, operation->argument.remove_vc_field.field_name, needs_write);
1410                         break;
1411                 case OP__REMOVE_VC_FIRSTFIELD:
1412                         ok = remove_vc_firstfield(block, operation->argument.remove_vc_firstfield.field_name, needs_write);
1413                         break;
1414                 case OP__SET_VC_FIELD:
1415                         ok = set_vc_field(block, &operation->argument.set_vc_field, needs_write);
1416                         break;
1417                 default:
1418                         ok = false;
1419                         FLAC__ASSERT(0);
1420                         break;
1421         };
1422
1423         return ok;
1424 }
1425
1426 FLAC__bool passes_filter(const CommandLineOptions *options, const FLAC__StreamMetadata *block, unsigned block_number)
1427 {
1428         unsigned i, j;
1429         FLAC__bool matches_number = false, matches_type = false;
1430         FLAC__bool has_block_number_arg = false;
1431
1432         for(i = 0; i < options->args.num_arguments; i++) {
1433                 if(options->args.arguments[i].type == ARG__BLOCK_TYPE || options->args.arguments[i].type == ARG__EXCEPT_BLOCK_TYPE) {
1434                         for(j = 0; j < options->args.arguments[i].value.block_type.num_entries; j++) {
1435                                 if(options->args.arguments[i].value.block_type.entries[j].type == block->type) {
1436                                         if(block->type != FLAC__METADATA_TYPE_APPLICATION || !options->args.arguments[i].value.block_type.entries[j].filter_application_by_id || 0 == memcmp(options->args.arguments[i].value.block_type.entries[j].application_id, block->data.application.id, FLAC__STREAM_METADATA_APPLICATION_ID_LEN/8))
1437                                                 matches_type = true;
1438                                 }
1439                         }
1440                 }
1441                 else if(options->args.arguments[i].type == ARG__BLOCK_NUMBER) {
1442                         has_block_number_arg = true;
1443                         for(j = 0; j < options->args.arguments[i].value.block_number.num_entries; j++) {
1444                                 if(options->args.arguments[i].value.block_number.entries[j] == block_number)
1445                                         matches_number = true;
1446                         }
1447                 }
1448         }
1449
1450         if(!has_block_number_arg)
1451                 matches_number = true;
1452
1453         if(options->args.checks.has_block_type) {
1454                 FLAC__ASSERT(!options->args.checks.has_except_block_type);
1455         }
1456         else if(options->args.checks.has_except_block_type)
1457                 matches_type = !matches_type;
1458         else
1459                 matches_type = true;
1460
1461         return matches_number && matches_type;
1462 }
1463
1464 void write_metadata(const char *filename, FLAC__StreamMetadata *block, unsigned block_number, FLAC__bool hexdump_application)
1465 {
1466         unsigned i;
1467
1468 /*@@@ yuck, should do this with a varargs function or something: */
1469 #define PPR if(filename)printf("%s:",filename);
1470         PPR; printf("METADATA block #%u\n", block_number);
1471         PPR; printf("  type: %u (%s)\n", (unsigned)block->type, block->type<=FLAC__METADATA_TYPE_VORBIS_COMMENT? FLAC__MetadataTypeString[block->type] : "UNKNOWN");
1472         PPR; printf("  is last: %s\n", block->is_last? "true":"false");
1473         PPR; printf("  length: %u\n", block->length);
1474
1475         switch(block->type) {
1476                 case FLAC__METADATA_TYPE_STREAMINFO:
1477                         PPR; printf("  minumum blocksize: %u samples\n", block->data.stream_info.min_blocksize);
1478                         PPR; printf("  maximum blocksize: %u samples\n", block->data.stream_info.max_blocksize);
1479                         PPR; printf("  minimum framesize: %u bytes\n", block->data.stream_info.min_framesize);
1480                         PPR; printf("  maximum framesize: %u bytes\n", block->data.stream_info.max_framesize);
1481                         PPR; printf("  sample_rate: %u Hz\n", block->data.stream_info.sample_rate);
1482                         PPR; printf("  channels: %u\n", block->data.stream_info.channels);
1483                         PPR; printf("  bits-per-sample: %u\n", block->data.stream_info.bits_per_sample);
1484                         PPR; printf("  total samples: %llu\n", block->data.stream_info.total_samples);
1485                         PPR; printf("  MD5 signature: ");
1486                         for(i = 0; i < 16; i++) {
1487                                 printf("%02x", (unsigned)block->data.stream_info.md5sum[i]);
1488                         }
1489                         printf("\n");
1490                         break;
1491                 case FLAC__METADATA_TYPE_PADDING:
1492                         /* nothing to print */
1493                         break;
1494                 case FLAC__METADATA_TYPE_APPLICATION:
1495                         PPR; printf("  application ID: ");
1496                         for(i = 0; i < 4; i++) {
1497                                 PPR; printf("%02x", block->data.application.id[i]);
1498                         }
1499                         PPR; printf("\n");
1500                         PPR; printf("  data contents:\n");
1501                         if(0 != block->data.application.data) {
1502                                 if(hexdump_application)
1503                                         hexdump(filename, block->data.application.data, block->length - FLAC__STREAM_METADATA_HEADER_LENGTH, "    ");
1504                                 else
1505                                         (void) fwrite(block->data.application.data, 1, block->length - FLAC__STREAM_METADATA_HEADER_LENGTH, stdout);
1506                         }
1507                         break;
1508                 case FLAC__METADATA_TYPE_SEEKTABLE:
1509                         PPR; printf("  seek points: %u\n", block->data.seek_table.num_points);
1510                         for(i = 0; i < block->data.seek_table.num_points; i++) {
1511                                 if(block->data.seek_table.points[i].sample_number != FLAC__STREAM_METADATA_SEEKPOINT_PLACEHOLDER) {
1512                                         PPR; printf("    point %d: sample_number=%llu, stream_offset=%llu, frame_samples=%u\n", i, block->data.seek_table.points[i].sample_number, block->data.seek_table.points[i].stream_offset, block->data.seek_table.points[i].frame_samples);
1513                                 }
1514                                 else {
1515                                         PPR; printf("    point %d: PLACEHOLDER\n", i);
1516                                 }
1517                         }
1518                         break;
1519                 case FLAC__METADATA_TYPE_VORBIS_COMMENT:
1520                         PPR; printf("  vendor string: ");
1521                         fwrite(block->data.vorbis_comment.vendor_string.entry, 1, block->data.vorbis_comment.vendor_string.length, stdout);
1522                         printf("\n");
1523                         PPR; printf("  comments: %u\n", block->data.vorbis_comment.num_comments);
1524                         for(i = 0; i < block->data.vorbis_comment.num_comments; i++) {
1525                                 PPR; printf("    comment[%u]: ", i);
1526                                 fwrite(block->data.vorbis_comment.comments[i].entry, 1, block->data.vorbis_comment.comments[i].length, stdout);
1527                                 printf("\n");
1528                         }
1529                         break;
1530                 default:
1531                         PPR; printf("SKIPPING block of unknown type\n");
1532                         break;
1533         }
1534 #undef PPR
1535 }
1536
1537 void write_vc_field(const char *filename, const FLAC__StreamMetadata_VorbisComment_Entry *entry)
1538 {
1539         if(filename)
1540                 printf("%s:", filename);
1541         (void) fwrite(entry->entry, 1, entry->length, stdout);
1542         printf("\n");
1543 }
1544
1545 void write_vc_fields(const char *filename, const char *field_name, const FLAC__StreamMetadata_VorbisComment_Entry entry[], unsigned num_entries)
1546 {
1547         unsigned i;
1548         const unsigned field_name_length = strlen(field_name);
1549
1550         for(i = 0; i < num_entries; i++) {
1551                 if(field_name_matches_entry(field_name, field_name_length, entry + i))
1552                         write_vc_field(filename, entry + i);
1553         }
1554 }
1555
1556 FLAC__bool remove_vc_all(FLAC__StreamMetadata *block, FLAC__bool *needs_write)
1557 {
1558         FLAC__ASSERT(0 != block);
1559         FLAC__ASSERT(block->type == FLAC__METADATA_TYPE_VORBIS_COMMENT);
1560         FLAC__ASSERT(0 != needs_write);
1561
1562         if(0 != block->data.vorbis_comment.comments) {
1563                 FLAC__ASSERT(block->data.vorbis_comment.num_comments > 0);
1564                 if(!FLAC__metadata_object_vorbiscomment_resize_comments(block, 0))
1565                         return false;
1566                 *needs_write = true;
1567         }
1568         else {
1569                 FLAC__ASSERT(block->data.vorbis_comment.num_comments == 0);
1570         }
1571
1572         return true;
1573 }
1574
1575 FLAC__bool remove_vc_field(FLAC__StreamMetadata *block, const char *field_name, FLAC__bool *needs_write)
1576 {
1577         FLAC__bool ok = true;
1578         const unsigned field_name_length = strlen(field_name);
1579         int i;
1580
1581         FLAC__ASSERT(0 != block);
1582         FLAC__ASSERT(block->type == FLAC__METADATA_TYPE_VORBIS_COMMENT);
1583         FLAC__ASSERT(0 != needs_write);
1584
1585         /* must delete from end to start otherwise it will interfere with our iteration */
1586         for(i = (int)block->data.vorbis_comment.num_comments - 1; ok && i >= 0; i--) {
1587                 if(field_name_matches_entry(field_name, field_name_length, block->data.vorbis_comment.comments + i)) {
1588                         ok &= FLAC__metadata_object_vorbiscomment_delete_comment(block, (unsigned)i);
1589                         if(ok)
1590                                 *needs_write = true;
1591                 }
1592         }
1593
1594         return ok;
1595 }
1596
1597 FLAC__bool remove_vc_firstfield(FLAC__StreamMetadata *block, const char *field_name, FLAC__bool *needs_write)
1598 {
1599         const unsigned field_name_length = strlen(field_name);
1600         unsigned i;
1601
1602         FLAC__ASSERT(0 != block);
1603         FLAC__ASSERT(block->type == FLAC__METADATA_TYPE_VORBIS_COMMENT);
1604         FLAC__ASSERT(0 != needs_write);
1605
1606         for(i = 0; i < block->data.vorbis_comment.num_comments; i++) {
1607                 if(field_name_matches_entry(field_name, field_name_length, block->data.vorbis_comment.comments + i)) {
1608                         if(!FLAC__metadata_object_vorbiscomment_delete_comment(block, (unsigned)i))
1609                                 return false;
1610                         else
1611                                 *needs_write = true;
1612                         break;
1613                 }
1614         }
1615
1616         return true;
1617 }
1618
1619 FLAC__bool set_vc_field(FLAC__StreamMetadata *block, const Argument_VcField *field, FLAC__bool *needs_write)
1620 {
1621         FLAC__StreamMetadata_VorbisComment_Entry entry;
1622         FLAC__ASSERT(0 != block);
1623         FLAC__ASSERT(block->type == FLAC__METADATA_TYPE_VORBIS_COMMENT);
1624         FLAC__ASSERT(0 != field);
1625         FLAC__ASSERT(0 != needs_write);
1626
1627         entry.length = strlen(field->field);
1628         entry.entry = field->field;
1629
1630         if(!FLAC__metadata_object_vorbiscomment_insert_comment(block, block->data.vorbis_comment.num_comments, entry, /*copy=*/true)) {
1631                 return false;
1632         }
1633         else {
1634                 *needs_write = true;
1635                 return true;
1636         }
1637 }
1638
1639 FLAC__bool field_name_matches_entry(const char *field_name, unsigned field_name_length, const FLAC__StreamMetadata_VorbisComment_Entry *entry)
1640 {
1641         return (0 != memchr(entry->entry, '=', entry->length) && 0 == strncmp(field_name, entry->entry, field_name_length));
1642 }
1643
1644 void hexdump(const char *filename, const FLAC__byte *buf, unsigned bytes, const char *indent)
1645 {
1646         unsigned i, left = bytes;
1647         const FLAC__byte *b = buf;
1648
1649         for(i = 0; i < bytes; i += 16) {
1650                 printf("%s%s%s%08X: "
1651                         "%02X %02X %02X %02X %02X %02X %02X %02X "
1652                         "%02X %02X %02X %02X %02X %02X %02X %02X "
1653                         "%c%c%c%c%c%c%c%c%c%c%c%c%c%c%c%c\n",
1654                         filename? filename:"", filename? ":":"",
1655                         indent, i,
1656                         left >  0? (unsigned char)b[ 0] : 0,
1657                         left >  1? (unsigned char)b[ 1] : 0,
1658                         left >  2? (unsigned char)b[ 2] : 0,
1659                         left >  3? (unsigned char)b[ 3] : 0,
1660                         left >  4? (unsigned char)b[ 4] : 0,
1661                         left >  5? (unsigned char)b[ 5] : 0,
1662                         left >  6? (unsigned char)b[ 6] : 0,
1663                         left >  7? (unsigned char)b[ 7] : 0,
1664                         left >  8? (unsigned char)b[ 8] : 0,
1665                         left >  9? (unsigned char)b[ 9] : 0,
1666                         left > 10? (unsigned char)b[10] : 0,
1667                         left > 11? (unsigned char)b[11] : 0,
1668                         left > 12? (unsigned char)b[12] : 0,
1669                         left > 13? (unsigned char)b[13] : 0,
1670                         left > 14? (unsigned char)b[14] : 0,
1671                         left > 15? (unsigned char)b[15] : 0,
1672                         (left >  0) ? (isprint(b[ 0]) ? b[ 0] : '.') : ' ',
1673                         (left >  1) ? (isprint(b[ 1]) ? b[ 1] : '.') : ' ',
1674                         (left >  2) ? (isprint(b[ 2]) ? b[ 2] : '.') : ' ',
1675                         (left >  3) ? (isprint(b[ 3]) ? b[ 3] : '.') : ' ',
1676                         (left >  4) ? (isprint(b[ 4]) ? b[ 4] : '.') : ' ',
1677                         (left >  5) ? (isprint(b[ 5]) ? b[ 5] : '.') : ' ',
1678                         (left >  6) ? (isprint(b[ 6]) ? b[ 6] : '.') : ' ',
1679                         (left >  7) ? (isprint(b[ 7]) ? b[ 7] : '.') : ' ',
1680                         (left >  8) ? (isprint(b[ 8]) ? b[ 8] : '.') : ' ',
1681                         (left >  9) ? (isprint(b[ 9]) ? b[ 9] : '.') : ' ',
1682                         (left > 10) ? (isprint(b[10]) ? b[10] : '.') : ' ',
1683                         (left > 11) ? (isprint(b[11]) ? b[11] : '.') : ' ',
1684                         (left > 12) ? (isprint(b[12]) ? b[12] : '.') : ' ',
1685                         (left > 13) ? (isprint(b[13]) ? b[13] : '.') : ' ',
1686                         (left > 14) ? (isprint(b[14]) ? b[14] : '.') : ' ',
1687                         (left > 15) ? (isprint(b[15]) ? b[15] : '.') : ' '
1688                 );
1689                 left -= 16;
1690                 b += 16;
1691    }
1692 }