开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 嵌入式/单片机编程 > Windows CE > 查看源码
main.c
资源名称：tcpmp.rar　[点击查看]
上传用户：wstnjxml
上传日期：2014-04-03
资源大小：7248k
文件大小：77k
源码类别：

Windows CE

开发平台：

C/C++

main.c：源码内容
  1. /* flac - Command-line FLAC encoder/decoder
  2.  * Copyright (C) 2000,2001,2002,2003,2004,2005  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.  */
  19. #include <ctype.h>
  20. #include <locale.h>
  21. #include <stdarg.h>
  22. #include <stdio.h>
  23. #include <stdlib.h>
  24. #include <string.h>
  25. #include <time.h>
  27. #ifdef HAVE_CONFIG_H
  28. #include <config.h>
  29. #endif
  31. #if !defined _MSC_VER && !defined __MINGW32__
  32. /* unlink is in stdio.h in VC++ */
  33. #include <unistd.h> /* for unlink() */
  34. #else
  35. #define strcasecmp stricmp
  36. #endif
  37. #include "FLAC/all.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"
  46. #if 0
  47. /*[JEC] was:#if HAVE_GETOPT_LONG*/
  48. /*[JEC] see flac/include/share/getopt.h as to why the change */
  49. #  include <getopt.h>
  50. #else
  51. #  include "share/getopt.h"
  52. #endif
  54. typedef enum { RAW, WAV, AIF } FileFormat;
  56. static int do_it();
  58. static FLAC__bool init_options();
  59. static int parse_options(int argc, char *argv[]);
  60. static int parse_option(int short_option, const char *long_option, const char *option_argument);
  61. static void free_options();
  63. static int usage_error(const char *message, ...);
  64. static void short_usage();
  65. static void show_version();
  66. static void show_help();
  67. static void show_explain();
  68. static void format_mistake(const char *infilename, const char *wrong, const char *right);
  70. static int encode_file(const char *infilename, FLAC__bool is_first_file, FLAC__bool is_last_file);
  71. static int decode_file(const char *infilename);
  73. static const char *get_encoded_outfilename(const char *infilename);
  74. static const char *get_decoded_outfilename(const char *infilename);
  75. static const char *get_outfilename(const char *infilename, const char *suffix);
  77. static void die(const char *message);
  78. static char *local_strdup(const char *source);
  81. /*
  82.  * share__getopt format struct; note that for long options with no
  83.  * short option equivalent we just set the 'val' field to 0.
  84.  */
  85. static struct share__option long_options_[] = {
  86. /*
  87.  * general options
  88.  */
  89. { "help"             , share__no_argument, 0, 'h' },
  90. { "explain"          , share__no_argument, 0, 'H' },
  91. { "version"          , share__no_argument, 0, 'v' },
  92. { "decode"           , share__no_argument, 0, 'd' },
  93. { "analyze"          , share__no_argument, 0, 'a' },
  94. { "test"             , share__no_argument, 0, 't' },
  95. { "stdout"           , share__no_argument, 0, 'c' },
  96. { "silent"           , share__no_argument, 0, 's' },
  97. { "totally-silent"   , share__no_argument, 0, 0 },
  98. { "force"            , share__no_argument, 0, 'f' },
  99. { "delete-input-file", share__no_argument, 0, 0 },
  100. { "output-prefix"    , share__required_argument, 0, 0 },
  101. { "output-name"      , share__required_argument, 0, 'o' },
  102. { "skip"             , share__required_argument, 0, 0 },
  103. { "until"            , share__required_argument, 0, 0 },
  105. /*
  106.  * decoding options
  107.  */
  108. { "decode-through-errors", share__no_argument, 0, 'F' },
  109. { "cue"                  , share__required_argument, 0, 0 },
  110. { "apply-replaygain-which-is-not-lossless", share__optional_argument, 0, 0 }, /* undocumented */
  112. /*
  113.  * encoding options
  114.  */
  115. { "cuesheet"                  , share__required_argument, 0, 0 },
  116. { "no-cued-seekpoints"        , share__no_argument, 0, 0 },
  117. { "tag"                       , share__required_argument, 0, 'T' },
  118. { "compression-level-0"       , share__no_argument, 0, '0' },
  119. { "compression-level-1"       , share__no_argument, 0, '1' },
  120. { "compression-level-2"       , share__no_argument, 0, '2' },
  121. { "compression-level-3"       , share__no_argument, 0, '3' },
  122. { "compression-level-4"       , share__no_argument, 0, '4' },
  123. { "compression-level-5"       , share__no_argument, 0, '5' },
  124. { "compression-level-6"       , share__no_argument, 0, '6' },
  125. { "compression-level-7"       , share__no_argument, 0, '7' },
  126. { "compression-level-8"       , share__no_argument, 0, '8' },
  127. { "compression-level-9"       , share__no_argument, 0, '9' },
  128. { "best"                      , share__no_argument, 0, '8' },
  129. { "fast"                      , share__no_argument, 0, '0' },
  130. { "super-secret-totally-impractical-compression-level", share__no_argument, 0, 0 },
  131. { "verify"                    , share__no_argument, 0, 'V' },
  132. { "force-aiff-format"         , share__no_argument, 0, 0 },
  133. { "force-raw-format"          , share__no_argument, 0, 0 },
  134. { "lax"                       , share__no_argument, 0, 0 },
  135. { "replay-gain"               , share__no_argument, 0, 0 },
  136. { "sector-align"              , share__no_argument, 0, 0 },
  137. { "seekpoint"                 , share__required_argument, 0, 'S' },
  138. { "padding"                   , share__required_argument, 0, 'P' },
  139. #ifdef FLAC__HAS_OGG
  140. { "ogg"                       , share__no_argument, 0, 0 },
  141. { "serial-number"             , share__required_argument, 0, 0 },
  142. #endif
  143. { "blocksize"                 , share__required_argument, 0, 'b' },
  144. { "exhaustive-model-search"   , share__no_argument, 0, 'e' },
  145. { "max-lpc-order"             , share__required_argument, 0, 'l' },
  146. { "mid-side"                  , share__no_argument, 0, 'm' },
  147. { "adaptive-mid-side"         , share__no_argument, 0, 'M' },
  148. { "qlp-coeff-precision-search", share__no_argument, 0, 'p' },
  149. { "qlp-coeff-precision"       , share__required_argument, 0, 'q' },
  150. { "rice-partition-order"      , share__required_argument, 0, 'r' },
  151. { "endian"                    , share__required_argument, 0, 0 },
  152. { "channels"                  , share__required_argument, 0, 0 },
  153. { "bps"                       , share__required_argument, 0, 0 },
  154. { "sample-rate"               , share__required_argument, 0, 0 },
  155. { "sign"                      , share__required_argument, 0, 0 },
  156. { "input-size"                , share__required_argument, 0, 0 },
  158. /*
  159.  * analysis options
  160.  */
  161. { "residual-gnuplot", share__no_argument, 0, 0 },
  162. { "residual-text", share__no_argument, 0, 0 },
  164. /*
  165.  * negatives
  166.  */
  167. { "no-decode-through-errors"  , share__no_argument, 0, 0 },
  168. { "no-silent"                 , share__no_argument, 0, 0 },
  169. { "no-force"                  , share__no_argument, 0, 0 },
  170. { "no-seektable"              , share__no_argument, 0, 0 },
  171. { "no-delete-input-file"      , share__no_argument, 0, 0 },
  172. { "no-replay-gain"            , share__no_argument, 0, 0 },
  173. { "no-sector-align"           , share__no_argument, 0, 0 },
  174. { "no-lax"                    , share__no_argument, 0, 0 },
  175. #ifdef FLAC__HAS_OGG
  176. { "no-ogg"                    , share__no_argument, 0, 0 },
  177. #endif
  178. { "no-exhaustive-model-search", share__no_argument, 0, 0 },
  179. { "no-mid-side"               , share__no_argument, 0, 0 },
  180. { "no-adaptive-mid-side"      , share__no_argument, 0, 0 },
  181. { "no-qlp-coeff-prec-search"  , share__no_argument, 0, 0 },
  182. { "no-padding"                , share__no_argument, 0, 0 },
  183. { "no-verify"                 , share__no_argument, 0, 0 },
  184. { "no-residual-gnuplot"       , share__no_argument, 0, 0 },
  185. { "no-residual-text"          , share__no_argument, 0, 0 },
  186. /*
  187.  * undocumented debugging options for the test suite
  188.  */
  189. { "disable-constant-subframes", share__no_argument, 0, 0 },
  190. { "disable-fixed-subframes"   , share__no_argument, 0, 0 },
  191. { "disable-verbatim-subframes", share__no_argument, 0, 0 },
  193. {0, 0, 0, 0}
  194. };
  197. /*
  198.  * global to hold command-line option values
  199.  */
  201. static struct {
  202. FLAC__bool show_help;
  203. FLAC__bool show_explain;
  204. FLAC__bool show_version;
  205. FLAC__bool mode_decode;
  206. FLAC__bool verify;
  207. FLAC__bool force_file_overwrite;
  208. FLAC__bool continue_through_decode_errors;
  209. replaygain_synthesis_spec_t replaygain_synthesis_spec;
  210. FLAC__bool lax;
  211. FLAC__bool test_only;
  212. FLAC__bool analyze;
  213. FLAC__bool use_ogg;
  214. FLAC__bool has_serial_number; /* true iff --serial-number was used */
  215. long serial_number; /* this is the Ogg serial number and is unused for native FLAC */
  216. FLAC__bool do_mid_side;
  217. FLAC__bool loose_mid_side;
  218. FLAC__bool do_exhaustive_model_search;
  219. FLAC__bool do_escape_coding;
  220. FLAC__bool do_qlp_coeff_prec_search;
  221. FLAC__bool force_to_stdout;
  222. FLAC__bool force_aiff_format;
  223. FLAC__bool force_raw_format;
  224. FLAC__bool delete_input;
  225. FLAC__bool replay_gain;
  226. FLAC__bool sector_align;
  227. const char *cmdline_forced_outfilename;
  228. const char *output_prefix;
  229. analysis_options aopts;
  230. int padding;
  231. unsigned max_lpc_order;
  232. unsigned qlp_coeff_precision;
  233. const char *skip_specification;
  234. const char *until_specification;
  235. const char *cue_specification;
  236. int format_is_big_endian;
  237. int format_is_unsigned_samples;
  238. int format_channels;
  239. int format_bps;
  240. int format_sample_rate;
  241. long format_input_size;
  242. int blocksize;
  243. int min_residual_partition_order;
  244. int max_residual_partition_order;
  245. int rice_parameter_search_dist;
  246. char requested_seek_points[50000]; /* bad MAGIC NUMBER but buffer overflow is checked */
  247. int num_requested_seek_points; /* -1 => no -S options were given, 0 => -S- was given */
  248. const char *cuesheet_filename;
  249. FLAC__bool cued_seekpoints;
  251. unsigned num_files;
  252. char **filenames;
  254. FLAC__StreamMetadata *vorbis_comment;
  256. struct {
  257. FLAC__bool disable_constant_subframes;
  258. FLAC__bool disable_fixed_subframes;
  259. FLAC__bool disable_verbatim_subframes;
  260. } debug;
  261. } option_values;
  264. /*
  265.  * miscellaneous globals
  266.  */
  268. static FLAC__int32 align_reservoir_0[588], align_reservoir_1[588]; /* for carrying over samples from --sector-align */
  269. static FLAC__int32 *align_reservoir[2] = { align_reservoir_0, align_reservoir_1 };
  270. static unsigned align_reservoir_samples = 0; /* 0 .. 587 */
  273. int main(int argc, char *argv[])
  274. {
  275. int retval = 0;
  277. setlocale(LC_ALL, "");
  278. if(!init_options()) {
  279. flac__utils_printf(stderr, 1, "ERROR: allocating memoryn");
  280. retval = 1;
  281. }
  282. else {
  283. if((retval = parse_options(argc, argv)) == 0)
  284. retval = do_it();
  285. }
  287. free_options();
  289. return retval;
  290. }
  292. int do_it()
  293. {
  294. int retval = 0;
  296. if(option_values.show_version) {
  297. show_version();
  298. return 0;
  299. }
  300. else if(option_values.show_explain) {
  301. show_explain();
  302. return 0;
  303. }
  304. else if(option_values.show_help) {
  305. show_help();
  306. return 0;
  307. }
  308. else {
  309. if(option_values.num_files == 0) {
  310. if(flac__utils_verbosity_ >= 1)
  311. short_usage();
  312. return 0;
  313. }
  315. /*
  316.  * tweak options; validate the values
  317.  */
  318. if(!option_values.mode_decode) {
  319. if(option_values.blocksize < 0) {
  320. if(option_values.max_lpc_order == 0)
  321. option_values.blocksize = 1152;
  322. else
  323. option_values.blocksize = 4608;
  324. }
  325. if(option_values.max_residual_partition_order < 0) {
  326. if(option_values.blocksize <= 1152)
  327. option_values.max_residual_partition_order = 2;
  328. else if(option_values.blocksize <= 2304)
  329. option_values.max_residual_partition_order = 3;
  330. else if(option_values.blocksize <= 4608)
  331. option_values.max_residual_partition_order = 3;
  332. else
  333. option_values.max_residual_partition_order = 4;
  334. option_values.min_residual_partition_order = option_values.max_residual_partition_order;
  335. }
  336. if(option_values.rice_parameter_search_dist < 0) {
  337. option_values.rice_parameter_search_dist = 0;
  338. }
  339. if(0 != option_values.cue_specification)
  340. return usage_error("ERROR: --cue is not allowed in test moden");
  341. }
  342. else {
  343. if(option_values.test_only) {
  344. if(0 != option_values.skip_specification)
  345. return usage_error("ERROR: --skip is not allowed in test moden");
  346. if(0 != option_values.until_specification)
  347. return usage_error("ERROR: --until is not allowed in test moden");
  348. if(0 != option_values.cue_specification)
  349. return usage_error("ERROR: --cue is not allowed in test moden");
  350. }
  351. }
  353. if(0 != option_values.cue_specification && (0 != option_values.skip_specification || 0 != option_values.until_specification))
  354. return usage_error("ERROR: --cue may not be combined with --skip or --untiln");
  356. FLAC__ASSERT(option_values.blocksize >= 0 || option_values.mode_decode);
  358. if(option_values.format_channels >= 0) {
  359. if(option_values.format_channels == 0 || (unsigned)option_values.format_channels > FLAC__MAX_CHANNELS)
  360. return usage_error("ERROR: invalid number of channels '%u', must be > 0 and <= %un", option_values.format_channels, FLAC__MAX_CHANNELS);
  361. }
  362. if(option_values.format_bps >= 0) {
  363. if(option_values.format_bps != 8 && option_values.format_bps != 16 && option_values.format_bps != 24)
  364. return usage_error("ERROR: invalid bits per sample '%u' (must be 8/16/24)n", option_values.format_bps);
  365. }
  366. if(option_values.format_sample_rate >= 0) {
  367. if(!FLAC__format_sample_rate_is_valid(option_values.format_sample_rate))
  368. return usage_error("ERROR: invalid sample rate '%u', must be > 0 and <= %un", option_values.format_sample_rate, FLAC__MAX_SAMPLE_RATE);
  369. }
  370. if(option_values.force_raw_format && option_values.force_aiff_format)
  371. return usage_error("ERROR: only one of --force-raw-format and --force-aiff-format allowedn");
  372. if(option_values.mode_decode) {
  373. if(!option_values.force_raw_format) {
  374. if(option_values.format_is_big_endian >= 0)
  375. return usage_error("ERROR: --endian only allowed with --force-raw-formatn");
  376. if(option_values.format_is_unsigned_samples >= 0)
  377. return usage_error("ERROR: --sign only allowed with --force-raw-formatn");
  378. }
  379. if(option_values.format_channels >= 0)
  380. return usage_error("ERROR: --channels not allowed with --decoden");
  381. if(option_values.format_bps >= 0)
  382. return usage_error("ERROR: --bps not allowed with --decoden");
  383. if(option_values.format_sample_rate >= 0)
  384. return usage_error("ERROR: --sample-rate not allowed with --decoden");
  385. }
  386. if(!option_values.mode_decode && ((unsigned)option_values.blocksize < FLAC__MIN_BLOCK_SIZE || (unsigned)option_values.blocksize > FLAC__MAX_BLOCK_SIZE)) {
  387. return usage_error("ERROR: invalid blocksize '%u', must be >= %u and <= %un", (unsigned)option_values.blocksize, FLAC__MIN_BLOCK_SIZE, FLAC__MAX_BLOCK_SIZE);
  388. }
  389. if(option_values.qlp_coeff_precision > 0 && option_values.qlp_coeff_precision < FLAC__MIN_QLP_COEFF_PRECISION) {
  390. return usage_error("ERROR: invalid value '%u' for qlp coeff precision, must be 0 or >= %un", option_values.qlp_coeff_precision, FLAC__MIN_QLP_COEFF_PRECISION);
  391. }
  393. if(option_values.sector_align) {
  394. if(option_values.mode_decode)
  395. return usage_error("ERROR: --sector-align only allowed for encodingn");
  396. if(0 != option_values.skip_specification)
  397. return usage_error("ERROR: --sector-align not allowed with --skipn");
  398. if(0 != option_values.until_specification)
  399. return usage_error("ERROR: --sector-align not allowed with --untiln");
  400. if(0 != option_values.cue_specification)
  401. return usage_error("ERROR: --sector-align not allowed with --cuen");
  402. if(option_values.format_channels >= 0 && option_values.format_channels != 2)
  403. return usage_error("ERROR: --sector-align can only be done with stereo inputn");
  404. if(option_values.format_bps >= 0 && option_values.format_bps != 16)
  405. return usage_error("ERROR: --sector-align can only be done with 16-bit samplesn");
  406. if(option_values.format_sample_rate >= 0 && option_values.format_sample_rate != 44100)
  407. return usage_error("ERROR: --sector-align can only be done with a sample rate of 44100n");
  408. }
  409. if(option_values.replay_gain) {
  410. if(option_values.force_to_stdout)
  411. return usage_error("ERROR: --replay-gain not allowed with -c/--stdoutn");
  412. if(option_values.mode_decode)
  413. return usage_error("ERROR: --replay-gain only allowed for encodingn");
  414. if(option_values.format_channels > 2)
  415. return usage_error("ERROR: --replay-gain can only be done with mono/stereo inputn");
  416. if(option_values.format_sample_rate >= 0 && !grabbag__replaygain_is_valid_sample_frequency(option_values.format_sample_rate))
  417. return usage_error("ERROR: invalid sample rate used with --replay-gainn");
  418. /*
  419.  * We want to reserve padding space for the ReplayGain
  420.  * tags that we will set later, to avoid rewriting the
  421.  * whole file.
  422.  */
  423. if(option_values.padding < 0) {
  424. flac__utils_printf(stderr, 1, "NOTE: --replay-gain may leave a small PADDING block even with --no-paddingn");
  425. option_values.padding = GRABBAG__REPLAYGAIN_MAX_TAG_SPACE_REQUIRED;
  426. }
  427. else {
  428. option_values.padding += GRABBAG__REPLAYGAIN_MAX_TAG_SPACE_REQUIRED;
  429. }
  430. }
  431. if(option_values.num_files > 1 && option_values.cmdline_forced_outfilename) {
  432. return usage_error("ERROR: -o/--output-name cannot be used with multiple filesn");
  433. }
  434. if(option_values.cmdline_forced_outfilename && option_values.output_prefix) {
  435. return usage_error("ERROR: --output-prefix conflicts with -o/--output-namen");
  436. }
  437. if(!option_values.mode_decode && 0 != option_values.cuesheet_filename && option_values.num_files > 1) {
  438. return usage_error("ERROR: --cuesheet cannot be used when encoding multiple filesn");
  439. }
  440. }
  442. flac__utils_printf(stderr, 2, "n");
  443. flac__utils_printf(stderr, 2, "flac %s, Copyright (C) 2000,2001,2002,2003,2004,2005  Josh Coalsonn", FLAC__VERSION_STRING);
  444. flac__utils_printf(stderr, 2, "flac comes with ABSOLUTELY NO WARRANTY.  This is free software, and you aren");
  445. flac__utils_printf(stderr, 2, "welcome to redistribute it under certain conditions.  Type `flac' for details.nn");
  447. if(!option_values.mode_decode) {
  448. char padopt[16];
  449. if(option_values.padding < 0)
  450. strcpy(padopt, "-");
  451. else
  452. sprintf(padopt, " %d", option_values.padding);
  453. flac__utils_printf(stderr, 2,
  454. "options:%s%s%s%s -P%s -b %u%s -l %u%s%s%s -q %u -r %u,%u%sn",
  455. option_values.delete_input?" --delete-input-file":"",
  456. option_values.sector_align?" --sector-align":"",
  457. option_values.use_ogg?" --ogg":"",
  458. option_values.lax?" --lax":"",
  459. padopt,
  460. (unsigned)option_values.blocksize,
  461. option_values.loose_mid_side?" -M":option_values.do_mid_side?" -m":"",
  462. option_values.max_lpc_order,
  463. option_values.do_exhaustive_model_search?" -e":"",
  464. option_values.do_escape_coding?" -E":"",
  465. option_values.do_qlp_coeff_prec_search?" -p":"",
  466. option_values.qlp_coeff_precision,
  467. (unsigned)option_values.min_residual_partition_order,
  468. (unsigned)option_values.max_residual_partition_order,
  469. option_values.verify? " -V":""
  470. );
  471. }
  473. if(option_values.mode_decode) {
  474. FLAC__bool first = true;
  476. if(option_values.num_files == 0) {
  477. retval = decode_file("-");
  478. }
  479. else {
  480. unsigned i;
  481. if(option_values.num_files > 1)
  482. option_values.cmdline_forced_outfilename = 0;
  483. for(i = 0, retval = 0; i < option_values.num_files; i++) {
  484. if(0 == strcmp(option_values.filenames[i], "-") && !first)
  485. continue;
  486. retval |= decode_file(option_values.filenames[i]);
  487. first = false;
  488. }
  489. }
  490. }
  491. else { /* encode */
  492. FLAC__bool first = true;
  494. if(option_values.num_files == 0) {
  495. retval = encode_file("-", first, true);
  496. }
  497. else {
  498. unsigned i;
  499. if(option_values.num_files > 1)
  500. option_values.cmdline_forced_outfilename = 0;
  501. for(i = 0, retval = 0; i < option_values.num_files; i++) {
  502. if(0 == strcmp(option_values.filenames[i], "-") && !first)
  503. continue;
  504. retval |= encode_file(option_values.filenames[i], first, i == (option_values.num_files-1));
  505. first = false;
  506. }
  507. if(option_values.replay_gain && retval == 0) {
  508. float album_gain, album_peak;
  509. grabbag__replaygain_get_album(&album_gain, &album_peak);
  510. for(i = 0; i < option_values.num_files; i++) {
  511. const char *error, *outfilename = get_encoded_outfilename(option_values.filenames[i]);
  512. if(0 == outfilename) {
  513. flac__utils_printf(stderr, 1, "ERROR: filename too long: %s", option_values.filenames[i]);
  514. return 1;
  515. }
  516. if(0 == strcmp(option_values.filenames[i], "-")) {
  517. FLAC__ASSERT(0);
  518. /* double protection */
  519. flac__utils_printf(stderr, 1, "internal errorn");
  520. return 2;
  521. }
  522. if(0 != (error = grabbag__replaygain_store_to_file_album(outfilename, album_gain, album_peak, /*preserve_modtime=*/true))) {
  523. flac__utils_printf(stderr, 1, "%s: ERROR writing ReplayGain album tagsn", outfilename);
  524. retval = 1;
  525. }
  526. }
  527. }
  528. }
  529. }
  531. return retval;
  532. }
  534. FLAC__bool init_options()
  535. {
  536. option_values.show_help = false;
  537. option_values.show_explain = false;
  538. option_values.mode_decode = false;
  539. option_values.verify = false;
  540. option_values.force_file_overwrite = false;
  541. option_values.continue_through_decode_errors = false;
  542. option_values.replaygain_synthesis_spec.apply = false;
  543. option_values.replaygain_synthesis_spec.use_album_gain = true;
  544. option_values.replaygain_synthesis_spec.limiter = RGSS_LIMIT__HARD;
  545. option_values.replaygain_synthesis_spec.noise_shaping = NOISE_SHAPING_LOW;
  546. option_values.replaygain_synthesis_spec.preamp = 0.0;
  547. option_values.lax = false;
  548. option_values.test_only = false;
  549. option_values.analyze = false;
  550. option_values.use_ogg = false;
  551. option_values.has_serial_number = false;
  552. option_values.serial_number = 0;
  553. option_values.do_mid_side = true;
  554. option_values.loose_mid_side = false;
  555. option_values.do_exhaustive_model_search = false;
  556. option_values.do_escape_coding = false;
  557. option_values.do_qlp_coeff_prec_search = false;
  558. option_values.force_to_stdout = false;
  559. option_values.force_aiff_format = false;
  560. option_values.force_raw_format = false;
  561. option_values.delete_input = false;
  562. option_values.replay_gain = false;
  563. option_values.sector_align = false;
  564. option_values.cmdline_forced_outfilename = 0;
  565. option_values.output_prefix = 0;
  566. option_values.aopts.do_residual_text = false;
  567. option_values.aopts.do_residual_gnuplot = false;
  568. option_values.padding = 4096;
  569. option_values.max_lpc_order = 8;
  570. option_values.qlp_coeff_precision = 0;
  571. option_values.skip_specification = 0;
  572. option_values.until_specification = 0;
  573. option_values.cue_specification = 0;
  574. option_values.format_is_big_endian = -1;
  575. option_values.format_is_unsigned_samples = -1;
  576. option_values.format_channels = -1;
  577. option_values.format_bps = -1;
  578. option_values.format_sample_rate = -1;
  579. option_values.format_input_size = -1;
  580. option_values.blocksize = -1;
  581. option_values.min_residual_partition_order = -1;
  582. option_values.max_residual_partition_order = -1;
  583. option_values.rice_parameter_search_dist = -1;
  584. option_values.requested_seek_points[0] = '';
  585. option_values.num_requested_seek_points = -1;
  586. option_values.cuesheet_filename = 0;
  587. option_values.cued_seekpoints = true;
  589. option_values.num_files = 0;
  590. option_values.filenames = 0;
  592. if(0 == (option_values.vorbis_comment = FLAC__metadata_object_new(FLAC__METADATA_TYPE_VORBIS_COMMENT)))
  593. return false;
  595. option_values.debug.disable_constant_subframes = false;
  596. option_values.debug.disable_fixed_subframes = false;
  597. option_values.debug.disable_verbatim_subframes = false;
  599. return true;
  600. }
  602. int parse_options(int argc, char *argv[])
  603. {
  604. int short_option;
  605. int option_index = 1;
  606. FLAC__bool had_error = false;
  607. const char *short_opts = "0123456789ab:cdefFhHl:mMo:pP:q:r:sS:tT:vV";
  609. while ((short_option = share__getopt_long(argc, argv, short_opts, long_options_, &option_index)) != -1) {
  610. switch (short_option) {
  611. case 0: /* long option with no equivalent short option */
  612. had_error |= (parse_option(short_option, long_options_[option_index].name, share__optarg) != 0);
  613. break;
  614. case '?':
  615. case ':':
  616. had_error = true;
  617. break;
  618. default: /* short option */
  619. had_error |= (parse_option(short_option, 0, share__optarg) != 0);
  620. break;
  621. }
  622. }
  624. if(had_error) {
  625. return 1;
  626. }
  628. FLAC__ASSERT(share__optind <= argc);
  630. option_values.num_files = argc - share__optind;
  632. if(option_values.num_files > 0) {
  633. unsigned i = 0;
  634. if(0 == (option_values.filenames = (char**)malloc(sizeof(char*) * option_values.num_files)))
  635. die("out of memory allocating space for file names list");
  636. while(share__optind < argc)
  637. option_values.filenames[i++] = local_strdup(argv[share__optind++]);
  638. }
  640. return 0;
  641. }
  643. int parse_option(int short_option, const char *long_option, const char *option_argument)
  644. {
  645. char *p;
  647. if(short_option == 0) {
  648. FLAC__ASSERT(0 != long_option);
  649. if(0 == strcmp(long_option, "totally-silent")) {
  650. flac__utils_verbosity_ = 0;
  651. }
  652. else if(0 == strcmp(long_option, "delete-input-file")) {
  653. option_values.delete_input = true;
  654. }
  655. else if(0 == strcmp(long_option, "output-prefix")) {
  656. FLAC__ASSERT(0 != option_argument);
  657. option_values.output_prefix = option_argument;
  658. }
  659. else if(0 == strcmp(long_option, "skip")) {
  660. FLAC__ASSERT(0 != option_argument);
  661. option_values.skip_specification = option_argument;
  662. }
  663. else if(0 == strcmp(long_option, "until")) {
  664. FLAC__ASSERT(0 != option_argument);
  665. option_values.until_specification = option_argument;
  666. }
  667. else if(0 == strcmp(long_option, "input-size")) {
  668. FLAC__ASSERT(0 != option_argument);
  669. option_values.format_input_size = atol(option_argument);
  670. }
  671. else if(0 == strcmp(long_option, "cue")) {
  672. FLAC__ASSERT(0 != option_argument);
  673. option_values.cue_specification = option_argument;
  674. }
  675. else if(0 == strcmp(long_option, "apply-replaygain-which-is-not-lossless")) {
  676. option_values.replaygain_synthesis_spec.apply = true;
  677. if (0 != option_argument) {
  678. char *p;
  679. option_values.replaygain_synthesis_spec.limiter = RGSS_LIMIT__NONE;
  680. option_values.replaygain_synthesis_spec.noise_shaping = NOISE_SHAPING_NONE;
  681. option_values.replaygain_synthesis_spec.preamp = strtod(option_argument, &p);
  682. for ( ; *p; p++) {
  683. if (*p == 'a')
  684. option_values.replaygain_synthesis_spec.use_album_gain = true;
  685. else if (*p == 't')
  686. option_values.replaygain_synthesis_spec.use_album_gain = false;
  687. else if (*p == 'l')
  688. option_values.replaygain_synthesis_spec.limiter = RGSS_LIMIT__PEAK;
  689. else if (*p == 'L')
  690. option_values.replaygain_synthesis_spec.limiter = RGSS_LIMIT__HARD;
  691. else if (*p == 'n' && p[1] >= '0' && p[1] <= '3') {
  692. option_values.replaygain_synthesis_spec.noise_shaping = p[1] - '0';
  693. p++;
  694. }
  695. else
  696. return usage_error("ERROR: bad specification string "%s" for --%sn", option_argument, long_option);
  697. }
  698. }
  699. }
  700. else if(0 == strcmp(long_option, "cuesheet")) {
  701. FLAC__ASSERT(0 != option_argument);
  702. option_values.cuesheet_filename = option_argument;
  703. }
  704. else if(0 == strcmp(long_option, "no-cued-seekpoints")) {
  705. option_values.cued_seekpoints = false;
  706. }
  707. else if(0 == strcmp(long_option, "super-secret-totally-impractical-compression-level")) {
  708. option_values.lax = true;
  709. option_values.do_exhaustive_model_search = true;
  710. option_values.do_escape_coding = true;
  711. option_values.do_mid_side = true;
  712. option_values.loose_mid_side = false;
  713. option_values.do_qlp_coeff_prec_search = true;
  714. option_values.min_residual_partition_order = 0;
  715. option_values.max_residual_partition_order = 16;
  716. option_values.rice_parameter_search_dist = 0;
  717. option_values.max_lpc_order = 32;
  718. }
  719. else if(0 == strcmp(long_option, "force-aiff-format")) {
  720. option_values.force_aiff_format = true;
  721. }
  722. else if(0 == strcmp(long_option, "force-raw-format")) {
  723. option_values.force_raw_format = true;
  724. }
  725. else if(0 == strcmp(long_option, "lax")) {
  726. option_values.lax = true;
  727. }
  728. else if(0 == strcmp(long_option, "replay-gain")) {
  729. option_values.replay_gain = true;
  730. }
  731. else if(0 == strcmp(long_option, "sector-align")) {
  732. option_values.sector_align = true;
  733. }
  734. #ifdef FLAC__HAS_OGG
  735. else if(0 == strcmp(long_option, "ogg")) {
  736. option_values.use_ogg = true;
  737. }
  738. else if(0 == strcmp(long_option, "serial-number")) {
  739. option_values.has_serial_number = true;
  740. option_values.serial_number = atol(option_argument);
  741. }
  742. #endif
  743. else if(0 == strcmp(long_option, "endian")) {
  744. FLAC__ASSERT(0 != option_argument);
  745. if(0 == strncmp(option_argument, "big", strlen(option_argument)))
  746. option_values.format_is_big_endian = true;
  747. else if(0 == strncmp(option_argument, "little", strlen(option_argument)))
  748. option_values.format_is_big_endian = false;
  749. else
  750. return usage_error("ERROR: argument to --endian must be "big" or "little"n");
  751. }
  752. else if(0 == strcmp(long_option, "channels")) {
  753. FLAC__ASSERT(0 != option_argument);
  754. option_values.format_channels = atoi(option_argument);
  755. }
  756. else if(0 == strcmp(long_option, "bps")) {
  757. FLAC__ASSERT(0 != option_argument);
  758. option_values.format_bps = atoi(option_argument);
  759. }
  760. else if(0 == strcmp(long_option, "sample-rate")) {
  761. FLAC__ASSERT(0 != option_argument);
  762. option_values.format_sample_rate = atoi(option_argument);
  763. }
  764. else if(0 == strcmp(long_option, "sign")) {
  765. FLAC__ASSERT(0 != option_argument);
  766. if(0 == strncmp(option_argument, "signed", strlen(option_argument)))
  767. option_values.format_is_unsigned_samples = false;
  768. else if(0 == strncmp(option_argument, "unsigned", strlen(option_argument)))
  769. option_values.format_is_unsigned_samples = true;
  770. else
  771. return usage_error("ERROR: argument to --sign must be "signed" or "unsigned"n");
  772. }
  773. else if(0 == strcmp(long_option, "residual-gnuplot")) {
  774. option_values.aopts.do_residual_gnuplot = true;
  775. }
  776. else if(0 == strcmp(long_option, "residual-text")) {
  777. option_values.aopts.do_residual_text = true;
  778. }
  779. /*
  780.  * negatives
  781.  */
  782. else if(0 == strcmp(long_option, "no-decode-through-errors")) {
  783. option_values.continue_through_decode_errors = false;
  784. }
  785. else if(0 == strcmp(long_option, "no-silent")) {
  786. flac__utils_verbosity_ = 2;
  787. }
  788. else if(0 == strcmp(long_option, "no-force")) {
  789. option_values.force_file_overwrite = false;
  790. }
  791. else if(0 == strcmp(long_option, "no-seektable")) {
  792. option_values.num_requested_seek_points = 0;
  793. option_values.requested_seek_points[0] = '';
  794. }
  795. else if(0 == strcmp(long_option, "no-delete-input-file")) {
  796. option_values.delete_input = false;
  797. }
  798. else if(0 == strcmp(long_option, "no-replay-gain")) {
  799. option_values.replay_gain = false;
  800. }
  801. else if(0 == strcmp(long_option, "no-sector-align")) {
  802. option_values.sector_align = false;
  803. }
  804. else if(0 == strcmp(long_option, "no-lax")) {
  805. option_values.lax = false;
  806. }
  807. #ifdef FLAC__HAS_OGG
  808. else if(0 == strcmp(long_option, "no-ogg")) {
  809. option_values.use_ogg = false;
  810. }
  811. #endif
  812. else if(0 == strcmp(long_option, "no-exhaustive-model-search")) {
  813. option_values.do_exhaustive_model_search = false;
  814. }
  815. else if(0 == strcmp(long_option, "no-mid-side")) {
  816. option_values.do_mid_side = option_values.loose_mid_side = false;
  817. }
  818. else if(0 == strcmp(long_option, "no-adaptive-mid-side")) {
  819. option_values.loose_mid_side = option_values.do_mid_side = false;
  820. }
  821. else if(0 == strcmp(long_option, "no-qlp-coeff-prec-search")) {
  822. option_values.do_qlp_coeff_prec_search = false;
  823. }
  824. else if(0 == strcmp(long_option, "no-padding")) {
  825. option_values.padding = -1;
  826. }
  827. else if(0 == strcmp(long_option, "no-verify")) {
  828. option_values.verify = false;
  829. }
  830. else if(0 == strcmp(long_option, "no-residual-gnuplot")) {
  831. option_values.aopts.do_residual_gnuplot = false;
  832. }
  833. else if(0 == strcmp(long_option, "no-residual-text")) {
  834. option_values.aopts.do_residual_text = false;
  835. }
  836. else if(0 == strcmp(long_option, "disable-constant-subframes")) {
  837. option_values.debug.disable_constant_subframes = true;
  838. }
  839. else if(0 == strcmp(long_option, "disable-fixed-subframes")) {
  840. option_values.debug.disable_fixed_subframes = true;
  841. }
  842. else if(0 == strcmp(long_option, "disable-verbatim-subframes")) {
  843. option_values.debug.disable_verbatim_subframes = true;
  844. }
  845. }
  846. else {
  847. const char *violation;
  848. switch(short_option) {
  849. case 'h':
  850. option_values.show_help = true;
  851. break;
  852. case 'H':
  853. option_values.show_explain = true;
  854. break;
  855. case 'v':
  856. option_values.show_version = true;
  857. break;
  858. case 'd':
  859. option_values.mode_decode = true;
  860. break;
  861. case 'a':
  862. option_values.mode_decode = true;
  863. option_values.analyze = true;
  864. break;
  865. case 't':
  866. option_values.mode_decode = true;
  867. option_values.test_only = true;
  868. break;
  869. case 'c':
  870. option_values.force_to_stdout = true;
  871. break;
  872. case 's':
  873. flac__utils_verbosity_ = 1;
  874. break;
  875. case 'f':
  876. option_values.force_file_overwrite = true;
  877. break;
  878. case 'o':
  879. FLAC__ASSERT(0 != option_argument);
  880. option_values.cmdline_forced_outfilename = option_argument;
  881. break;
  882. case 'F':
  883. option_values.continue_through_decode_errors = true;
  884. break;
  885. case 'T':
  886. FLAC__ASSERT(0 != option_argument);
  887. if(!flac__vorbiscomment_add(option_values.vorbis_comment, option_argument, &violation))
  888. return usage_error("ERROR: (-T/--tag) %sn", violation);
  889. break;
  890. case '0':
  891. option_values.do_exhaustive_model_search = false;
  892. option_values.do_escape_coding = false;
  893. option_values.do_mid_side = false;
  894. option_values.loose_mid_side = false;
  895. option_values.qlp_coeff_precision = 0;
  896. option_values.min_residual_partition_order = option_values.max_residual_partition_order = 2;
  897. option_values.rice_parameter_search_dist = 0;
  898. option_values.max_lpc_order = 0;
  899. break;
  900. case '1':
  901. option_values.do_exhaustive_model_search = false;
  902. option_values.do_escape_coding = false;
  903. option_values.do_mid_side = true;
  904. option_values.loose_mid_side = true;
  905. option_values.qlp_coeff_precision = 0;
  906. option_values.min_residual_partition_order = option_values.max_residual_partition_order = 2;
  907. option_values.rice_parameter_search_dist = 0;
  908. option_values.max_lpc_order = 0;
  909. break;
  910. case '2':
  911. option_values.do_exhaustive_model_search = false;
  912. option_values.do_escape_coding = false;
  913. option_values.do_mid_side = true;
  914. option_values.loose_mid_side = false;
  915. option_values.qlp_coeff_precision = 0;
  916. option_values.min_residual_partition_order = 0;
  917. option_values.max_residual_partition_order = 3;
  918. option_values.rice_parameter_search_dist = 0;
  919. option_values.max_lpc_order = 0;
  920. break;
  921. case '3':
  922. option_values.do_exhaustive_model_search = false;
  923. option_values.do_escape_coding = false;
  924. option_values.do_mid_side = false;
  925. option_values.loose_mid_side = false;
  926. option_values.qlp_coeff_precision = 0;
  927. option_values.min_residual_partition_order = option_values.max_residual_partition_order = 3;
  928. option_values.rice_parameter_search_dist = 0;
  929. option_values.max_lpc_order = 6;
  930. break;
  931. case '4':
  932. option_values.do_exhaustive_model_search = false;
  933. option_values.do_escape_coding = false;
  934. option_values.do_mid_side = true;
  935. option_values.loose_mid_side = true;
  936. option_values.qlp_coeff_precision = 0;
  937. option_values.min_residual_partition_order = option_values.max_residual_partition_order = 3;
  938. option_values.rice_parameter_search_dist = 0;
  939. option_values.max_lpc_order = 8;
  940. break;
  941. case '5':
  942. option_values.do_exhaustive_model_search = false;
  943. option_values.do_escape_coding = false;
  944. option_values.do_mid_side = true;
  945. option_values.loose_mid_side = false;
  946. option_values.qlp_coeff_precision = 0;
  947. option_values.min_residual_partition_order = option_values.max_residual_partition_order = 3;
  948. option_values.rice_parameter_search_dist = 0;
  949. option_values.max_lpc_order = 8;
  950. break;
  951. case '6':
  952. option_values.do_exhaustive_model_search = false;
  953. option_values.do_escape_coding = false;
  954. option_values.do_mid_side = true;
  955. option_values.loose_mid_side = false;
  956. option_values.qlp_coeff_precision = 0;
  957. option_values.min_residual_partition_order = 0;
  958. option_values.max_residual_partition_order = 4;
  959. option_values.rice_parameter_search_dist = 0;
  960. option_values.max_lpc_order = 8;
  961. break;
  962. case '7':
  963. option_values.do_exhaustive_model_search = true;
  964. option_values.do_escape_coding = false;
  965. option_values.do_mid_side = true;
  966. option_values.loose_mid_side = false;
  967. option_values.qlp_coeff_precision = 0;
  968. option_values.min_residual_partition_order = 0;
  969. option_values.max_residual_partition_order = 6;
  970. option_values.rice_parameter_search_dist = 0;
  971. option_values.max_lpc_order = 8;
  972. break;
  973. case '8':
  974. option_values.do_exhaustive_model_search = true;
  975. option_values.do_escape_coding = false;
  976. option_values.do_mid_side = true;
  977. option_values.loose_mid_side = false;
  978. option_values.qlp_coeff_precision = 0;
  979. option_values.min_residual_partition_order = 0;
  980. option_values.max_residual_partition_order = 6;
  981. option_values.rice_parameter_search_dist = 0;
  982. option_values.max_lpc_order = 12;
  983. break;
  984. case '9':
  985. return usage_error("ERROR: compression level '9' is reservedn");
  986. case 'V':
  987. option_values.verify = true;
  988. break;
  989. case 'S':
  990. FLAC__ASSERT(0 != option_argument);
  991. if(option_values.num_requested_seek_points < 0)
  992. option_values.num_requested_seek_points = 0;
  993. option_values.num_requested_seek_points++;
  994. if(strlen(option_values.requested_seek_points)+strlen(option_argument)+2 >= sizeof(option_values.requested_seek_points)) {
  995. return usage_error("ERROR: too many seekpoints requestedn");
  996. }
  997. else {
  998. strcat(option_values.requested_seek_points, option_argument);
  999. strcat(option_values.requested_seek_points, ";");
  1000. }
  1001. break;
  1002. case 'P':
  1003. FLAC__ASSERT(0 != option_argument);
  1004. option_values.padding = atoi(option_argument);
  1005. if(option_values.padding < 0)
  1006. return usage_error("ERROR: argument to -P must be >= 0n");
  1007. break;
  1008. case 'b':
  1009. FLAC__ASSERT(0 != option_argument);
  1010. option_values.blocksize = atoi(option_argument);
  1011. break;
  1012. case 'e':
  1013. option_values.do_exhaustive_model_search = true;
  1014. break;
  1015. case 'E':
  1016. option_values.do_escape_coding = true;
  1017. break;
  1018. case 'l':
  1019. FLAC__ASSERT(0 != option_argument);
  1020. option_values.max_lpc_order = atoi(option_argument);
  1021. break;
  1022. case 'm':
  1023. option_values.do_mid_side = true;
  1024. option_values.loose_mid_side = false;
  1025. break;
  1026. case 'M':
  1027. option_values.loose_mid_side = option_values.do_mid_side = true;
  1028. break;
  1029. case 'p':
  1030. option_values.do_qlp_coeff_prec_search = true;
  1031. break;
  1032. case 'q':
  1033. FLAC__ASSERT(0 != option_argument);
  1034. option_values.qlp_coeff_precision = atoi(option_argument);
  1035. break;
  1036. case 'r':
  1037. FLAC__ASSERT(0 != option_argument);
  1038. p = strchr(option_argument, ',');
  1039. if(0 == p) {
  1040. option_values.min_residual_partition_order = 0;
  1041. option_values.max_residual_partition_order = atoi(option_argument);
  1042. }
  1043. else {
  1044. option_values.min_residual_partition_order = atoi(option_argument);
  1045. option_values.max_residual_partition_order = atoi(++p);
  1046. }
  1047. break;
  1048. case 'R':
  1049. FLAC__ASSERT(0 != option_argument);
  1050. option_values.rice_parameter_search_dist = atoi(option_argument);
  1051. break;
  1052. default:
  1053. FLAC__ASSERT(0);
  1054. }
  1055. }
  1057. return 0;
  1058. }
  1060. void free_options()
  1061. {
  1062. unsigned i;
  1063. if(0 != option_values.filenames) {
  1064. for(i = 0; i < option_values.num_files; i++) {
  1065. if(0 != option_values.filenames[i])
  1066. free(option_values.filenames[i]);
  1067. }
  1068. free(option_values.filenames);
  1069. }
  1070. if(0 != option_values.vorbis_comment)
  1071. FLAC__metadata_object_delete(option_values.vorbis_comment);
  1072. }
  1074. int usage_error(const char *message, ...)
  1075. {
  1076. if(flac__utils_verbosity_ >= 1) {
  1077. va_list args;
  1079. FLAC__ASSERT(0 != message);
  1081. va_start(args, message);
  1083. (void) vfprintf(stderr, message, args);
  1085. va_end(args);
  1087. printf("Type "flac" for a usage summary or "flac --help" for all optionsn");
  1088. }
  1090. return 1;
  1091. }
  1093. void show_version()
  1094. {
  1095. printf("flac %sn", FLAC__VERSION_STRING);
  1096. }
  1098. static void usage_header()
  1099. {
  1100. printf("===============================================================================n");
  1101. printf("flac - Command-line FLAC encoder/decoder version %sn", FLAC__VERSION_STRING);
  1102. printf("Copyright (C) 2000,2001,2002,2003,2004,2005  Josh Coalsonn");
  1103. printf("n");
  1104. printf("This program is free software; you can redistribute it and/orn");
  1105. printf("modify it under the terms of the GNU General Public Licensen");
  1106. printf("as published by the Free Software Foundation; either version 2n");
  1107. printf("of the License, or (at your option) any later version.n");
  1108. printf("n");
  1109. printf("This program is distributed in the hope that it will be useful,n");
  1110. printf("but WITHOUT ANY WARRANTY; without even the implied warranty ofn");
  1111. printf("MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See then");
  1112. printf("GNU General Public License for more details.n");
  1113. printf("n");
  1114. printf("You should have received a copy of the GNU General Public Licensen");
  1115. printf("along with this program; if not, write to the Free Softwaren");
  1116. printf("Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.n");
  1117. printf("===============================================================================n");
  1118. }
  1120. static void usage_summary()
  1121. {
  1122. printf("Usage:n");
  1123. printf("n");
  1124. printf(" Encoding: flac [<general-options>] [<encoding/format-options>] [INPUTFILE [...]]n");
  1125. printf(" Decoding: flac -d [<general-options>] [<format-options>] [FLACFILE [...]]n");
  1126. printf("  Testing: flac -t [<general-options>] [FLACFILE [...]]n");
  1127. printf("Analyzing: flac -a [<general-options>] [<analysis-options>] [FLACFILE [...]]n");
  1128. printf("n");
  1129. }
  1131. void short_usage()
  1132. {
  1133. usage_header();
  1134. printf("n");
  1135. printf("This is the short help; for all options use 'flac --help'; for even moren");
  1136. printf("instructions use 'flac --explain'n");
  1137. printf("n");
  1138. printf("To encode:n");
  1139. printf("  flac [-#] [INPUTFILE [...]]n");
  1140. printf("n");
  1141. printf("  -# is -0 (fastest compression) to -8 (highest compression); -5 is the defaultn");
  1142. printf("n");
  1143. printf("To decode:n");
  1144. printf("  flac -d [INPUTFILE [...]]n");
  1145. printf("n");
  1146. printf("To test:n");
  1147. printf("  flac -t [INPUTFILE [...]]n");
  1148. }
  1150. void show_help()
  1151. {
  1152. usage_header();
  1153. usage_summary();
  1154. printf("general options:n");
  1155. printf("  -v, --version                Show the flac version numbern");
  1156. printf("  -h, --help                   Show this screenn");
  1157. printf("  -H, --explain                Show detailed explanation of usage and optionsn");
  1158. printf("  -d, --decode                 Decode (the default behavior is to encode)n");
  1159. printf("  -t, --test                   Same as -d except no decoded file is writtenn");
  1160. printf("  -a, --analyze                Same as -d except an analysis file is writtenn");
  1161. printf("  -c, --stdout                 Write output to stdoutn");
  1162. printf("  -s, --silent                 Do not write runtime encode/decode statisticsn");
  1163. printf("      --totally-silent         Do not print anything, including errorsn");
  1164. printf("  -f, --force                  Force overwriting of output filesn");
  1165. printf("  -o, --output-name=FILENAME   Force the output file namen");
  1166. printf("      --output-prefix=STRING   Prepend STRING to output namesn");
  1167. printf("      --delete-input-file      Deletes after a successful encode/decoden");
  1168. printf("      --skip={#|mm:ss.ss}      Skip the given initial samples for each inputn");
  1169. printf("      --until={#|[+|-]mm:ss.ss}  Stop at the given sample for each input filen");
  1170. #ifdef FLAC__HAS_OGG
  1171. printf("      --ogg                    Use Ogg as transport layern");
  1172. printf("      --serial-number          Serial number to use for the FLAC streamn");
  1173. #endif
  1174. printf("analysis options:n");
  1175. printf("      --residual-text          Include residual signal in text outputn");
  1176. printf("      --residual-gnuplot       Generate gnuplot files of residual distributionn");
  1177. printf("decoding options:n");
  1178. printf("  -F, --decode-through-errors  Continue decoding through stream errorsn");
  1179. printf("      --cue=[#.#][-[#.#]]      Set the beginning and ending cuepoints to decoden");
  1180. printf("encoding options:n");
  1181. printf("  -V, --verify                 Verify a correct encodingn");
  1182. printf("      --lax                    Allow encoder to generate non-Subset filesn");
  1183. printf("      --sector-align           Align multiple files on sector boundariesn");
  1184. printf("      --replay-gain            Calculate ReplayGain & store in Vorbis commentsn");
  1185. printf("      --cuesheet=FILENAME      Import cuesheet and store in CUESHEET blockn");
  1186. printf("  -T, --tag=FIELD=VALUE        Add a Vorbis comment; may appear multiple timesn");
  1187. printf("  -S, --seekpoint={#|X|#x|#s}  Add seek point(s)n");
  1188. printf("  -P, --padding=#              Write a PADDING block of length #n");
  1189. printf("  -0, --compression-level-0, --fast  Synonymous with -l 0 -b 1152 -r 2,2n");
  1190. printf("  -1, --compression-level-1          Synonymous with -l 0 -b 1152 -M -r 2,2n");
  1191. printf("  -2, --compression-level-2          Synonymous with -l 0 -b 1152 -m -r 3n");
  1192. printf("  -3, --compression-level-3          Synonymous with -l 6 -b 4608 -r 3,3n");
  1193. printf("  -4, --compression-level-4          Synonymous with -l 8 -b 4608 -M -r 3,3n");
  1194. printf("  -5, --compression-level-5          Synonymous with -l 8 -b 4608 -m -r 3,3n");
  1195. printf("  -6, --compression-level-6          Synonymous with -l 8 -b 4608 -m -r 4n");
  1196. printf("  -7, --compression-level-7          Synonymous with -l 8 -b 4608 -m -e -r 6n");
  1197. printf("  -8, --compression-level-8, --best  Synonymous with -l 12 -b 4608 -m -e -r 6n");
  1198. printf("  -b, --blocksize=#                  Specify blocksize in samplesn");
  1199. printf("  -m, --mid-side                     Try mid-side coding for each framen");
  1200. printf("  -M, --adaptive-mid-side            Adaptive mid-side coding for all framesn");
  1201. printf("  -e, --exhaustive-model-search      Do exhaustive model search (expensive!)n");
  1202. printf("  -l, --max-lpc-order=#              Max LPC order; 0 => only fixed predictorsn");
  1203. printf("  -p, --qlp-coeff-precision-search   Exhaustively search LP coeff quantizationn");
  1204. printf("  -q, --qlp-coeff-precision=#        Specify precision in bitsn");
  1205. printf("  -r, --rice-partition-order=[#,]#   Set [min,]max residual partition ordern");
  1206. printf("format options:n");
  1207. printf("      --endian={big|little}    Set byte order for samplesn");
  1208. printf("      --channels=#             Number of channelsn");
  1209. printf("      --bps=#                  Number of bits per samplen");
  1210. printf("      --sample-rate=#          Sample rate in Hzn");
  1211. printf("      --sign={signed|unsigned} Sign of samplesn");
  1212. printf("      --input-size=#           Size of the raw input in bytesn");
  1213. printf("      --force-aiff-format      Force decoding to AIFF formatn");
  1214. printf("      --force-raw-format       Treat input or output as raw samplesn");
  1215. printf("negative options:n");
  1216. printf("      --no-adaptive-mid-siden");
  1217. printf("      --no-decode-through-errorsn");
  1218. printf("      --no-delete-input-filen");
  1219. printf("      --no-exhaustive-model-searchn");
  1220. printf("      --no-laxn");
  1221. printf("      --no-mid-siden");
  1222. #ifdef FLAC__HAS_OGG
  1223. printf("      --no-oggn");
  1224. #endif
  1225. printf("      --no-paddingn");
  1226. printf("      --no-qlp-coeff-prec-searchn");
  1227. printf("      --no-replay-gainn");
  1228. printf("      --no-residual-gnuplotn");
  1229. printf("      --no-residual-textn");
  1230. printf("      --no-sector-alignn");
  1231. printf("      --no-seektablen");
  1232. printf("      --no-silentn");
  1233. printf("      --no-forcen");
  1234. printf("      --no-verifyn");
  1235. }
  1237. void show_explain()
  1238. {
  1239. usage_header();
  1240. usage_summary();
  1241. printf("For encoding:n");
  1242. printf("  The input file(s) may be a PCM RIFF WAVE file, AIFF file, or raw samples.n");
  1243. printf("  The output file(s) will be in native FLAC or Ogg FLAC formatn");
  1244. printf("For decoding, the reverse is true.n");
  1245. printf("n");
  1246. printf("A single INPUTFILE may be - for stdin.  No INPUTFILE implies stdin.  Use ofn");
  1247. printf("stdin implies -c (write to stdout).  Normally you should use:n");
  1248. printf("   flac [options] -o outfilename  or  flac -d [options] -o outfilenamen");
  1249. printf("instead of:n");
  1250. printf("   flac [options] > outfilename   or  flac -d [options] > outfilenamen");
  1251. printf("since the former allows flac to seek backwards to write the STREAMINFO orn");
  1252. printf("WAVE/AIFF header contents when necessary.n");
  1253. printf("n");
  1254. printf("flac checks for the presence of a AIFF/WAVE header to decide whether or not ton");
  1255. printf("treat an input file as AIFF/WAVE format or raw samples.  If any input file isn");
  1256. printf("raw you must specify the format options {-fb|fl} -fc -fp and -fs, which willn");
  1257. printf("apply to all raw files.  You can force AIFF/WAVE files to be treated as rawn");
  1258. printf("files using -fr.n");
  1259. printf("n");
  1260. printf("general options:n");
  1261. printf("  -v, --version                Show the flac version numbern");
  1262. printf("  -h, --help                   Show basic usage a list of all optionsn");
  1263. printf("  -H, --explain                Show this screenn");
  1264. printf("  -d, --decode                 Decode (the default behavior is to encode)n");
  1265. printf("  -t, --test                   Same as -d except no decoded file is writtenn");
  1266. printf("  -a, --analyze                Same as -d except an analysis file is writtenn");
  1267. printf("  -c, --stdout                 Write output to stdoutn");
  1268. printf("  -s, --silent                 Do not write runtime encode/decode statisticsn");
  1269. printf("      --totally-silent         Do not print anything of any kind, includingn");
  1270. printf("                               warnings or errors.  The exit code will be then");
  1271. printf("                               only way to determine successful completion.n");
  1272. printf("  -f, --force                  Force overwriting of output filesn");
  1273. printf("  -o, --output-name=FILENAME   Force the output file name; usually flac justn");
  1274. printf("                               changes the extension.  May only be used whenn");
  1275. printf("                               encoding a single file.  May not be used inn");
  1276. printf("                               conjunction with --output-prefix.n");
  1277. printf("      --output-prefix=STRING   Prefix each output file name with the givenn");
  1278. printf("                               STRING.  This can be useful for encoding orn");
  1279. printf("                               decoding files to a different directory.  Maken");
  1280. printf("                               sure if your STRING is a path name that it endsn");
  1281. printf("                               with a '/' slash.n");
  1282. printf("      --delete-input-file      Automatically delete the input file after an");
  1283. printf("                               successful encode or decode.  If there was ann");
  1284. printf("                               error (including a verify error) the input filen");
  1285. printf("                               is left intact.n");
  1286. printf("      --skip={#|mm:ss.ss}      Skip the first # samples of each input file; cann");
  1287. printf("                               be used both for encoding and decoding.  Then");
  1288. printf("                               alternative form mm:ss.ss can be used to specifyn");
  1289. printf("                               minutes, seconds, and fractions of a second.n");
  1290. printf("      --until={#|[+|-]mm:ss.ss}  Stop at the given sample number for each inputn");
  1291. printf("                               file.  The given sample number is not includedn");
  1292. printf("                               in the decoded output.  The alternative formn");
  1293. printf("                               mm:ss.ss can be used to specify minutes,n");
  1294. printf("                               seconds, and fractions of a second.  If a `+'n");
  1295. printf("                               sign is at the beginning, the --until point isn");
  1296. printf("                               relative to the --skip point.  If a `-' sign isn");
  1297. printf("                               at the beginning, the --until point is relativen");
  1298. printf("                               to end of the audio.n");
  1299. #ifdef FLAC__HAS_OGG
  1300. printf("      --ogg                    When encoding, generate Ogg FLAC output insteadn");
  1301. printf("                               of native FLAC.  Ogg FLAC streams are FLACn");
  1302. printf("                               streams wrapped in an Ogg transport layer.  Then");
  1303. printf("                               resulting file should have an '.ogg' extensionn");
  1304. printf("                               and will still be decodable by flac.  Whenn");
  1305. printf("                               decoding, force the input to be treated asn");
  1306. printf("                               Ogg FLAC.  This is useful when piping inputn");
  1307. printf("                               from stdin or when the filename does not end inn");
  1308. printf("                               '.ogg'.n");
  1309. printf("      --serial-number          Serial number to use for the FLAC stream.  Whenn");
  1310. printf("                               encoding and no serial number is given, flacn");
  1311. printf("                               uses '0'.  When decoding and no number isn");
  1312. printf("                               given, flac uses the serial number of the firstn");
  1313. printf("                               page.n");
  1314. #endif
  1315. printf("analysis options:n");
  1316. printf("      --residual-text          Include residual signal in text output.  Thisn");
  1317. printf("                               will make the file very big, much larger thann");
  1318. printf("                               even the decoded file.n");
  1319. printf("      --residual-gnuplot       Generate gnuplot files of residual distributionn");
  1320. printf("                               of each subframen");
  1321. printf("decoding options:n");
  1322. printf("  -F, --decode-through-errors  By default flac stops decoding with an errorn");
  1323. printf("                               and removes the partially decoded file if itn");
  1324. printf("                               encounters a bitstream error.  With -F, errorsn");
  1325. printf("                               are still printed but flac will continuen");
  1326. printf("                               decoding to completion.  Note that errors mayn");
  1327. printf("                               cause the decoded audio to be missing somen");
  1328. printf("                               samples or have silent sections.n");
  1329. printf("      --cue=[#.#][-[#.#]]      Set the beginning and ending cuepoints ton");
  1330. printf("                               decode.  The optional first #.# is the track andn");
  1331. printf("                               index point at which decoding will start; then");
  1332. printf("                               default is the beginning of the stream.  Then");
  1333. printf("                               optional second #.# is the track and index pointn");
  1334. printf("                               at which decoding will end; the default is then");
  1335. printf("                               end of the stream.  If the cuepoint does notn");
  1336. printf("                               exist, the closest one before it (for the startn");
  1337. printf("                               point) or after it (for the end point) will ben");
  1338. printf("                               used.  The cuepoints are merely translated inton");
  1339. printf("                               sample numbers then used as --skip and --until.n");
  1340. printf("encoding options:n");
  1341. printf("  -V, --verify                 Verify a correct encoding by decoding then");
  1342. printf("                               output in parallel and comparing to then");
  1343. printf("                               originaln");
  1344. printf("      --lax                    Allow encoder to generate non-Subset filesn");
  1345. printf("      --sector-align           Align encoding of multiple CD format WAVE filesn");
  1346. printf("                               on sector boundaries.n");
  1347. printf("      --replay-gain            Calculate ReplayGain values and store in Vorbisn");
  1348. printf("                               comments.  Title gains/peaks will be computedn");
  1349. printf("                               for each file, and an album gain/peak will ben");
  1350. printf("                               computed for all files.  All input files mustn");
  1351. printf("                               have the same resolution, sample rate, andn");
  1352. printf("                               number of channels.  The sample rate must ben");
  1353. printf("                               one of 8, 11.025, 12, 16, 22.05, 24, 32, 44.1,n");
  1354. printf("                               or 48 kHz.  NOTE: this option may also leave an");
  1355. printf("                               few extra bytes in the PADDING block.n");
  1356. printf("      --cuesheet=FILENAME      Import the given cuesheet file and store it inn");
  1357. printf("                               a CUESHEET metadata block.  This option may onlyn");
  1358. printf("                               be used when encoding a single file.  An");
  1359. printf("                               seekpoint will be added for each index point inn");
  1360. printf("                               the cuesheet to the SEEKTABLE unlessn");
  1361. printf("                               --no-cued-seekpoints is specified.n");
  1362. printf("  -T, --tag=FIELD=VALUE        Add a Vorbis comment.  Make sure to quote then");
  1363. printf("                               comment if necessary.  This option may appearn");
  1364. printf("                               more than once to add several comments.  NOTE:n");
  1365. printf("                               all tags will be added to all encoded files.n");
  1366. printf("  -S, --seekpoint={#|X|#x|#s}  Include a point or points in a SEEKTABLEn");
  1367. printf("       #  : a specific sample number for a seek pointn");
  1368. printf("       X  : a placeholder point (always goes at the end of the SEEKTABLE)n");
  1369. printf("       #x : # evenly spaced seekpoints, the first being at sample 0n");
  1370. printf("       #s : a seekpoint every # seconds; # does not have to be a whole numbern");
  1371. printf("     You may use many -S options; the resulting SEEKTABLE will be the unique-n");
  1372. printf("           ified union of all such values.n");
  1373. printf("     With no -S options, flac defaults to '-S 10s'.  Use -S- for no SEEKTABLE.n");
  1374. printf("     Note: -S #x and -S #s will not work if the encoder can't determine then");
  1375. printf("           input size before starting.n");
  1376. printf("     Note: if you use -S # and # is >= samples in the input, there will ben");
  1377. printf("           either no seek point entered (if the input size is determinablen");
  1378. printf("           before encoding starts) or a placeholder point (if input size is notn");
  1379. printf("           determinable)n");
  1380. printf("  -P, --padding=#              Tell the encoder to write a PADDING metadatan");
  1381. printf("                               block of the given length (in bytes) after then");
  1382. printf("                               STREAMINFO block.  This is useful if you plann");
  1383. printf("                               to tag the file later with an APPLICATIONn");
  1384. printf("                               block; instead of having to rewrite the entiren");
  1385. printf("                               file later just to insert your block, you cann");
  1386. printf("                               write directly over the PADDING block.  Noten");
  1387. printf("                               that the total length of the PADDING block willn");
  1388. printf("                               be 4 bytes longer than the length given becausen");
  1389. printf("                               of the 4 metadata block header bytes.  You cann");
  1390. printf("                               force no PADDING block at all to be written withn");
  1391. printf("                               --no-padding.  The encoder writes a PADDINGn");
  1392. printf("                               block of 4096 bytes by default.n");
  1393. printf("  -b, --blocksize=#            Specify the blocksize in samples; the default isn");
  1394. printf("                               1152 for -l 0, else 4608; must be one of 192,n");
  1395. printf("                               576, 1152, 2304, 4608, 256, 512, 1024, 2048,n");
  1396. printf("                               4096, 8192, 16384, or 32768 (unless --lax isn");
  1397. printf("                               used)n");
  1398. printf("  -0, --compression-level-0, --fast  Synonymous with -l 0 -b 1152 -r 2,2n");
  1399. printf("  -1, --compression-level-1          Synonymous with -l 0 -b 1152 -M -r 2,2n");
  1400. printf("  -2, --compression-level-2          Synonymous with -l 0 -b 1152 -m -r 3n");
  1401. printf("  -3, --compression-level-3          Synonymous with -l 6 -b 4608 -r 3,3n");
  1402. printf("  -4, --compression-level-4          Synonymous with -l 8 -b 4608 -M -r 3,3n");
  1403. printf("  -5, --compression-level-5          Synonymous with -l 8 -b 4608 -m -r 3,3n");
  1404. printf("                                     -5 is the default settingn");
  1405. printf("  -6, --compression-level-6          Synonymous with -l 8 -b 4608 -m -r 4n");
  1406. printf("  -7, --compression-level-7          Synonymous with -l 8 -b 4608 -m -e -r 6n");
  1407. printf("  -8, --compression-level-8, --best  Synonymous with -l 12 -b 4608 -m -e -r 6n");
  1408. printf("  -m, --mid-side                     Try mid-side coding for each framen");
  1409. printf("                                     (stereo only)n");
  1410. printf("  -M, --adaptive-mid-side            Adaptive mid-side coding for all framesn");
  1411. printf("                                     (stereo only)n");
  1412. printf("  -e, --exhaustive-model-search      Do exhaustive model search (expensive!)n");
  1413. printf("  -l, --max-lpc-order=#              Max LPC order; 0 => only fixed predictorsn");
  1414. printf("  -p, --qlp-coeff-precision-search   Do exhaustive search of LP coefficientn");
  1415. printf("                                     quantization (expensive!); overrides -q;n");
  1416. printf("                                     does nothing if using -l 0n");
  1417. printf("  -q, --qlp-coeff-precision=#        Specify precision in bits of quantizedn");
  1418. printf("                                     linear-predictor coefficients; 0 => letn");
  1419. printf("                                     encoder decide (the minimun is %u, then", FLAC__MIN_QLP_COEFF_PRECISION);
  1420. printf("                                     default is -q 0)n");
  1421. printf("  -r, --rice-partition-order=[#,]#   Set [min,]max residual partition ordern");
  1422. printf("                                     (# is 0..16; min defaults to 0; then");
  1423. printf("                                     default is -r 0; above 4 doesn't usuallyn");
  1424. printf("                                     help much)n");
  1425. printf("format options:n");
  1426. printf("      --endian={big|little}    Set byte order for samplesn");
  1427. printf("      --channels=#             Number of channelsn");
  1428. printf("      --bps=#                  Number of bits per samplen");
  1429. printf("      --sample-rate=#          Sample rate in Hzn");
  1430. printf("      --sign={signed|unsigned} Sign of samples (the default is signed)n");
  1431. printf("      --input-size=#           Size of the raw input in bytes.  If you aren");
  1432. printf("                               encoding raw samples from stdin, you must setn");
  1433. printf("                               this option in order to be able to use --skip,n");
  1434. printf("                               --until, --cue-sheet, or other options that needn");
  1435. printf("                               to know the size of the input beforehand.  Ifn");
  1436. printf("                               the size given is greater than what is found inn");
  1437. printf("                               the input stream, the encoder will complainn");
  1438. printf("                               about an unexpected end-of-file.  If the sizen");
  1439. printf("                               given is less, samples will be truncated.n");
  1440. printf("      --force-aiff-format      Force the decoder to output AIFF format.  Thisn");
  1441. printf("                               option is not needed if the output filename (asn");
  1442. printf("                               set by -o) ends with .aif or .aiff; this optionn");
  1443. printf("                               has no effect when encoding since input AIFF isn");
  1444. printf("                               auto-detected.n");
  1445. printf("      --force-raw-format       Force input (when encoding) or output (whenn");
  1446. printf("                               decoding) to be treated as raw samplesn");
  1447. printf("negative options:n");
  1448. printf("      --no-adaptive-mid-siden");
  1449. printf("      --no-decode-through-errorsn");
  1450. printf("      --no-delete-input-filen");
  1451. printf("      --no-exhaustive-model-searchn");
  1452. printf("      --no-laxn");
  1453. printf("      --no-mid-siden");
  1454. #ifdef FLAC__HAS_OGG
  1455. printf("      --no-oggn");
  1456. #endif
  1457. printf("      --no-paddingn");
  1458. printf("      --no-qlp-coeff-prec-searchn");
  1459. printf("      --no-residual-gnuplotn");
  1460. printf("      --no-residual-textn");
  1461. printf("      --no-sector-alignn");
  1462. printf("      --no-seektablen");
  1463. printf("      --no-silentn");
  1464. printf("      --no-forcen");
  1465. printf("      --no-verifyn");
  1466. }
  1468. void format_mistake(const char *infilename, const char *wrong, const char *right)
  1469. {
  1470. flac__utils_printf(stderr, 1, "WARNING: %s is not a %s file; treating as a %s filen", infilename, wrong, right);
  1471. }
  1473. int encode_file(const char *infilename, FLAC__bool is_first_file, FLAC__bool is_last_file)
  1474. {
  1475. FILE *encode_infile;
  1476. FLAC__byte lookahead[12];
  1477. unsigned lookahead_length = 0;
  1478. FileFormat fmt= RAW;
  1479. int retval;
  1480. long infilesize;
  1481. encode_options_t common_options;
  1482. const char *outfilename = get_encoded_outfilename(infilename);
  1484. if(0 == outfilename) {
  1485. flac__utils_printf(stderr, 1, "ERROR: filename too long: %s", infilename);
  1486. return 1;
  1487. }
  1489. /*
  1490.  * Error if output file already exists (and -f not used).
  1491.  * Use grabbag__file_get_filesize() as a cheap way to check.
  1492.  */
  1493. if(!option_values.test_only && !option_values.force_file_overwrite && grabbag__file_get_filesize(outfilename) != (off_t)(-1)) {
  1494. flac__utils_printf(stderr, 1, "ERROR: output file %s already exists, use -f to overriden", outfilename);
  1495. return 1;
  1496. }
  1498. if(0 == strcmp(infilename, "-")) {
  1499. infilesize = -1;
  1500. encode_infile = grabbag__file_get_binary_stdin();
  1501. }
  1502. else {
  1503. infilesize = grabbag__file_get_filesize(infilename);
  1504. if(0 == (encode_infile = fopen(infilename, "rb"))) {
  1505. flac__utils_printf(stderr, 1, "ERROR: can't open input file %sn", infilename);
  1506. return 1;
  1507. }
  1508. }
  1510. if(!option_values.force_raw_format) {
  1511. /* first set format based on name */
  1512. if(strlen(infilename) >= 4 && 0 == strcasecmp(infilename+(strlen(infilename)-4), ".wav"))
  1513. fmt= WAV;
  1514. else if(strlen(infilename) >= 4 && 0 == strcasecmp(infilename+(strlen(infilename)-4), ".aif"))
  1515. fmt= AIF;
  1516. else if(strlen(infilename) >= 5 && 0 == strcasecmp(infilename+(strlen(infilename)-5), ".aiff"))
  1517. fmt= AIF;
  1519. /* attempt to guess the file type based on the first 12 bytes */
  1520. if((lookahead_length = fread(lookahead, 1, 12, encode_infile)) < 12) {
  1521. if(fmt != RAW)
  1522. format_mistake(infilename, fmt == AIF ? "AIFF" : "WAVE", "raw");
  1523. fmt= RAW;
  1524. }
  1525. else {
  1526. if(!strncmp((const char *)lookahead, "RIFF", 4) && !strncmp((const char *)lookahead+8, "WAVE", 4))
  1527. fmt= WAV;
  1528. else if(!strncmp((const char *)lookahead, "FORM", 4) && !strncmp((const char *)lookahead+8, "AIFF", 4))
  1529. fmt= AIF;
  1530. else {
  1531. if(fmt != RAW)
  1532. format_mistake(infilename, fmt == AIF ? "AIFF" : "WAVE", "raw");
  1533. fmt= RAW;
  1534. }
  1535. }
  1536. }
  1538. if(option_values.format_input_size >= 0) {
  1539.     if (fmt != RAW || infilesize >= 0) {
  1540. flac__utils_printf(stderr, 1, "ERROR: can only use --input-size when encoding raw samples from stdinn");
  1541. return 1;
  1542. }
  1543. else {
  1544. infilesize = option_values.format_input_size;
  1545. }
  1546. }
  1548. if(option_values.sector_align && fmt == RAW && infilesize < 0) {
  1549. flac__utils_printf(stderr, 1, "ERROR: can't --sector-align when the input size is unknownn");
  1550. return 1;
  1551. }
  1553. if(fmt == RAW) {
  1554. 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)
  1555. return usage_error("ERROR: for encoding a raw file you must specify a value for --endian, --sign, --channels, --bps, and --sample-raten");
  1556. }
  1558. if(encode_infile == stdin || option_values.force_to_stdout) {
  1559. if(option_values.replay_gain)
  1560. return usage_error("ERROR: --replay-gain cannot be used when encoding to stdoutn");
  1561. }
  1563. if(!flac__utils_parse_skip_until_specification(option_values.skip_specification, &common_options.skip_specification) || common_options.skip_specification.is_relative)
  1564. return usage_error("ERROR: invalid value for --skipn");
  1566. 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 */
  1567. return usage_error("ERROR: invalid value for --untiln");
  1568. /* if there is no "--until" we want to default to "--until=-0" */
  1569. if(0 == option_values.until_specification)
  1570. common_options.until_specification.is_relative = true;
  1572. common_options.verify = option_values.verify;
  1573. #ifdef FLAC__HAS_OGG
  1574. common_options.use_ogg = option_values.use_ogg;
  1575. /* set a random serial number if one has not yet been specified */
  1576. if(!option_values.has_serial_number) {
  1577. srand(time(0));
  1578. option_values.serial_number = rand();
  1579. option_values.has_serial_number = true;
  1580. }
  1581. common_options.serial_number = option_values.serial_number++;
  1582. #endif
  1583. common_options.lax = option_values.lax;
  1584. common_options.do_mid_side = option_values.do_mid_side;
  1585. common_options.loose_mid_side = option_values.loose_mid_side;
  1586. common_options.do_exhaustive_model_search = option_values.do_exhaustive_model_search;
  1587. common_options.do_escape_coding = option_values.do_escape_coding;
  1588. common_options.do_qlp_coeff_prec_search = option_values.do_qlp_coeff_prec_search;
  1589. common_options.min_residual_partition_order = option_values.min_residual_partition_order;
  1590. common_options.max_residual_partition_order = option_values.max_residual_partition_order;
  1591. common_options.rice_parameter_search_dist = option_values.rice_parameter_search_dist;
  1592. common_options.max_lpc_order = option_values.max_lpc_order;
  1593. common_options.blocksize = (unsigned)option_values.blocksize;
  1594. common_options.qlp_coeff_precision = option_values.qlp_coeff_precision;
  1595. common_options.padding = option_values.padding;
  1596. common_options.requested_seek_points = option_values.requested_seek_points;
  1597. common_options.num_requested_seek_points = option_values.num_requested_seek_points;
  1598. common_options.cuesheet_filename = option_values.cuesheet_filename;
  1599. common_options.cued_seekpoints = option_values.cued_seekpoints;
  1600. common_options.is_first_file = is_first_file;
  1601. common_options.is_last_file = is_last_file;
  1602. common_options.align_reservoir = align_reservoir;
  1603. common_options.align_reservoir_samples = &align_reservoir_samples;
  1604. common_options.replay_gain = option_values.replay_gain;
  1605. common_options.sector_align = option_values.sector_align;
  1606. common_options.vorbis_comment = option_values.vorbis_comment;
  1607. common_options.debug.disable_constant_subframes = option_values.debug.disable_constant_subframes;
  1608. common_options.debug.disable_fixed_subframes = option_values.debug.disable_fixed_subframes;
  1609. common_options.debug.disable_verbatim_subframes = option_values.debug.disable_verbatim_subframes;
  1611. if(fmt == RAW) {
  1612. raw_encode_options_t options;
  1614. options.common = common_options;
  1615. options.is_big_endian = option_values.format_is_big_endian;
  1616. options.is_unsigned_samples = option_values.format_is_unsigned_samples;
  1617. options.channels = option_values.format_channels;
  1618. options.bps = option_values.format_bps;
  1619. options.sample_rate = option_values.format_sample_rate;
  1621. retval = flac__encode_raw(encode_infile, infilesize, infilename, outfilename, lookahead, lookahead_length, options);
  1622. }
  1623. else {
  1624. wav_encode_options_t options;
  1626. options.common = common_options;
  1628. if(fmt == AIF)
  1629. retval = flac__encode_aif(encode_infile, infilesize, infilename, outfilename, lookahead, lookahead_length, options);
  1630. else
  1631. retval = flac__encode_wav(encode_infile, infilesize, infilename, outfilename, lookahead, lookahead_length, options);
  1632. }
  1634. if(retval == 0 && strcmp(infilename, "-")) {
  1635. if(strcmp(outfilename, "-")) {
  1636. if(option_values.replay_gain) {
  1637. float title_gain, title_peak;
  1638. const char *error;
  1639. grabbag__replaygain_get_title(&title_gain, &title_peak);
  1640. if(0 != (error = grabbag__replaygain_store_to_file_title(outfilename, title_gain, title_peak, /*preserve_modtime=*/true))) {
  1641. flac__utils_printf(stderr, 1, "%s: ERROR writing ReplayGain title tagsn", outfilename);
  1642. }
  1643. }
  1644. grabbag__file_copy_metadata(infilename, outfilename);
  1645. }
  1646. if(option_values.delete_input)
  1647. unlink(infilename);
  1648. }
  1650. return retval;
  1651. }
  1653. int decode_file(const char *infilename)
  1654. {
  1655. int retval;
  1656. FLAC__bool treat_as_ogg = false;
  1657. decode_options_t common_options;
  1658. const char *outfilename = get_decoded_outfilename(infilename);
  1660. if(0 == outfilename) {
  1661. flac__utils_printf(stderr, 1, "ERROR: filename too long: %s", infilename);
  1662. return 1;
  1663. }
  1665. /*
  1666.  * Error if output file already exists (and -f not used).
  1667.  * Use grabbag__file_get_filesize() as a cheap way to check.
  1668.  */
  1669. if(!option_values.test_only && !option_values.force_file_overwrite && grabbag__file_get_filesize(outfilename) != (off_t)(-1)) {
  1670. flac__utils_printf(stderr, 1, "ERROR: output file %s already exists, use -f to overriden", outfilename);
  1671. return 1;
  1672. }
  1674. if(!option_values.test_only && !option_values.analyze) {
  1675. if(option_values.force_raw_format && (option_values.format_is_big_endian < 0 || option_values.format_is_unsigned_samples < 0))
  1676. return usage_error("ERROR: for decoding to a raw file you must specify a value for --endian and --signn");
  1677. }
  1679. if(option_values.use_ogg)
  1680. treat_as_ogg = true;
  1681. else if(strlen(infilename) >= 4 && 0 == strcasecmp(infilename+(strlen(infilename)-4), ".ogg"))
  1682. treat_as_ogg = true;
  1683. else
  1684. treat_as_ogg = false;
  1686. #ifndef FLAC__HAS_OGG
  1687. if(treat_as_ogg) {
  1688. flac__utils_printf(stderr, 1, "%s: Ogg support has not been built into this copy of flacn", infilename);
  1689. return 1;
  1690. }
  1691. #endif
  1693. if(!flac__utils_parse_skip_until_specification(option_values.skip_specification, &common_options.skip_specification) || common_options.skip_specification.is_relative)
  1694. return usage_error("ERROR: invalid value for --skipn");
  1696. 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 */
  1697. return usage_error("ERROR: invalid value for --untiln");
  1698. /* if there is no "--until" we want to default to "--until=-0" */
  1699. if(0 == option_values.until_specification)
  1700. common_options.until_specification.is_relative = true;
  1702. if(option_values.cue_specification) {
  1703. if(!flac__utils_parse_cue_specification(option_values.cue_specification, &common_options.cue_specification))
  1704. return usage_error("ERROR: invalid value for --cuen");
  1705. common_options.has_cue_specification = true;
  1706. }
  1707. else
  1708. common_options.has_cue_specification = false;
  1710. common_options.continue_through_decode_errors = option_values.continue_through_decode_errors;
  1711. common_options.replaygain_synthesis_spec = option_values.replaygain_synthesis_spec;
  1712. #ifdef FLAC__HAS_OGG
  1713. common_options.is_ogg = treat_as_ogg;
  1714. common_options.use_first_serial_number = !option_values.has_serial_number;
  1715. common_options.serial_number = option_values.serial_number;
  1716. #endif
  1718. if(!option_values.force_raw_format) {
  1719. wav_decode_options_t options;
  1721. options.common = common_options;
  1723. if(
  1724. option_values.force_aiff_format ||
  1725. (strlen(outfilename) >= 4 && 0 == strcasecmp(outfilename+(strlen(outfilename)-4), ".aif")) ||
  1726. (strlen(outfilename) >= 5 && 0 == strcasecmp(outfilename+(strlen(outfilename)-5), ".aiff"))
  1727. )
  1728. retval = flac__decode_aiff(infilename, option_values.test_only? 0 : outfilename, option_values.analyze, option_values.aopts, options);
  1729. else
  1730. retval = flac__decode_wav(infilename, option_values.test_only? 0 : outfilename, option_values.analyze, option_values.aopts, options);
  1731. }
  1732. else {
  1733. raw_decode_options_t options;
  1735. options.common = common_options;
  1736. options.is_big_endian = option_values.format_is_big_endian;
  1737. options.is_unsigned_samples = option_values.format_is_unsigned_samples;
  1739. retval = flac__decode_raw(infilename, option_values.test_only? 0 : outfilename, option_values.analyze, option_values.aopts, options);
  1740. }
  1742. if(retval == 0 && strcmp(infilename, "-")) {
  1743. if(strcmp(outfilename, "-"))
  1744. grabbag__file_copy_metadata(infilename, outfilename);
  1745. if(option_values.delete_input && !option_values.test_only && !option_values.analyze)
  1746. unlink(infilename);
  1747. }
  1749. return retval;
  1750. }
  1752. const char *get_encoded_outfilename(const char *infilename)
  1753. {
  1754. const char *suffix = (option_values.use_ogg? ".ogg" : ".flac");
  1755. return get_outfilename(infilename, suffix);
  1756. }
  1758. const char *get_decoded_outfilename(const char *infilename)
  1759. {
  1760. const char *suffix;
  1761. if(option_values.analyze) {
  1762. suffix = ".ana";
  1763. }
  1764. else if(option_values.force_raw_format) {
  1765. suffix = ".raw";
  1766. }
  1767. else if(option_values.force_aiff_format) {
  1768. suffix = ".aiff";
  1769. }
  1770. else {
  1771. suffix = ".wav";
  1772. }
  1773. return get_outfilename(infilename, suffix);
  1774. }
  1776. const char *get_outfilename(const char *infilename, const char *suffix)
  1777. {
  1778. if(0 == option_values.cmdline_forced_outfilename) {
  1779. static char buffer[4096]; /* @@@ bad MAGIC NUMBER */
  1781. if(0 == strcmp(infilename, "-") || option_values.force_to_stdout) {
  1782. strcpy(buffer, "-");
  1783. }
  1784. else {
  1785. char *p;
  1786. if (flac__strlcpy(buffer, option_values.output_prefix? option_values.output_prefix : "", sizeof buffer) >= sizeof buffer)
  1787. return 0;
  1788. if (flac__strlcat(buffer, infilename, sizeof buffer) >= sizeof buffer)
  1789. return 0;
  1790. if(0 == (p = strrchr(buffer, '.'))) {
  1791. if (flac__strlcat(buffer, suffix, sizeof buffer) >= sizeof buffer)
  1792. return 0;
  1793. }
  1794. else {
  1795. if(0 == strcmp(p, suffix)) {
  1796. *p = '';
  1797. if (flac__strlcat(buffer, "_new", sizeof buffer) >= sizeof buffer)
  1798. return 0;
  1799. }
  1800. else {
  1801. *p = '';
  1802. }
  1803. if (flac__strlcat(buffer, suffix, sizeof buffer) >= sizeof buffer)
  1804. return 0;
  1805. }
  1806. }
  1807. return buffer;
  1808. }
  1809. else
  1810. return option_values.cmdline_forced_outfilename;
  1811. }
  1813. void die(const char *message)
  1814. {
  1815. FLAC__ASSERT(0 != message);
  1816. flac__utils_printf(stderr, 1, "ERROR: %sn", message);
  1817. exit(1);
  1818. }
  1820. char *local_strdup(const char *source)
  1821. {
  1822. char *ret;
  1823. FLAC__ASSERT(0 != source);
  1824. if(0 == (ret = strdup(source)))
  1825. die("out of memory during strdup()");
  1826. return ret;
  1827. }