1 /* flac - Command-line FLAC encoder/decoder
2 * Copyright (C) 2000,2001,2002,2003,2004,2005,2006,2007 Josh Coalson
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.
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.
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.
23 #if defined _WIN32 && !defined __CYGWIN__
24 /* where MSVC puts unlink() */
29 #if defined _MSC_VER || defined __MINGW32__
30 #include <sys/types.h> /* for off_t */
31 #if _MSC_VER <= 1600 /* @@@ [2G limit] */
37 #include <limits.h> /* for LONG_MAX */
38 #include <math.h> /* for floor() */
39 #include <stdio.h> /* for FILE etc. */
40 #include <stdlib.h> /* for malloc */
41 #include <string.h> /* for strcmp(), strerror() */
43 #include "share/alloc.h"
44 #include "share/grabbag.h"
47 #ifdef TARGET_MSDOS /* @@@ [2G limit] */
55 #define min(x,y) ((x)<(y)?(x):(y))
59 #define max(x,y) ((x)>(y)?(x):(y))
61 /* this MUST be >= 588 so that sector aligning can take place with one read */
62 #define CHUNK_OF_SAMPLES 2048
70 FLAC__bool outputfile_opened; /* true if we successfully opened the output file and we want it to be deleted if there is an error */
71 const char *inbasefilename;
72 const char *infilename;
73 const char *outfilename;
76 FLAC__uint64 until; /* a value of 0 mean end-of-stream (i.e. --until=-0) */
77 FLAC__bool treat_warnings_as_errors;
78 FLAC__bool continue_through_decode_errors;
79 FLAC__bool replay_gain;
81 unsigned bits_per_sample;
83 FLAC__uint64 unencoded_size;
84 FLAC__uint64 total_samples_to_encode;
85 FLAC__uint64 bytes_written;
86 FLAC__uint64 samples_written;
89 FLAC__StreamEncoder *encoder;
92 FLAC__StreamMetadata *seek_table_template;
95 /* this is data attached to the FLAC decoder when encoding from a FLAC file */
97 EncoderSession *encoder_session;
99 const FLAC__byte *lookahead;
100 unsigned lookahead_length;
101 size_t num_metadata_blocks;
102 FLAC__StreamMetadata *metadata_blocks[1024]; /*@@@ BAD MAGIC number */
103 FLAC__uint64 samples_left_to_process;
104 FLAC__bool fatal_error;
107 const int FLAC_ENCODE__DEFAULT_PADDING = 8192;
109 static FLAC__bool is_big_endian_host_;
111 static unsigned char ucbuffer_[CHUNK_OF_SAMPLES*FLAC__MAX_CHANNELS*((FLAC__REFERENCE_CODEC_MAX_BITS_PER_SAMPLE+7)/8)];
112 static signed char *scbuffer_ = (signed char *)ucbuffer_;
113 static FLAC__uint16 *usbuffer_ = (FLAC__uint16 *)ucbuffer_;
114 static FLAC__int16 *ssbuffer_ = (FLAC__int16 *)ucbuffer_;
116 static FLAC__int32 in_[FLAC__MAX_CHANNELS][CHUNK_OF_SAMPLES];
117 static FLAC__int32 *input_[FLAC__MAX_CHANNELS];
121 * unpublished debug routines from the FLAC libs
123 extern FLAC__bool FLAC__stream_encoder_disable_constant_subframes(FLAC__StreamEncoder *encoder, FLAC__bool value);
124 extern FLAC__bool FLAC__stream_encoder_disable_fixed_subframes(FLAC__StreamEncoder *encoder, FLAC__bool value);
125 extern FLAC__bool FLAC__stream_encoder_disable_verbatim_subframes(FLAC__StreamEncoder *encoder, FLAC__bool value);
126 extern FLAC__bool FLAC__stream_encoder_set_do_md5(FLAC__StreamEncoder *encoder, FLAC__bool value);
131 static FLAC__bool EncoderSession_construct(EncoderSession *e, FLAC__bool use_ogg, FLAC__bool verify, FLAC__bool treat_warnings_as_errors, FLAC__bool continue_through_decode_errors, FILE *infile, const char *infilename, const char *outfilename);
132 static void EncoderSession_destroy(EncoderSession *e);
133 static int EncoderSession_finish_ok(EncoderSession *e, int info_align_carry, int info_align_zero, foreign_metadata_t *foreign_metadata);
134 static int EncoderSession_finish_error(EncoderSession *e);
135 static FLAC__bool EncoderSession_init_encoder(EncoderSession *e, encode_options_t options, FLAC__uint32 channel_mask, unsigned channels, unsigned bps, unsigned sample_rate, const foreign_metadata_t *foreign_metadata, FLACDecoderData *flac_decoder_data);
136 static FLAC__bool EncoderSession_process(EncoderSession *e, const FLAC__int32 * const buffer[], unsigned samples);
137 static FLAC__bool convert_to_seek_table_template(const char *requested_seek_points, int num_requested_seek_points, FLAC__StreamMetadata *cuesheet, EncoderSession *e);
138 static FLAC__bool canonicalize_until_specification(utils__SkipUntilSpecification *spec, const char *inbasefilename, unsigned sample_rate, FLAC__uint64 skip, FLAC__uint64 total_samples_in_input);
139 static FLAC__bool verify_metadata(const EncoderSession *e, FLAC__StreamMetadata **metadata, unsigned num_metadata);
140 static FLAC__bool format_input(FLAC__int32 *dest[], unsigned wide_samples, FLAC__bool is_big_endian, FLAC__bool is_unsigned_samples, unsigned channels, unsigned bps, unsigned shift, size_t *channel_map);
141 static void encoder_progress_callback(const FLAC__StreamEncoder *encoder, FLAC__uint64 bytes_written, FLAC__uint64 samples_written, unsigned frames_written, unsigned total_frames_estimate, void *client_data);
142 static FLAC__StreamDecoderReadStatus flac_decoder_read_callback(const FLAC__StreamDecoder *decoder, FLAC__byte buffer[], size_t *bytes, void *client_data);
143 static FLAC__StreamDecoderSeekStatus flac_decoder_seek_callback(const FLAC__StreamDecoder *decoder, FLAC__uint64 absolute_byte_offset, void *client_data);
144 static FLAC__StreamDecoderTellStatus flac_decoder_tell_callback(const FLAC__StreamDecoder *decoder, FLAC__uint64 *absolute_byte_offset, void *client_data);
145 static FLAC__StreamDecoderLengthStatus flac_decoder_length_callback(const FLAC__StreamDecoder *decoder, FLAC__uint64 *stream_length, void *client_data);
146 static FLAC__bool flac_decoder_eof_callback(const FLAC__StreamDecoder *decoder, void *client_data);
147 static FLAC__StreamDecoderWriteStatus flac_decoder_write_callback(const FLAC__StreamDecoder *decoder, const FLAC__Frame *frame, const FLAC__int32 * const buffer[], void *client_data);
148 static void flac_decoder_metadata_callback(const FLAC__StreamDecoder *decoder, const FLAC__StreamMetadata *metadata, void *client_data);
149 static void flac_decoder_error_callback(const FLAC__StreamDecoder *decoder, FLAC__StreamDecoderErrorStatus status, void *client_data);
150 static FLAC__bool parse_cuesheet(FLAC__StreamMetadata **cuesheet, const char *cuesheet_filename, const char *inbasefilename, FLAC__bool is_cdda, FLAC__uint64 lead_out_offset, FLAC__bool treat_warnings_as_errors);
151 static void print_stats(const EncoderSession *encoder_session);
152 static void print_error_with_init_status(const EncoderSession *e, const char *message, FLAC__StreamEncoderInitStatus init_status);
153 static void print_error_with_state(const EncoderSession *e, const char *message);
154 static void print_verify_error(EncoderSession *e);
155 static FLAC__bool read_little_endian_uint16(FILE *f, FLAC__uint16 *val, FLAC__bool eof_ok, const char *fn);
156 static FLAC__bool read_little_endian_uint32(FILE *f, FLAC__uint32 *val, FLAC__bool eof_ok, const char *fn);
157 static FLAC__bool read_big_endian_uint16(FILE *f, FLAC__uint16 *val, FLAC__bool eof_ok, const char *fn);
158 static FLAC__bool read_big_endian_uint32(FILE *f, FLAC__uint32 *val, FLAC__bool eof_ok, const char *fn);
159 static FLAC__bool read_sane_extended(FILE *f, FLAC__uint32 *val, FLAC__bool eof_ok, const char *fn);
160 static FLAC__bool fskip_ahead(FILE *f, FLAC__uint64 offset);
161 static unsigned count_channel_mask_bits(FLAC__uint32 mask);
163 static FLAC__uint32 limit_channel_mask(FLAC__uint32 mask, unsigned channels);
169 int flac__encode_aif(FILE *infile, off_t infilesize, const char *infilename, const char *outfilename, const FLAC__byte *lookahead, unsigned lookahead_length, wav_encode_options_t options, FLAC__bool is_aifc)
171 EncoderSession encoder_session;
174 unsigned int channels= 0U, bps= 0U, shift= 0U, sample_rate= 0U, sample_frames= 0U;
175 size_t channel_map[FLAC__MAX_CHANNELS];
176 FLAC__bool got_comm_chunk= false, got_ssnd_chunk= false;
177 int info_align_carry= -1, info_align_zero= -1;
178 FLAC__bool is_big_endian_pcm = true;
180 (void)infilesize; /* silence compiler warning about unused parameter */
181 (void)lookahead; /* silence compiler warning about unused parameter */
182 (void)lookahead_length; /* silence compiler warning about unused parameter */
185 EncoderSession_construct(
188 options.common.use_ogg,
192 options.common.verify,
193 options.common.treat_warnings_as_errors,
194 options.common.continue_through_decode_errors,
202 /* initialize default channel map that preserves channel order */
205 for(i = 0; i < sizeof(channel_map)/sizeof(channel_map[0]); i++)
209 if(options.foreign_metadata) {
211 if(!flac__foreign_metadata_read_from_aiff(options.foreign_metadata, infilename, &error)) {
212 flac__utils_printf(stderr, 1, "%s: ERROR reading foreign metadata: %s\n", encoder_session.inbasefilename, error);
213 return EncoderSession_finish_error(&encoder_session);
217 /* lookahead[] already has "FORMxxxxAIFF", do sub-chunks */
221 char chunk_id[5] = { '\0', '\0', '\0', '\0', '\0' }; /* one extra byte for terminating NUL so we can also treat it like a C string */
223 /* chunk identifier; really conservative about behavior of fread() and feof() */
224 if(feof(infile) || ((c= fread(chunk_id, 1U, 4U, infile)), c==0U && feof(infile)))
226 else if(c<4U || feof(infile)) {
227 flac__utils_printf(stderr, 1, "%s: ERROR: incomplete chunk identifier\n", encoder_session.inbasefilename);
228 return EncoderSession_finish_error(&encoder_session);
231 if(got_comm_chunk==false && !memcmp(chunk_id, "COMM", 4)) { /* common chunk */
233 const FLAC__uint32 minimum_comm_size = (is_aifc? 22 : 18);
235 /* COMM chunk size */
236 if(!read_big_endian_uint32(infile, &xx, false, encoder_session.inbasefilename))
237 return EncoderSession_finish_error(&encoder_session);
238 else if(xx<minimum_comm_size) {
239 flac__utils_printf(stderr, 1, "%s: ERROR: non-standard %s 'COMM' chunk has length = %u\n", encoder_session.inbasefilename, is_aifc? "AIFF-C" : "AIFF", (unsigned int)xx);
240 return EncoderSession_finish_error(&encoder_session);
242 else if(!is_aifc && xx!=minimum_comm_size) {
243 flac__utils_printf(stderr, 1, "%s: WARNING: non-standard %s 'COMM' chunk has length = %u, expected %u\n", encoder_session.inbasefilename, is_aifc? "AIFF-C" : "AIFF", (unsigned int)xx, minimum_comm_size);
244 if(encoder_session.treat_warnings_as_errors)
245 return EncoderSession_finish_error(&encoder_session);
247 skip= (xx-minimum_comm_size)+(xx & 1U);
249 /* number of channels */
250 if(!read_big_endian_uint16(infile, &x, false, encoder_session.inbasefilename))
251 return EncoderSession_finish_error(&encoder_session);
252 else if(x==0U || x>FLAC__MAX_CHANNELS) {
253 flac__utils_printf(stderr, 1, "%s: ERROR: unsupported number channels %u\n", encoder_session.inbasefilename, (unsigned int)x);
254 return EncoderSession_finish_error(&encoder_session);
256 else if(x>2U && !options.common.channel_map_none) {
257 flac__utils_printf(stderr, 1, "%s: ERROR: unsupported number channels %u for AIFF\n", encoder_session.inbasefilename, (unsigned int)x);
258 return EncoderSession_finish_error(&encoder_session);
260 else if(options.common.sector_align && x!=2U) {
261 flac__utils_printf(stderr, 1, "%s: ERROR: file has %u channels, must be 2 for --sector-align\n", encoder_session.inbasefilename, (unsigned int)x);
262 return EncoderSession_finish_error(&encoder_session);
266 /* number of sample frames */
267 if(!read_big_endian_uint32(infile, &xx, false, encoder_session.inbasefilename))
268 return EncoderSession_finish_error(&encoder_session);
271 /* bits per sample */
272 if(!read_big_endian_uint16(infile, &x, false, encoder_session.inbasefilename))
273 return EncoderSession_finish_error(&encoder_session);
274 else if(x<4U || x>24U) {
275 flac__utils_printf(stderr, 1, "%s: ERROR: unsupported bits-per-sample %u\n", encoder_session.inbasefilename, (unsigned int)x);
276 return EncoderSession_finish_error(&encoder_session);
278 else if(options.common.sector_align && x!=16U) {
279 flac__utils_printf(stderr, 1, "%s: ERROR: file has %u bits-per-sample, must be 16 for --sector-align\n", encoder_session.inbasefilename, (unsigned int)x);
280 return EncoderSession_finish_error(&encoder_session);
283 shift= (bps%8)? 8-(bps%8) : 0; /* SSND data is always byte-aligned, left-justified but format_input() will double-check */
287 if(!read_sane_extended(infile, &xx, false, encoder_session.inbasefilename))
288 return EncoderSession_finish_error(&encoder_session);
289 else if(!FLAC__format_sample_rate_is_valid(xx)) {
290 flac__utils_printf(stderr, 1, "%s: ERROR: unsupported sample rate %u\n", encoder_session.inbasefilename, (unsigned int)xx);
291 return EncoderSession_finish_error(&encoder_session);
293 else if(options.common.sector_align && xx!=44100U) {
294 flac__utils_printf(stderr, 1, "%s: ERROR: file's sample rate is %u, must be 44100 for --sector-align\n", encoder_session.inbasefilename, (unsigned int)xx);
295 return EncoderSession_finish_error(&encoder_session);
299 /* check compression type for AIFF-C */
301 if(!read_big_endian_uint32(infile, &xx, false, encoder_session.inbasefilename))
302 return EncoderSession_finish_error(&encoder_session);
303 if(xx == 0x736F7774) /* "sowt" */
304 is_big_endian_pcm = false;
305 else if(xx == 0x4E4F4E45) /* "NONE" */
306 ; /* nothing to do, we already default to big-endian */
308 flac__utils_printf(stderr, 1, "%s: ERROR: can't handle AIFF-C compression type \"%c%c%c%c\"\n", encoder_session.inbasefilename, (char)(xx>>24), (char)((xx>>16)&8), (char)((xx>>8)&8), (char)(xx&8));
309 return EncoderSession_finish_error(&encoder_session);
313 /* set channel mapping */
314 /* FLAC order follows SMPTE and WAVEFORMATEXTENSIBLE but with fewer channels, which are: */
315 /* front left, front right, center, LFE, back left, back right, surround left, surround right */
316 /* specs say the channel ordering is:
318 * ___________________________________________________
322 * quad (ambiguous with 4ch) Fl Fr Bl Br
325 * l:left r:right c:center Fl:front-left Fr:front-right Bl:back-left Br:back-right Lc:left-center Rc:right-center S:surround
326 * so we only have unambiguous mappings for 2, 3, and 5 channels
329 options.common.channel_map_none ||
330 channels == 1 || /* 1 channel: (mono) */
331 channels == 2 || /* 2 channels: left, right */
332 channels == 3 || /* 3 channels: left, right, center */
333 channels == 5 /* 5 channels: front left, front right, center, surround left, surround right */
335 /* keep default channel order */
338 flac__utils_printf(stderr, 1, "%s: ERROR: unsupported number channels %u for AIFF\n", encoder_session.inbasefilename, channels);
339 return EncoderSession_finish_error(&encoder_session);
342 /* skip any extra data in the COMM chunk */
343 if(!fskip_ahead(infile, skip)) {
344 flac__utils_printf(stderr, 1, "%s: ERROR during read while skipping over extra COMM data\n", encoder_session.inbasefilename);
345 return EncoderSession_finish_error(&encoder_session);
349 * now that we know the sample rate, canonicalize the
350 * --skip string to a number of samples:
352 flac__utils_canonicalize_skip_until_specification(&options.common.skip_specification, sample_rate);
353 FLAC__ASSERT(options.common.skip_specification.value.samples >= 0);
354 encoder_session.skip = (FLAC__uint64)options.common.skip_specification.value.samples;
355 FLAC__ASSERT(!options.common.sector_align || encoder_session.skip == 0);
357 got_comm_chunk= true;
359 else if(got_ssnd_chunk==false && !memcmp(chunk_id, "SSND", 4)) { /* sound data chunk */
360 unsigned int offset= 0U, block_size= 0U, align_remainder= 0U, data_bytes;
361 const size_t bytes_per_frame= channels*(bps>>3);
362 FLAC__uint64 total_samples_in_input, trim = 0;
363 FLAC__bool pad= false;
365 if(got_comm_chunk==false) {
366 flac__utils_printf(stderr, 1, "%s: ERROR: got 'SSND' chunk before 'COMM' chunk\n", encoder_session.inbasefilename);
367 return EncoderSession_finish_error(&encoder_session);
370 /* SSND chunk size */
371 if(!read_big_endian_uint32(infile, &xx, false, encoder_session.inbasefilename))
372 return EncoderSession_finish_error(&encoder_session);
373 if(options.common.ignore_chunk_sizes) {
374 FLAC__ASSERT(!options.common.sector_align);
375 data_bytes = (unsigned)(-(int)bytes_per_frame); /* max out data_bytes; we'll use EOF as signal to stop reading */
379 data_bytes-= 8U; /* discount the offset and block size fields */
381 pad= (data_bytes & 1U) ? true : false;
384 if(!read_big_endian_uint32(infile, &xx, false, encoder_session.inbasefilename))
385 return EncoderSession_finish_error(&encoder_session);
390 if(!read_big_endian_uint32(infile, &xx, false, encoder_session.inbasefilename))
391 return EncoderSession_finish_error(&encoder_session);
393 flac__utils_printf(stderr, 1, "%s: ERROR: block size is %u; must be 0\n", encoder_session.inbasefilename, (unsigned int)xx);
394 return EncoderSession_finish_error(&encoder_session);
398 /* skip any SSND offset bytes */
399 FLAC__ASSERT(offset<=LONG_MAX);
400 if(!fskip_ahead(infile, offset)) {
401 flac__utils_printf(stderr, 1, "%s: ERROR: skipping offset in SSND chunk\n", encoder_session.inbasefilename);
402 return EncoderSession_finish_error(&encoder_session);
404 if(data_bytes!=(sample_frames*bytes_per_frame)) {
405 flac__utils_printf(stderr, 1, "%s: ERROR: SSND chunk size inconsistent with sample frame count\n", encoder_session.inbasefilename);
406 return EncoderSession_finish_error(&encoder_session);
409 /* *options.common.align_reservoir_samples will be 0 unless --sector-align is used */
410 FLAC__ASSERT(options.common.sector_align || *options.common.align_reservoir_samples == 0);
411 total_samples_in_input = data_bytes / bytes_per_frame + *options.common.align_reservoir_samples;
414 * now that we know the input size, canonicalize the
415 * --until string to an absolute sample number:
417 if(!canonicalize_until_specification(&options.common.until_specification, encoder_session.inbasefilename, sample_rate, encoder_session.skip, total_samples_in_input))
418 return EncoderSession_finish_error(&encoder_session);
419 encoder_session.until = (FLAC__uint64)options.common.until_specification.value.samples;
420 FLAC__ASSERT(!options.common.sector_align || encoder_session.until == 0);
422 if(encoder_session.skip>0U) {
423 if(!fskip_ahead(infile, encoder_session.skip*bytes_per_frame)) {
424 flac__utils_printf(stderr, 1, "%s: ERROR during read while skipping samples\n", encoder_session.inbasefilename);
425 return EncoderSession_finish_error(&encoder_session);
429 data_bytes-= (unsigned int)encoder_session.skip*bytes_per_frame; /*@@@ WATCHOUT: 4GB limit */
430 if(options.common.ignore_chunk_sizes) {
431 encoder_session.total_samples_to_encode= 0;
432 flac__utils_printf(stderr, 2, "(No runtime statistics possible; please wait for encoding to finish...)\n");
433 FLAC__ASSERT(0 == encoder_session.until);
436 encoder_session.total_samples_to_encode= total_samples_in_input - encoder_session.skip;
438 if(encoder_session.until > 0) {
439 trim = total_samples_in_input - encoder_session.until;
440 FLAC__ASSERT(total_samples_in_input > 0);
441 FLAC__ASSERT(!options.common.sector_align);
442 data_bytes-= (unsigned int)trim*bytes_per_frame;
443 encoder_session.total_samples_to_encode-= trim;
445 if(options.common.sector_align) {
446 align_remainder= (unsigned int)(encoder_session.total_samples_to_encode % 588U);
447 if(options.common.is_last_file)
448 encoder_session.total_samples_to_encode+= (588U-align_remainder); /* will pad with zeroes */
450 encoder_session.total_samples_to_encode-= align_remainder; /* will stop short and carry over to next file */
453 /* +54 for the size of the AIFF headers; this is just an estimate for the progress indicator and doesn't need to be exact */
454 encoder_session.unencoded_size= encoder_session.total_samples_to_encode*bytes_per_frame+54;
456 if(!EncoderSession_init_encoder(&encoder_session, options.common, /*channel_mask=*/0, channels, bps-shift, sample_rate, options.foreign_metadata, /*flac_decoder_data=*/0))
457 return EncoderSession_finish_error(&encoder_session);
459 /* first do any samples in the reservoir */
460 if(options.common.sector_align && *options.common.align_reservoir_samples>0U) {
462 if(!EncoderSession_process(&encoder_session, (const FLAC__int32 *const *)options.common.align_reservoir, *options.common.align_reservoir_samples)) {
463 print_error_with_state(&encoder_session, "ERROR during encoding");
464 return EncoderSession_finish_error(&encoder_session);
468 /* decrement the data_bytes counter if we need to align the file */
469 if(options.common.sector_align) {
470 if(options.common.is_last_file)
471 *options.common.align_reservoir_samples= 0U;
473 *options.common.align_reservoir_samples= align_remainder;
474 data_bytes-= (*options.common.align_reservoir_samples)*bytes_per_frame;
478 /* now do from the file */
479 while(data_bytes>0) {
480 size_t bytes_read= fread(ucbuffer_, 1U, min(data_bytes, CHUNK_OF_SAMPLES*bytes_per_frame), infile);
484 flac__utils_printf(stderr, 1, "%s: ERROR during read\n", encoder_session.inbasefilename);
485 return EncoderSession_finish_error(&encoder_session);
487 else if(feof(infile)) {
488 if(options.common.ignore_chunk_sizes) {
489 flac__utils_printf(stderr, 1, "%s: INFO: hit EOF with --ignore-chunk-sizes, got %u samples\n", encoder_session.inbasefilename, (unsigned)encoder_session.samples_written);
492 flac__utils_printf(stderr, 1, "%s: WARNING: unexpected EOF; expected %u samples, got %u samples\n", encoder_session.inbasefilename, (unsigned)encoder_session.total_samples_to_encode, (unsigned)encoder_session.samples_written);
493 if(encoder_session.treat_warnings_as_errors)
494 return EncoderSession_finish_error(&encoder_session);
500 if(bytes_read % bytes_per_frame != 0U) {
501 flac__utils_printf(stderr, 1, "%s: ERROR: got partial sample\n", encoder_session.inbasefilename);
502 return EncoderSession_finish_error(&encoder_session);
505 unsigned int frames= bytes_read/bytes_per_frame;
506 if(!format_input(input_, frames, is_big_endian_pcm, /*is_unsigned_samples=*/false, channels, bps, shift, channel_map))
507 return EncoderSession_finish_error(&encoder_session);
509 if(!EncoderSession_process(&encoder_session, (const FLAC__int32 *const *)input_, frames)) {
510 print_error_with_state(&encoder_session, "ERROR during encoding");
511 return EncoderSession_finish_error(&encoder_session);
514 data_bytes-= bytes_read;
520 FLAC__ASSERT(!options.common.sector_align);
521 if(!fskip_ahead(infile, trim*bytes_per_frame)) {
522 flac__utils_printf(stderr, 1, "%s: ERROR during read while skipping samples\n", encoder_session.inbasefilename);
523 return EncoderSession_finish_error(&encoder_session);
527 /* now read unaligned samples into reservoir or pad with zeroes if necessary */
528 if(options.common.sector_align) {
529 if(options.common.is_last_file) {
530 unsigned int pad_frames= 588U-align_remainder;
532 if(pad_frames<588U) {
535 info_align_zero= pad_frames;
536 for(i= 0U; i<channels; ++i)
537 memset(input_[i], 0, sizeof(input_[0][0])*pad_frames);
539 if(!EncoderSession_process(&encoder_session, (const FLAC__int32 *const *)input_, pad_frames)) {
540 print_error_with_state(&encoder_session, "ERROR during encoding");
541 return EncoderSession_finish_error(&encoder_session);
546 if(*options.common.align_reservoir_samples > 0) {
547 size_t bytes_read= fread(ucbuffer_, 1U, (*options.common.align_reservoir_samples)*bytes_per_frame, infile);
549 FLAC__ASSERT(CHUNK_OF_SAMPLES>=588U);
550 if(bytes_read==0U && ferror(infile)) {
551 flac__utils_printf(stderr, 1, "%s: ERROR during read\n", encoder_session.inbasefilename);
552 return EncoderSession_finish_error(&encoder_session);
554 else if(bytes_read != (*options.common.align_reservoir_samples) * bytes_per_frame) {
555 flac__utils_printf(stderr, 1, "%s: WARNING: unexpected EOF; read %u bytes; expected %u samples, got %u samples\n", encoder_session.inbasefilename, (unsigned int)bytes_read, (unsigned int)encoder_session.total_samples_to_encode, (unsigned int)encoder_session.samples_written);
556 if(encoder_session.treat_warnings_as_errors)
557 return EncoderSession_finish_error(&encoder_session);
560 info_align_carry= *options.common.align_reservoir_samples;
561 if(!format_input(options.common.align_reservoir, *options.common.align_reservoir_samples, is_big_endian_pcm, /*is_unsigned_samples=*/false, channels, bps, shift, channel_map))
562 return EncoderSession_finish_error(&encoder_session);
571 if(fread(&tmp, 1U, 1U, infile)<1U) {
572 flac__utils_printf(stderr, 1, "%s: ERROR during read of SSND pad byte\n", encoder_session.inbasefilename);
573 return EncoderSession_finish_error(&encoder_session);
577 got_ssnd_chunk= true;
579 else { /* other chunk */
580 if(!options.foreign_metadata) {
581 if(!memcmp(chunk_id, "COMM", 4))
582 flac__utils_printf(stderr, 1, "%s: WARNING: skipping extra 'COMM' chunk (use --keep-foreign-metadata to keep)\n", encoder_session.inbasefilename);
583 else if(!memcmp(chunk_id, "SSND", 4))
584 flac__utils_printf(stderr, 1, "%s: WARNING: skipping extra 'SSND' chunk (use --keep-foreign-metadata to keep)\n", encoder_session.inbasefilename);
585 else if(!options.foreign_metadata)
586 flac__utils_printf(stderr, 1, "%s: WARNING: skipping unknown chunk '%s' (use --keep-foreign-metadata to keep)\n", encoder_session.inbasefilename, chunk_id);
587 if(encoder_session.treat_warnings_as_errors)
588 return EncoderSession_finish_error(&encoder_session);
592 if(!read_big_endian_uint32(infile, &xx, false, encoder_session.inbasefilename))
593 return EncoderSession_finish_error(&encoder_session);
595 unsigned long skip= xx+(xx & 1U);
597 FLAC__ASSERT(skip<=LONG_MAX);
598 if(!fskip_ahead(infile, skip)) {
599 fprintf(stderr, "%s: ERROR during read while skipping over unknown chunk\n", encoder_session.inbasefilename);
600 return EncoderSession_finish_error(&encoder_session);
606 if(got_ssnd_chunk==false && sample_frames!=0U) {
607 flac__utils_printf(stderr, 1, "%s: ERROR: missing SSND chunk\n", encoder_session.inbasefilename);
608 return EncoderSession_finish_error(&encoder_session);
611 return EncoderSession_finish_ok(&encoder_session, info_align_carry, info_align_zero, options.foreign_metadata);
614 int flac__encode_wav(FILE *infile, off_t infilesize, const char *infilename, const char *outfilename, const FLAC__byte *lookahead, unsigned lookahead_length, wav_encode_options_t options)
616 EncoderSession encoder_session;
617 FLAC__bool is_unsigned_samples = false;
618 unsigned channels = 0, bps = 0, sample_rate = 0, shift = 0;
620 size_t channel_map[FLAC__MAX_CHANNELS];
621 FLAC__uint16 x, format; /* format is the wFormatTag word from the 'fmt ' chunk */
622 FLAC__uint32 xx, channel_mask = 0;
623 FLAC__bool got_fmt_chunk = false, got_data_chunk = false;
624 unsigned align_remainder = 0;
625 int info_align_carry = -1, info_align_zero = -1;
629 (void)lookahead_length;
632 EncoderSession_construct(
635 options.common.use_ogg,
639 options.common.verify,
640 options.common.treat_warnings_as_errors,
641 options.common.continue_through_decode_errors,
649 /* initialize default channel map that preserves channel order */
652 for(i = 0; i < sizeof(channel_map)/sizeof(channel_map[0]); i++)
656 if(options.foreign_metadata) {
658 if(!flac__foreign_metadata_read_from_wave(options.foreign_metadata, infilename, &error)) {
659 flac__utils_printf(stderr, 1, "%s: ERROR reading foreign metadata: %s\n", encoder_session.inbasefilename, error);
660 return EncoderSession_finish_error(&encoder_session);
665 * lookahead[] already has "RIFFxxxxWAVE", do sub-chunks
667 while(!feof(infile)) {
668 if(!read_little_endian_uint32(infile, &xx, true, encoder_session.inbasefilename))
669 return EncoderSession_finish_error(&encoder_session);
672 if(xx == 0x20746d66 && !got_fmt_chunk) { /* "fmt " */
673 unsigned block_align, data_bytes;
676 * http://www-mmsp.ece.mcgill.ca/Documents/AudioFormats/WAVE/WAVE.html
677 * http://windowssdk.msdn.microsoft.com/en-us/library/ms713497.aspx
678 * http://msdn.microsoft.com/library/default.asp?url=/library/en-us/audio_r/hh/Audio_r/aud-prop_d40f094e-44f9-4baa-8a15-03e4fb369501.xml.asp
681 * 4 byte: subchunk size
682 * 2 byte: format type: 1 for WAVE_FORMAT_PCM, 65534 for WAVE_FORMAT_EXTENSIBLE
684 * 4 byte: sample rate (Hz)
685 * 4 byte: avg bytes per sec
686 * 2 byte: block align
687 * 2 byte: bits per sample (not necessarily all significant)
689 * 2 byte: extension size in bytes (usually 0 for WAVEFORMATEX and 22 for WAVEFORMATEXTENSIBLE with PCM)
690 * WAVEFORMATEXTENSIBLE adds
691 * 2 byte: valid bits per sample
692 * 4 byte: channel mask
693 * 16 byte: subformat GUID, first 2 bytes have format type, 1 being PCM
695 * Current spec says WAVEFORMATEX with PCM must have bps == 8 or 16, or any multiple of 8 for WAVEFORMATEXTENSIBLE.
696 * Lots of old broken WAVEs/apps have don't follow it, e.g. 20 bps but a block align of 3/6 for mono/stereo.
698 * Block align for WAVE_FORMAT_PCM or WAVE_FORMAT_EXTENSIBLE is also supposed to be channels*bps/8
700 * If the channel mask has more set bits than # of channels, the extra MSBs are ignored.
701 * If the channel mask has less set bits than # of channels, the extra channels are unassigned to any speaker.
703 * Data is supposed to be unsigned for bps <= 8 else signed.
706 /* fmt sub-chunk size */
707 if(!read_little_endian_uint32(infile, &xx, false, encoder_session.inbasefilename))
708 return EncoderSession_finish_error(&encoder_session);
710 if(data_bytes < 16) {
711 flac__utils_printf(stderr, 1, "%s: ERROR: found non-standard 'fmt ' sub-chunk which has length = %u\n", encoder_session.inbasefilename, data_bytes);
712 return EncoderSession_finish_error(&encoder_session);
715 if(!read_little_endian_uint16(infile, &format, false, encoder_session.inbasefilename))
716 return EncoderSession_finish_error(&encoder_session);
717 if(format != 1 /*WAVE_FORMAT_PCM*/ && format != 65534 /*WAVE_FORMAT_EXTENSIBLE*/) {
718 flac__utils_printf(stderr, 1, "%s: ERROR: unsupported format type %u\n", encoder_session.inbasefilename, (unsigned)format);
719 return EncoderSession_finish_error(&encoder_session);
721 /* number of channels */
722 if(!read_little_endian_uint16(infile, &x, false, encoder_session.inbasefilename))
723 return EncoderSession_finish_error(&encoder_session);
724 channels = (unsigned)x;
725 if(channels == 0 || channels > FLAC__MAX_CHANNELS) {
726 flac__utils_printf(stderr, 1, "%s: ERROR: unsupported number of channels %u\n", encoder_session.inbasefilename, channels);
727 return EncoderSession_finish_error(&encoder_session);
729 else if(options.common.sector_align && channels != 2) {
730 flac__utils_printf(stderr, 1, "%s: ERROR: file has %u channels, must be 2 for --sector-align\n", encoder_session.inbasefilename, channels);
731 return EncoderSession_finish_error(&encoder_session);
734 if(!read_little_endian_uint32(infile, &xx, false, encoder_session.inbasefilename))
735 return EncoderSession_finish_error(&encoder_session);
737 if(!FLAC__format_sample_rate_is_valid(sample_rate)) {
738 flac__utils_printf(stderr, 1, "%s: ERROR: unsupported sample rate %u\n", encoder_session.inbasefilename, sample_rate);
739 return EncoderSession_finish_error(&encoder_session);
741 else if(options.common.sector_align && sample_rate != 44100) {
742 flac__utils_printf(stderr, 1, "%s: ERROR: file's sample rate is %u, must be 44100 for --sector-align\n", encoder_session.inbasefilename, sample_rate);
743 return EncoderSession_finish_error(&encoder_session);
745 /* avg bytes per second (ignored) */
746 if(!read_little_endian_uint32(infile, &xx, false, encoder_session.inbasefilename))
747 return EncoderSession_finish_error(&encoder_session);
749 if(!read_little_endian_uint16(infile, &x, false, encoder_session.inbasefilename))
750 return EncoderSession_finish_error(&encoder_session);
751 block_align = (unsigned)x;
752 /* bits per sample */
753 if(!read_little_endian_uint16(infile, &x, false, encoder_session.inbasefilename))
754 return EncoderSession_finish_error(&encoder_session);
756 is_unsigned_samples = (bps <= 8);
758 if(bps != 8 && bps != 16) {
759 if(bps == 24 || bps == 32) {
760 /* let these slide with a warning since they're unambiguous */
761 flac__utils_printf(stderr, 1, "%s: WARNING: legacy WAVE file has format type %u but bits-per-sample=%u\n", encoder_session.inbasefilename, (unsigned)format, bps);
762 if(encoder_session.treat_warnings_as_errors)
763 return EncoderSession_finish_error(&encoder_session);
766 /* @@@ we could add an option to specify left- or right-justified blocks so we knew how to set 'shift' */
767 flac__utils_printf(stderr, 1, "%s: ERROR: legacy WAVE file has format type %u but bits-per-sample=%u\n", encoder_session.inbasefilename, (unsigned)format, bps);
768 return EncoderSession_finish_error(&encoder_session);
771 #if 0 /* @@@ reinstate once we can get an answer about whether the samples are left- or right-justified */
772 if((bps+7)/8 * channels == block_align) {
774 /* assume legacy file is byte aligned with some LSBs zero; this is double-checked in format_input() */
775 flac__utils_printf(stderr, 1, "%s: WARNING: legacy WAVE file (format type %d) has block alignment=%u, bits-per-sample=%u, channels=%u\n", encoder_session.inbasefilename, (unsigned)format, block_align, bps, channels);
776 if(encoder_session.treat_warnings_as_errors)
777 return EncoderSession_finish_error(&encoder_session);
778 shift = 8 - (bps % 8);
785 flac__utils_printf(stderr, 1, "%s: ERROR: illegal WAVE file (format type %d) has block alignment=%u, bits-per-sample=%u, channels=%u\n", encoder_session.inbasefilename, (unsigned)format, block_align, bps, channels);
786 return EncoderSession_finish_error(&encoder_session);
791 if(channels > 2 && !options.common.channel_map_none) {
792 flac__utils_printf(stderr, 1, "%s: ERROR: WAVE has >2 channels but is not WAVE_FORMAT_EXTENSIBLE; cannot assign channels\n", encoder_session.inbasefilename);
793 return EncoderSession_finish_error(&encoder_session);
795 FLAC__ASSERT(data_bytes >= 16);
799 if(data_bytes < 40) {
800 flac__utils_printf(stderr, 1, "%s: ERROR: invalid WAVEFORMATEXTENSIBLE chunk with size %u\n", encoder_session.inbasefilename, data_bytes);
801 return EncoderSession_finish_error(&encoder_session);
804 if(!read_little_endian_uint16(infile, &x, false, encoder_session.inbasefilename))
805 return EncoderSession_finish_error(&encoder_session);
807 flac__utils_printf(stderr, 1, "%s: ERROR: invalid WAVEFORMATEXTENSIBLE chunk with cbSize %u\n", encoder_session.inbasefilename, (unsigned)x);
808 return EncoderSession_finish_error(&encoder_session);
811 if(!read_little_endian_uint16(infile, &x, false, encoder_session.inbasefilename))
812 return EncoderSession_finish_error(&encoder_session);
813 if((unsigned)x > bps) {
814 flac__utils_printf(stderr, 1, "%s: ERROR: invalid WAVEFORMATEXTENSIBLE chunk with wValidBitsPerSample (%u) > wBitsPerSample (%u)\n", encoder_session.inbasefilename, (unsigned)x, bps);
815 return EncoderSession_finish_error(&encoder_session);
817 shift = bps - (unsigned)x;
819 if(!read_little_endian_uint32(infile, &channel_mask, false, encoder_session.inbasefilename))
820 return EncoderSession_finish_error(&encoder_session);
821 /* for mono/stereo and unassigned channels, we fake the mask */
822 if(channel_mask == 0) {
824 channel_mask = 0x0001;
825 else if(channels == 2)
826 channel_mask = 0x0003;
828 /* set channel mapping */
829 /* FLAC order follows SMPTE and WAVEFORMATEXTENSIBLE but with fewer channels, which are: */
830 /* front left, front right, center, LFE, back left, back right, surround left, surround right */
831 /* the default mapping is sufficient for 1-6 channels and 7-8 are currently unspecified anyway */
833 /* @@@ example for dolby/vorbis order, for reference later in case it becomes important */
835 options.common.channel_map_none ||
836 channel_mask == 0x0001 || /* 1 channel: (mono) */
837 channel_mask == 0x0003 || /* 2 channels: front left, front right */
838 channel_mask == 0x0033 || /* 4 channels: front left, front right, back left, back right */
839 channel_mask == 0x0603 /* 4 channels: front left, front right, side left, side right */
841 /* keep default channel order */
844 channel_mask == 0x0007 || /* 3 channels: front left, front right, front center */
845 channel_mask == 0x0037 || /* 5 channels: front left, front right, front center, back left, back right */
846 channel_mask == 0x0607 /* 5 channels: front left, front right, front center, side left, side right */
848 /* to dolby order: front left, center, front right [, surround left, surround right ] */
853 channel_mask == 0x003f || /* 6 channels: front left, front right, front center, LFE, back left, back right */
854 channel_mask == 0x060f /* 6 channels: front left, front right, front center, LFE, side left, side right */
856 /* to dolby order: front left, center, front right, surround left, surround right, LFE */
865 options.common.channel_map_none ||
866 channel_mask == 0x0001 || /* 1 channel: (mono) */
867 channel_mask == 0x0003 || /* 2 channels: front left, front right */
868 channel_mask == 0x0007 || /* 3 channels: front left, front right, front center */
869 channel_mask == 0x0033 || /* 4 channels: front left, front right, back left, back right */
870 channel_mask == 0x0603 || /* 4 channels: front left, front right, side left, side right */
871 channel_mask == 0x0037 || /* 5 channels: front left, front right, front center, back left, back right */
872 channel_mask == 0x0607 || /* 5 channels: front left, front right, front center, side left, side right */
873 channel_mask == 0x003f || /* 6 channels: front left, front right, front center, LFE, back left, back right */
874 channel_mask == 0x060f /* 6 channels: front left, front right, front center, LFE, side left, side right */
876 /* keep default channel order */
880 flac__utils_printf(stderr, 1, "%s: ERROR: WAVEFORMATEXTENSIBLE chunk with unsupported channel mask=0x%04X\n", encoder_session.inbasefilename, (unsigned)channel_mask);
881 return EncoderSession_finish_error(&encoder_session);
883 if(!options.common.channel_map_none) {
884 if(count_channel_mask_bits(channel_mask) < channels) {
885 flac__utils_printf(stderr, 1, "%s: ERROR: WAVEFORMATEXTENSIBLE chunk: channel mask 0x%04X has unassigned channels (#channels=%u)\n", encoder_session.inbasefilename, (unsigned)channel_mask, channels);
886 return EncoderSession_finish_error(&encoder_session);
889 /* supporting this is too difficult with channel mapping; e.g. what if mask is 0x003f but #channels=4?
890 * there would be holes in the order that would have to be filled in, or the mask would have to be
891 * limited and the logic above rerun to see if it still fits into the FLAC mapping.
893 else if(count_channel_mask_bits(channel_mask) > channels)
894 channel_mask = limit_channel_mask(channel_mask, channels);
896 else if(count_channel_mask_bits(channel_mask) > channels) {
897 flac__utils_printf(stderr, 1, "%s: ERROR: WAVEFORMATEXTENSIBLE chunk: channel mask 0x%04X has extra bits for non-existant channels (#channels=%u)\n", encoder_session.inbasefilename, (unsigned)channel_mask, channels);
898 return EncoderSession_finish_error(&encoder_session);
902 /* first part of GUID */
903 if(!read_little_endian_uint16(infile, &x, false, encoder_session.inbasefilename))
904 return EncoderSession_finish_error(&encoder_session);
906 flac__utils_printf(stderr, 1, "%s: ERROR: unsupported WAVEFORMATEXTENSIBLE chunk with non-PCM format %u\n", encoder_session.inbasefilename, (unsigned)x);
907 return EncoderSession_finish_error(&encoder_session);
912 if(bps-shift < 4 || bps-shift > 24) {
913 flac__utils_printf(stderr, 1, "%s: ERROR: unsupported bits-per-sample %u\n", encoder_session.inbasefilename, bps-shift);
914 return EncoderSession_finish_error(&encoder_session);
916 else if(options.common.sector_align && bps-shift != 16) {
917 flac__utils_printf(stderr, 1, "%s: ERROR: file has %u bits-per-sample, must be 16 for --sector-align\n", encoder_session.inbasefilename, bps-shift);
918 return EncoderSession_finish_error(&encoder_session);
921 /* skip any extra data in the fmt sub-chunk */
922 if(!fskip_ahead(infile, data_bytes)) {
923 flac__utils_printf(stderr, 1, "%s: ERROR during read while skipping over extra 'fmt' data\n", encoder_session.inbasefilename);
924 return EncoderSession_finish_error(&encoder_session);
928 * now that we know the sample rate, canonicalize the
929 * --skip string to a number of samples:
931 flac__utils_canonicalize_skip_until_specification(&options.common.skip_specification, sample_rate);
932 FLAC__ASSERT(options.common.skip_specification.value.samples >= 0);
933 encoder_session.skip = (FLAC__uint64)options.common.skip_specification.value.samples;
934 FLAC__ASSERT(!options.common.sector_align || encoder_session.skip == 0);
936 got_fmt_chunk = true;
938 else if(xx == 0x61746164 && !got_data_chunk && got_fmt_chunk) { /* "data" */
939 FLAC__uint64 total_samples_in_input, trim = 0;
940 FLAC__bool pad = false;
941 const size_t bytes_per_wide_sample = channels * (bps >> 3);
945 if(!read_little_endian_uint32(infile, &xx, false, encoder_session.inbasefilename))
946 return EncoderSession_finish_error(&encoder_session);
947 if(options.common.ignore_chunk_sizes) {
948 FLAC__ASSERT(!options.common.sector_align);
949 data_bytes = (unsigned)(-(int)bytes_per_wide_sample); /* max out data_bytes; we'll use EOF as signal to stop reading */
953 if(0 == data_bytes) {
954 flac__utils_printf(stderr, 1, "%s: ERROR: 'data' subchunk has size of 0\n", encoder_session.inbasefilename);
955 return EncoderSession_finish_error(&encoder_session);
958 pad = (data_bytes & 1U) ? true : false;
960 /* *options.common.align_reservoir_samples will be 0 unless --sector-align is used */
961 FLAC__ASSERT(options.common.sector_align || *options.common.align_reservoir_samples == 0);
962 total_samples_in_input = data_bytes / bytes_per_wide_sample + *options.common.align_reservoir_samples;
965 * now that we know the input size, canonicalize the
966 * --until string to an absolute sample number:
968 if(!canonicalize_until_specification(&options.common.until_specification, encoder_session.inbasefilename, sample_rate, encoder_session.skip, total_samples_in_input))
969 return EncoderSession_finish_error(&encoder_session);
970 encoder_session.until = (FLAC__uint64)options.common.until_specification.value.samples;
971 FLAC__ASSERT(!options.common.sector_align || encoder_session.until == 0);
973 if(encoder_session.skip > 0) {
974 if(!fskip_ahead(infile, encoder_session.skip * bytes_per_wide_sample)) {
975 flac__utils_printf(stderr, 1, "%s: ERROR during read while skipping samples\n", encoder_session.inbasefilename);
976 return EncoderSession_finish_error(&encoder_session);
980 data_bytes -= (unsigned)encoder_session.skip * bytes_per_wide_sample; /*@@@ WATCHOUT: 4GB limit */
981 if(options.common.ignore_chunk_sizes) {
982 encoder_session.total_samples_to_encode = 0;
983 flac__utils_printf(stderr, 2, "(No runtime statistics possible; please wait for encoding to finish...)\n");
984 FLAC__ASSERT(0 == encoder_session.until);
987 encoder_session.total_samples_to_encode = total_samples_in_input - encoder_session.skip;
989 if(encoder_session.until > 0) {
990 trim = total_samples_in_input - encoder_session.until;
991 FLAC__ASSERT(total_samples_in_input > 0);
992 FLAC__ASSERT(!options.common.sector_align);
993 data_bytes -= (unsigned int)trim * bytes_per_wide_sample;
994 encoder_session.total_samples_to_encode -= trim;
996 if(options.common.sector_align) {
997 align_remainder = (unsigned)(encoder_session.total_samples_to_encode % 588);
998 if(options.common.is_last_file)
999 encoder_session.total_samples_to_encode += (588-align_remainder); /* will pad with zeroes */
1001 encoder_session.total_samples_to_encode -= align_remainder; /* will stop short and carry over to next file */
1004 /* +44 for the size of the WAV headers; this is just an estimate for the progress indicator and doesn't need to be exact */
1005 encoder_session.unencoded_size = encoder_session.total_samples_to_encode * bytes_per_wide_sample + 44;
1007 if(!EncoderSession_init_encoder(&encoder_session, options.common, channel_mask, channels, bps-shift, sample_rate, options.foreign_metadata, /*flac_decoder_data=*/0))
1008 return EncoderSession_finish_error(&encoder_session);
1011 * first do any samples in the reservoir
1013 if(options.common.sector_align && *options.common.align_reservoir_samples > 0) {
1014 if(!EncoderSession_process(&encoder_session, (const FLAC__int32 * const *)options.common.align_reservoir, *options.common.align_reservoir_samples)) {
1015 print_error_with_state(&encoder_session, "ERROR during encoding");
1016 return EncoderSession_finish_error(&encoder_session);
1021 * decrement the data_bytes counter if we need to align the file
1023 if(options.common.sector_align) {
1024 if(options.common.is_last_file) {
1025 *options.common.align_reservoir_samples = 0;
1028 *options.common.align_reservoir_samples = align_remainder;
1029 data_bytes -= (*options.common.align_reservoir_samples) * bytes_per_wide_sample;
1034 * now do from the file
1036 while(data_bytes > 0) {
1037 bytes_read = fread(ucbuffer_, sizeof(unsigned char), min(data_bytes, CHUNK_OF_SAMPLES * bytes_per_wide_sample), infile);
1038 if(bytes_read == 0) {
1039 if(ferror(infile)) {
1040 flac__utils_printf(stderr, 1, "%s: ERROR during read\n", encoder_session.inbasefilename);
1041 return EncoderSession_finish_error(&encoder_session);
1043 else if(feof(infile)) {
1044 if(options.common.ignore_chunk_sizes) {
1045 flac__utils_printf(stderr, 1, "%s: INFO: hit EOF with --ignore-chunk-sizes, got %u samples\n", encoder_session.inbasefilename, (unsigned)encoder_session.samples_written);
1048 flac__utils_printf(stderr, 1, "%s: WARNING: unexpected EOF; expected %u samples, got %u samples\n", encoder_session.inbasefilename, (unsigned)encoder_session.total_samples_to_encode, (unsigned)encoder_session.samples_written);
1049 if(encoder_session.treat_warnings_as_errors)
1050 return EncoderSession_finish_error(&encoder_session);
1056 if(bytes_read % bytes_per_wide_sample != 0) {
1057 flac__utils_printf(stderr, 1, "%s: ERROR: got partial sample\n", encoder_session.inbasefilename);
1058 return EncoderSession_finish_error(&encoder_session);
1061 unsigned wide_samples = bytes_read / bytes_per_wide_sample;
1062 if(!format_input(input_, wide_samples, /*is_big_endian=*/false, is_unsigned_samples, channels, bps, shift, channel_map))
1063 return EncoderSession_finish_error(&encoder_session);
1065 if(!EncoderSession_process(&encoder_session, (const FLAC__int32 * const *)input_, wide_samples)) {
1066 print_error_with_state(&encoder_session, "ERROR during encoding");
1067 return EncoderSession_finish_error(&encoder_session);
1069 data_bytes -= bytes_read;
1075 FLAC__ASSERT(!options.common.sector_align);
1076 if(!fskip_ahead(infile, trim * bytes_per_wide_sample)) {
1077 flac__utils_printf(stderr, 1, "%s: ERROR during read while skipping samples\n", encoder_session.inbasefilename);
1078 return EncoderSession_finish_error(&encoder_session);
1083 * now read unaligned samples into reservoir or pad with zeroes if necessary
1085 if(options.common.sector_align) {
1086 if(options.common.is_last_file) {
1087 unsigned wide_samples = 588 - align_remainder;
1088 if(wide_samples < 588) {
1091 info_align_zero = wide_samples;
1092 for(channel = 0; channel < channels; channel++)
1093 memset(input_[channel], 0, sizeof(input_[0][0]) * wide_samples);
1095 if(!EncoderSession_process(&encoder_session, (const FLAC__int32 * const *)input_, wide_samples)) {
1096 print_error_with_state(&encoder_session, "ERROR during encoding");
1097 return EncoderSession_finish_error(&encoder_session);
1102 if(*options.common.align_reservoir_samples > 0) {
1103 FLAC__ASSERT(CHUNK_OF_SAMPLES >= 588);
1104 bytes_read = fread(ucbuffer_, sizeof(unsigned char), (*options.common.align_reservoir_samples) * bytes_per_wide_sample, infile);
1105 if(bytes_read == 0 && ferror(infile)) {
1106 flac__utils_printf(stderr, 1, "%s: ERROR during read\n", encoder_session.inbasefilename);
1107 return EncoderSession_finish_error(&encoder_session);
1109 else if(bytes_read != (*options.common.align_reservoir_samples) * bytes_per_wide_sample) {
1110 flac__utils_printf(stderr, 1, "%s: WARNING: unexpected EOF; read %u bytes; expected %u samples, got %u samples\n", encoder_session.inbasefilename, (unsigned)bytes_read, (unsigned)encoder_session.total_samples_to_encode, (unsigned)encoder_session.samples_written);
1111 if(encoder_session.treat_warnings_as_errors)
1112 return EncoderSession_finish_error(&encoder_session);
1115 info_align_carry = *options.common.align_reservoir_samples;
1116 if(!format_input(options.common.align_reservoir, *options.common.align_reservoir_samples, /*is_big_endian=*/false, is_unsigned_samples, channels, bps, shift, channel_map))
1117 return EncoderSession_finish_error(&encoder_session);
1126 if(fread(&tmp, 1U, 1U, infile) < 1U) {
1127 flac__utils_printf(stderr, 1, "%s: ERROR during read of data pad byte\n", encoder_session.inbasefilename);
1128 return EncoderSession_finish_error(&encoder_session);
1132 got_data_chunk = true;
1135 if(xx == 0x61746164 && !got_fmt_chunk) { /* "data" */
1136 flac__utils_printf(stderr, 1, "%s: ERROR: got 'data' sub-chunk before 'fmt' sub-chunk\n", encoder_session.inbasefilename);
1137 return EncoderSession_finish_error(&encoder_session);
1140 if(!options.foreign_metadata) {
1141 if(xx == 0x20746d66 && got_fmt_chunk) /* "fmt " */
1142 flac__utils_printf(stderr, 1, "%s: WARNING: skipping extra 'fmt ' sub-chunk (use --keep-foreign-metadata to keep)\n", encoder_session.inbasefilename);
1143 else if(xx == 0x61746164) /* "data" */
1144 flac__utils_printf(stderr, 1, "%s: WARNING: skipping extra 'data' sub-chunk (use --keep-foreign-metadata to keep)\n", encoder_session.inbasefilename);
1146 flac__utils_printf(stderr, 1, "%s: WARNING: skipping unknown sub-chunk '%c%c%c%c' (use --keep-foreign-metadata to keep)\n", encoder_session.inbasefilename, (char)(xx&255), (char)((xx>>8)&255), (char)((xx>>16)&255), (char)(xx>>24));
1147 if(encoder_session.treat_warnings_as_errors)
1148 return EncoderSession_finish_error(&encoder_session);
1151 /* sub-chunk size */
1152 if(!read_little_endian_uint32(infile, &xx, false, encoder_session.inbasefilename))
1153 return EncoderSession_finish_error(&encoder_session);
1155 unsigned long skip = xx+(xx & 1U);
1157 FLAC__ASSERT(skip<=LONG_MAX);
1158 if(!fskip_ahead(infile, skip)) {
1159 flac__utils_printf(stderr, 1, "%s: ERROR during read while skipping over unsupported sub-chunk\n", encoder_session.inbasefilename);
1160 return EncoderSession_finish_error(&encoder_session);
1166 return EncoderSession_finish_ok(&encoder_session, info_align_carry, info_align_zero, options.foreign_metadata);
1169 int flac__encode_raw(FILE *infile, off_t infilesize, const char *infilename, const char *outfilename, const FLAC__byte *lookahead, unsigned lookahead_length, raw_encode_options_t options)
1171 EncoderSession encoder_session;
1173 const size_t bytes_per_wide_sample = options.channels * (options.bps >> 3);
1174 unsigned align_remainder = 0;
1175 int info_align_carry = -1, info_align_zero = -1;
1176 FLAC__uint64 total_samples_in_input = 0;
1178 FLAC__ASSERT(!options.common.sector_align || options.channels == 2);
1179 FLAC__ASSERT(!options.common.sector_align || options.bps == 16);
1180 FLAC__ASSERT(!options.common.sector_align || options.sample_rate == 44100);
1181 FLAC__ASSERT(!options.common.sector_align || infilesize >= 0);
1182 FLAC__ASSERT(!options.common.replay_gain || options.channels <= 2);
1183 FLAC__ASSERT(!options.common.replay_gain || grabbag__replaygain_is_valid_sample_frequency(options.sample_rate));
1186 EncoderSession_construct(
1189 options.common.use_ogg,
1193 options.common.verify,
1194 options.common.treat_warnings_as_errors,
1195 options.common.continue_through_decode_errors,
1204 * now that we know the sample rate, canonicalize the
1205 * --skip string to a number of samples:
1207 flac__utils_canonicalize_skip_until_specification(&options.common.skip_specification, options.sample_rate);
1208 FLAC__ASSERT(options.common.skip_specification.value.samples >= 0);
1209 encoder_session.skip = (FLAC__uint64)options.common.skip_specification.value.samples;
1210 FLAC__ASSERT(!options.common.sector_align || encoder_session.skip == 0);
1213 total_samples_in_input = 0;
1215 /* *options.common.align_reservoir_samples will be 0 unless --sector-align is used */
1216 FLAC__ASSERT(options.common.sector_align || *options.common.align_reservoir_samples == 0);
1217 total_samples_in_input = (FLAC__uint64)infilesize / bytes_per_wide_sample + *options.common.align_reservoir_samples;
1221 * now that we know the input size, canonicalize the
1222 * --until strings to a number of samples:
1224 if(!canonicalize_until_specification(&options.common.until_specification, encoder_session.inbasefilename, options.sample_rate, encoder_session.skip, total_samples_in_input))
1225 return EncoderSession_finish_error(&encoder_session);
1226 encoder_session.until = (FLAC__uint64)options.common.until_specification.value.samples;
1227 FLAC__ASSERT(!options.common.sector_align || encoder_session.until == 0);
1229 infilesize -= (off_t)encoder_session.skip * bytes_per_wide_sample;
1230 encoder_session.total_samples_to_encode = total_samples_in_input - encoder_session.skip;
1231 if(encoder_session.until > 0) {
1232 const FLAC__uint64 trim = total_samples_in_input - encoder_session.until;
1233 FLAC__ASSERT(total_samples_in_input > 0);
1234 FLAC__ASSERT(!options.common.sector_align);
1235 infilesize -= (off_t)trim * bytes_per_wide_sample;
1236 encoder_session.total_samples_to_encode -= trim;
1238 if(infilesize >= 0 && options.common.sector_align) {
1239 FLAC__ASSERT(encoder_session.skip == 0);
1240 align_remainder = (unsigned)(encoder_session.total_samples_to_encode % 588);
1241 if(options.common.is_last_file)
1242 encoder_session.total_samples_to_encode += (588-align_remainder); /* will pad with zeroes */
1244 encoder_session.total_samples_to_encode -= align_remainder; /* will stop short and carry over to next file */
1246 encoder_session.unencoded_size = encoder_session.total_samples_to_encode * bytes_per_wide_sample;
1248 if(encoder_session.total_samples_to_encode <= 0)
1249 flac__utils_printf(stderr, 2, "(No runtime statistics possible; please wait for encoding to finish...)\n");
1251 if(encoder_session.skip > 0) {
1252 unsigned skip_bytes = bytes_per_wide_sample * (unsigned)encoder_session.skip;
1253 if(skip_bytes > lookahead_length) {
1254 skip_bytes -= lookahead_length;
1255 lookahead_length = 0;
1256 if(!fskip_ahead(infile, skip_bytes)) {
1257 flac__utils_printf(stderr, 1, "%s: ERROR during read while skipping samples\n", encoder_session.inbasefilename);
1258 return EncoderSession_finish_error(&encoder_session);
1262 lookahead += skip_bytes;
1263 lookahead_length -= skip_bytes;
1267 if(!EncoderSession_init_encoder(&encoder_session, options.common, /*channel_mask=*/0, options.channels, options.bps, options.sample_rate, /*foreign_metadata=*/0, /*flac_decoder_data=*/0))
1268 return EncoderSession_finish_error(&encoder_session);
1271 * first do any samples in the reservoir
1273 if(options.common.sector_align && *options.common.align_reservoir_samples > 0) {
1274 if(!EncoderSession_process(&encoder_session, (const FLAC__int32 * const *)options.common.align_reservoir, *options.common.align_reservoir_samples)) {
1275 print_error_with_state(&encoder_session, "ERROR during encoding");
1276 return EncoderSession_finish_error(&encoder_session);
1281 * decrement infilesize if we need to align the file
1283 if(options.common.sector_align) {
1284 FLAC__ASSERT(infilesize >= 0);
1285 if(options.common.is_last_file) {
1286 *options.common.align_reservoir_samples = 0;
1289 *options.common.align_reservoir_samples = align_remainder;
1290 infilesize -= (off_t)((*options.common.align_reservoir_samples) * bytes_per_wide_sample);
1291 FLAC__ASSERT(infilesize >= 0);
1296 * now do from the file
1298 if(infilesize < 0) {
1299 while(!feof(infile)) {
1300 if(lookahead_length > 0) {
1301 FLAC__ASSERT(lookahead_length < CHUNK_OF_SAMPLES * bytes_per_wide_sample);
1302 memcpy(ucbuffer_, lookahead, lookahead_length);
1303 bytes_read = fread(ucbuffer_+lookahead_length, sizeof(unsigned char), CHUNK_OF_SAMPLES * bytes_per_wide_sample - lookahead_length, infile) + lookahead_length;
1304 if(ferror(infile)) {
1305 flac__utils_printf(stderr, 1, "%s: ERROR during read\n", encoder_session.inbasefilename);
1306 return EncoderSession_finish_error(&encoder_session);
1308 lookahead_length = 0;
1311 bytes_read = fread(ucbuffer_, sizeof(unsigned char), CHUNK_OF_SAMPLES * bytes_per_wide_sample, infile);
1313 if(bytes_read == 0) {
1314 if(ferror(infile)) {
1315 flac__utils_printf(stderr, 1, "%s: ERROR during read\n", encoder_session.inbasefilename);
1316 return EncoderSession_finish_error(&encoder_session);
1319 else if(bytes_read % bytes_per_wide_sample != 0) {
1320 flac__utils_printf(stderr, 1, "%s: ERROR: got partial sample\n", encoder_session.inbasefilename);
1321 return EncoderSession_finish_error(&encoder_session);
1324 unsigned wide_samples = bytes_read / bytes_per_wide_sample;
1325 if(!format_input(input_, wide_samples, options.is_big_endian, options.is_unsigned_samples, options.channels, options.bps, /*shift=*/0, /*channel_map=*/0))
1326 return EncoderSession_finish_error(&encoder_session);
1328 if(!EncoderSession_process(&encoder_session, (const FLAC__int32 * const *)input_, wide_samples)) {
1329 print_error_with_state(&encoder_session, "ERROR during encoding");
1330 return EncoderSession_finish_error(&encoder_session);
1336 const FLAC__uint64 max_input_bytes = infilesize;
1337 FLAC__uint64 total_input_bytes_read = 0;
1338 while(total_input_bytes_read < max_input_bytes) {
1340 size_t wanted = (CHUNK_OF_SAMPLES * bytes_per_wide_sample);
1341 wanted = (size_t) min((FLAC__uint64)wanted, max_input_bytes - total_input_bytes_read);
1343 if(lookahead_length > 0) {
1344 FLAC__ASSERT(lookahead_length <= wanted);
1345 memcpy(ucbuffer_, lookahead, lookahead_length);
1346 wanted -= lookahead_length;
1347 bytes_read = lookahead_length;
1349 bytes_read += fread(ucbuffer_+lookahead_length, sizeof(unsigned char), wanted, infile);
1350 if(ferror(infile)) {
1351 flac__utils_printf(stderr, 1, "%s: ERROR during read\n", encoder_session.inbasefilename);
1352 return EncoderSession_finish_error(&encoder_session);
1355 lookahead_length = 0;
1358 bytes_read = fread(ucbuffer_, sizeof(unsigned char), wanted, infile);
1361 if(bytes_read == 0) {
1362 if(ferror(infile)) {
1363 flac__utils_printf(stderr, 1, "%s: ERROR during read\n", encoder_session.inbasefilename);
1364 return EncoderSession_finish_error(&encoder_session);
1366 else if(feof(infile)) {
1367 flac__utils_printf(stderr, 1, "%s: WARNING: unexpected EOF; expected %u samples, got %u samples\n", encoder_session.inbasefilename, (unsigned)encoder_session.total_samples_to_encode, (unsigned)encoder_session.samples_written);
1368 if(encoder_session.treat_warnings_as_errors)
1369 return EncoderSession_finish_error(&encoder_session);
1370 total_input_bytes_read = max_input_bytes;
1374 if(bytes_read % bytes_per_wide_sample != 0) {
1375 flac__utils_printf(stderr, 1, "%s: ERROR: got partial sample\n", encoder_session.inbasefilename);
1376 return EncoderSession_finish_error(&encoder_session);
1379 unsigned wide_samples = bytes_read / bytes_per_wide_sample;
1380 if(!format_input(input_, wide_samples, options.is_big_endian, options.is_unsigned_samples, options.channels, options.bps, /*shift=*/0, /*channel_map=*/0))
1381 return EncoderSession_finish_error(&encoder_session);
1383 if(!EncoderSession_process(&encoder_session, (const FLAC__int32 * const *)input_, wide_samples)) {
1384 print_error_with_state(&encoder_session, "ERROR during encoding");
1385 return EncoderSession_finish_error(&encoder_session);
1387 total_input_bytes_read += bytes_read;
1394 * now read unaligned samples into reservoir or pad with zeroes if necessary
1396 if(options.common.sector_align) {
1397 if(options.common.is_last_file) {
1398 unsigned wide_samples = 588 - align_remainder;
1399 if(wide_samples < 588) {
1402 info_align_zero = wide_samples;
1403 for(channel = 0; channel < options.channels; channel++)
1404 memset(input_[channel], 0, sizeof(input_[0][0]) * wide_samples);
1406 if(!EncoderSession_process(&encoder_session, (const FLAC__int32 * const *)input_, wide_samples)) {
1407 print_error_with_state(&encoder_session, "ERROR during encoding");
1408 return EncoderSession_finish_error(&encoder_session);
1413 if(*options.common.align_reservoir_samples > 0) {
1414 FLAC__ASSERT(CHUNK_OF_SAMPLES >= 588);
1415 bytes_read = fread(ucbuffer_, sizeof(unsigned char), (*options.common.align_reservoir_samples) * bytes_per_wide_sample, infile);
1416 if(bytes_read == 0 && ferror(infile)) {
1417 flac__utils_printf(stderr, 1, "%s: ERROR during read\n", encoder_session.inbasefilename);
1418 return EncoderSession_finish_error(&encoder_session);
1420 else if(bytes_read != (*options.common.align_reservoir_samples) * bytes_per_wide_sample) {
1421 flac__utils_printf(stderr, 1, "%s: WARNING: unexpected EOF; read %u bytes; expected %u samples, got %u samples\n", encoder_session.inbasefilename, (unsigned)bytes_read, (unsigned)encoder_session.total_samples_to_encode, (unsigned)encoder_session.samples_written);
1422 if(encoder_session.treat_warnings_as_errors)
1423 return EncoderSession_finish_error(&encoder_session);
1426 info_align_carry = *options.common.align_reservoir_samples;
1427 if(!format_input(options.common.align_reservoir, *options.common.align_reservoir_samples, options.is_big_endian, options.is_unsigned_samples, options.channels, options.bps, /*shift=*/0, /*channel_map=*/0))
1428 return EncoderSession_finish_error(&encoder_session);
1434 return EncoderSession_finish_ok(&encoder_session, info_align_carry, info_align_zero, /*foreign_metadata=*/0);
1437 int flac__encode_flac(FILE *infile, off_t infilesize, const char *infilename, const char *outfilename, const FLAC__byte *lookahead, unsigned lookahead_length, flac_encode_options_t options, FLAC__bool input_is_ogg)
1439 EncoderSession encoder_session;
1440 FLAC__StreamDecoder *decoder = 0;
1441 FLACDecoderData decoder_data;
1446 EncoderSession_construct(
1449 options.common.use_ogg,
1453 options.common.verify,
1454 options.common.treat_warnings_as_errors,
1455 options.common.continue_through_decode_errors,
1463 decoder_data.encoder_session = &encoder_session;
1464 decoder_data.filesize = (infilesize == (off_t)(-1)? 0 : infilesize);
1465 decoder_data.lookahead = lookahead;
1466 decoder_data.lookahead_length = lookahead_length;
1467 decoder_data.num_metadata_blocks = 0;
1468 decoder_data.samples_left_to_process = 0;
1469 decoder_data.fatal_error = false;
1472 * set up FLAC decoder for the input
1474 if (0 == (decoder = FLAC__stream_decoder_new())) {
1475 flac__utils_printf(stderr, 1, "%s: ERROR: creating decoder for FLAC input\n", encoder_session.inbasefilename);
1476 return EncoderSession_finish_error(&encoder_session);
1479 FLAC__stream_decoder_set_md5_checking(decoder, false) &&
1480 FLAC__stream_decoder_set_metadata_respond_all(decoder)
1482 flac__utils_printf(stderr, 1, "%s: ERROR: setting up decoder for FLAC input\n", encoder_session.inbasefilename);
1483 goto fubar1; /*@@@ yuck */
1487 if (FLAC__stream_decoder_init_ogg_stream(decoder, flac_decoder_read_callback, flac_decoder_seek_callback, flac_decoder_tell_callback, flac_decoder_length_callback, flac_decoder_eof_callback, flac_decoder_write_callback, flac_decoder_metadata_callback, flac_decoder_error_callback, /*client_data=*/&decoder_data) != FLAC__STREAM_DECODER_INIT_STATUS_OK) {
1488 flac__utils_printf(stderr, 1, "%s: ERROR: initializing decoder for Ogg FLAC input, state = %s\n", encoder_session.inbasefilename, FLAC__stream_decoder_get_resolved_state_string(decoder));
1489 goto fubar1; /*@@@ yuck */
1492 else if (FLAC__stream_decoder_init_stream(decoder, flac_decoder_read_callback, flac_decoder_seek_callback, flac_decoder_tell_callback, flac_decoder_length_callback, flac_decoder_eof_callback, flac_decoder_write_callback, flac_decoder_metadata_callback, flac_decoder_error_callback, /*client_data=*/&decoder_data) != FLAC__STREAM_DECODER_INIT_STATUS_OK) {
1493 flac__utils_printf(stderr, 1, "%s: ERROR: initializing decoder for FLAC input, state = %s\n", encoder_session.inbasefilename, FLAC__stream_decoder_get_resolved_state_string(decoder));
1494 goto fubar1; /*@@@ yuck */
1497 if (!FLAC__stream_decoder_process_until_end_of_metadata(decoder) || decoder_data.fatal_error) {
1498 if (decoder_data.fatal_error)
1499 flac__utils_printf(stderr, 1, "%s: ERROR: out of memory or too many metadata blocks while reading metadata in FLAC input\n", encoder_session.inbasefilename);
1501 flac__utils_printf(stderr, 1, "%s: ERROR: reading metadata in FLAC input, state = %s\n", encoder_session.inbasefilename, FLAC__stream_decoder_get_resolved_state_string(decoder));
1502 goto fubar1; /*@@@ yuck */
1505 if (decoder_data.num_metadata_blocks == 0) {
1506 flac__utils_printf(stderr, 1, "%s: ERROR: reading metadata in FLAC input, got no metadata blocks\n", encoder_session.inbasefilename);
1507 goto fubar2; /*@@@ yuck */
1509 else if (decoder_data.metadata_blocks[0]->type != FLAC__METADATA_TYPE_STREAMINFO) {
1510 flac__utils_printf(stderr, 1, "%s: ERROR: reading metadata in FLAC input, first metadata block is not STREAMINFO\n", encoder_session.inbasefilename);
1511 goto fubar2; /*@@@ yuck */
1513 else if (decoder_data.metadata_blocks[0]->data.stream_info.total_samples == 0) {
1514 flac__utils_printf(stderr, 1, "%s: ERROR: FLAC input has STREAMINFO with unknown total samples which is not supported\n", encoder_session.inbasefilename);
1515 goto fubar2; /*@@@ yuck */
1519 * now that we have the STREAMINFO and know the sample rate,
1520 * canonicalize the --skip string to a number of samples:
1522 flac__utils_canonicalize_skip_until_specification(&options.common.skip_specification, decoder_data.metadata_blocks[0]->data.stream_info.sample_rate);
1523 FLAC__ASSERT(options.common.skip_specification.value.samples >= 0);
1524 encoder_session.skip = (FLAC__uint64)options.common.skip_specification.value.samples;
1525 FLAC__ASSERT(!options.common.sector_align); /* --sector-align with FLAC input is not supported */
1528 FLAC__uint64 total_samples_in_input, trim = 0;
1530 total_samples_in_input = decoder_data.metadata_blocks[0]->data.stream_info.total_samples;
1533 * now that we know the input size, canonicalize the
1534 * --until string to an absolute sample number:
1536 if(!canonicalize_until_specification(&options.common.until_specification, encoder_session.inbasefilename, decoder_data.metadata_blocks[0]->data.stream_info.sample_rate, encoder_session.skip, total_samples_in_input))
1537 goto fubar2; /*@@@ yuck */
1538 encoder_session.until = (FLAC__uint64)options.common.until_specification.value.samples;
1540 encoder_session.total_samples_to_encode = total_samples_in_input - encoder_session.skip;
1541 if(encoder_session.until > 0) {
1542 trim = total_samples_in_input - encoder_session.until;
1543 FLAC__ASSERT(total_samples_in_input > 0);
1544 encoder_session.total_samples_to_encode -= trim;
1547 encoder_session.unencoded_size = decoder_data.filesize;
1549 /* (channel mask will get copied over from the source VORBIS_COMMENT if it exists) */
1550 if(!EncoderSession_init_encoder(&encoder_session, options.common, /*channel_mask=*/0, decoder_data.metadata_blocks[0]->data.stream_info.channels, decoder_data.metadata_blocks[0]->data.stream_info.bits_per_sample, decoder_data.metadata_blocks[0]->data.stream_info.sample_rate, /*foreign_metadata=*/0, &decoder_data))
1551 goto fubar2; /*@@@ yuck */
1554 * have to wait until the FLAC encoder is set up for writing
1555 * before any seeking in the input FLAC file, because the seek
1556 * itself will usually call the decoder's write callback, and
1557 * our decoder's write callback passes samples to our FLAC
1560 decoder_data.samples_left_to_process = encoder_session.total_samples_to_encode;
1561 if(encoder_session.skip > 0) {
1562 if(!FLAC__stream_decoder_seek_absolute(decoder, encoder_session.skip)) {
1563 flac__utils_printf(stderr, 1, "%s: ERROR while skipping samples, FLAC decoder state = %s\n", encoder_session.inbasefilename, FLAC__stream_decoder_get_resolved_state_string(decoder));
1564 goto fubar2; /*@@@ yuck */
1569 * now do samples from the file
1571 while(!decoder_data.fatal_error && decoder_data.samples_left_to_process > 0) {
1572 /* We can also hit the end of stream without samples_left_to_process
1573 * going to 0 if there are errors and continue_through_decode_errors
1574 * is on, so we want to break in that case too:
1576 if(encoder_session.continue_through_decode_errors && FLAC__stream_decoder_get_state(decoder) == FLAC__STREAM_DECODER_END_OF_STREAM)
1578 if(!FLAC__stream_decoder_process_single(decoder)) {
1579 flac__utils_printf(stderr, 1, "%s: ERROR: while decoding FLAC input, state = %s\n", encoder_session.inbasefilename, FLAC__stream_decoder_get_resolved_state_string(decoder));
1580 goto fubar2; /*@@@ yuck */
1583 if(decoder_data.fatal_error) {
1584 flac__utils_printf(stderr, 1, "%s: ERROR: while decoding FLAC input, state = %s\n", encoder_session.inbasefilename, FLAC__stream_decoder_get_resolved_state_string(decoder));
1585 goto fubar2; /*@@@ yuck */
1589 FLAC__stream_decoder_delete(decoder);
1590 retval = EncoderSession_finish_ok(&encoder_session, -1, -1, /*foreign_metadata=*/0);
1591 /* have to wail until encoder is completely finished before deleting because of the final step of writing the seekpoint offsets */
1592 for(i = 0; i < decoder_data.num_metadata_blocks; i++)
1593 FLAC__metadata_object_delete(decoder_data.metadata_blocks[i]);
1597 for(i = 0; i < decoder_data.num_metadata_blocks; i++)
1598 FLAC__metadata_object_delete(decoder_data.metadata_blocks[i]);
1600 FLAC__stream_decoder_delete(decoder);
1601 return EncoderSession_finish_error(&encoder_session);
1604 FLAC__bool EncoderSession_construct(EncoderSession *e, FLAC__bool use_ogg, FLAC__bool verify, FLAC__bool treat_warnings_as_errors, FLAC__bool continue_through_decode_errors, FILE *infile, const char *infilename, const char *outfilename)
1607 FLAC__uint32 test = 1;
1610 * initialize globals
1613 is_big_endian_host_ = (*((FLAC__byte*)(&test)))? false : true;
1615 for(i = 0; i < FLAC__MAX_CHANNELS; i++)
1616 input_[i] = &(in_[i][0]);
1620 * initialize instance
1624 e->use_ogg = use_ogg;
1629 e->treat_warnings_as_errors = treat_warnings_as_errors;
1630 e->continue_through_decode_errors = continue_through_decode_errors;
1632 e->is_stdout = (0 == strcmp(outfilename, "-"));
1633 e->outputfile_opened = false;
1635 e->inbasefilename = grabbag__file_get_basename(infilename);
1636 e->infilename = infilename;
1637 e->outfilename = outfilename;
1639 e->skip = 0; /* filled in later after the sample_rate is known */
1640 e->unencoded_size = 0;
1641 e->total_samples_to_encode = 0;
1642 e->bytes_written = 0;
1643 e->samples_written = 0;
1649 e->seek_table_template = 0;
1651 if(0 == (e->seek_table_template = FLAC__metadata_object_new(FLAC__METADATA_TYPE_SEEKTABLE))) {
1652 flac__utils_printf(stderr, 1, "%s: ERROR allocating memory for seek table\n", e->inbasefilename);
1656 e->encoder = FLAC__stream_encoder_new();
1657 if(0 == e->encoder) {
1658 flac__utils_printf(stderr, 1, "%s: ERROR creating the encoder instance\n", e->inbasefilename);
1659 EncoderSession_destroy(e);
1666 void EncoderSession_destroy(EncoderSession *e)
1671 if(0 != e->encoder) {
1672 FLAC__stream_encoder_delete(e->encoder);
1676 if(0 != e->seek_table_template) {
1677 FLAC__metadata_object_delete(e->seek_table_template);
1678 e->seek_table_template = 0;
1682 int EncoderSession_finish_ok(EncoderSession *e, int info_align_carry, int info_align_zero, foreign_metadata_t *foreign_metadata)
1684 FLAC__StreamEncoderState fse_state = FLAC__STREAM_ENCODER_OK;
1686 FLAC__bool verify_error = false;
1689 fse_state = FLAC__stream_encoder_get_state(e->encoder);
1690 ret = FLAC__stream_encoder_finish(e->encoder)? 0 : 1;
1692 fse_state == FLAC__STREAM_ENCODER_VERIFY_MISMATCH_IN_AUDIO_DATA ||
1693 FLAC__stream_encoder_get_state(e->encoder) == FLAC__STREAM_ENCODER_VERIFY_MISMATCH_IN_AUDIO_DATA
1696 /* all errors except verify errors should interrupt the stats */
1697 if(ret && !verify_error)
1698 print_error_with_state(e, "ERROR during encoding");
1699 else if(e->total_samples_to_encode > 0) {
1701 flac__utils_printf(stderr, 2, "\n");
1705 print_verify_error(e);
1709 if(info_align_carry >= 0) {
1710 flac__utils_printf(stderr, 1, "%s: INFO: sector alignment causing %d samples to be carried over\n", e->inbasefilename, info_align_carry);
1712 if(info_align_zero >= 0) {
1713 flac__utils_printf(stderr, 1, "%s: INFO: sector alignment causing %d zero samples to be appended\n", e->inbasefilename, info_align_zero);
1717 /*@@@@@@ should this go here or somewhere else? */
1718 if(ret == 0 && foreign_metadata) {
1720 if(!flac__foreign_metadata_write_to_flac(foreign_metadata, e->infilename, e->outfilename, &error)) {
1721 flac__utils_printf(stderr, 1, "%s: ERROR: updating foreign metadata in FLAC file: %s\n", e->inbasefilename, error);
1726 EncoderSession_destroy(e);
1731 int EncoderSession_finish_error(EncoderSession *e)
1733 FLAC__ASSERT(e->encoder);
1735 if(e->total_samples_to_encode > 0)
1736 flac__utils_printf(stderr, 2, "\n");
1738 if(FLAC__stream_encoder_get_state(e->encoder) == FLAC__STREAM_ENCODER_VERIFY_MISMATCH_IN_AUDIO_DATA)
1739 print_verify_error(e);
1740 else if(e->outputfile_opened)
1741 /* only want to delete the file if we opened it; otherwise it could be an existing file and our overwrite failed */
1742 unlink(e->outfilename);
1744 EncoderSession_destroy(e);
1750 unsigned num_metadata;
1751 FLAC__bool *needs_delete;
1752 FLAC__StreamMetadata **metadata;
1753 FLAC__StreamMetadata *cuesheet; /* always needs to be deleted */
1754 } static_metadata_t;
1756 static void static_metadata_init(static_metadata_t *m)
1758 m->num_metadata = 0;
1759 m->needs_delete = 0;
1764 static void static_metadata_clear(static_metadata_t *m)
1767 for(i = 0; i < m->num_metadata; i++)
1768 if(m->needs_delete[i])
1769 FLAC__metadata_object_delete(m->metadata[i]);
1773 free(m->needs_delete);
1775 FLAC__metadata_object_delete(m->cuesheet);
1776 static_metadata_init(m);
1779 static FLAC__bool static_metadata_append(static_metadata_t *m, FLAC__StreamMetadata *d, FLAC__bool needs_delete)
1782 if(0 == (x = safe_realloc_muladd2_(m->metadata, sizeof(*m->metadata), /*times (*/m->num_metadata, /*+*/1/*)*/)))
1784 m->metadata = (FLAC__StreamMetadata**)x;
1785 if(0 == (x = safe_realloc_muladd2_(m->needs_delete, sizeof(*m->needs_delete), /*times (*/m->num_metadata, /*+*/1/*)*/)))
1787 m->needs_delete = (FLAC__bool*)x;
1788 m->metadata[m->num_metadata] = d;
1789 m->needs_delete[m->num_metadata] = needs_delete;
1794 FLAC__bool EncoderSession_init_encoder(EncoderSession *e, encode_options_t options, FLAC__uint32 channel_mask, unsigned channels, unsigned bps, unsigned sample_rate, const foreign_metadata_t *foreign_metadata, FLACDecoderData *flac_decoder_data)
1796 FLAC__StreamMetadata padding;
1797 FLAC__StreamMetadata **metadata = 0;
1798 static_metadata_t static_metadata;
1799 unsigned num_metadata = 0, i;
1800 FLAC__StreamEncoderInitStatus init_status;
1801 const FLAC__bool is_cdda = (channels == 1 || channels == 2) && (bps == 16) && (sample_rate == 44100);
1802 char apodizations[2000];
1804 FLAC__ASSERT(sizeof(options.pictures)/sizeof(options.pictures[0]) <= 64);
1806 static_metadata_init(&static_metadata);
1808 e->replay_gain = options.replay_gain;
1809 e->channels = channels;
1810 e->bits_per_sample = bps;
1811 e->sample_rate = sample_rate;
1813 apodizations[0] = '\0';
1815 if(e->replay_gain) {
1816 if(channels != 1 && channels != 2) {
1817 flac__utils_printf(stderr, 1, "%s: ERROR, number of channels (%u) must be 1 or 2 for --replay-gain\n", e->inbasefilename, channels);
1820 if(!grabbag__replaygain_is_valid_sample_frequency(sample_rate)) {
1821 flac__utils_printf(stderr, 1, "%s: ERROR, invalid sample rate (%u) for --replay-gain\n", e->inbasefilename, sample_rate);
1824 if(options.is_first_file) {
1825 if(!grabbag__replaygain_init(sample_rate)) {
1826 flac__utils_printf(stderr, 1, "%s: ERROR initializing ReplayGain stage\n", e->inbasefilename);
1832 if(!parse_cuesheet(&static_metadata.cuesheet, options.cuesheet_filename, e->inbasefilename, is_cdda, e->total_samples_to_encode, e->treat_warnings_as_errors))
1835 if(!convert_to_seek_table_template(options.requested_seek_points, options.num_requested_seek_points, options.cued_seekpoints? static_metadata.cuesheet : 0, e)) {
1836 flac__utils_printf(stderr, 1, "%s: ERROR allocating memory for seek table\n", e->inbasefilename);
1837 static_metadata_clear(&static_metadata);
1841 /* build metadata */
1842 if(flac_decoder_data) {
1844 * we're encoding from FLAC so we will use the FLAC file's
1845 * metadata as the basis for the encoded file
1849 * first handle pictures: simple append any --pictures
1852 for(i = 0; i < options.num_pictures; i++) {
1853 FLAC__StreamMetadata *pic = FLAC__metadata_object_clone(options.pictures[i]);
1855 flac__utils_printf(stderr, 1, "%s: ERROR allocating memory for PICTURE block\n", e->inbasefilename);
1856 static_metadata_clear(&static_metadata);
1859 flac_decoder_data->metadata_blocks[flac_decoder_data->num_metadata_blocks++] = pic;
1864 * next handle vorbis comment: if any tags were specified
1865 * or there is no existing vorbis comment, we create a
1866 * new vorbis comment (discarding any existing one); else
1867 * we keep the existing one. also need to make sure to
1868 * propagate any channel mask tag.
1870 /* @@@ change to append -T values from options.vorbis_comment if input has VC already? */
1872 FLAC__bool vc_found = false;
1873 for(i = 0, j = 0; i < flac_decoder_data->num_metadata_blocks; i++) {
1874 if(flac_decoder_data->metadata_blocks[i]->type == FLAC__METADATA_TYPE_VORBIS_COMMENT)
1876 if(flac_decoder_data->metadata_blocks[i]->type == FLAC__METADATA_TYPE_VORBIS_COMMENT && options.vorbis_comment->data.vorbis_comment.num_comments > 0) {
1877 (void) flac__utils_get_channel_mask_tag(flac_decoder_data->metadata_blocks[i], &channel_mask);
1878 flac__utils_printf(stderr, 1, "%s: WARNING, replacing tags from input FLAC file with those given on the command-line\n", e->inbasefilename);
1879 if(e->treat_warnings_as_errors) {
1880 static_metadata_clear(&static_metadata);
1883 FLAC__metadata_object_delete(flac_decoder_data->metadata_blocks[i]);
1884 flac_decoder_data->metadata_blocks[i] = 0;
1887 flac_decoder_data->metadata_blocks[j++] = flac_decoder_data->metadata_blocks[i];
1889 flac_decoder_data->num_metadata_blocks = j;
1890 if((!vc_found || options.vorbis_comment->data.vorbis_comment.num_comments > 0) && flac_decoder_data->num_metadata_blocks < sizeof(flac_decoder_data->metadata_blocks)/sizeof(flac_decoder_data->metadata_blocks[0])) {
1892 FLAC__StreamMetadata *vc = FLAC__metadata_object_clone(options.vorbis_comment);
1893 if(0 == vc || (channel_mask && !flac__utils_set_channel_mask_tag(vc, channel_mask))) {
1894 flac__utils_printf(stderr, 1, "%s: ERROR allocating memory for VORBIS_COMMENT block\n", e->inbasefilename);
1895 static_metadata_clear(&static_metadata);
1898 for(i = flac_decoder_data->num_metadata_blocks; i > 1; i--)
1899 flac_decoder_data->metadata_blocks[i] = flac_decoder_data->metadata_blocks[i-1];
1900 flac_decoder_data->metadata_blocks[1] = vc;
1901 flac_decoder_data->num_metadata_blocks++;
1906 * next handle cuesheet: if --cuesheet was specified, use
1907 * it; else if file has existing CUESHEET and cuesheet's
1908 * lead-out offset is correct, keep it; else no CUESHEET
1911 for(i = 0, j = 0; i < flac_decoder_data->num_metadata_blocks; i++) {
1912 FLAC__bool existing_cuesheet_is_bad = false;
1913 /* check if existing cuesheet matches the input audio */
1914 if(flac_decoder_data->metadata_blocks[i]->type == FLAC__METADATA_TYPE_CUESHEET && 0 == static_metadata.cuesheet) {
1915 const FLAC__StreamMetadata_CueSheet *cs = &flac_decoder_data->metadata_blocks[i]->data.cue_sheet;
1916 if(e->total_samples_to_encode == 0) {
1917 flac__utils_printf(stderr, 1, "%s: WARNING, cuesheet in input FLAC file cannot be kept if input size is not known, dropping it...\n", e->inbasefilename);
1918 if(e->treat_warnings_as_errors) {
1919 static_metadata_clear(&static_metadata);
1922 existing_cuesheet_is_bad = true;
1924 else if(e->total_samples_to_encode != cs->tracks[cs->num_tracks-1].offset) {
1925 flac__utils_printf(stderr, 1, "%s: WARNING, lead-out offset of cuesheet in input FLAC file does not match input length, dropping existing cuesheet...\n", e->inbasefilename);
1926 if(e->treat_warnings_as_errors) {
1927 static_metadata_clear(&static_metadata);
1930 existing_cuesheet_is_bad = true;
1933 if(flac_decoder_data->metadata_blocks[i]->type == FLAC__METADATA_TYPE_CUESHEET && (existing_cuesheet_is_bad || 0 != static_metadata.cuesheet)) {
1934 if(0 != static_metadata.cuesheet) {
1935 flac__utils_printf(stderr, 1, "%s: WARNING, replacing cuesheet in input FLAC file with the one given on the command-line\n", e->inbasefilename);
1936 if(e->treat_warnings_as_errors) {
1937 static_metadata_clear(&static_metadata);
1941 FLAC__metadata_object_delete(flac_decoder_data->metadata_blocks[i]);
1942 flac_decoder_data->metadata_blocks[i] = 0;
1945 flac_decoder_data->metadata_blocks[j++] = flac_decoder_data->metadata_blocks[i];
1947 flac_decoder_data->num_metadata_blocks = j;
1948 if(0 != static_metadata.cuesheet && flac_decoder_data->num_metadata_blocks < sizeof(flac_decoder_data->metadata_blocks)/sizeof(flac_decoder_data->metadata_blocks[0])) {
1950 FLAC__StreamMetadata *cs = FLAC__metadata_object_clone(static_metadata.cuesheet);
1952 flac__utils_printf(stderr, 1, "%s: ERROR allocating memory for CUESHEET block\n", e->inbasefilename);
1953 static_metadata_clear(&static_metadata);
1956 for(i = flac_decoder_data->num_metadata_blocks; i > 1; i--)
1957 flac_decoder_data->metadata_blocks[i] = flac_decoder_data->metadata_blocks[i-1];
1958 flac_decoder_data->metadata_blocks[1] = cs;
1959 flac_decoder_data->num_metadata_blocks++;
1964 * next handle seektable: if -S- was specified, no
1965 * SEEKTABLE; else if -S was specified, use it/them;
1966 * else if file has existing SEEKTABLE and input size is
1967 * preserved (no --skip/--until/etc specified), keep it;
1968 * else use default seektable options
1970 * note: meanings of num_requested_seek_points:
1971 * -1 : no -S option given, default to some value
1972 * 0 : -S- given (no seektable)
1973 * >0 : one or more -S options given
1976 FLAC__bool existing_seektable = false;
1977 for(i = 0, j = 0; i < flac_decoder_data->num_metadata_blocks; i++) {
1978 if(flac_decoder_data->metadata_blocks[i]->type == FLAC__METADATA_TYPE_SEEKTABLE)
1979 existing_seektable = true;
1980 if(flac_decoder_data->metadata_blocks[i]->type == FLAC__METADATA_TYPE_SEEKTABLE && (e->total_samples_to_encode != flac_decoder_data->metadata_blocks[0]->data.stream_info.total_samples || options.num_requested_seek_points >= 0)) {
1981 if(options.num_requested_seek_points > 0) {
1982 flac__utils_printf(stderr, 1, "%s: WARNING, replacing seektable in input FLAC file with the one given on the command-line\n", e->inbasefilename);
1983 if(e->treat_warnings_as_errors) {
1984 static_metadata_clear(&static_metadata);
1988 else if(options.num_requested_seek_points == 0)
1989 ; /* no warning, silently delete existing SEEKTABLE since user specified --no-seektable (-S-) */
1991 flac__utils_printf(stderr, 1, "%s: WARNING, can't use existing seektable in input FLAC since the input size is changing or unknown, dropping existing SEEKTABLE block...\n", e->inbasefilename);
1992 if(e->treat_warnings_as_errors) {
1993 static_metadata_clear(&static_metadata);
1997 FLAC__metadata_object_delete(flac_decoder_data->metadata_blocks[i]);
1998 flac_decoder_data->metadata_blocks[i] = 0;
1999 existing_seektable = false;
2002 flac_decoder_data->metadata_blocks[j++] = flac_decoder_data->metadata_blocks[i];
2004 flac_decoder_data->num_metadata_blocks = j;
2005 if((options.num_requested_seek_points > 0 || (options.num_requested_seek_points < 0 && !existing_seektable)) && flac_decoder_data->num_metadata_blocks < sizeof(flac_decoder_data->metadata_blocks)/sizeof(flac_decoder_data->metadata_blocks[0])) {
2007 FLAC__StreamMetadata *st = FLAC__metadata_object_clone(e->seek_table_template);
2009 flac__utils_printf(stderr, 1, "%s: ERROR allocating memory for SEEKTABLE block\n", e->inbasefilename);
2010 static_metadata_clear(&static_metadata);
2013 for(i = flac_decoder_data->num_metadata_blocks; i > 1; i--)
2014 flac_decoder_data->metadata_blocks[i] = flac_decoder_data->metadata_blocks[i-1];
2015 flac_decoder_data->metadata_blocks[1] = st;
2016 flac_decoder_data->num_metadata_blocks++;
2021 * finally handle padding: if --no-padding was specified,
2022 * then delete all padding; else if -P was specified,
2023 * use that instead of existing padding (if any); else
2024 * if existing file has padding, move all existing
2025 * padding blocks to one padding block at the end; else
2026 * use default padding.
2030 for(i = 0, j = 0; i < flac_decoder_data->num_metadata_blocks; i++) {
2031 if(flac_decoder_data->metadata_blocks[i]->type == FLAC__METADATA_TYPE_PADDING) {
2034 p += flac_decoder_data->metadata_blocks[i]->length;
2035 FLAC__metadata_object_delete(flac_decoder_data->metadata_blocks[i]);
2036 flac_decoder_data->metadata_blocks[i] = 0;
2039 flac_decoder_data->metadata_blocks[j++] = flac_decoder_data->metadata_blocks[i];
2041 flac_decoder_data->num_metadata_blocks = j;
2042 if(options.padding > 0)
2043 p = options.padding;
2045 p = e->total_samples_to_encode / e->sample_rate < 20*60? FLAC_ENCODE__DEFAULT_PADDING : FLAC_ENCODE__DEFAULT_PADDING*8;
2046 if(options.padding != 0) {
2047 if(p > 0 && flac_decoder_data->num_metadata_blocks < sizeof(flac_decoder_data->metadata_blocks)/sizeof(flac_decoder_data->metadata_blocks[0])) {
2048 flac_decoder_data->metadata_blocks[flac_decoder_data->num_metadata_blocks] = FLAC__metadata_object_new(FLAC__METADATA_TYPE_PADDING);
2049 if(0 == flac_decoder_data->metadata_blocks[flac_decoder_data->num_metadata_blocks]) {
2050 flac__utils_printf(stderr, 1, "%s: ERROR allocating memory for PADDING block\n", e->inbasefilename);
2051 static_metadata_clear(&static_metadata);
2054 flac_decoder_data->metadata_blocks[flac_decoder_data->num_metadata_blocks]->is_last = false; /* the encoder will set this for us */
2055 flac_decoder_data->metadata_blocks[flac_decoder_data->num_metadata_blocks]->length = p;
2056 flac_decoder_data->num_metadata_blocks++;
2060 metadata = &flac_decoder_data->metadata_blocks[1]; /* don't include STREAMINFO */
2061 num_metadata = flac_decoder_data->num_metadata_blocks - 1;
2065 * we're not encoding from FLAC so we will build the metadata
2068 if(e->seek_table_template->data.seek_table.num_points > 0) {
2069 e->seek_table_template->is_last = false; /* the encoder will set this for us */
2070 static_metadata_append(&static_metadata, e->seek_table_template, /*needs_delete=*/false);
2072 if(0 != static_metadata.cuesheet)
2073 static_metadata_append(&static_metadata, static_metadata.cuesheet, /*needs_delete=*/false);
2075 if(!flac__utils_set_channel_mask_tag(options.vorbis_comment, channel_mask)) {
2076 flac__utils_printf(stderr, 1, "%s: ERROR adding channel mask tag\n", e->inbasefilename);
2077 static_metadata_clear(&static_metadata);
2081 static_metadata_append(&static_metadata, options.vorbis_comment, /*needs_delete=*/false);
2082 for(i = 0; i < options.num_pictures; i++)
2083 static_metadata_append(&static_metadata, options.pictures[i], /*needs_delete=*/false);
2084 if(foreign_metadata) {
2085 for(i = 0; i < foreign_metadata->num_blocks; i++) {
2086 FLAC__StreamMetadata *p = FLAC__metadata_object_new(FLAC__METADATA_TYPE_PADDING);
2088 flac__utils_printf(stderr, 1, "%s: ERROR: out of memory\n", e->inbasefilename);
2089 static_metadata_clear(&static_metadata);
2092 static_metadata_append(&static_metadata, p, /*needs_delete=*/true);
2093 static_metadata.metadata[static_metadata.num_metadata-1]->length = FLAC__STREAM_METADATA_APPLICATION_ID_LEN/8 + foreign_metadata->blocks[i].size;
2094 /*fprintf(stderr,"@@@@@@ add PADDING=%u\n",static_metadata.metadata[static_metadata.num_metadata-1]->length);*/
2097 if(options.padding != 0) {
2098 padding.is_last = false; /* the encoder will set this for us */
2099 padding.type = FLAC__METADATA_TYPE_PADDING;
2100 padding.length = (unsigned)(options.padding>0? options.padding : (e->total_samples_to_encode / e->sample_rate < 20*60? FLAC_ENCODE__DEFAULT_PADDING : FLAC_ENCODE__DEFAULT_PADDING*8));
2101 static_metadata_append(&static_metadata, &padding, /*needs_delete=*/false);
2103 metadata = static_metadata.metadata;
2104 num_metadata = static_metadata.num_metadata;
2107 /* check for a few things that have not already been checked. the
2108 * FLAC__stream_encoder_init*() will check it but only return
2109 * FLAC__STREAM_ENCODER_INIT_STATUS_INVALID_METADATA so we check some
2110 * up front to give a better error message.
2112 if(!verify_metadata(e, metadata, num_metadata)) {
2113 static_metadata_clear(&static_metadata);
2117 FLAC__stream_encoder_set_verify(e->encoder, options.verify);
2118 FLAC__stream_encoder_set_streamable_subset(e->encoder, !options.lax);
2119 FLAC__stream_encoder_set_channels(e->encoder, channels);
2120 FLAC__stream_encoder_set_bits_per_sample(e->encoder, bps);
2121 FLAC__stream_encoder_set_sample_rate(e->encoder, sample_rate);
2122 for(i = 0; i < options.num_compression_settings; i++) {
2123 switch(options.compression_settings[i].type) {
2125 FLAC__stream_encoder_set_blocksize(e->encoder, options.compression_settings[i].value.t_unsigned);
2127 case CST_COMPRESSION_LEVEL:
2128 FLAC__stream_encoder_set_compression_level(e->encoder, options.compression_settings[i].value.t_unsigned);
2129 apodizations[0] = '\0';
2131 case CST_DO_MID_SIDE:
2132 FLAC__stream_encoder_set_do_mid_side_stereo(e->encoder, options.compression_settings[i].value.t_bool);
2134 case CST_LOOSE_MID_SIDE:
2135 FLAC__stream_encoder_set_loose_mid_side_stereo(e->encoder, options.compression_settings[i].value.t_bool);
2137 case CST_APODIZATION:
2138 if(strlen(apodizations)+strlen(options.compression_settings[i].value.t_string)+2 >= sizeof(apodizations)) {
2139 flac__utils_printf(stderr, 1, "%s: ERROR: too many apodization functions requested\n", e->inbasefilename);
2140 static_metadata_clear(&static_metadata);
2144 strcat(apodizations, options.compression_settings[i].value.t_string);
2145 strcat(apodizations, ";");
2148 case CST_MAX_LPC_ORDER:
2149 FLAC__stream_encoder_set_max_lpc_order(e->encoder, options.compression_settings[i].value.t_unsigned);
2151 case CST_QLP_COEFF_PRECISION:
2152 FLAC__stream_encoder_set_qlp_coeff_precision(e->encoder, options.compression_settings[i].value.t_unsigned);
2154 case CST_DO_QLP_COEFF_PREC_SEARCH:
2155 FLAC__stream_encoder_set_do_qlp_coeff_prec_search(e->encoder, options.compression_settings[i].value.t_bool);
2157 case CST_DO_ESCAPE_CODING:
2158 FLAC__stream_encoder_set_do_escape_coding(e->encoder, options.compression_settings[i].value.t_bool);
2160 case CST_DO_EXHAUSTIVE_MODEL_SEARCH:
2161 FLAC__stream_encoder_set_do_exhaustive_model_search(e->encoder, options.compression_settings[i].value.t_bool);
2163 case CST_MIN_RESIDUAL_PARTITION_ORDER:
2164 FLAC__stream_encoder_set_min_residual_partition_order(e->encoder, options.compression_settings[i].value.t_unsigned);
2166 case CST_MAX_RESIDUAL_PARTITION_ORDER:
2167 FLAC__stream_encoder_set_max_residual_partition_order(e->encoder, options.compression_settings[i].value.t_unsigned);
2169 case CST_RICE_PARAMETER_SEARCH_DIST:
2170 FLAC__stream_encoder_set_rice_parameter_search_dist(e->encoder, options.compression_settings[i].value.t_unsigned);
2175 FLAC__stream_encoder_set_apodization(e->encoder, apodizations);
2176 FLAC__stream_encoder_set_total_samples_estimate(e->encoder, e->total_samples_to_encode);
2177 FLAC__stream_encoder_set_metadata(e->encoder, (num_metadata > 0)? metadata : 0, num_metadata);
2179 FLAC__stream_encoder_disable_constant_subframes(e->encoder, options.debug.disable_constant_subframes);
2180 FLAC__stream_encoder_disable_fixed_subframes(e->encoder, options.debug.disable_fixed_subframes);
2181 FLAC__stream_encoder_disable_verbatim_subframes(e->encoder, options.debug.disable_verbatim_subframes);
2182 if(!options.debug.do_md5) {
2183 flac__utils_printf(stderr, 1, "%s: WARNING, MD5 computation disabled, resulting file will not have MD5 sum\n", e->inbasefilename);
2184 if(e->treat_warnings_as_errors) {
2185 static_metadata_clear(&static_metadata);
2188 FLAC__stream_encoder_set_do_md5(e->encoder, false);
2193 FLAC__stream_encoder_set_ogg_serial_number(e->encoder, options.serial_number);
2195 init_status = FLAC__stream_encoder_init_ogg_file(e->encoder, e->is_stdout? 0 : e->outfilename, encoder_progress_callback, /*client_data=*/e);
2200 init_status = FLAC__stream_encoder_init_file(e->encoder, e->is_stdout? 0 : e->outfilename, encoder_progress_callback, /*client_data=*/e);
2203 if(init_status != FLAC__STREAM_ENCODER_INIT_STATUS_OK) {
2204 print_error_with_init_status(e, "ERROR initializing encoder", init_status);
2205 if(FLAC__stream_encoder_get_state(e->encoder) != FLAC__STREAM_ENCODER_IO_ERROR)
2206 e->outputfile_opened = true;
2207 static_metadata_clear(&static_metadata);
2211 e->outputfile_opened = true;
2214 (FLAC__stream_encoder_get_do_exhaustive_model_search(e->encoder) && FLAC__stream_encoder_get_do_qlp_coeff_prec_search(e->encoder))? 0x07 :
2215 (FLAC__stream_encoder_get_do_exhaustive_model_search(e->encoder) || FLAC__stream_encoder_get_do_qlp_coeff_prec_search(e->encoder))? 0x0f :
2218 static_metadata_clear(&static_metadata);
2223 FLAC__bool EncoderSession_process(EncoderSession *e, const FLAC__int32 * const buffer[], unsigned samples)
2225 if(e->replay_gain) {
2226 if(!grabbag__replaygain_analyze(buffer, e->channels==2, e->bits_per_sample, samples)) {
2227 flac__utils_printf(stderr, 1, "%s: WARNING, error while calculating ReplayGain\n", e->inbasefilename);
2228 if(e->treat_warnings_as_errors)
2233 return FLAC__stream_encoder_process(e->encoder, buffer, samples);
2236 FLAC__bool convert_to_seek_table_template(const char *requested_seek_points, int num_requested_seek_points, FLAC__StreamMetadata *cuesheet, EncoderSession *e)
2238 const FLAC__bool only_placeholders = e->is_stdout;
2239 FLAC__bool has_real_points;
2241 if(num_requested_seek_points == 0 && 0 == cuesheet)
2244 if(num_requested_seek_points < 0) {
2246 /*@@@@@@ workaround ogg bug: too many seekpoints makes table not fit in one page */
2247 if(e->use_ogg && e->total_samples_to_encode > 0 && e->total_samples_to_encode / e->sample_rate / 10 > 230)
2248 requested_seek_points = "230x;";
2251 requested_seek_points = "10s;";
2252 num_requested_seek_points = 1;
2255 if(num_requested_seek_points > 0) {
2256 if(!grabbag__seektable_convert_specification_to_template(requested_seek_points, only_placeholders, e->total_samples_to_encode, e->sample_rate, e->seek_table_template, &has_real_points))
2262 const FLAC__StreamMetadata_CueSheet *cs = &cuesheet->data.cue_sheet;
2263 for(i = 0; i < cs->num_tracks; i++) {
2264 const FLAC__StreamMetadata_CueSheet_Track *tr = cs->tracks+i;
2265 for(j = 0; j < tr->num_indices; j++) {
2266 if(!FLAC__metadata_object_seektable_template_append_point(e->seek_table_template, tr->offset + tr->indices[j].offset))
2268 has_real_points = true;
2272 if(!FLAC__metadata_object_seektable_template_sort(e->seek_table_template, /*compact=*/true))
2276 if(has_real_points) {
2278 flac__utils_printf(stderr, 1, "%s: WARNING, cannot write back seekpoints when encoding to stdout\n", e->inbasefilename);
2279 if(e->treat_warnings_as_errors)
2287 FLAC__bool canonicalize_until_specification(utils__SkipUntilSpecification *spec, const char *inbasefilename, unsigned sample_rate, FLAC__uint64 skip, FLAC__uint64 total_samples_in_input)
2289 /* convert from mm:ss.sss to sample number if necessary */
2290 flac__utils_canonicalize_skip_until_specification(spec, sample_rate);
2292 /* special case: if "--until=-0", use the special value '0' to mean "end-of-stream" */
2293 if(spec->is_relative && spec->value.samples == 0) {
2294 spec->is_relative = false;
2298 /* in any other case the total samples in the input must be known */
2299 if(total_samples_in_input == 0) {
2300 flac__utils_printf(stderr, 1, "%s: ERROR, cannot use --until when input length is unknown\n", inbasefilename);
2304 FLAC__ASSERT(spec->value_is_samples);
2306 /* convert relative specifications to absolute */
2307 if(spec->is_relative) {
2308 if(spec->value.samples <= 0)
2309 spec->value.samples += (FLAC__int64)total_samples_in_input;
2311 spec->value.samples += skip;
2312 spec->is_relative = false;
2316 if(spec->value.samples < 0) {
2317 flac__utils_printf(stderr, 1, "%s: ERROR, --until value is before beginning of input\n", inbasefilename);
2320 if((FLAC__uint64)spec->value.samples <= skip) {
2321 flac__utils_printf(stderr, 1, "%s: ERROR, --until value is before --skip point\n", inbasefilename);
2324 if((FLAC__uint64)spec->value.samples > total_samples_in_input) {
2325 flac__utils_printf(stderr, 1, "%s: ERROR, --until value is after end of input\n", inbasefilename);
2332 FLAC__bool verify_metadata(const EncoderSession *e, FLAC__StreamMetadata **metadata, unsigned num_metadata)
2334 FLAC__bool metadata_picture_has_type1 = false;
2335 FLAC__bool metadata_picture_has_type2 = false;
2338 FLAC__ASSERT(0 != metadata);
2339 for(i = 0; i < num_metadata; i++) {
2340 const FLAC__StreamMetadata *m = metadata[i];
2341 if(m->type == FLAC__METADATA_TYPE_SEEKTABLE) {
2342 if(!FLAC__format_seektable_is_legal(&m->data.seek_table)) {
2343 flac__utils_printf(stderr, 1, "%s: ERROR: SEEKTABLE metadata block is invalid\n", e->inbasefilename);
2347 else if(m->type == FLAC__METADATA_TYPE_CUESHEET) {
2348 if(!FLAC__format_cuesheet_is_legal(&m->data.cue_sheet, m->data.cue_sheet.is_cd, /*violation=*/0)) {
2349 flac__utils_printf(stderr, 1, "%s: ERROR: CUESHEET metadata block is invalid\n", e->inbasefilename);
2353 else if(m->type == FLAC__METADATA_TYPE_PICTURE) {
2354 const char *error = 0;
2355 if(!FLAC__format_picture_is_legal(&m->data.picture, &error)) {
2356 flac__utils_printf(stderr, 1, "%s: ERROR: PICTURE metadata block is invalid: %s\n", e->inbasefilename, error);
2359 if(m->data.picture.type == FLAC__STREAM_METADATA_PICTURE_TYPE_FILE_ICON_STANDARD) {
2360 if(metadata_picture_has_type1) {
2361 flac__utils_printf(stderr, 1, "%s: ERROR: there may only be one picture of type 1 (32x32 icon) in the file\n", e->inbasefilename);
2364 metadata_picture_has_type1 = true;
2366 else if(m->data.picture.type == FLAC__STREAM_METADATA_PICTURE_TYPE_FILE_ICON) {
2367 if(metadata_picture_has_type2) {
2368 flac__utils_printf(stderr, 1, "%s: ERROR: there may only be one picture of type 2 (icon) in the file\n", e->inbasefilename);
2371 metadata_picture_has_type2 = true;
2379 FLAC__bool format_input(FLAC__int32 *dest[], unsigned wide_samples, FLAC__bool is_big_endian, FLAC__bool is_unsigned_samples, unsigned channels, unsigned bps, unsigned shift, size_t *channel_map)
2381 unsigned wide_sample, sample, channel, byte;
2382 FLAC__int32 *out[FLAC__MAX_CHANNELS];
2384 if(0 == channel_map) {
2385 for(channel = 0; channel < channels; channel++)
2386 out[channel] = dest[channel];
2389 for(channel = 0; channel < channels; channel++)
2390 out[channel] = dest[channel_map[channel]];
2394 if(is_unsigned_samples) {
2395 for(sample = wide_sample = 0; wide_sample < wide_samples; wide_sample++)
2396 for(channel = 0; channel < channels; channel++, sample++)
2397 out[channel][wide_sample] = (FLAC__int32)ucbuffer_[sample] - 0x80;
2400 for(sample = wide_sample = 0; wide_sample < wide_samples; wide_sample++)
2401 for(channel = 0; channel < channels; channel++, sample++)
2402 out[channel][wide_sample] = (FLAC__int32)scbuffer_[sample];
2405 else if(bps == 16) {
2406 if(is_big_endian != is_big_endian_host_) {
2408 const unsigned bytes = wide_samples * channels * (bps >> 3);
2409 for(byte = 0; byte < bytes; byte += 2) {
2410 tmp = ucbuffer_[byte];
2411 ucbuffer_[byte] = ucbuffer_[byte+1];
2412 ucbuffer_[byte+1] = tmp;
2415 if(is_unsigned_samples) {
2416 for(sample = wide_sample = 0; wide_sample < wide_samples; wide_sample++)
2417 for(channel = 0; channel < channels; channel++, sample++)
2418 out[channel][wide_sample] = (FLAC__int32)usbuffer_[sample] - 0x8000;
2421 for(sample = wide_sample = 0; wide_sample < wide_samples; wide_sample++)
2422 for(channel = 0; channel < channels; channel++, sample++)
2423 out[channel][wide_sample] = (FLAC__int32)ssbuffer_[sample];
2426 else if(bps == 24) {
2427 if(!is_big_endian) {
2429 const unsigned bytes = wide_samples * channels * (bps >> 3);
2430 for(byte = 0; byte < bytes; byte += 3) {
2431 tmp = ucbuffer_[byte];
2432 ucbuffer_[byte] = ucbuffer_[byte+2];
2433 ucbuffer_[byte+2] = tmp;
2436 if(is_unsigned_samples) {
2437 for(byte = sample = wide_sample = 0; wide_sample < wide_samples; wide_sample++)
2438 for(channel = 0; channel < channels; channel++, sample++) {
2439 out[channel][wide_sample] = ucbuffer_[byte++]; out[channel][wide_sample] <<= 8;
2440 out[channel][wide_sample] |= ucbuffer_[byte++]; out[channel][wide_sample] <<= 8;
2441 out[channel][wide_sample] |= ucbuffer_[byte++];
2442 out[channel][wide_sample] -= 0x800000;
2446 for(byte = sample = wide_sample = 0; wide_sample < wide_samples; wide_sample++)
2447 for(channel = 0; channel < channels; channel++, sample++) {
2448 out[channel][wide_sample] = scbuffer_[byte++]; out[channel][wide_sample] <<= 8;
2449 out[channel][wide_sample] |= ucbuffer_[byte++]; out[channel][wide_sample] <<= 8;
2450 out[channel][wide_sample] |= ucbuffer_[byte++];
2458 FLAC__int32 mask = (1<<shift)-1;
2459 for(wide_sample = 0; wide_sample < wide_samples; wide_sample++)
2460 for(channel = 0; channel < channels; channel++) {
2461 if(out[channel][wide_sample] & mask) {
2462 flac__utils_printf(stderr, 1, "ERROR during read, sample data (channel#%u sample#%u = %d) has non-zero least-significant bits\n WAVE/AIFF header said the last %u bits are not significant and should be zero.\n", channel, wide_sample, out[channel][wide_sample], shift);
2465 out[channel][wide_sample] >>= shift;
2471 void encoder_progress_callback(const FLAC__StreamEncoder *encoder, FLAC__uint64 bytes_written, FLAC__uint64 samples_written, unsigned frames_written, unsigned total_frames_estimate, void *client_data)
2473 EncoderSession *encoder_session = (EncoderSession*)client_data;
2475 (void)encoder, (void)total_frames_estimate;
2477 encoder_session->bytes_written = bytes_written;
2478 encoder_session->samples_written = samples_written;
2480 if(encoder_session->total_samples_to_encode > 0 && !((frames_written-1) & encoder_session->stats_mask))
2481 print_stats(encoder_session);
2484 FLAC__StreamDecoderReadStatus flac_decoder_read_callback(const FLAC__StreamDecoder *decoder, FLAC__byte buffer[], size_t *bytes, void *client_data)
2487 FLACDecoderData *data = (FLACDecoderData*)client_data;
2490 if (data->fatal_error)
2491 return FLAC__STREAM_DECODER_READ_STATUS_ABORT;
2493 /* use up lookahead first */
2494 if (data->lookahead_length) {
2495 n = min(data->lookahead_length, *bytes);
2496 memcpy(buffer, data->lookahead, n);
2498 data->lookahead += n;
2499 data->lookahead_length -= n;
2502 /* get the rest from file */
2504 *bytes = n + fread(buffer, 1, *bytes-n, data->encoder_session->fin);
2505 if(ferror(data->encoder_session->fin))
2506 return FLAC__STREAM_DECODER_READ_STATUS_ABORT;
2507 else if(0 == *bytes)
2508 return FLAC__STREAM_DECODER_READ_STATUS_END_OF_STREAM;
2510 return FLAC__STREAM_DECODER_READ_STATUS_CONTINUE;
2513 return FLAC__STREAM_DECODER_READ_STATUS_CONTINUE;
2516 FLAC__StreamDecoderSeekStatus flac_decoder_seek_callback(const FLAC__StreamDecoder *decoder, FLAC__uint64 absolute_byte_offset, void *client_data)
2518 FLACDecoderData *data = (FLACDecoderData*)client_data;
2521 if(fseeko(data->encoder_session->fin, (off_t)absolute_byte_offset, SEEK_SET) < 0)
2522 return FLAC__STREAM_DECODER_SEEK_STATUS_ERROR;
2524 return FLAC__STREAM_DECODER_SEEK_STATUS_OK;
2527 FLAC__StreamDecoderTellStatus flac_decoder_tell_callback(const FLAC__StreamDecoder *decoder, FLAC__uint64 *absolute_byte_offset, void *client_data)
2529 FLACDecoderData *data = (FLACDecoderData*)client_data;
2533 if((pos = ftello(data->encoder_session->fin)) < 0)
2534 return FLAC__STREAM_DECODER_TELL_STATUS_ERROR;
2536 *absolute_byte_offset = (FLAC__uint64)pos;
2537 return FLAC__STREAM_DECODER_TELL_STATUS_OK;
2541 FLAC__StreamDecoderLengthStatus flac_decoder_length_callback(const FLAC__StreamDecoder *decoder, FLAC__uint64 *stream_length, void *client_data)
2543 FLACDecoderData *data = (FLACDecoderData*)client_data;
2546 if(0 == data->filesize)
2547 return FLAC__STREAM_DECODER_LENGTH_STATUS_ERROR;
2549 *stream_length = (FLAC__uint64)data->filesize;
2550 return FLAC__STREAM_DECODER_LENGTH_STATUS_OK;
2554 FLAC__bool flac_decoder_eof_callback(const FLAC__StreamDecoder *decoder, void *client_data)
2556 FLACDecoderData *data = (FLACDecoderData*)client_data;
2559 return feof(data->encoder_session->fin)? true : false;
2562 FLAC__StreamDecoderWriteStatus flac_decoder_write_callback(const FLAC__StreamDecoder *decoder, const FLAC__Frame *frame, const FLAC__int32 * const buffer[], void *client_data)
2564 FLACDecoderData *data = (FLACDecoderData*)client_data;
2565 FLAC__uint64 n = min(data->samples_left_to_process, frame->header.blocksize);
2568 if(!EncoderSession_process(data->encoder_session, buffer, (unsigned)n)) {
2569 print_error_with_state(data->encoder_session, "ERROR during encoding");
2570 data->fatal_error = true;
2571 return FLAC__STREAM_DECODER_WRITE_STATUS_ABORT;
2574 data->samples_left_to_process -= n;
2575 return FLAC__STREAM_DECODER_WRITE_STATUS_CONTINUE;
2578 void flac_decoder_metadata_callback(const FLAC__StreamDecoder *decoder, const FLAC__StreamMetadata *metadata, void *client_data)
2580 FLACDecoderData *data = (FLACDecoderData*)client_data;
2583 if (data->fatal_error)
2587 data->num_metadata_blocks == sizeof(data->metadata_blocks)/sizeof(data->metadata_blocks[0]) ||
2588 0 == (data->metadata_blocks[data->num_metadata_blocks] = FLAC__metadata_object_clone(metadata))
2590 data->fatal_error = true;
2592 data->num_metadata_blocks++;
2595 void flac_decoder_error_callback(const FLAC__StreamDecoder *decoder, FLAC__StreamDecoderErrorStatus status, void *client_data)
2597 FLACDecoderData *data = (FLACDecoderData*)client_data;
2600 flac__utils_printf(stderr, 1, "%s: ERROR got %s while decoding FLAC input\n", data->encoder_session->inbasefilename, FLAC__StreamDecoderErrorStatusString[status]);
2601 if(!data->encoder_session->continue_through_decode_errors)
2602 data->fatal_error = true;
2605 FLAC__bool parse_cuesheet(FLAC__StreamMetadata **cuesheet, const char *cuesheet_filename, const char *inbasefilename, FLAC__bool is_cdda, FLAC__uint64 lead_out_offset, FLAC__bool treat_warnings_as_errors)
2608 unsigned last_line_read;
2609 const char *error_message;
2611 if(0 == cuesheet_filename)
2614 if(lead_out_offset == 0) {
2615 flac__utils_printf(stderr, 1, "%s: ERROR cannot import cuesheet when the number of input samples to encode is unknown\n", inbasefilename);
2619 if(0 == (f = fopen(cuesheet_filename, "r"))) {
2620 flac__utils_printf(stderr, 1, "%s: ERROR opening cuesheet \"%s\" for reading: %s\n", inbasefilename, cuesheet_filename, strerror(errno));
2624 *cuesheet = grabbag__cuesheet_parse(f, &error_message, &last_line_read, is_cdda, lead_out_offset);
2628 if(0 == *cuesheet) {
2629 flac__utils_printf(stderr, 1, "%s: ERROR parsing cuesheet \"%s\" on line %u: %s\n", inbasefilename, cuesheet_filename, last_line_read, error_message);
2633 if(!FLAC__format_cuesheet_is_legal(&(*cuesheet)->data.cue_sheet, /*check_cd_da_subset=*/false, &error_message)) {
2634 flac__utils_printf(stderr, 1, "%s: ERROR parsing cuesheet \"%s\": %s\n", inbasefilename, cuesheet_filename, error_message);
2638 /* if we're expecting CDDA, warn about non-compliance */
2639 if(is_cdda && !FLAC__format_cuesheet_is_legal(&(*cuesheet)->data.cue_sheet, /*check_cd_da_subset=*/true, &error_message)) {
2640 flac__utils_printf(stderr, 1, "%s: WARNING cuesheet \"%s\" is not audio CD compliant: %s\n", inbasefilename, cuesheet_filename, error_message);
2641 if(treat_warnings_as_errors)
2643 (*cuesheet)->data.cue_sheet.is_cd = false;
2649 void print_stats(const EncoderSession *encoder_session)
2651 const FLAC__uint64 samples_written = min(encoder_session->total_samples_to_encode, encoder_session->samples_written);
2652 #if defined _MSC_VER || defined __MINGW32__
2653 /* with MSVC you have to spoon feed it the casting */
2654 const double progress = (double)(FLAC__int64)samples_written / (double)(FLAC__int64)encoder_session->total_samples_to_encode;
2655 const double ratio = (double)(FLAC__int64)encoder_session->bytes_written / ((double)(FLAC__int64)encoder_session->unencoded_size * min(1.0, progress));
2657 const double progress = (double)samples_written / (double)encoder_session->total_samples_to_encode;
2658 const double ratio = (double)encoder_session->bytes_written / ((double)encoder_session->unencoded_size * min(1.0, progress));
2661 FLAC__ASSERT(encoder_session->total_samples_to_encode > 0);
2663 if(samples_written == encoder_session->total_samples_to_encode) {
2664 flac__utils_printf(stderr, 2, "\r%s:%s wrote %u bytes, ratio=%0.3f",
2665 encoder_session->inbasefilename,
2666 encoder_session->verify? " Verify OK," : "",
2667 (unsigned)encoder_session->bytes_written,
2672 flac__utils_printf(stderr, 2, "\r%s: %u%% complete, ratio=%0.3f", encoder_session->inbasefilename, (unsigned)floor(progress * 100.0 + 0.5), ratio);
2676 void print_error_with_init_status(const EncoderSession *e, const char *message, FLAC__StreamEncoderInitStatus init_status)
2678 const int ilen = strlen(e->inbasefilename) + 1;
2679 const char *state_string = "";
2681 flac__utils_printf(stderr, 1, "\n%s: %s\n", e->inbasefilename, message);
2683 flac__utils_printf(stderr, 1, "%*s init_status = %s\n", ilen, "", FLAC__StreamEncoderInitStatusString[init_status]);
2685 if(init_status == FLAC__STREAM_ENCODER_INIT_STATUS_ENCODER_ERROR) {
2686 state_string = FLAC__stream_encoder_get_resolved_state_string(e->encoder);
2688 flac__utils_printf(stderr, 1, "%*s state = %s\n", ilen, "", state_string);
2690 /* print out some more info for some errors: */
2691 if(0 == strcmp(state_string, FLAC__StreamEncoderStateString[FLAC__STREAM_ENCODER_CLIENT_ERROR])) {
2692 flac__utils_printf(stderr, 1,
2694 "An error occurred while writing; the most common cause is that the disk is full.\n"
2697 else if(0 == strcmp(state_string, FLAC__StreamEncoderStateString[FLAC__STREAM_ENCODER_IO_ERROR])) {
2698 flac__utils_printf(stderr, 1,
2700 "An error occurred opening the output file; it is likely that the output\n"
2701 "directory does not exist or is not writable, the output file already exists and\n"
2702 "is not writable, or the disk is full.\n"
2706 else if(init_status == FLAC__STREAM_ENCODER_INIT_STATUS_NOT_STREAMABLE) {
2707 flac__utils_printf(stderr, 1,
2709 "The encoding parameters specified do not conform to the FLAC Subset and may not\n"
2710 "be streamable or playable in hardware devices. If you really understand the\n"
2711 "consequences, you can add --lax to the command-line options to encode with\n"
2712 "these parameters anyway. See http://flac.sourceforge.net/format.html#subset\n"
2717 void print_error_with_state(const EncoderSession *e, const char *message)
2719 const int ilen = strlen(e->inbasefilename) + 1;
2720 const char *state_string;
2722 flac__utils_printf(stderr, 1, "\n%s: %s\n", e->inbasefilename, message);
2724 state_string = FLAC__stream_encoder_get_resolved_state_string(e->encoder);
2726 flac__utils_printf(stderr, 1, "%*s state = %s\n", ilen, "", state_string);
2728 /* print out some more info for some errors: */
2729 if(0 == strcmp(state_string, FLAC__StreamEncoderStateString[FLAC__STREAM_ENCODER_CLIENT_ERROR])) {
2730 flac__utils_printf(stderr, 1,
2732 "An error occurred while writing; the most common cause is that the disk is full.\n"
2737 void print_verify_error(EncoderSession *e)
2739 FLAC__uint64 absolute_sample;
2740 unsigned frame_number;
2743 FLAC__int32 expected;
2746 FLAC__stream_encoder_get_verify_decoder_error_stats(e->encoder, &absolute_sample, &frame_number, &channel, &sample, &expected, &got);
2748 flac__utils_printf(stderr, 1, "%s: ERROR: mismatch in decoded data, verify FAILED!\n", e->inbasefilename);
2749 flac__utils_printf(stderr, 1, " Absolute sample=%u, frame=%u, channel=%u, sample=%u, expected %d, got %d\n", (unsigned)absolute_sample, frame_number, channel, sample, expected, got);
2750 flac__utils_printf(stderr, 1, " In all known cases, verify errors are caused by hardware problems,\n");
2751 flac__utils_printf(stderr, 1, " usually overclocking or bad RAM. Delete %s\n", e->outfilename);
2752 flac__utils_printf(stderr, 1, " and repeat the flac command exactly as before. If it does not give a\n");
2753 flac__utils_printf(stderr, 1, " verify error in the exact same place each time you try it, then there is\n");
2754 flac__utils_printf(stderr, 1, " a problem with your hardware; please see the FAQ:\n");
2755 flac__utils_printf(stderr, 1, " http://flac.sourceforge.net/faq.html#tools__hardware_prob\n");
2756 flac__utils_printf(stderr, 1, " If it does fail in the exact same place every time, keep\n");
2757 flac__utils_printf(stderr, 1, " %s and submit a bug report to:\n", e->outfilename);
2758 flac__utils_printf(stderr, 1, " https://sourceforge.net/bugs/?func=addbug&group_id=13478\n");
2759 flac__utils_printf(stderr, 1, " Make sure to upload the FLAC file and use the \"Monitor\" feature to\n");
2760 flac__utils_printf(stderr, 1, " monitor the bug status.\n");
2761 flac__utils_printf(stderr, 1, "Verify FAILED! Do not trust %s\n", e->outfilename);
2764 FLAC__bool read_little_endian_uint16(FILE *f, FLAC__uint16 *val, FLAC__bool eof_ok, const char *fn)
2766 size_t bytes_read = fread(val, 1, 2, f);
2768 if(bytes_read == 0) {
2770 flac__utils_printf(stderr, 1, "%s: ERROR: unexpected EOF\n", fn);
2776 else if(bytes_read < 2) {
2777 flac__utils_printf(stderr, 1, "%s: ERROR: unexpected EOF\n", fn);
2781 if(is_big_endian_host_) {
2782 FLAC__byte tmp, *b = (FLAC__byte*)val;
2783 tmp = b[1]; b[1] = b[0]; b[0] = tmp;
2789 FLAC__bool read_little_endian_uint32(FILE *f, FLAC__uint32 *val, FLAC__bool eof_ok, const char *fn)
2791 size_t bytes_read = fread(val, 1, 4, f);
2793 if(bytes_read == 0) {
2795 flac__utils_printf(stderr, 1, "%s: ERROR: unexpected EOF\n", fn);
2801 else if(bytes_read < 4) {
2802 flac__utils_printf(stderr, 1, "%s: ERROR: unexpected EOF\n", fn);
2806 if(is_big_endian_host_) {
2807 FLAC__byte tmp, *b = (FLAC__byte*)val;
2808 tmp = b[3]; b[3] = b[0]; b[0] = tmp;
2809 tmp = b[2]; b[2] = b[1]; b[1] = tmp;
2815 FLAC__bool read_big_endian_uint16(FILE *f, FLAC__uint16 *val, FLAC__bool eof_ok, const char *fn)
2817 unsigned char buf[4];
2818 size_t bytes_read= fread(buf, 1, 2, f);
2820 if(bytes_read==0U && eof_ok)
2822 else if(bytes_read<2U) {
2823 flac__utils_printf(stderr, 1, "%s: ERROR: unexpected EOF\n", fn);
2827 /* this is independent of host endianness */
2828 *val= (FLAC__uint16)(buf[0])<<8 | buf[1];
2833 FLAC__bool read_big_endian_uint32(FILE *f, FLAC__uint32 *val, FLAC__bool eof_ok, const char *fn)
2835 unsigned char buf[4];
2836 size_t bytes_read= fread(buf, 1, 4, f);
2838 if(bytes_read==0U && eof_ok)
2840 else if(bytes_read<4U) {
2841 flac__utils_printf(stderr, 1, "%s: ERROR: unexpected EOF\n", fn);
2845 /* this is independent of host endianness */
2846 *val= (FLAC__uint32)(buf[0])<<24 | (FLAC__uint32)(buf[1])<<16 |
2847 (FLAC__uint32)(buf[2])<<8 | buf[3];
2852 FLAC__bool read_sane_extended(FILE *f, FLAC__uint32 *val, FLAC__bool eof_ok, const char *fn)
2853 /* Read an IEEE 754 80-bit (aka SANE) extended floating point value from 'f',
2854 * convert it into an integral value and store in 'val'. Return false if only
2855 * between 1 and 9 bytes remain in 'f', if 0 bytes remain in 'f' and 'eof_ok' is
2856 * false, or if the value is negative, between zero and one, or too large to be
2857 * represented by 'val'; return true otherwise.
2861 unsigned char buf[10];
2862 size_t bytes_read= fread(buf, 1U, 10U, f);
2863 FLAC__int16 e= ((FLAC__uint16)(buf[0])<<8 | (FLAC__uint16)(buf[1]))-0x3FFF;
2864 FLAC__int16 shift= 63-e;
2867 if(bytes_read==0U && eof_ok)
2869 else if(bytes_read<10U) {
2870 flac__utils_printf(stderr, 1, "%s: ERROR: unexpected EOF\n", fn);
2873 else if((buf[0]>>7)==1U || e<0 || e>63) {
2874 flac__utils_printf(stderr, 1, "%s: ERROR: invalid floating-point value\n", fn);
2878 for(i= 0U; i<8U; ++i)
2879 p|= (FLAC__uint64)(buf[i+2])<<(56U-i*8);
2880 *val= (FLAC__uint32)((p>>shift)+(p>>(shift-1) & 0x1));
2885 FLAC__bool fskip_ahead(FILE *f, FLAC__uint64 offset)
2887 static unsigned char dump[8192];
2891 /* MS' stdio impl can't even seek forward on stdin, have to use pure non-fseek() version: */
2893 const long need = (long)min(offset, sizeof(dump));
2894 if((long)fread(dump, 1, need, f) < need)
2903 long need = (long)min(offset, LONG_MAX);
2904 if(fseeko(f, need, SEEK_CUR) < 0) {
2905 need = (long)min(offset, sizeof(dump));
2906 if((long)fread(dump, 1, need, f) < need)
2915 unsigned count_channel_mask_bits(FLAC__uint32 mask)
2927 FLAC__uint32 limit_channel_mask(FLAC__uint32 mask, unsigned channels)
2929 FLAC__uint32 x = 0x80000000;
2930 unsigned count = count_channel_mask_bits(mask);
2931 while(x && count > channels) {
2938 FLAC__ASSERT(count_channel_mask_bits(mask) == channels);