1/* flac - Command-line FLAC encoder/decoder 2 * Copyright (C) 2000,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 <ctype.h> 24#include <errno.h> 25#include <locale.h> 26#include <stdarg.h> 27#include <stdio.h> 28#include <stdlib.h> 29#include <string.h> 30#include <time.h> 31 32#if !defined _MSC_VER && !defined __MINGW32__ 33/* unlink is in stdio.h in VC++ */ 34#include <unistd.h> /* for unlink() */ 35#endif 36#include "FLAC/all.h" 37#include "share/alloc.h" 38#include "share/grabbag.h" 39#include "analyze.h" 40#include "decode.h" 41#include "encode.h" 42#include "local_string_utils.h" /* for flac__strlcat() and flac__strlcpy() */ 43#include "utils.h" 44#include "vorbiscomment.h" 45 46#if defined _MSC_VER || defined __MINGW32__ || defined __EMX__ 47#define FLAC__STRCASECMP stricmp 48#else 49#define FLAC__STRCASECMP strcasecmp 50#endif 51 52#if 0 53/*[JEC] was:#if HAVE_GETOPT_LONG*/ 54/*[JEC] see flac/include/share/getopt.h as to why the change */ 55# include <getopt.h> 56#else 57# include "share/getopt.h" 58#endif 59 60typedef enum { RAW, WAV, AIF, FLAC, OGGFLAC } FileFormat; 61 62static int do_it(void); 63 64static FLAC__bool init_options(void); 65static int parse_options(int argc, char *argv[]); 66static int parse_option(int short_option, const char *long_option, const char *option_argument); 67static void free_options(void); 68static void add_compression_setting_bool(compression_setting_type_t type, FLAC__bool value); 69static void add_compression_setting_string(compression_setting_type_t type, const char *value); 70static void add_compression_setting_unsigned(compression_setting_type_t type, unsigned value); 71 72static int usage_error(const char *message, ...); 73static void short_usage(void); 74static void show_version(void); 75static void show_help(void); 76static void show_explain(void); 77static void format_mistake(const char *infilename, FileFormat wrong, FileFormat right); 78 79static int encode_file(const char *infilename, FLAC__bool is_first_file, FLAC__bool is_last_file); 80static int decode_file(const char *infilename); 81 82static const char *get_encoded_outfilename(const char *infilename); 83static const char *get_decoded_outfilename(const char *infilename); 84static const char *get_outfilename(const char *infilename, const char *suffix); 85 86static void die(const char *message); 87static int conditional_fclose(FILE *f); 88static char *local_strdup(const char *source); 89#ifdef _MSC_VER 90/* There's no strtoll() in MSVC6 so we just write a specialized one */ 91static FLAC__int64 local__strtoll(const char *src, char **endptr); 92#endif 93 94 95/* 96 * share__getopt format struct; note that for long options with no 97 * short option equivalent we just set the 'val' field to 0. 98 */ 99static struct share__option long_options_[] = { 100 /* 101 * general options 102 */ 103 { "help" , share__no_argument, 0, 'h' }, 104 { "explain" , share__no_argument, 0, 'H' }, 105 { "version" , share__no_argument, 0, 'v' }, 106 { "decode" , share__no_argument, 0, 'd' }, 107 { "analyze" , share__no_argument, 0, 'a' }, 108 { "test" , share__no_argument, 0, 't' }, 109 { "stdout" , share__no_argument, 0, 'c' }, 110 { "silent" , share__no_argument, 0, 's' }, 111 { "totally-silent" , share__no_argument, 0, 0 }, 112 { "warnings-as-errors" , share__no_argument, 0, 'w' }, 113 { "force" , share__no_argument, 0, 'f' }, 114 { "delete-input-file" , share__no_argument, 0, 0 }, 115 { "keep-foreign-metadata" , share__no_argument, 0, 0 }, 116 { "output-prefix" , share__required_argument, 0, 0 }, 117 { "output-name" , share__required_argument, 0, 'o' }, 118 { "skip" , share__required_argument, 0, 0 }, 119 { "until" , share__required_argument, 0, 0 }, 120 { "channel-map" , share__required_argument, 0, 0 }, /* undocumented */ 121 122 /* 123 * decoding options 124 */ 125 { "decode-through-errors", share__no_argument, 0, 'F' }, 126 { "cue" , share__required_argument, 0, 0 }, 127 { "apply-replaygain-which-is-not-lossless", share__optional_argument, 0, 0 }, /* undocumented */ 128 129 /* 130 * encoding options 131 */ 132 { "cuesheet" , share__required_argument, 0, 0 }, 133 { "no-cued-seekpoints" , share__no_argument, 0, 0 }, 134 { "picture" , share__required_argument, 0, 0 }, 135 { "tag" , share__required_argument, 0, 'T' }, 136 { "tag-from-file" , share__required_argument, 0, 0 }, 137 { "compression-level-0" , share__no_argument, 0, '0' }, 138 { "compression-level-1" , share__no_argument, 0, '1' }, 139 { "compression-level-2" , share__no_argument, 0, '2' }, 140 { "compression-level-3" , share__no_argument, 0, '3' }, 141 { "compression-level-4" , share__no_argument, 0, '4' }, 142 { "compression-level-5" , share__no_argument, 0, '5' }, 143 { "compression-level-6" , share__no_argument, 0, '6' }, 144 { "compression-level-7" , share__no_argument, 0, '7' }, 145 { "compression-level-8" , share__no_argument, 0, '8' }, 146 { "compression-level-9" , share__no_argument, 0, '9' }, 147 { "best" , share__no_argument, 0, '8' }, 148 { "fast" , share__no_argument, 0, '0' }, 149 { "verify" , share__no_argument, 0, 'V' }, 150 { "force-aiff-format" , share__no_argument, 0, 0 }, 151 { "force-raw-format" , share__no_argument, 0, 0 }, 152 { "lax" , share__no_argument, 0, 0 }, 153 { "replay-gain" , share__no_argument, 0, 0 }, 154 { "ignore-chunk-sizes" , share__no_argument, 0, 0 }, 155 { "sector-align" , share__no_argument, 0, 0 }, 156 { "seekpoint" , share__required_argument, 0, 'S' }, 157 { "padding" , share__required_argument, 0, 'P' }, 158#if FLAC__HAS_OGG 159 { "ogg" , share__no_argument, 0, 0 }, 160 { "serial-number" , share__required_argument, 0, 0 }, 161#endif 162 { "blocksize" , share__required_argument, 0, 'b' }, 163 { "exhaustive-model-search" , share__no_argument, 0, 'e' }, 164 { "max-lpc-order" , share__required_argument, 0, 'l' }, 165 { "apodization" , share__required_argument, 0, 'A' }, 166 { "mid-side" , share__no_argument, 0, 'm' }, 167 { "adaptive-mid-side" , share__no_argument, 0, 'M' }, 168 { "qlp-coeff-precision-search", share__no_argument, 0, 'p' }, 169 { "qlp-coeff-precision" , share__required_argument, 0, 'q' }, 170 { "rice-partition-order" , share__required_argument, 0, 'r' }, 171 { "endian" , share__required_argument, 0, 0 }, 172 { "channels" , share__required_argument, 0, 0 }, 173 { "bps" , share__required_argument, 0, 0 }, 174 { "sample-rate" , share__required_argument, 0, 0 }, 175 { "sign" , share__required_argument, 0, 0 }, 176 { "input-size" , share__required_argument, 0, 0 }, 177 178 /* 179 * analysis options 180 */ 181 { "residual-gnuplot", share__no_argument, 0, 0 }, 182 { "residual-text", share__no_argument, 0, 0 }, 183 184 /* 185 * negatives 186 */ 187 { "no-decode-through-errors" , share__no_argument, 0, 0 }, 188 { "no-silent" , share__no_argument, 0, 0 }, 189 { "no-force" , share__no_argument, 0, 0 }, 190 { "no-seektable" , share__no_argument, 0, 0 }, 191 { "no-delete-input-file" , share__no_argument, 0, 0 }, 192 { "no-keep-foreign-metadata" , share__no_argument, 0, 0 }, 193 { "no-replay-gain" , share__no_argument, 0, 0 }, 194 { "no-ignore-chunk-sizes" , share__no_argument, 0, 0 }, 195 { "no-sector-align" , share__no_argument, 0, 0 }, 196 { "no-utf8-convert" , share__no_argument, 0, 0 }, 197 { "no-lax" , share__no_argument, 0, 0 }, 198#if FLAC__HAS_OGG 199 { "no-ogg" , share__no_argument, 0, 0 }, 200#endif 201 { "no-exhaustive-model-search", share__no_argument, 0, 0 }, 202 { "no-mid-side" , share__no_argument, 0, 0 }, 203 { "no-adaptive-mid-side" , share__no_argument, 0, 0 }, 204 { "no-qlp-coeff-prec-search" , share__no_argument, 0, 0 }, 205 { "no-padding" , share__no_argument, 0, 0 }, 206 { "no-verify" , share__no_argument, 0, 0 }, 207 { "no-warnings-as-errors" , share__no_argument, 0, 0 }, 208 { "no-residual-gnuplot" , share__no_argument, 0, 0 }, 209 { "no-residual-text" , share__no_argument, 0, 0 }, 210 /* 211 * undocumented debugging options for the test suite 212 */ 213 { "disable-constant-subframes", share__no_argument, 0, 0 }, 214 { "disable-fixed-subframes" , share__no_argument, 0, 0 }, 215 { "disable-verbatim-subframes", share__no_argument, 0, 0 }, 216 { "no-md5-sum" , share__no_argument, 0, 0 }, 217 218 {0, 0, 0, 0} 219}; 220 221 222/* 223 * global to hold command-line option values 224 */ 225 226static struct { 227 FLAC__bool show_help; 228 FLAC__bool show_explain; 229 FLAC__bool show_version; 230 FLAC__bool mode_decode; 231 FLAC__bool verify; 232 FLAC__bool treat_warnings_as_errors; 233 FLAC__bool force_file_overwrite; 234 FLAC__bool continue_through_decode_errors; 235 replaygain_synthesis_spec_t replaygain_synthesis_spec; 236 FLAC__bool lax; 237 FLAC__bool test_only; 238 FLAC__bool analyze; 239 FLAC__bool use_ogg; 240 FLAC__bool has_serial_number; /* true iff --serial-number was used */ 241 long serial_number; /* this is the Ogg serial number and is unused for native FLAC */ 242 FLAC__bool force_to_stdout; 243 FLAC__bool force_aiff_format; 244 FLAC__bool force_raw_format; 245 FLAC__bool delete_input; 246 FLAC__bool keep_foreign_metadata; 247 FLAC__bool replay_gain; 248 FLAC__bool ignore_chunk_sizes; 249 FLAC__bool sector_align; 250 FLAC__bool utf8_convert; /* true by default, to convert tag strings from locale to utf-8, false if --no-utf8-convert used */ 251 const char *cmdline_forced_outfilename; 252 const char *output_prefix; 253 analysis_options aopts; 254 int padding; /* -1 => no -P options were given, 0 => -P- was given, else -P value */ 255 size_t num_compression_settings; 256 compression_setting_t compression_settings[64]; /* bad MAGIC NUMBER but buffer overflow is checked */ 257 const char *skip_specification; 258 const char *until_specification; 259 const char *cue_specification; 260 int format_is_big_endian; 261 int format_is_unsigned_samples; 262 int format_channels; 263 int format_bps; 264 int format_sample_rate; 265 off_t format_input_size; 266 char requested_seek_points[5000]; /* bad MAGIC NUMBER but buffer overflow is checked */ 267 int num_requested_seek_points; /* -1 => no -S options were given, 0 => -S- was given */ 268 const char *cuesheet_filename; 269 FLAC__bool cued_seekpoints; 270 FLAC__bool channel_map_none; /* --channel-map=none specified, eventually will expand to take actual channel map */ 271 272 unsigned num_files; 273 char **filenames; 274 275 FLAC__StreamMetadata *vorbis_comment; 276 FLAC__StreamMetadata *pictures[64]; 277 unsigned num_pictures; 278 279 struct { 280 FLAC__bool disable_constant_subframes; 281 FLAC__bool disable_fixed_subframes; 282 FLAC__bool disable_verbatim_subframes; 283 FLAC__bool do_md5; 284 } debug; 285} option_values; 286 287 288/* 289 * miscellaneous globals 290 */ 291 292static FLAC__int32 align_reservoir_0[588], align_reservoir_1[588]; /* for carrying over samples from --sector-align */ 293static FLAC__int32 *align_reservoir[2] = { align_reservoir_0, align_reservoir_1 }; 294static unsigned align_reservoir_samples = 0; /* 0 .. 587 */ 295 296 297int main(int argc, char *argv[]) 298{ 299 int retval = 0; 300 301#ifdef __EMX__ 302 _response(&argc, &argv); 303 _wildcard(&argc, &argv); 304#endif 305 306 srand((unsigned)time(0)); 307 setlocale(LC_ALL, ""); 308 if(!init_options()) { 309 flac__utils_printf(stderr, 1, "ERROR: allocating memory\n"); 310 retval = 1; 311 } 312 else { 313 if((retval = parse_options(argc, argv)) == 0) 314 retval = do_it(); 315 } 316 317 free_options(); 318 319 return retval; 320} 321 322int do_it(void) 323{ 324 int retval = 0; 325 326 if(option_values.show_version) { 327 show_version(); 328 return 0; 329 } 330 else if(option_values.show_explain) { 331 show_explain(); 332 return 0; 333 } 334 else if(option_values.show_help) { 335 show_help(); 336 return 0; 337 } 338 else { 339 if(option_values.num_files == 0) { 340 if(flac__utils_verbosity_ >= 1) 341 short_usage(); 342 return 0; 343 } 344 345 /* 346 * tweak options; validate the values 347 */ 348 if(!option_values.mode_decode) { 349 if(0 != option_values.cue_specification) 350 return usage_error("ERROR: --cue is not allowed in test mode\n"); 351 } 352 else { 353 if(option_values.test_only) { 354 if(0 != option_values.skip_specification) 355 return usage_error("ERROR: --skip is not allowed in test mode\n"); 356 if(0 != option_values.until_specification) 357 return usage_error("ERROR: --until is not allowed in test mode\n"); 358 if(0 != option_values.cue_specification) 359 return usage_error("ERROR: --cue is not allowed in test mode\n"); 360 if(0 != option_values.analyze) 361 return usage_error("ERROR: analysis mode (-a/--analyze) and test mode (-t/--test) cannot be used together\n"); 362 } 363 } 364 365 if(0 != option_values.cue_specification && (0 != option_values.skip_specification || 0 != option_values.until_specification)) 366 return usage_error("ERROR: --cue may not be combined with --skip or --until\n"); 367 368 if(option_values.format_channels >= 0) { 369 if(option_values.format_channels == 0 || (unsigned)option_values.format_channels > FLAC__MAX_CHANNELS) 370 return usage_error("ERROR: invalid number of channels '%u', must be > 0 and <= %u\n", option_values.format_channels, FLAC__MAX_CHANNELS); 371 } 372 if(option_values.format_bps >= 0) { 373 if(option_values.format_bps != 8 && option_values.format_bps != 16 && option_values.format_bps != 24) 374 return usage_error("ERROR: invalid bits per sample '%u' (must be 8/16/24)\n", option_values.format_bps); 375 } 376 if(option_values.format_sample_rate >= 0) { 377 if(!FLAC__format_sample_rate_is_valid(option_values.format_sample_rate)) 378 return usage_error("ERROR: invalid sample rate '%u', must be > 0 and <= %u\n", option_values.format_sample_rate, FLAC__MAX_SAMPLE_RATE); 379 } 380 if(option_values.force_raw_format && option_values.force_aiff_format) 381 return usage_error("ERROR: only one of --force-raw-format and --force-aiff-format allowed\n"); 382 if(option_values.mode_decode) { 383 if(!option_values.force_raw_format) { 384 if(option_values.format_is_big_endian >= 0) 385 return usage_error("ERROR: --endian only allowed with --force-raw-format\n"); 386 if(option_values.format_is_unsigned_samples >= 0) 387 return usage_error("ERROR: --sign only allowed with --force-raw-format\n"); 388 } 389 if(option_values.format_channels >= 0) 390 return usage_error("ERROR: --channels not allowed with --decode\n"); 391 if(option_values.format_bps >= 0) 392 return usage_error("ERROR: --bps not allowed with --decode\n"); 393 if(option_values.format_sample_rate >= 0) 394 return usage_error("ERROR: --sample-rate not allowed with --decode\n"); 395 } 396 397 if(option_values.ignore_chunk_sizes) { 398 if(option_values.mode_decode) 399 return usage_error("ERROR: --ignore-chunk-sizes only allowed for encoding\n"); 400 if(0 != option_values.sector_align) 401 return usage_error("ERROR: --ignore-chunk-sizes not allowed with --sector-align\n"); 402 if(0 != option_values.until_specification) 403 return usage_error("ERROR: --ignore-chunk-sizes not allowed with --until\n"); 404 if(0 != option_values.cue_specification) 405 return usage_error("ERROR: --ignore-chunk-sizes not allowed with --cue\n"); 406 if(0 != option_values.cuesheet_filename) 407 return usage_error("ERROR: --ignore-chunk-sizes not allowed with --cuesheet\n"); 408 } 409 if(option_values.sector_align) { 410 if(option_values.mode_decode) 411 return usage_error("ERROR: --sector-align only allowed for encoding\n"); 412 if(0 != option_values.skip_specification) 413 return usage_error("ERROR: --sector-align not allowed with --skip\n"); 414 if(0 != option_values.until_specification) 415 return usage_error("ERROR: --sector-align not allowed with --until\n"); 416 if(0 != option_values.cue_specification) 417 return usage_error("ERROR: --sector-align not allowed with --cue\n"); 418 if(option_values.format_channels >= 0 && option_values.format_channels != 2) 419 return usage_error("ERROR: --sector-align can only be done with stereo input\n"); 420 if(option_values.format_bps >= 0 && option_values.format_bps != 16) 421 return usage_error("ERROR: --sector-align can only be done with 16-bit samples\n"); 422 if(option_values.format_sample_rate >= 0 && option_values.format_sample_rate != 44100) 423 return usage_error("ERROR: --sector-align can only be done with a sample rate of 44100\n"); 424 } 425 if(option_values.replay_gain) { 426 if(option_values.force_to_stdout) 427 return usage_error("ERROR: --replay-gain not allowed with -c/--stdout\n"); 428 if(option_values.mode_decode) 429 return usage_error("ERROR: --replay-gain only allowed for encoding\n"); 430 if(option_values.format_channels > 2) 431 return usage_error("ERROR: --replay-gain can only be done with mono/stereo input\n"); 432 if(option_values.format_sample_rate >= 0 && !grabbag__replaygain_is_valid_sample_frequency(option_values.format_sample_rate)) 433 return usage_error("ERROR: invalid sample rate used with --replay-gain\n"); 434 /* 435 * We want to reserve padding space for the ReplayGain 436 * tags that we will set later, to avoid rewriting the 437 * whole file. 438 */ 439 if( 440 (option_values.padding >= 0 && option_values.padding < (int)GRABBAG__REPLAYGAIN_MAX_TAG_SPACE_REQUIRED) || 441 (option_values.padding < 0 && FLAC_ENCODE__DEFAULT_PADDING < (int)GRABBAG__REPLAYGAIN_MAX_TAG_SPACE_REQUIRED) 442 ) { 443 flac__utils_printf(stderr, 1, "NOTE: --replay-gain may leave a small PADDING block even with --no-padding\n"); 444 option_values.padding = GRABBAG__REPLAYGAIN_MAX_TAG_SPACE_REQUIRED; 445 } 446 else { 447 option_values.padding += GRABBAG__REPLAYGAIN_MAX_TAG_SPACE_REQUIRED; 448 } 449 } 450 if(option_values.num_files > 1 && option_values.cmdline_forced_outfilename) { 451 return usage_error("ERROR: -o/--output-name cannot be used with multiple files\n"); 452 } 453 if(option_values.cmdline_forced_outfilename && option_values.output_prefix) { 454 return usage_error("ERROR: --output-prefix conflicts with -o/--output-name\n"); 455 } 456 if(!option_values.mode_decode && 0 != option_values.cuesheet_filename && option_values.num_files > 1) { 457 return usage_error("ERROR: --cuesheet cannot be used when encoding multiple files\n"); 458 } 459 if(option_values.keep_foreign_metadata) { 460 /* we're not going to try and support the re-creation of broken WAVE files */ 461 if(option_values.ignore_chunk_sizes) 462 return usage_error("ERROR: using --keep-foreign-metadata cannot be used with --ignore-chunk-sizes\n"); 463 if(option_values.test_only) 464 return usage_error("ERROR: --keep-foreign-metadata is not allowed in test mode\n"); 465 if(option_values.analyze) 466 return usage_error("ERROR: --keep-foreign-metadata is not allowed in analyis mode\n"); 467 /*@@@@@@*/ 468 if(option_values.delete_input) 469 return usage_error("ERROR: using --delete-input-file with --keep-foreign-metadata has been disabled until more testing has been done.\n"); 470 flac__utils_printf(stderr, 1, "NOTE: --keep-foreign-metadata is a new feature; make sure to test the output file before deleting the original.\n"); 471 } 472 } 473 474 flac__utils_printf(stderr, 2, "\n"); 475 flac__utils_printf(stderr, 2, "flac %s, Copyright (C) 2000,2001,2002,2003,2004,2005,2006,2007 Josh Coalson\n", FLAC__VERSION_STRING); 476 flac__utils_printf(stderr, 2, "flac comes with ABSOLUTELY NO WARRANTY. This is free software, and you are\n"); 477 flac__utils_printf(stderr, 2, "welcome to redistribute it under certain conditions. Type `flac' for details.\n\n"); 478 479 if(option_values.mode_decode) { 480 FLAC__bool first = true; 481 482 if(option_values.num_files == 0) { 483 retval = decode_file("-"); 484 } 485 else { 486 unsigned i; 487 if(option_values.num_files > 1) 488 option_values.cmdline_forced_outfilename = 0; 489 for(i = 0, retval = 0; i < option_values.num_files; i++) { 490 if(0 == strcmp(option_values.filenames[i], "-") && !first) 491 continue; 492 retval |= decode_file(option_values.filenames[i]); 493 first = false; 494 } 495 } 496 } 497 else { /* encode */ 498 FLAC__bool first = true; 499 500 if(option_values.ignore_chunk_sizes) 501 flac__utils_printf(stderr, 1, "INFO: Make sure you know what you're doing when using --ignore-chunk-sizes.\n Improper use can cause flac to encode non-audio data as audio.\n"); 502 503 if(option_values.num_files == 0) { 504 retval = encode_file("-", first, true); 505 } 506 else { 507 unsigned i; 508 if(option_values.num_files > 1) 509 option_values.cmdline_forced_outfilename = 0; 510 for(i = 0, retval = 0; i < option_values.num_files; i++) { 511 if(0 == strcmp(option_values.filenames[i], "-") && !first) 512 continue; 513 retval |= encode_file(option_values.filenames[i], first, i == (option_values.num_files-1)); 514 first = false; 515 } 516 if(option_values.replay_gain && retval == 0) { 517 float album_gain, album_peak; 518 grabbag__replaygain_get_album(&album_gain, &album_peak); 519 for(i = 0; i < option_values.num_files; i++) { 520 const char *error, *outfilename = get_encoded_outfilename(option_values.filenames[i]); 521 if(0 == outfilename) { 522 flac__utils_printf(stderr, 1, "ERROR: filename too long: %s", option_values.filenames[i]); 523 return 1; 524 } 525 if(0 == strcmp(option_values.filenames[i], "-")) { 526 FLAC__ASSERT(0); 527 /* double protection */ 528 flac__utils_printf(stderr, 1, "internal error\n"); 529 return 2; 530 } 531 if(0 != (error = grabbag__replaygain_store_to_file_album(outfilename, album_gain, album_peak, /*preserve_modtime=*/true))) { 532 flac__utils_printf(stderr, 1, "%s: ERROR writing ReplayGain album tags (%s)\n", outfilename, error); 533 retval = 1; 534 } 535 } 536 } 537 } 538 } 539 540 return retval; 541} 542 543FLAC__bool init_options(void) 544{ 545 option_values.show_help = false; 546 option_values.show_explain = false; 547 option_values.mode_decode = false; 548 option_values.verify = false; 549 option_values.treat_warnings_as_errors = false; 550 option_values.force_file_overwrite = false; 551 option_values.continue_through_decode_errors = false; 552 option_values.replaygain_synthesis_spec.apply = false; 553 option_values.replaygain_synthesis_spec.use_album_gain = true; 554 option_values.replaygain_synthesis_spec.limiter = RGSS_LIMIT__HARD; 555 option_values.replaygain_synthesis_spec.noise_shaping = NOISE_SHAPING_LOW; 556 option_values.replaygain_synthesis_spec.preamp = 0.0; 557 option_values.lax = false; 558 option_values.test_only = false; 559 option_values.analyze = false; 560 option_values.use_ogg = false; 561 option_values.has_serial_number = false; 562 option_values.serial_number = 0; 563 option_values.force_to_stdout = false; 564 option_values.force_aiff_format = false; 565 option_values.force_raw_format = false; 566 option_values.delete_input = false; 567 option_values.keep_foreign_metadata = false; 568 option_values.replay_gain = false; 569 option_values.ignore_chunk_sizes = false; 570 option_values.sector_align = false; 571 option_values.utf8_convert = true; 572 option_values.cmdline_forced_outfilename = 0; 573 option_values.output_prefix = 0; 574 option_values.aopts.do_residual_text = false; 575 option_values.aopts.do_residual_gnuplot = false; 576 option_values.padding = -1; 577 option_values.num_compression_settings = 1; 578 option_values.compression_settings[0].type = CST_COMPRESSION_LEVEL; 579 option_values.compression_settings[0].value.t_unsigned = 5; 580 option_values.skip_specification = 0; 581 option_values.until_specification = 0; 582 option_values.cue_specification = 0; 583 option_values.format_is_big_endian = -1; 584 option_values.format_is_unsigned_samples = -1; 585 option_values.format_channels = -1; 586 option_values.format_bps = -1; 587 option_values.format_sample_rate = -1; 588 option_values.format_input_size = (off_t)(-1); 589 option_values.requested_seek_points[0] = '\0'; 590 option_values.num_requested_seek_points = -1; 591 option_values.cuesheet_filename = 0; 592 option_values.cued_seekpoints = true; 593 option_values.channel_map_none = false; 594 595 option_values.num_files = 0; 596 option_values.filenames = 0; 597 598 if(0 == (option_values.vorbis_comment = FLAC__metadata_object_new(FLAC__METADATA_TYPE_VORBIS_COMMENT))) 599 return false; 600 option_values.num_pictures = 0; 601 602 option_values.debug.disable_constant_subframes = false; 603 option_values.debug.disable_fixed_subframes = false; 604 option_values.debug.disable_verbatim_subframes = false; 605 option_values.debug.do_md5 = true; 606 607 return true; 608} 609 610int parse_options(int argc, char *argv[]) 611{ 612 int short_option; 613 int option_index = 1; 614 FLAC__bool had_error = false; 615 const char *short_opts = "0123456789aA:b:cdefFhHl:mMo:pP:q:r:sS:tT:vVw"; 616 617 while ((short_option = share__getopt_long(argc, argv, short_opts, long_options_, &option_index)) != -1) { 618 switch (short_option) { 619 case 0: /* long option with no equivalent short option */ 620 had_error |= (parse_option(short_option, long_options_[option_index].name, share__optarg) != 0); 621 break; 622 case '?': 623 case ':': 624 had_error = true; 625 break; 626 default: /* short option */ 627 had_error |= (parse_option(short_option, 0, share__optarg) != 0); 628 break; 629 } 630 } 631 632 if(had_error) { 633 return 1; 634 } 635 636 FLAC__ASSERT(share__optind <= argc); 637 638 option_values.num_files = argc - share__optind; 639 640 if(option_values.num_files > 0) { 641 unsigned i = 0; 642 if(0 == (option_values.filenames = (char**)malloc(sizeof(char*) * option_values.num_files))) 643 die("out of memory allocating space for file names list"); 644 while(share__optind < argc) 645 option_values.filenames[i++] = local_strdup(argv[share__optind++]); 646 } 647 648 return 0; 649} 650 651int parse_option(int short_option, const char *long_option, const char *option_argument) 652{ 653 const char *violation; 654 char *p; 655 int i; 656 657 if(short_option == 0) { 658 FLAC__ASSERT(0 != long_option); 659 if(0 == strcmp(long_option, "totally-silent")) { 660 flac__utils_verbosity_ = 0; 661 } 662 else if(0 == strcmp(long_option, "delete-input-file")) { 663 option_values.delete_input = true; 664 } 665 else if(0 == strcmp(long_option, "keep-foreign-metadata")) { 666 option_values.keep_foreign_metadata = true; 667 } 668 else if(0 == strcmp(long_option, "output-prefix")) { 669 FLAC__ASSERT(0 != option_argument); 670 option_values.output_prefix = option_argument; 671 } 672 else if(0 == strcmp(long_option, "skip")) { 673 FLAC__ASSERT(0 != option_argument); 674 option_values.skip_specification = option_argument; 675 } 676 else if(0 == strcmp(long_option, "until")) { 677 FLAC__ASSERT(0 != option_argument); 678 option_values.until_specification = option_argument; 679 } 680 else if(0 == strcmp(long_option, "input-size")) { 681 FLAC__ASSERT(0 != option_argument); 682 { 683 char *end; 684#ifdef _MSC_VER 685 FLAC__int64 i; 686 i = local__strtoll(option_argument, &end); 687#else 688 long long i; 689 i = strtoll(option_argument, &end, 10); 690#endif 691 if(0 == strlen(option_argument) || *end) 692 return usage_error("ERROR: --%s must be a number\n", long_option); 693 option_values.format_input_size = (off_t)i; 694 if(option_values.format_input_size != i) /* check if off_t is smaller than long long */ 695 return usage_error("ERROR: --%s too large; this build of flac does not support filesizes over 2GB\n", long_option); 696 if(option_values.format_input_size <= 0) 697 return usage_error("ERROR: --%s must be > 0\n", long_option); 698 } 699 } 700 else if(0 == strcmp(long_option, "cue")) { 701 FLAC__ASSERT(0 != option_argument); 702 option_values.cue_specification = option_argument; 703 } 704 else if(0 == strcmp(long_option, "apply-replaygain-which-is-not-lossless")) { 705 option_values.replaygain_synthesis_spec.apply = true; 706 if (0 != option_argument) { 707 char *p; 708 option_values.replaygain_synthesis_spec.limiter = RGSS_LIMIT__NONE; 709 option_values.replaygain_synthesis_spec.noise_shaping = NOISE_SHAPING_NONE; 710 option_values.replaygain_synthesis_spec.preamp = strtod(option_argument, &p); 711 for ( ; *p; p++) { 712 if (*p == 'a') 713 option_values.replaygain_synthesis_spec.use_album_gain = true; 714 else if (*p == 't') 715 option_values.replaygain_synthesis_spec.use_album_gain = false; 716 else if (*p == 'l') 717 option_values.replaygain_synthesis_spec.limiter = RGSS_LIMIT__PEAK; 718 else if (*p == 'L') 719 option_values.replaygain_synthesis_spec.limiter = RGSS_LIMIT__HARD; 720 else if (*p == 'n' && p[1] >= '0' && p[1] <= '3') { 721 option_values.replaygain_synthesis_spec.noise_shaping = p[1] - '0'; 722 p++; 723 } 724 else 725 return usage_error("ERROR: bad specification string \"%s\" for --%s\n", option_argument, long_option); 726 } 727 } 728 } 729 else if(0 == strcmp(long_option, "channel-map")) { 730 if (0 == option_argument || strcmp(option_argument, "none")) 731 return usage_error("ERROR: only --channel-map=none currently supported\n"); 732 option_values.channel_map_none = true; 733 } 734 else if(0 == strcmp(long_option, "cuesheet")) { 735 FLAC__ASSERT(0 != option_argument); 736 option_values.cuesheet_filename = option_argument; 737 } 738 else if(0 == strcmp(long_option, "picture")) { 739 const unsigned max_pictures = sizeof(option_values.pictures)/sizeof(option_values.pictures[0]); 740 FLAC__ASSERT(0 != option_argument); 741 if(option_values.num_pictures >= max_pictures) 742 return usage_error("ERROR: too many --picture arguments, only %u allowed\n", max_pictures); 743 if(0 == (option_values.pictures[option_values.num_pictures] = grabbag__picture_parse_specification(option_argument, &violation))) 744 return usage_error("ERROR: (--picture) %s\n", violation); 745 option_values.num_pictures++; 746 } 747 else if(0 == strcmp(long_option, "tag-from-file")) { 748 FLAC__ASSERT(0 != option_argument); 749 if(!flac__vorbiscomment_add(option_values.vorbis_comment, option_argument, /*value_from_file=*/true, /*raw=*/!option_values.utf8_convert, &violation)) 750 return usage_error("ERROR: (--tag-from-file) %s\n", violation); 751 } 752 else if(0 == strcmp(long_option, "no-cued-seekpoints")) { 753 option_values.cued_seekpoints = false; 754 } 755 else if(0 == strcmp(long_option, "force-aiff-format")) { 756 option_values.force_aiff_format = true; 757 } 758 else if(0 == strcmp(long_option, "force-raw-format")) { 759 option_values.force_raw_format = true; 760 } 761 else if(0 == strcmp(long_option, "lax")) { 762 option_values.lax = true; 763 } 764 else if(0 == strcmp(long_option, "replay-gain")) { 765 option_values.replay_gain = true; 766 } 767 else if(0 == strcmp(long_option, "ignore-chunk-sizes")) { 768 option_values.ignore_chunk_sizes = true; 769 } 770 else if(0 == strcmp(long_option, "sector-align")) { 771 option_values.sector_align = true; 772 } 773#if FLAC__HAS_OGG 774 else if(0 == strcmp(long_option, "ogg")) { 775 option_values.use_ogg = true; 776 } 777 else if(0 == strcmp(long_option, "serial-number")) { 778 option_values.has_serial_number = true; 779 option_values.serial_number = atol(option_argument); 780 } 781#endif 782 else if(0 == strcmp(long_option, "endian")) { 783 FLAC__ASSERT(0 != option_argument); 784 if(0 == strncmp(option_argument, "big", strlen(option_argument))) 785 option_values.format_is_big_endian = true; 786 else if(0 == strncmp(option_argument, "little", strlen(option_argument))) 787 option_values.format_is_big_endian = false; 788 else 789 return usage_error("ERROR: argument to --endian must be \"big\" or \"little\"\n"); 790 } 791 else if(0 == strcmp(long_option, "channels")) { 792 FLAC__ASSERT(0 != option_argument); 793 option_values.format_channels = atoi(option_argument); 794 } 795 else if(0 == strcmp(long_option, "bps")) { 796 FLAC__ASSERT(0 != option_argument); 797 option_values.format_bps = atoi(option_argument); 798 } 799 else if(0 == strcmp(long_option, "sample-rate")) { 800 FLAC__ASSERT(0 != option_argument); 801 option_values.format_sample_rate = atoi(option_argument); 802 } 803 else if(0 == strcmp(long_option, "sign")) { 804 FLAC__ASSERT(0 != option_argument); 805 if(0 == strncmp(option_argument, "signed", strlen(option_argument))) 806 option_values.format_is_unsigned_samples = false; 807 else if(0 == strncmp(option_argument, "unsigned", strlen(option_argument))) 808 option_values.format_is_unsigned_samples = true; 809 else 810 return usage_error("ERROR: argument to --sign must be \"signed\" or \"unsigned\"\n"); 811 } 812 else if(0 == strcmp(long_option, "residual-gnuplot")) { 813 option_values.aopts.do_residual_gnuplot = true; 814 } 815 else if(0 == strcmp(long_option, "residual-text")) { 816 option_values.aopts.do_residual_text = true; 817 } 818 /* 819 * negatives 820 */ 821 else if(0 == strcmp(long_option, "no-decode-through-errors")) { 822 option_values.continue_through_decode_errors = false; 823 } 824 else if(0 == strcmp(long_option, "no-silent")) { 825 flac__utils_verbosity_ = 2; 826 } 827 else if(0 == strcmp(long_option, "no-force")) { 828 option_values.force_file_overwrite = false; 829 } 830 else if(0 == strcmp(long_option, "no-seektable")) { 831 option_values.num_requested_seek_points = 0; 832 option_values.requested_seek_points[0] = '\0'; 833 } 834 else if(0 == strcmp(long_option, "no-delete-input-file")) { 835 option_values.delete_input = false; 836 } 837 else if(0 == strcmp(long_option, "no-keep-foreign-metadata")) { 838 option_values.keep_foreign_metadata = false; 839 } 840 else if(0 == strcmp(long_option, "no-replay-gain")) { 841 option_values.replay_gain = false; 842 } 843 else if(0 == strcmp(long_option, "no-ignore-chunk-sizes")) { 844 option_values.ignore_chunk_sizes = false; 845 } 846 else if(0 == strcmp(long_option, "no-sector-align")) { 847 option_values.sector_align = false; 848 } 849 else if(0 == strcmp(long_option, "no-utf8-convert")) { 850 option_values.utf8_convert = false; 851 } 852 else if(0 == strcmp(long_option, "no-lax")) { 853 option_values.lax = false; 854 } 855#if FLAC__HAS_OGG 856 else if(0 == strcmp(long_option, "no-ogg")) { 857 option_values.use_ogg = false; 858 } 859#endif 860 else if(0 == strcmp(long_option, "no-exhaustive-model-search")) { 861 add_compression_setting_bool(CST_DO_EXHAUSTIVE_MODEL_SEARCH, false); 862 } 863 else if(0 == strcmp(long_option, "no-mid-side")) { 864 add_compression_setting_bool(CST_DO_MID_SIDE, false); 865 add_compression_setting_bool(CST_LOOSE_MID_SIDE, false); 866 } 867 else if(0 == strcmp(long_option, "no-adaptive-mid-side")) { 868 add_compression_setting_bool(CST_DO_MID_SIDE, false); 869 add_compression_setting_bool(CST_LOOSE_MID_SIDE, false); 870 } 871 else if(0 == strcmp(long_option, "no-qlp-coeff-prec-search")) { 872 add_compression_setting_bool(CST_DO_QLP_COEFF_PREC_SEARCH, false); 873 } 874 else if(0 == strcmp(long_option, "no-padding")) { 875 option_values.padding = 0; 876 } 877 else if(0 == strcmp(long_option, "no-verify")) { 878 option_values.verify = false; 879 } 880 else if(0 == strcmp(long_option, "no-warnings-as-errors")) { 881 option_values.treat_warnings_as_errors = false; 882 } 883 else if(0 == strcmp(long_option, "no-residual-gnuplot")) { 884 option_values.aopts.do_residual_gnuplot = false; 885 } 886 else if(0 == strcmp(long_option, "no-residual-text")) { 887 option_values.aopts.do_residual_text = false; 888 } 889 else if(0 == strcmp(long_option, "disable-constant-subframes")) { 890 option_values.debug.disable_constant_subframes = true; 891 } 892 else if(0 == strcmp(long_option, "disable-fixed-subframes")) { 893 option_values.debug.disable_fixed_subframes = true; 894 } 895 else if(0 == strcmp(long_option, "disable-verbatim-subframes")) { 896 option_values.debug.disable_verbatim_subframes = true; 897 } 898 else if(0 == strcmp(long_option, "no-md5-sum")) { 899 option_values.debug.do_md5 = false; 900 } 901 } 902 else { 903 switch(short_option) { 904 case 'h': 905 option_values.show_help = true; 906 break; 907 case 'H': 908 option_values.show_explain = true; 909 break; 910 case 'v': 911 option_values.show_version = true; 912 break; 913 case 'd': 914 option_values.mode_decode = true; 915 break; 916 case 'a': 917 option_values.mode_decode = true; 918 option_values.analyze = true; 919 break; 920 case 't': 921 option_values.mode_decode = true; 922 option_values.test_only = true; 923 break; 924 case 'c': 925 option_values.force_to_stdout = true; 926 break; 927 case 's': 928 flac__utils_verbosity_ = 1; 929 break; 930 case 'f': 931 option_values.force_file_overwrite = true; 932 break; 933 case 'o': 934 FLAC__ASSERT(0 != option_argument); 935 option_values.cmdline_forced_outfilename = option_argument; 936 break; 937 case 'F': 938 option_values.continue_through_decode_errors = true; 939 break; 940 case 'T': 941 FLAC__ASSERT(0 != option_argument); 942 if(!flac__vorbiscomment_add(option_values.vorbis_comment, option_argument, /*value_from_file=*/false, /*raw=*/!option_values.utf8_convert, &violation)) 943 return usage_error("ERROR: (-T/--tag) %s\n", violation); 944 break; 945 case '0': 946 case '1': 947 case '2': 948 case '3': 949 case '4': 950 case '5': 951 case '6': 952 case '7': 953 case '8': 954 add_compression_setting_unsigned(CST_COMPRESSION_LEVEL, short_option-'0'); 955 break; 956 case '9': 957 return usage_error("ERROR: compression level '9' is reserved\n"); 958 case 'V': 959 option_values.verify = true; 960 break; 961 case 'w': 962 option_values.treat_warnings_as_errors = true; 963 break; 964 case 'S': 965 FLAC__ASSERT(0 != option_argument); 966 if(0 == strcmp(option_argument, "-")) { 967 option_values.num_requested_seek_points = 0; 968 option_values.requested_seek_points[0] = '\0'; 969 } 970 else { 971 if(option_values.num_requested_seek_points < 0) 972 option_values.num_requested_seek_points = 0; 973 option_values.num_requested_seek_points++; 974 if(strlen(option_values.requested_seek_points)+strlen(option_argument)+2 >= sizeof(option_values.requested_seek_points)) { 975 return usage_error("ERROR: too many seekpoints requested\n"); 976 } 977 else { 978 strcat(option_values.requested_seek_points, option_argument); 979 strcat(option_values.requested_seek_points, ";"); 980 } 981 } 982 break; 983 case 'P': 984 FLAC__ASSERT(0 != option_argument); 985 option_values.padding = atoi(option_argument); 986 if(option_values.padding < 0) 987 return usage_error("ERROR: argument to -%c must be >= 0; for no padding use -%c-\n", short_option, short_option); 988 break; 989 case 'b': 990 FLAC__ASSERT(0 != option_argument); 991 i = atoi(option_argument); 992 if((i < (int)FLAC__MIN_BLOCK_SIZE || i > (int)FLAC__MAX_BLOCK_SIZE)) 993 return usage_error("ERROR: invalid blocksize (-%c) '%d', must be >= %u and <= %u\n", short_option, i, FLAC__MIN_BLOCK_SIZE, FLAC__MAX_BLOCK_SIZE); 994 add_compression_setting_unsigned(CST_BLOCKSIZE, (unsigned)i); 995 break; 996 case 'e': 997 add_compression_setting_bool(CST_DO_EXHAUSTIVE_MODEL_SEARCH, true); 998 break; 999 case 'E': 1000 add_compression_setting_bool(CST_DO_ESCAPE_CODING, true); 1001 break; 1002 case 'l': 1003 FLAC__ASSERT(0 != option_argument); 1004 i = atoi(option_argument); 1005 if((i < 0 || i > (int)FLAC__MAX_LPC_ORDER)) 1006 return usage_error("ERROR: invalid LPC order (-%c) '%d', must be >= %u and <= %u\n", short_option, i, 0, FLAC__MAX_LPC_ORDER); 1007 add_compression_setting_unsigned(CST_MAX_LPC_ORDER, (unsigned)i); 1008 break; 1009 case 'A': 1010 FLAC__ASSERT(0 != option_argument); 1011 add_compression_setting_string(CST_APODIZATION, option_argument); 1012 break; 1013 case 'm': 1014 add_compression_setting_bool(CST_DO_MID_SIDE, true); 1015 add_compression_setting_bool(CST_LOOSE_MID_SIDE, false); 1016 break; 1017 case 'M': 1018 add_compression_setting_bool(CST_DO_MID_SIDE, true); 1019 add_compression_setting_bool(CST_LOOSE_MID_SIDE, true); 1020 break; 1021 case 'p': 1022 add_compression_setting_bool(CST_DO_QLP_COEFF_PREC_SEARCH, true); 1023 break; 1024 case 'q': 1025 FLAC__ASSERT(0 != option_argument); 1026 i = atoi(option_argument); 1027 if(i < 0 || (i > 0 && (i < (int)FLAC__MIN_QLP_COEFF_PRECISION || i > (int)FLAC__MAX_QLP_COEFF_PRECISION))) 1028 return usage_error("ERROR: invalid value '%d' for qlp coeff precision (-%c), must be 0 or between %u and %u, inclusive\n", i, short_option, FLAC__MIN_QLP_COEFF_PRECISION, FLAC__MAX_QLP_COEFF_PRECISION); 1029 add_compression_setting_unsigned(CST_QLP_COEFF_PRECISION, (unsigned)i); 1030 break; 1031 case 'r': 1032 FLAC__ASSERT(0 != option_argument); 1033 p = strchr(option_argument, ','); 1034 if(0 == p) { 1035 add_compression_setting_unsigned(CST_MIN_RESIDUAL_PARTITION_ORDER, 0); 1036 i = atoi(option_argument); 1037 if(i < 0) 1038 return usage_error("ERROR: invalid value '%d' for residual partition order (-%c), must be between 0 and %u, inclusive\n", i, short_option, FLAC__MAX_RICE_PARTITION_ORDER); 1039 add_compression_setting_unsigned(CST_MAX_RESIDUAL_PARTITION_ORDER, (unsigned)i); 1040 } 1041 else { 1042 i = atoi(option_argument); 1043 if(i < 0) 1044 return usage_error("ERROR: invalid value '%d' for min residual partition order (-%c), must be between 0 and %u, inclusive\n", i, short_option, FLAC__MAX_RICE_PARTITION_ORDER); 1045 add_compression_setting_unsigned(CST_MIN_RESIDUAL_PARTITION_ORDER, (unsigned)i); 1046 i = atoi(++p); 1047 if(i < 0) 1048 return usage_error("ERROR: invalid value '%d' for max residual partition order (-%c), must be between 0 and %u, inclusive\n", i, short_option, FLAC__MAX_RICE_PARTITION_ORDER); 1049 add_compression_setting_unsigned(CST_MAX_RESIDUAL_PARTITION_ORDER, (unsigned)i); 1050 } 1051 break; 1052 case 'R': 1053 i = atoi(option_argument); 1054 if(i < 0) 1055 return usage_error("ERROR: invalid value '%d' for Rice parameter search distance (-%c), must be >= 0\n", i, short_option); 1056 add_compression_setting_unsigned(CST_RICE_PARAMETER_SEARCH_DIST, (unsigned)i); 1057 break; 1058 default: 1059 FLAC__ASSERT(0); 1060 } 1061 } 1062 1063 return 0; 1064} 1065 1066void free_options(void) 1067{ 1068 unsigned i; 1069 if(0 != option_values.filenames) { 1070 for(i = 0; i < option_values.num_files; i++) { 1071 if(0 != option_values.filenames[i]) 1072 free(option_values.filenames[i]); 1073 } 1074 free(option_values.filenames); 1075 } 1076 if(0 != option_values.vorbis_comment) 1077 FLAC__metadata_object_delete(option_values.vorbis_comment); 1078 for(i = 0; i < option_values.num_pictures; i++) 1079 FLAC__metadata_object_delete(option_values.pictures[i]); 1080} 1081 1082void add_compression_setting_bool(compression_setting_type_t type, FLAC__bool value) 1083{ 1084 if(option_values.num_compression_settings >= sizeof(option_values.compression_settings)/sizeof(option_values.compression_settings[0])) 1085 die("too many compression settings"); 1086 option_values.compression_settings[option_values.num_compression_settings].type = type; 1087 option_values.compression_settings[option_values.num_compression_settings].value.t_bool = value; 1088 option_values.num_compression_settings++; 1089} 1090 1091void add_compression_setting_string(compression_setting_type_t type, const char *value) 1092{ 1093 if(option_values.num_compression_settings >= sizeof(option_values.compression_settings)/sizeof(option_values.compression_settings[0])) 1094 die("too many compression settings"); 1095 option_values.compression_settings[option_values.num_compression_settings].type = type; 1096 option_values.compression_settings[option_values.num_compression_settings].value.t_string = value; 1097 option_values.num_compression_settings++; 1098} 1099 1100void add_compression_setting_unsigned(compression_setting_type_t type, unsigned value) 1101{ 1102 if(option_values.num_compression_settings >= sizeof(option_values.compression_settings)/sizeof(option_values.compression_settings[0])) 1103 die("too many compression settings"); 1104 option_values.compression_settings[option_values.num_compression_settings].type = type; 1105 option_values.compression_settings[option_values.num_compression_settings].value.t_unsigned = value; 1106 option_values.num_compression_settings++; 1107} 1108 1109int usage_error(const char *message, ...) 1110{ 1111 if(flac__utils_verbosity_ >= 1) { 1112 va_list args; 1113 1114 FLAC__ASSERT(0 != message); 1115 1116 va_start(args, message); 1117 1118 (void) vfprintf(stderr, message, args); 1119 1120 va_end(args); 1121 1122 printf("Type \"flac\" for a usage summary or \"flac --help\" for all options\n"); 1123 } 1124 1125 return 1; 1126} 1127 1128void show_version(void) 1129{ 1130 printf("flac %s\n", FLAC__VERSION_STRING); 1131} 1132 1133static void usage_header(void) 1134{ 1135 printf("===============================================================================\n"); 1136 printf("flac - Command-line FLAC encoder/decoder version %s\n", FLAC__VERSION_STRING); 1137 printf("Copyright (C) 2000,2001,2002,2003,2004,2005,2006,2007 Josh Coalson\n"); 1138 printf("\n"); 1139 printf("This program is free software; you can redistribute it and/or\n"); 1140 printf("modify it under the terms of the GNU General Public License\n"); 1141 printf("as published by the Free Software Foundation; either version 2\n"); 1142 printf("of the License, or (at your option) any later version.\n"); 1143 printf("\n"); 1144 printf("This program is distributed in the hope that it will be useful,\n"); 1145 printf("but WITHOUT ANY WARRANTY; without even the implied warranty of\n"); 1146 printf("MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n"); 1147 printf("GNU General Public License for more details.\n"); 1148 printf("\n"); 1149 printf("You should have received a copy of the GNU General Public License\n"); 1150 printf("along with this program; if not, write to the Free Software\n"); 1151 printf("Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.\n"); 1152 printf("===============================================================================\n"); 1153} 1154 1155static void usage_summary(void) 1156{ 1157 printf("Usage:\n"); 1158 printf("\n"); 1159 printf(" Encoding: flac [<general-options>] [<encoding/format-options>] [INPUTFILE [...]]\n"); 1160 printf(" Decoding: flac -d [<general-options>] [<format-options>] [FLACFILE [...]]\n"); 1161 printf(" Testing: flac -t [<general-options>] [FLACFILE [...]]\n"); 1162 printf("Analyzing: flac -a [<general-options>] [<analysis-options>] [FLACFILE [...]]\n"); 1163 printf("\n"); 1164} 1165 1166void short_usage(void) 1167{ 1168 usage_header(); 1169 printf("\n"); 1170 printf("This is the short help; for all options use 'flac --help'; for even more\n"); 1171 printf("instructions use 'flac --explain'\n"); 1172 printf("\n"); 1173 printf("To encode:\n"); 1174 printf(" flac [-#] [INPUTFILE [...]]\n"); 1175 printf("\n"); 1176 printf(" -# is -0 (fastest compression) to -8 (highest compression); -5 is the default\n"); 1177 printf("\n"); 1178 printf("To decode:\n"); 1179 printf(" flac -d [INPUTFILE [...]]\n"); 1180 printf("\n"); 1181 printf("To test:\n"); 1182 printf(" flac -t [INPUTFILE [...]]\n"); 1183} 1184 1185void show_help(void) 1186{ 1187 usage_header(); 1188 usage_summary(); 1189 printf("general options:\n"); 1190 printf(" -v, --version Show the flac version number\n"); 1191 printf(" -h, --help Show this screen\n"); 1192 printf(" -H, --explain Show detailed explanation of usage and options\n"); 1193 printf(" -d, --decode Decode (the default behavior is to encode)\n"); 1194 printf(" -t, --test Same as -d except no decoded file is written\n"); 1195 printf(" -a, --analyze Same as -d except an analysis file is written\n"); 1196 printf(" -c, --stdout Write output to stdout\n"); 1197 printf(" -s, --silent Do not write runtime encode/decode statistics\n"); 1198 printf(" --totally-silent Do not print anything, including errors\n"); 1199 printf(" --no-utf8-convert Do not convert tags from local charset to UTF-8\n"); 1200 printf(" -w, --warnings-as-errors Treat all warnings as errors\n"); 1201 printf(" -f, --force Force overwriting of output files\n"); 1202 printf(" -o, --output-name=FILENAME Force the output file name\n"); 1203 printf(" --output-prefix=STRING Prepend STRING to output names\n"); 1204 printf(" --delete-input-file Deletes after a successful encode/decode\n"); 1205 printf(" --keep-foreign-metadata Save/restore WAVE or AIFF non-audio chunks\n"); 1206 printf(" --skip={#|mm:ss.ss} Skip the given initial samples for each input\n"); 1207 printf(" --until={#|[+|-]mm:ss.ss} Stop at the given sample for each input file\n"); 1208#if FLAC__HAS_OGG 1209 printf(" --ogg Use Ogg as transport layer\n"); 1210 printf(" --serial-number Serial number to use for the FLAC stream\n"); 1211#endif 1212 printf("analysis options:\n"); 1213 printf(" --residual-text Include residual signal in text output\n"); 1214 printf(" --residual-gnuplot Generate gnuplot files of residual distribution\n"); 1215 printf("decoding options:\n"); 1216 printf(" -F, --decode-through-errors Continue decoding through stream errors\n"); 1217 printf(" --cue=[#.#][-[#.#]] Set the beginning and ending cuepoints to decode\n"); 1218 printf("encoding options:\n"); 1219 printf(" -V, --verify Verify a correct encoding\n"); 1220 printf(" --lax Allow encoder to generate non-Subset files\n"); 1221#if 0 /*@@@ currently undocumented */ 1222 printf(" --ignore-chunk-sizes Ignore data chunk sizes in WAVE/AIFF files\n"); 1223#endif 1224 printf(" --sector-align Align multiple files on sector boundaries\n"); 1225 printf(" --replay-gain Calculate ReplayGain & store in FLAC tags\n"); 1226 printf(" --cuesheet=FILENAME Import cuesheet and store in CUESHEET block\n"); 1227 printf(" --picture=SPECIFICATION Import picture and store in PICTURE block\n"); 1228 printf(" -T, --tag=FIELD=VALUE Add a FLAC tag; may appear multiple times\n"); 1229 printf(" --tag-from-file=FIELD=FILENAME Like --tag but gets value from file\n"); 1230 printf(" -S, --seekpoint={#|X|#x|#s} Add seek point(s)\n"); 1231 printf(" -P, --padding=# Write a PADDING block of length #\n"); 1232 printf(" -0, --compression-level-0, --fast Synonymous with -l 0 -b 1152 -r 3\n"); 1233 printf(" -1, --compression-level-1 Synonymous with -l 0 -b 1152 -M -r 3\n"); 1234 printf(" -2, --compression-level-2 Synonymous with -l 0 -b 1152 -m -r 3\n"); 1235 printf(" -3, --compression-level-3 Synonymous with -l 6 -b 4096 -r 4\n"); 1236 printf(" -4, --compression-level-4 Synonymous with -l 8 -b 4096 -M -r 4\n"); 1237 printf(" -5, --compression-level-5 Synonymous with -l 8 -b 4096 -m -r 5\n"); 1238 printf(" -6, --compression-level-6 Synonymous with -l 8 -b 4096 -m -r 6\n"); 1239 printf(" -7, --compression-level-7 Synonymous with -l 8 -b 4096 -m -e -r 6\n"); 1240 printf(" -8, --compression-level-8, --best Synonymous with -l 12 -b 4096 -m -e -r 6\n"); 1241 printf(" -b, --blocksize=# Specify blocksize in samples\n"); 1242 printf(" -m, --mid-side Try mid-side coding for each frame\n"); 1243 printf(" -M, --adaptive-mid-side Adaptive mid-side coding for all frames\n"); 1244 printf(" -e, --exhaustive-model-search Do exhaustive model search (expensive!)\n"); 1245 printf(" -A, --apodization=\"function\" Window audio data with given the function\n"); 1246 printf(" -l, --max-lpc-order=# Max LPC order; 0 => only fixed predictors\n"); 1247 printf(" -p, --qlp-coeff-precision-search Exhaustively search LP coeff quantization\n"); 1248 printf(" -q, --qlp-coeff-precision=# Specify precision in bits\n"); 1249 printf(" -r, --rice-partition-order=[#,]# Set [min,]max residual partition order\n"); 1250 printf("format options:\n"); 1251 printf(" --endian={big|little} Set byte order for samples\n"); 1252 printf(" --channels=# Number of channels\n"); 1253 printf(" --bps=# Number of bits per sample\n"); 1254 printf(" --sample-rate=# Sample rate in Hz\n"); 1255 printf(" --sign={signed|unsigned} Sign of samples\n"); 1256 printf(" --input-size=# Size of the raw input in bytes\n"); 1257 printf(" --force-aiff-format Force decoding to AIFF format\n"); 1258 printf(" --force-raw-format Treat input or output as raw samples\n"); 1259 printf("negative options:\n"); 1260 printf(" --no-adaptive-mid-side\n"); 1261 printf(" --no-decode-through-errors\n"); 1262 printf(" --no-delete-input-file\n"); 1263 printf(" --no-keep-foreign-metadata\n"); 1264 printf(" --no-exhaustive-model-search\n"); 1265 printf(" --no-lax\n"); 1266 printf(" --no-mid-side\n"); 1267#if FLAC__HAS_OGG 1268 printf(" --no-ogg\n"); 1269#endif 1270 printf(" --no-padding\n"); 1271 printf(" --no-qlp-coeff-prec-search\n"); 1272 printf(" --no-replay-gain\n"); 1273 printf(" --no-residual-gnuplot\n"); 1274 printf(" --no-residual-text\n"); 1275#if 0 /*@@@ currently undocumented */ 1276 printf(" --no-ignore-chunk-sizes\n"); 1277#endif 1278 printf(" --no-sector-align\n"); 1279 printf(" --no-seektable\n"); 1280 printf(" --no-silent\n"); 1281 printf(" --no-force\n"); 1282 printf(" --no-verify\n"); 1283 printf(" --no-warnings-as-errors\n"); 1284} 1285 1286void show_explain(void) 1287{ 1288 usage_header(); 1289 usage_summary(); 1290 printf("For encoding:\n"); 1291 printf(" The input file(s) may be a PCM WAVE file, AIFF (or uncompressed AIFF-C)\n"); 1292 printf(" file, or raw samples.\n"); 1293 printf(" The output file(s) will be in native FLAC or Ogg FLAC format\n"); 1294 printf("For decoding, the reverse is true.\n"); 1295 printf("\n"); 1296 printf("A single INPUTFILE may be - for stdin. No INPUTFILE implies stdin. Use of\n"); 1297 printf("stdin implies -c (write to stdout). Normally you should use:\n"); 1298 printf(" flac [options] -o outfilename or flac -d [options] -o outfilename\n"); 1299 printf("instead of:\n"); 1300 printf(" flac [options] > outfilename or flac -d [options] > outfilename\n"); 1301 printf("since the former allows flac to seek backwards to write the STREAMINFO or\n"); 1302 printf("WAVE/AIFF header contents when necessary.\n"); 1303 printf("\n"); 1304 printf("flac checks for the presence of a AIFF/WAVE header to decide whether or not to\n"); 1305 printf("treat an input file as AIFF/WAVE format or raw samples. If any input file is\n"); 1306 printf("raw you must specify the format options {-fb|fl} -fc -fp and -fs, which will\n"); 1307 printf("apply to all raw files. You can force AIFF/WAVE files to be treated as raw\n"); 1308 printf("files using -fr.\n"); 1309 printf("\n"); 1310 printf("general options:\n"); 1311 printf(" -v, --version Show the flac version number\n"); 1312 printf(" -h, --help Show basic usage a list of all options\n"); 1313 printf(" -H, --explain Show this screen\n"); 1314 printf(" -d, --decode Decode (the default behavior is to encode)\n"); 1315 printf(" -t, --test Same as -d except no decoded file is written\n"); 1316 printf(" -a, --analyze Same as -d except an analysis file is written\n"); 1317 printf(" -c, --stdout Write output to stdout\n"); 1318 printf(" -s, --silent Do not write runtime encode/decode statistics\n"); 1319 printf(" --totally-silent Do not print anything of any kind, including\n"); 1320 printf(" warnings or errors. The exit code will be the\n"); 1321 printf(" only way to determine successful completion.\n"); 1322 printf(" --no-utf8-convert Do not convert tags from local charset to UTF-8.\n"); 1323 printf(" This is useful for scripts, and setting tags in\n"); 1324 printf(" situations where the locale is wrong. This\n"); 1325 printf(" option must appear before any tag options!\n"); 1326 printf(" -w, --warnings-as-errors Treat all warnings as errors\n"); 1327 printf(" -f, --force Force overwriting of output files\n"); 1328 printf(" -o, --output-name=FILENAME Force the output file name; usually flac just\n"); 1329 printf(" changes the extension. May only be used when\n"); 1330 printf(" encoding a single file. May not be used in\n"); 1331 printf(" conjunction with --output-prefix.\n"); 1332 printf(" --output-prefix=STRING Prefix each output file name with the given\n"); 1333 printf(" STRING. This can be useful for encoding or\n"); 1334 printf(" decoding files to a different directory. Make\n"); 1335 printf(" sure if your STRING is a path name that it ends\n"); 1336 printf(" with a '/' slash.\n"); 1337 printf(" --delete-input-file Automatically delete the input file after a\n"); 1338 printf(" successful encode or decode. If there was an\n"); 1339 printf(" error (including a verify error) the input file\n"); 1340 printf(" is left intact.\n"); 1341 printf(" --keep-foreign-metadata If encoding, save WAVE or AIFF non-audio chunks\n"); 1342 printf(" in FLAC metadata. If decoding, restore any saved\n"); 1343 printf(" non-audio chunks from FLAC metadata when writing\n"); 1344 printf(" the decoded file. Foreign metadata cannot be\n"); 1345 printf(" transcoded, e.g. WAVE chunks saved in a FLAC file\n"); 1346 printf(" cannot be restored when decoding to AIFF. Input\n"); 1347 printf(" and output must be regular files, not stdin/out.\n"); 1348 printf(" --skip={#|mm:ss.ss} Skip the first # samples of each input file; can\n"); 1349 printf(" be used both for encoding and decoding. The\n"); 1350 printf(" alternative form mm:ss.ss can be used to specify\n"); 1351 printf(" minutes, seconds, and fractions of a second.\n"); 1352 printf(" --until={#|[+|-]mm:ss.ss} Stop at the given sample number for each input\n"); 1353 printf(" file. The given sample number is not included\n"); 1354 printf(" in the decoded output. The alternative form\n"); 1355 printf(" mm:ss.ss can be used to specify minutes,\n"); 1356 printf(" seconds, and fractions of a second. If a `+'\n"); 1357 printf(" sign is at the beginning, the --until point is\n"); 1358 printf(" relative to the --skip point. If a `-' sign is\n"); 1359 printf(" at the beginning, the --until point is relative\n"); 1360 printf(" to end of the audio.\n"); 1361#if FLAC__HAS_OGG 1362 printf(" --ogg When encoding, generate Ogg FLAC output instead\n"); 1363 printf(" of native FLAC. Ogg FLAC streams are FLAC\n"); 1364 printf(" streams wrapped in an Ogg transport layer. The\n"); 1365 printf(" resulting file should have an '.oga' extension\n"); 1366 printf(" and will still be decodable by flac. When\n"); 1367 printf(" decoding, force the input to be treated as\n"); 1368 printf(" Ogg FLAC. This is useful when piping input\n"); 1369 printf(" from stdin or when the filename does not end in\n"); 1370 printf(" '.oga' or '.ogg'.\n"); 1371 printf(" --serial-number Serial number to use for the FLAC stream. When\n"); 1372 printf(" encoding and no serial number is given, flac\n"); 1373 printf(" uses a random one. If encoding to multiple files\n"); 1374 printf(" the serial number is incremented for each file.\n"); 1375 printf(" When decoding and no number is given, flac uses\n"); 1376 printf(" the serial number of the first page.\n"); 1377#endif 1378 printf("analysis options:\n"); 1379 printf(" --residual-text Include residual signal in text output. This\n"); 1380 printf(" will make the file very big, much larger than\n"); 1381 printf(" even the decoded file.\n"); 1382 printf(" --residual-gnuplot Generate gnuplot files of residual distribution\n"); 1383 printf(" of each subframe\n"); 1384 printf("decoding options:\n"); 1385 printf(" -F, --decode-through-errors By default flac stops decoding with an error\n"); 1386 printf(" and removes the partially decoded file if it\n"); 1387 printf(" encounters a bitstream error. With -F, errors\n"); 1388 printf(" are still printed but flac will continue\n"); 1389 printf(" decoding to completion. Note that errors may\n"); 1390 printf(" cause the decoded audio to be missing some\n"); 1391 printf(" samples or have silent sections.\n"); 1392 printf(" --cue=[#.#][-[#.#]] Set the beginning and ending cuepoints to\n"); 1393 printf(" decode. The optional first #.# is the track and\n"); 1394 printf(" index point at which decoding will start; the\n"); 1395 printf(" default is the beginning of the stream. The\n"); 1396 printf(" optional second #.# is the track and index point\n"); 1397 printf(" at which decoding will end; the default is the\n"); 1398 printf(" end of the stream. If the cuepoint does not\n"); 1399 printf(" exist, the closest one before it (for the start\n"); 1400 printf(" point) or after it (for the end point) will be\n"); 1401 printf(" used. The cuepoints are merely translated into\n"); 1402 printf(" sample numbers then used as --skip and --until.\n"); 1403 printf(" A CD track can always be cued by, for example,\n"); 1404 printf(" --cue=9.1-10.1 for track 9, even if the CD has\n"); 1405 printf(" no 10th track.\n"); 1406 printf("encoding options:\n"); 1407 printf(" -V, --verify Verify a correct encoding by decoding the\n"); 1408 printf(" output in parallel and comparing to the\n"); 1409 printf(" original\n"); 1410 printf(" --lax Allow encoder to generate non-Subset files\n"); 1411#if 0 /*@@@ currently undocumented */ 1412 printf(" --ignore-chunk-sizes Ignore data chunk sizes in WAVE/AIFF files;\n"); 1413 printf(" useful when piping data from programs which\n"); 1414 printf(" generate bogus data chunk sizes.\n"); 1415#endif 1416 printf(" --sector-align Align encoding of multiple CD format WAVE files\n"); 1417 printf(" on sector boundaries.\n"); 1418 printf(" --replay-gain Calculate ReplayGain values and store them as\n"); 1419 printf(" FLAC tags. Title gains/peaks will be computed\n"); 1420 printf(" for each file, and an album gain/peak will be\n"); 1421 printf(" computed for all files. All input files must\n"); 1422 printf(" have the same resolution, sample rate, and\n"); 1423 printf(" number of channels. The sample rate must be\n"); 1424 printf(" one of 8, 11.025, 12, 16, 22.05, 24, 32, 44.1,\n"); 1425 printf(" or 48 kHz. NOTE: this option may also leave a\n"); 1426 printf(" few extra bytes in the PADDING block.\n"); 1427 printf(" --cuesheet=FILENAME Import the given cuesheet file and store it in\n"); 1428 printf(" a CUESHEET metadata block. This option may only\n"); 1429 printf(" be used when encoding a single file. A\n"); 1430 printf(" seekpoint will be added for each index point in\n"); 1431 printf(" the cuesheet to the SEEKTABLE unless\n"); 1432 printf(" --no-cued-seekpoints is specified.\n"); 1433 printf(" --picture=SPECIFICATION Import a picture and store it in a PICTURE block.\n"); 1434 printf(" More than one --picture command can be specified.\n"); 1435 printf(" The SPECIFICATION can either be a simple filename\n"); 1436 printf(" for the picture file, or a complete specification\n"); 1437 printf(" whose parts are separated by | characters. Some\n"); 1438 printf(" parts may be left empty to invoke default values.\n"); 1439 printf(" Using a filename is shorthand for \"||||FILE\".\n"); 1440 printf(" The SPECIFICATION format is:\n"); 1441 printf(" [TYPE]|[MIME-TYPE]|[DESCRIPTION]|[WIDTHxHEIGHTxDEPTH[/COLORS]]|FILE\n"); 1442 printf(" TYPE is optional; it is a number from one of:\n"); 1443 printf(" 0: Other\n"); 1444 printf(" 1: 32x32 pixels 'file icon' (PNG only)\n"); 1445 printf(" 2: Other file icon\n"); 1446 printf(" 3: Cover (front)\n"); 1447 printf(" 4: Cover (back)\n"); 1448 printf(" 5: Leaflet page\n"); 1449 printf(" 6: Media (e.g. label side of CD)\n"); 1450 printf(" 7: Lead artist/lead performer/soloist\n"); 1451 printf(" 8: Artist/performer\n"); 1452 printf(" 9: Conductor\n"); 1453 printf(" 10: Band/Orchestra\n"); 1454 printf(" 11: Composer\n"); 1455 printf(" 12: Lyricist/text writer\n"); 1456 printf(" 13: Recording Location\n"); 1457 printf(" 14: During recording\n"); 1458 printf(" 15: During performance\n"); 1459 printf(" 16: Movie/video screen capture\n"); 1460 printf(" 17: A bright coloured fish\n"); 1461 printf(" 18: Illustration\n"); 1462 printf(" 19: Band/artist logotype\n"); 1463 printf(" 20: Publisher/Studio logotype\n"); 1464 printf(" The default is 3 (front cover). There may only be one picture each\n"); 1465 printf(" of type 1 and 2 in a file.\n"); 1466 printf(" MIME-TYPE is optional; if left blank, it will be detected from the\n"); 1467 printf(" file. For best compatibility with players, use pictures with MIME\n"); 1468 printf(" type image/jpeg or image/png. The MIME type can also be --> to\n"); 1469 printf(" mean that FILE is actually a URL to an image, though this use is\n"); 1470 printf(" discouraged.\n"); 1471 printf(" DESCRIPTION is optional; the default is an empty string\n"); 1472 printf(" The next part specfies the resolution and color information. If\n"); 1473 printf(" the MIME-TYPE is image/jpeg, image/png, or image/gif, you can\n"); 1474 printf(" usually leave this empty and they can be detected from the file.\n"); 1475 printf(" Otherwise, you must specify the width in pixels, height in pixels,\n"); 1476 printf(" and color depth in bits-per-pixel. If the image has indexed colors\n"); 1477 printf(" you should also specify the number of colors used.\n"); 1478 printf(" FILE is the path to the picture file to be imported, or the URL if\n"); 1479 printf(" MIME type is -->\n"); 1480 printf(" -T, --tag=FIELD=VALUE Add a FLAC tag. Make sure to quote the\n"); 1481 printf(" comment if necessary. This option may appear\n"); 1482 printf(" more than once to add several comments. NOTE:\n"); 1483 printf(" all tags will be added to all encoded files.\n"); 1484 printf(" --tag-from-file=FIELD=FILENAME Like --tag, except FILENAME is a file\n"); 1485 printf(" whose contents will be read verbatim to set the\n"); 1486 printf(" tag value. The contents will be converted to\n"); 1487 printf(" UTF-8 from the local charset. This can be used\n"); 1488 printf(" to store a cuesheet in a tag (e.g.\n"); 1489 printf(" --tag-from-file=\"CUESHEET=image.cue\"). Do not\n"); 1490 printf(" try to store binary data in tag fields! Use\n"); 1491 printf(" APPLICATION blocks for that.\n"); 1492 printf(" -S, --seekpoint={#|X|#x|#s} Include a point or points in a SEEKTABLE\n"); 1493 printf(" # : a specific sample number for a seek point\n"); 1494 printf(" X : a placeholder point (always goes at the end of the SEEKTABLE)\n"); 1495 printf(" #x : # evenly spaced seekpoints, the first being at sample 0\n"); 1496 printf(" #s : a seekpoint every # seconds; # does not have to be a whole number\n"); 1497 printf(" You may use many -S options; the resulting SEEKTABLE will be the unique-\n"); 1498 printf(" ified union of all such values.\n"); 1499 printf(" With no -S options, flac defaults to '-S 10s'. Use -S- for no SEEKTABLE.\n"); 1500 printf(" Note: -S #x and -S #s will not work if the encoder can't determine the\n"); 1501 printf(" input size before starting.\n"); 1502 printf(" Note: if you use -S # and # is >= samples in the input, there will be\n"); 1503 printf(" either no seek point entered (if the input size is determinable\n"); 1504 printf(" before encoding starts) or a placeholder point (if input size is not\n"); 1505 printf(" determinable)\n"); 1506 printf(" -P, --padding=# Tell the encoder to write a PADDING metadata\n"); 1507 printf(" block of the given length (in bytes) after the\n"); 1508 printf(" STREAMINFO block. This is useful if you plan\n"); 1509 printf(" to tag the file later with an APPLICATION\n"); 1510 printf(" block; instead of having to rewrite the entire\n"); 1511 printf(" file later just to insert your block, you can\n"); 1512 printf(" write directly over the PADDING block. Note\n"); 1513 printf(" that the total length of the PADDING block will\n"); 1514 printf(" be 4 bytes longer than the length given because\n"); 1515 printf(" of the 4 metadata block header bytes. You can\n"); 1516 printf(" force no PADDING block at all to be written with\n"); 1517 printf(" --no-padding. The encoder writes a PADDING\n"); 1518 printf(" block of 8192 bytes by default, or 65536 bytes\n"); 1519 printf(" if the input audio is more than 20 minutes long.\n"); 1520 printf(" -b, --blocksize=# Specify the blocksize in samples; the default is\n"); 1521 printf(" 1152 for -l 0, else 4096; must be one of 192,\n"); 1522 printf(" 576, 1152, 2304, 4608, 256, 512, 1024, 2048,\n"); 1523 printf(" 4096 (and 8192 or 16384 if the sample rate is\n"); 1524 printf(" >48kHz) for Subset streams.\n"); 1525 printf(" -0, --compression-level-0, --fast Synonymous with -l 0 -b 1152 -r 3\n"); 1526 printf(" -1, --compression-level-1 Synonymous with -l 0 -b 1152 -M -r 3\n"); 1527 printf(" -2, --compression-level-2 Synonymous with -l 0 -b 1152 -m -r 3\n"); 1528 printf(" -3, --compression-level-3 Synonymous with -l 6 -b 4096 -r 4\n"); 1529 printf(" -4, --compression-level-4 Synonymous with -l 8 -b 4096 -M -r 4\n"); 1530 printf(" -5, --compression-level-5 Synonymous with -l 8 -b 4096 -m -r 5\n"); 1531 printf(" -5 is the default setting\n"); 1532 printf(" -6, --compression-level-6 Synonymous with -l 8 -b 4096 -m -r 6\n"); 1533 printf(" -7, --compression-level-7 Synonymous with -l 8 -b 4096 -m -e -r 6\n"); 1534 printf(" -8, --compression-level-8, --best Synonymous with -l 12 -b 4096 -m -e -r 6\n"); 1535 printf(" -m, --mid-side Try mid-side coding for each frame\n"); 1536 printf(" (stereo only)\n"); 1537 printf(" -M, --adaptive-mid-side Adaptive mid-side coding for all frames\n"); 1538 printf(" (stereo only)\n"); 1539 printf(" -e, --exhaustive-model-search Do exhaustive model search (expensive!)\n"); 1540 printf(" -A, --apodization=\"function\" Window audio data with given the function.\n"); 1541 printf(" The functions are: bartlett, bartlett_hann,\n"); 1542 printf(" blackman, blackman_harris_4term_92db,\n"); 1543 printf(" connes, flattop, gauss(STDDEV), hamming,\n"); 1544 printf(" hann, kaiser_bessel, nuttall, rectangle,\n"); 1545 printf(" triangle, tukey(P), welch. More than one\n"); 1546 printf(" may be specified but encoding time is a\n"); 1547 printf(" multiple of the number of functions since\n"); 1548 printf(" they are each tried in turn. The encoder\n"); 1549 printf(" chooses suitable defaults in the absence\n"); 1550 printf(" of any -A options.\n"); 1551 printf(" -l, --max-lpc-order=# Max LPC order; 0 => only fixed predictors.\n"); 1552 printf(" Must be <= 12 for Subset streams if sample\n"); 1553 printf(" rate is <=48kHz.\n"); 1554 printf(" -p, --qlp-coeff-precision-search Do exhaustive search of LP coefficient\n"); 1555 printf(" quantization (expensive!); overrides -q;\n"); 1556 printf(" does nothing if using -l 0\n"); 1557 printf(" -q, --qlp-coeff-precision=# Specify precision in bits of quantized\n"); 1558 printf(" linear-predictor coefficients; 0 => let\n"); 1559 printf(" encoder decide (the minimun is %u, the\n", FLAC__MIN_QLP_COEFF_PRECISION); 1560 printf(" default is -q 0)\n"); 1561 printf(" -r, --rice-partition-order=[#,]# Set [min,]max residual partition order\n"); 1562 printf(" (# is 0..16; min defaults to 0; the\n"); 1563 printf(" default is -r 0; above 4 doesn't usually\n"); 1564 printf(" help much)\n"); 1565 printf("format options:\n"); 1566 printf(" --endian={big|little} Set byte order for samples\n"); 1567 printf(" --channels=# Number of channels\n"); 1568 printf(" --bps=# Number of bits per sample\n"); 1569 printf(" --sample-rate=# Sample rate in Hz\n"); 1570 printf(" --sign={signed|unsigned} Sign of samples (the default is signed)\n"); 1571 printf(" --input-size=# Size of the raw input in bytes. If you are\n"); 1572 printf(" encoding raw samples from stdin, you must set\n"); 1573 printf(" this option in order to be able to use --skip,\n"); 1574 printf(" --until, --cue-sheet, or other options that need\n"); 1575 printf(" to know the size of the input beforehand. If\n"); 1576 printf(" the size given is greater than what is found in\n"); 1577 printf(" the input stream, the encoder will complain\n"); 1578 printf(" about an unexpected end-of-file. If the size\n"); 1579 printf(" given is less, samples will be truncated.\n"); 1580 printf(" --force-aiff-format Force the decoder to output AIFF format. This\n"); 1581 printf(" option is not needed if the output filename (as\n"); 1582 printf(" set by -o) ends with .aif or .aiff; this option\n"); 1583 printf(" has no effect when encoding since input AIFF is\n"); 1584 printf(" auto-detected.\n"); 1585 printf(" --force-raw-format Force input (when encoding) or output (when\n"); 1586 printf(" decoding) to be treated as raw samples\n"); 1587 printf("negative options:\n"); 1588 printf(" --no-adaptive-mid-side\n"); 1589 printf(" --no-decode-through-errors\n"); 1590 printf(" --no-delete-input-file\n"); 1591 printf(" --no-keep-foreign-metadata\n"); 1592 printf(" --no-exhaustive-model-search\n"); 1593 printf(" --no-lax\n"); 1594 printf(" --no-mid-side\n"); 1595#if FLAC__HAS_OGG 1596 printf(" --no-ogg\n"); 1597#endif 1598 printf(" --no-padding\n"); 1599 printf(" --no-qlp-coeff-prec-search\n"); 1600 printf(" --no-residual-gnuplot\n"); 1601 printf(" --no-residual-text\n"); 1602#if 0 /*@@@ currently undocumented */ 1603 printf(" --no-ignore-chunk-sizes\n"); 1604#endif 1605 printf(" --no-sector-align\n"); 1606 printf(" --no-seektable\n"); 1607 printf(" --no-silent\n"); 1608 printf(" --no-force\n"); 1609 printf(" --no-verify\n"); 1610 printf(" --no-warnings-as-errors\n"); 1611} 1612 1613void format_mistake(const char *infilename, FileFormat wrong, FileFormat right) 1614{ 1615 /* WATCHOUT: indexed by FileFormat */ 1616 static const char * const ff[] = { "raw", "WAVE", "AIFF", "FLAC", "Ogg FLAC" }; 1617 flac__utils_printf(stderr, 1, "WARNING: %s is not a %s file; treating as a %s file\n", infilename, ff[wrong], ff[right]); 1618} 1619 1620int encode_file(const char *infilename, FLAC__bool is_first_file, FLAC__bool is_last_file) 1621{ 1622 FILE *encode_infile; 1623 FLAC__byte lookahead[12]; 1624 unsigned lookahead_length = 0; 1625 FileFormat input_format = RAW; 1626 FLAC__bool is_aifc = false; 1627 int retval; 1628 off_t infilesize; 1629 encode_options_t common_options; 1630 const char *outfilename = get_encoded_outfilename(infilename); /* the final name of the encoded file */ 1631 /* internal_outfilename is the file we will actually write to; it will be a temporary name if infilename==outfilename */ 1632 char *internal_outfilename = 0; /* NULL implies 'use outfilename' */ 1633 1634 if(0 == outfilename) { 1635 flac__utils_printf(stderr, 1, "ERROR: filename too long: %s", infilename); 1636 return 1; 1637 } 1638 1639 if(0 == strcmp(infilename, "-")) { 1640 infilesize = (off_t)(-1); 1641 encode_infile = grabbag__file_get_binary_stdin(); 1642 } 1643 else { 1644 infilesize = grabbag__file_get_filesize(infilename); 1645 if(0 == (encode_infile = fopen(infilename, "rb"))) { 1646 flac__utils_printf(stderr, 1, "ERROR: can't open input file %s: %s\n", infilename, strerror(errno)); 1647 return 1; 1648 } 1649 } 1650 1651 if(!option_values.force_raw_format) { 1652 /* first set format based on name */ 1653 if(strlen(infilename) >= 4 && 0 == FLAC__STRCASECMP(infilename+(strlen(infilename)-4), ".wav")) 1654 input_format = WAV; 1655 else if(strlen(infilename) >= 4 && 0 == FLAC__STRCASECMP(infilename+(strlen(infilename)-4), ".aif")) 1656 input_format = AIF; 1657 else if(strlen(infilename) >= 5 && 0 == FLAC__STRCASECMP(infilename+(strlen(infilename)-5), ".aiff")) 1658 input_format = AIF; 1659 else if(strlen(infilename) >= 5 && 0 == FLAC__STRCASECMP(infilename+(strlen(infilename)-5), ".flac")) 1660 input_format = FLAC; 1661 else if(strlen(infilename) >= 4 && 0 == FLAC__STRCASECMP(infilename+(strlen(infilename)-4), ".oga")) 1662 input_format = OGGFLAC; 1663 else if(strlen(infilename) >= 4 && 0 == FLAC__STRCASECMP(infilename+(strlen(infilename)-4), ".ogg")) 1664 input_format = OGGFLAC; 1665 1666 /* attempt to guess the file type based on the first 12 bytes */ 1667 if((lookahead_length = fread(lookahead, 1, 12, encode_infile)) < 12) { 1668 if(input_format != RAW) { 1669 format_mistake(infilename, input_format, RAW); 1670 if(option_values.treat_warnings_as_errors) { 1671 conditional_fclose(encode_infile); 1672 return 1; 1673 } 1674 } 1675 input_format = RAW; 1676 } 1677 else { 1678 if(!strncmp((const char *)lookahead, "ID3", 3)) { 1679 flac__utils_printf(stderr, 1, "ERROR: input file %s has an ID3v2 tag\n", infilename); 1680 return 1; 1681 } 1682 else if(!strncmp((const char *)lookahead, "RIFF", 4) && !strncmp((const char *)lookahead+8, "WAVE", 4)) 1683 input_format = WAV; 1684 else if(!strncmp((const char *)lookahead, "FORM", 4) && !strncmp((const char *)lookahead+8, "AIFF", 4)) 1685 input_format = AIF; 1686 else if(!strncmp((const char *)lookahead, "FORM", 4) && !strncmp((const char *)lookahead+8, "AIFC", 4)) { 1687 input_format = AIF; 1688 is_aifc = true; 1689 } 1690 else if(!memcmp(lookahead, FLAC__STREAM_SYNC_STRING, sizeof(FLAC__STREAM_SYNC_STRING))) 1691 input_format = FLAC; 1692 /* this could be made more accurate by looking at the first packet */ 1693 else if(!memcmp(lookahead, "OggS", 4)) 1694 input_format = OGGFLAC; 1695 else { 1696 if(input_format != RAW) { 1697 format_mistake(infilename, input_format, RAW); 1698 if(option_values.treat_warnings_as_errors) { 1699 conditional_fclose(encode_infile); 1700 return 1; 1701 } 1702 } 1703 input_format = RAW; 1704 } 1705 } 1706 } 1707 1708 if(option_values.keep_foreign_metadata) { 1709 if(encode_infile == stdin || option_values.force_to_stdout) { 1710 conditional_fclose(encode_infile); 1711 return usage_error("ERROR: --keep-foreign-metadata cannot be used when encoding from stdin or to stdout\n"); 1712 } 1713 if(input_format != WAV && input_format != AIF) { 1714 conditional_fclose(encode_infile); 1715 return usage_error("ERROR: --keep-foreign-metadata can only be used with WAVE or AIFF input\n"); 1716 } 1717 } 1718 1719 /* 1720 * Error if output file already exists (and -f not used). 1721 * Use grabbag__file_get_filesize() as a cheap way to check. 1722 */ 1723 if(!option_values.test_only && !option_values.force_file_overwrite && strcmp(outfilename, "-") && grabbag__file_get_filesize(outfilename) != (off_t)(-1)) { 1724 if(input_format == FLAC) { 1725 /* need more detailed error message when re-flac'ing to avoid confusing the user */ 1726 flac__utils_printf(stderr, 1, 1727 "ERROR: output file %s already exists.\n\n" 1728 "By default flac encodes files to FLAC format; if you meant to decode this file\n" 1729 "from FLAC to something else, use -d. If you meant to re-encode this file from\n" 1730 "FLAC to FLAC again, use -f to force writing to the same file, or -o to specify\n" 1731 "a different output filename.\n", 1732 outfilename 1733 ); 1734 } 1735 else if(input_format == OGGFLAC) { 1736 /* need more detailed error message when re-flac'ing to avoid confusing the user */ 1737 flac__utils_printf(stderr, 1, 1738 "ERROR: output file %s already exists.\n\n" 1739 "By default 'flac -ogg' encodes files to Ogg FLAC format; if you meant to decode\n" 1740 "this file from Ogg FLAC to something else, use -d. If you meant to re-encode\n" 1741 "this file from Ogg FLAC to Ogg FLAC again, use -f to force writing to the same\n" 1742 "file, or -o to specify a different output filename.\n", 1743 outfilename 1744 ); 1745 } 1746 else 1747 flac__utils_printf(stderr, 1, "ERROR: output file %s already exists, use -f to override\n", outfilename); 1748 conditional_fclose(encode_infile); 1749 return 1; 1750 } 1751 1752 if(option_values.format_input_size >= 0) { 1753 if (input_format != RAW || infilesize >= 0) { 1754 flac__utils_printf(stderr, 1, "ERROR: can only use --input-size when encoding raw samples from stdin\n"); 1755 conditional_fclose(encode_infile); 1756 return 1; 1757 } 1758 else { 1759 infilesize = option_values.format_input_size; 1760 } 1761 } 1762 1763 if(option_values.sector_align && (input_format == FLAC || input_format == OGGFLAC)) { 1764 flac__utils_printf(stderr, 1, "ERROR: can't use --sector-align when the input file is FLAC or Ogg FLAC\n"); 1765 conditional_fclose(encode_infile); 1766 return 1; 1767 } 1768 if(option_values.sector_align && input_format == RAW && infilesize < 0) { 1769 flac__utils_printf(stderr, 1, "ERROR: can't use --sector-align when the input size is unknown\n"); 1770 conditional_fclose(encode_infile); 1771 return 1; 1772 } 1773 1774 if(input_format == RAW) { 1775 if(option_values.format_is_big_endian < 0 || option_values.format_is_unsigned_samples < 0 || option_values.format_channels < 0 || option_values.format_bps < 0 || option_values.format_sample_rate < 0) { 1776 conditional_fclose(encode_infile); 1777 return usage_error("ERROR: for encoding a raw file you must specify a value for --endian, --sign, --channels, --bps, and --sample-rate\n"); 1778 } 1779 } 1780 1781 if(/*@@@@@@why no stdin?*/encode_infile == stdin || option_values.force_to_stdout) { 1782 if(option_values.replay_gain) { 1783 conditional_fclose(encode_infile); 1784 return usage_error("ERROR: --replay-gain cannot be used when encoding to stdout\n"); 1785 } 1786 } 1787 if(option_values.replay_gain && option_values.use_ogg) { 1788 conditional_fclose(encode_infile); 1789 return usage_error("ERROR: --replay-gain cannot be used when encoding to Ogg FLAC yet\n"); 1790 } 1791 1792 if(!flac__utils_parse_skip_until_specification(option_values.skip_specification, &common_options.skip_specification) || common_options.skip_specification.is_relative) { 1793 conditional_fclose(encode_infile); 1794 return usage_error("ERROR: invalid value for --skip\n"); 1795 } 1796 1797 if(!flac__utils_parse_skip_until_specification(option_values.until_specification, &common_options.until_specification)) { /*@@@@ more checks: no + without --skip, no - unless known total_samples_to_{en,de}code */ 1798 conditional_fclose(encode_infile); 1799 return usage_error("ERROR: invalid value for --until\n"); 1800 } 1801 /* if there is no "--until" we want to default to "--until=-0" */ 1802 if(0 == option_values.until_specification) 1803 common_options.until_specification.is_relative = true; 1804 1805 common_options.verify = option_values.verify; 1806 common_options.treat_warnings_as_errors = option_values.treat_warnings_as_errors; 1807#if FLAC__HAS_OGG 1808 common_options.use_ogg = option_values.use_ogg; 1809 /* set a random serial number if one has not yet been specified */ 1810 if(!option_values.has_serial_number) { 1811 option_values.serial_number = rand(); 1812 option_values.has_serial_number = true; 1813 } 1814 common_options.serial_number = option_values.serial_number++; 1815#endif 1816 common_options.lax = option_values.lax; 1817 common_options.padding = option_values.padding; 1818 common_options.num_compression_settings = option_values.num_compression_settings; 1819 FLAC__ASSERT(sizeof(common_options.compression_settings) >= sizeof(option_values.compression_settings)); 1820 memcpy(common_options.compression_settings, option_values.compression_settings, sizeof(option_values.compression_settings)); 1821 common_options.requested_seek_points = option_values.requested_seek_points; 1822 common_options.num_requested_seek_points = option_values.num_requested_seek_points; 1823 common_options.cuesheet_filename = option_values.cuesheet_filename; 1824 common_options.continue_through_decode_errors = option_values.continue_through_decode_errors; 1825 common_options.cued_seekpoints = option_values.cued_seekpoints; 1826 common_options.channel_map_none = option_values.channel_map_none; 1827 common_options.is_first_file = is_first_file; 1828 common_options.is_last_file = is_last_file; 1829 common_options.align_reservoir = align_reservoir; 1830 common_options.align_reservoir_samples = &align_reservoir_samples; 1831 common_options.replay_gain = option_values.replay_gain; 1832 common_options.ignore_chunk_sizes = option_values.ignore_chunk_sizes; 1833 common_options.sector_align = option_values.sector_align; 1834 common_options.vorbis_comment = option_values.vorbis_comment; 1835 FLAC__ASSERT(sizeof(common_options.pictures) >= sizeof(option_values.pictures)); 1836 memcpy(common_options.pictures, option_values.pictures, sizeof(option_values.pictures)); 1837 common_options.num_pictures = option_values.num_pictures; 1838 common_options.debug.disable_constant_subframes = option_values.debug.disable_constant_subframes; 1839 common_options.debug.disable_fixed_subframes = option_values.debug.disable_fixed_subframes; 1840 common_options.debug.disable_verbatim_subframes = option_values.debug.disable_verbatim_subframes; 1841 common_options.debug.do_md5 = option_values.debug.do_md5; 1842 1843 /* if infilename and outfilename point to the same file, we need to write to a temporary file */ 1844 if(encode_infile != stdin && grabbag__file_are_same(infilename, outfilename)) { 1845 static const char *tmp_suffix = ".tmp,fl-ac+en'c"; 1846 /*@@@@ still a remote possibility that a file with this filename exists */ 1847 if(0 == (internal_outfilename = (char *)safe_malloc_add_3op_(strlen(outfilename), /*+*/strlen(tmp_suffix), /*+*/1))) { 1848 flac__utils_printf(stderr, 1, "ERROR allocating memory for tempfile name\n"); 1849 conditional_fclose(encode_infile); 1850 return 1; 1851 } 1852 strcpy(internal_outfilename, outfilename); 1853 strcat(internal_outfilename, tmp_suffix); 1854 } 1855 1856 if(input_format == RAW) { 1857 raw_encode_options_t options; 1858 1859 options.common = common_options; 1860 options.is_big_endian = option_values.format_is_big_endian; 1861 options.is_unsigned_samples = option_values.format_is_unsigned_samples; 1862 options.channels = option_values.format_channels; 1863 options.bps = option_values.format_bps; 1864 options.sample_rate = option_values.format_sample_rate; 1865 1866 retval = flac__encode_raw(encode_infile, infilesize, infilename, internal_outfilename? internal_outfilename : outfilename, lookahead, lookahead_length, options); 1867 } 1868 else if(input_format == FLAC || input_format == OGGFLAC) { 1869 flac_encode_options_t options; 1870 1871 options.common = common_options; 1872 1873 retval = flac__encode_flac(encode_infile, infilesize, infilename, internal_outfilename? internal_outfilename : outfilename, lookahead, lookahead_length, options, input_format==OGGFLAC); 1874 } 1875 else { 1876 wav_encode_options_t options; 1877 1878 options.common = common_options; 1879 options.foreign_metadata = 0; 1880 1881 /* read foreign metadata if requested */ 1882 if(option_values.keep_foreign_metadata) { 1883 if(0 == (options.foreign_metadata = flac__foreign_metadata_new(input_format==AIF? FOREIGN_BLOCK_TYPE__AIFF : FOREIGN_BLOCK_TYPE__RIFF))) { 1884 flac__utils_printf(stderr, 1, "ERROR: creating foreign metadata object\n"); 1885 conditional_fclose(encode_infile); 1886 return 1; 1887 } 1888 } 1889 1890 if(input_format == AIF) 1891 retval = flac__encode_aif(encode_infile, infilesize, infilename, internal_outfilename? internal_outfilename : outfilename, lookahead, lookahead_length, options, is_aifc); 1892 else 1893 retval = flac__encode_wav(encode_infile, infilesize, infilename, internal_outfilename? internal_outfilename : outfilename, lookahead, lookahead_length, options); 1894 1895 if(options.foreign_metadata) 1896 flac__foreign_metadata_delete(options.foreign_metadata); 1897 } 1898 1899 if(retval == 0) { 1900 if(strcmp(outfilename, "-")) { 1901 if(option_values.replay_gain) { 1902 float title_gain, title_peak; 1903 const char *error; 1904 grabbag__replaygain_get_title(&title_gain, &title_peak); 1905 if( 1906 0 != (error = grabbag__replaygain_store_to_file_reference(internal_outfilename? internal_outfilename : outfilename, /*preserve_modtime=*/true)) || 1907 0 != (error = grabbag__replaygain_store_to_file_title(internal_outfilename? internal_outfilename : outfilename, title_gain, title_peak, /*preserve_modtime=*/true)) 1908 ) { 1909 flac__utils_printf(stderr, 1, "%s: ERROR writing ReplayGain reference/title tags (%s)\n", outfilename, error); 1910 retval = 1; 1911 } 1912 } 1913 if(strcmp(infilename, "-")) 1914 grabbag__file_copy_metadata(infilename, internal_outfilename? internal_outfilename : outfilename); 1915 } 1916 } 1917 1918 /* rename temporary file if necessary */ 1919 if(retval == 0 && internal_outfilename != 0) { 1920 if(rename(internal_outfilename, outfilename) < 0) { 1921#if defined _MSC_VER || defined __MINGW32__ || defined __EMX__ 1922 /* on some flavors of windows, rename() will fail if the destination already exists, so we unlink and try again */ 1923 if(unlink(outfilename) < 0) { 1924 flac__utils_printf(stderr, 1, "ERROR: moving new FLAC file %s back on top of original FLAC file %s, keeping both\n", internal_outfilename, outfilename); 1925 retval = 1; 1926 } 1927 else if(rename(internal_outfilename, outfilename) < 0) { 1928 flac__utils_printf(stderr, 1, "ERROR: moving new FLAC file %s back on top of original FLAC file %s, you must do it\n", internal_outfilename, outfilename); 1929 retval = 1; 1930 } 1931#else 1932 flac__utils_printf(stderr, 1, "ERROR: moving new FLAC file %s back on top of original FLAC file %s, keeping both\n", internal_outfilename, outfilename); 1933 retval = 1; 1934#endif 1935 } 1936 } 1937 1938 /* handle --delete-input-file, but don't want to delete if piping from stdin, or if input filename and output filename are the same */ 1939 if(retval == 0 && option_values.delete_input && strcmp(infilename, "-") && internal_outfilename == 0) 1940 unlink(infilename); 1941 1942 if(internal_outfilename != 0) 1943 free(internal_outfilename); 1944 1945 return retval; 1946} 1947 1948int decode_file(const char *infilename) 1949{ 1950 int retval; 1951 FLAC__bool treat_as_ogg = false; 1952 FileFormat output_format = WAV; 1953 decode_options_t common_options; 1954 const char *outfilename = get_decoded_outfilename(infilename); 1955 1956 if(0 == outfilename) { 1957 flac__utils_printf(stderr, 1, "ERROR: filename too long: %s", infilename); 1958 return 1; 1959 } 1960 1961 /* 1962 * Error if output file already exists (and -f not used). 1963 * Use grabbag__file_get_filesize() as a cheap way to check. 1964 */ 1965 if(!option_values.test_only && !option_values.force_file_overwrite && strcmp(outfilename, "-") && grabbag__file_get_filesize(outfilename) != (off_t)(-1)) { 1966 flac__utils_printf(stderr, 1, "ERROR: output file %s already exists, use -f to override\n", outfilename); 1967 return 1; 1968 } 1969 1970 if(option_values.force_raw_format) 1971 output_format = RAW; 1972 else if( 1973 option_values.force_aiff_format || 1974 (strlen(outfilename) >= 4 && 0 == FLAC__STRCASECMP(outfilename+(strlen(outfilename)-4), ".aif")) || 1975 (strlen(outfilename) >= 5 && 0 == FLAC__STRCASECMP(outfilename+(strlen(outfilename)-5), ".aiff")) 1976 ) 1977 output_format = AIF; 1978 else 1979 output_format = WAV; 1980 1981 if(!option_values.test_only && !option_values.analyze) { 1982 if(output_format == RAW && (option_values.format_is_big_endian < 0 || option_values.format_is_unsigned_samples < 0)) 1983 return usage_error("ERROR: for decoding to a raw file you must specify a value for --endian and --sign\n"); 1984 } 1985 1986 if(option_values.keep_foreign_metadata) { 1987 if(0 == strcmp(infilename, "-") || 0 == strcmp(outfilename, "-")) 1988 return usage_error("ERROR: --keep-foreign-metadata cannot be used when decoding from stdin or to stdout\n"); 1989 if(output_format != WAV && output_format != AIF) 1990 return usage_error("ERROR: --keep-foreign-metadata can only be used with WAVE or AIFF output\n"); 1991 } 1992 1993 if(option_values.use_ogg) 1994 treat_as_ogg = true; 1995 else if(strlen(infilename) >= 4 && 0 == FLAC__STRCASECMP(infilename+(strlen(infilename)-4), ".oga")) 1996 treat_as_ogg = true; 1997 else if(strlen(infilename) >= 4 && 0 == FLAC__STRCASECMP(infilename+(strlen(infilename)-4), ".ogg")) 1998 treat_as_ogg = true; 1999 else 2000 treat_as_ogg = false; 2001 2002#if !FLAC__HAS_OGG 2003 if(treat_as_ogg) { 2004 flac__utils_printf(stderr, 1, "%s: Ogg support has not been built into this copy of flac\n", infilename); 2005 return 1; 2006 } 2007#endif 2008 2009 if(!flac__utils_parse_skip_until_specification(option_values.skip_specification, &common_options.skip_specification) || common_options.skip_specification.is_relative) 2010 return usage_error("ERROR: invalid value for --skip\n"); 2011 2012 if(!flac__utils_parse_skip_until_specification(option_values.until_specification, &common_options.until_specification)) /*@@@ more checks: no + without --skip, no - unless known total_samples_to_{en,de}code */ 2013 return usage_error("ERROR: invalid value for --until\n"); 2014 /* if there is no "--until" we want to default to "--until=-0" */ 2015 if(0 == option_values.until_specification) 2016 common_options.until_specification.is_relative = true; 2017 2018 if(option_values.cue_specification) { 2019 if(!flac__utils_parse_cue_specification(option_values.cue_specification, &common_options.cue_specification)) 2020 return usage_error("ERROR: invalid value for --cue\n"); 2021 common_options.has_cue_specification = true; 2022 } 2023 else 2024 common_options.has_cue_specification = false; 2025 2026 common_options.treat_warnings_as_errors = option_values.treat_warnings_as_errors; 2027 common_options.continue_through_decode_errors = option_values.continue_through_decode_errors; 2028 common_options.replaygain_synthesis_spec = option_values.replaygain_synthesis_spec; 2029#if FLAC__HAS_OGG 2030 common_options.is_ogg = treat_as_ogg; 2031 common_options.use_first_serial_number = !option_values.has_serial_number; 2032 common_options.serial_number = option_values.serial_number; 2033#endif 2034 common_options.channel_map_none = option_values.channel_map_none; 2035 2036 if(output_format == RAW) { 2037 raw_decode_options_t options; 2038 2039 options.common = common_options; 2040 options.is_big_endian = option_values.format_is_big_endian; 2041 options.is_unsigned_samples = option_values.format_is_unsigned_samples; 2042 2043 retval = flac__decode_raw(infilename, option_values.test_only? 0 : outfilename, option_values.analyze, option_values.aopts, options); 2044 } 2045 else { 2046 wav_decode_options_t options; 2047 2048 options.common = common_options; 2049 options.foreign_metadata = 0; 2050 2051 /* read foreign metadata if requested */ 2052 if(option_values.keep_foreign_metadata) { 2053 if(0 == (options.foreign_metadata = flac__foreign_metadata_new(output_format==AIF? FOREIGN_BLOCK_TYPE__AIFF : FOREIGN_BLOCK_TYPE__RIFF))) { 2054 flac__utils_printf(stderr, 1, "ERROR: creating foreign metadata object\n"); 2055 return 1; 2056 } 2057 } 2058 2059 if(output_format == AIF) 2060 retval = flac__decode_aiff(infilename, option_values.test_only? 0 : outfilename, option_values.analyze, option_values.aopts, options); 2061 else 2062 retval = flac__decode_wav(infilename, option_values.test_only? 0 : outfilename, option_values.analyze, option_values.aopts, options); 2063 2064 if(options.foreign_metadata) 2065 flac__foreign_metadata_delete(options.foreign_metadata); 2066 } 2067 2068 if(retval == 0 && strcmp(infilename, "-")) { 2069 if(strcmp(outfilename, "-")) 2070 grabbag__file_copy_metadata(infilename, outfilename); 2071 if(option_values.delete_input && !option_values.test_only && !option_values.analyze) 2072 unlink(infilename); 2073 } 2074 2075 return retval; 2076} 2077 2078const char *get_encoded_outfilename(const char *infilename) 2079{ 2080 const char *suffix = (option_values.use_ogg? ".oga" : ".flac"); 2081 return get_outfilename(infilename, suffix); 2082} 2083 2084const char *get_decoded_outfilename(const char *infilename) 2085{ 2086 const char *suffix; 2087 if(option_values.analyze) { 2088 suffix = ".ana"; 2089 } 2090 else if(option_values.force_raw_format) { 2091 suffix = ".raw"; 2092 } 2093 else if(option_values.force_aiff_format) { 2094 suffix = ".aiff"; 2095 } 2096 else { 2097 suffix = ".wav"; 2098 } 2099 return get_outfilename(infilename, suffix); 2100} 2101 2102const char *get_outfilename(const char *infilename, const char *suffix) 2103{ 2104 if(0 == option_values.cmdline_forced_outfilename) { 2105 static char buffer[4096]; /* @@@ bad MAGIC NUMBER */ 2106 2107 if(0 == strcmp(infilename, "-") || option_values.force_to_stdout) { 2108 strcpy(buffer, "-"); 2109 } 2110 else { 2111 char *p; 2112 if (flac__strlcpy(buffer, option_values.output_prefix? option_values.output_prefix : "", sizeof buffer) >= sizeof buffer) 2113 return 0; 2114 if (flac__strlcat(buffer, infilename, sizeof buffer) >= sizeof buffer) 2115 return 0; 2116 /* the . must come after any / to avoid problems with, e.g. "some.directory/extensionless-filename" */ 2117 if(0 == (p = strrchr(buffer, '.')) || strchr(p, '/')) { 2118 if (flac__strlcat(buffer, suffix, sizeof buffer) >= sizeof buffer) 2119 return 0; 2120 } 2121 else { 2122 *p = '\0'; 2123 if (flac__strlcat(buffer, suffix, sizeof buffer) >= sizeof buffer) 2124 return 0; 2125 } 2126 } 2127 return buffer; 2128 } 2129 else 2130 return option_values.cmdline_forced_outfilename; 2131} 2132 2133void die(const char *message) 2134{ 2135 FLAC__ASSERT(0 != message); 2136 flac__utils_printf(stderr, 1, "ERROR: %s\n", message); 2137 exit(1); 2138} 2139 2140int conditional_fclose(FILE *f) 2141{ 2142 if(f == 0 || f == stdin || f == stdout) 2143 return 0; 2144 else 2145 return fclose(f); 2146} 2147 2148char *local_strdup(const char *source) 2149{ 2150 char *ret; 2151 FLAC__ASSERT(0 != source); 2152 if(0 == (ret = strdup(source))) 2153 die("out of memory during strdup()"); 2154 return ret; 2155} 2156 2157#ifdef _MSC_VER 2158/* There's no strtoll() in MSVC6 so we just write a specialized one */ 2159FLAC__int64 local__strtoll(const char *src, char **endptr) 2160{ 2161 FLAC__bool neg = false; 2162 FLAC__int64 ret = 0; 2163 int c; 2164 FLAC__ASSERT(0 != src); 2165 if(*src == '-') { 2166 neg = true; 2167 src++; 2168 } 2169 while(0 != (c = *src)) { 2170 c -= '0'; 2171 if(c >= 0 && c <= 9) 2172 ret = (ret * 10) + c; 2173 else 2174 break; 2175 src++; 2176 } 2177 if(endptr) 2178 *endptr = (char*)src; 2179 return neg? -ret : ret; 2180} 2181#endif 2182