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/grabbag.h"
49 #define min(x,y) ((x)<(y)?(x):(y))
53 #define max(x,y) ((x)>(y)?(x):(y))
55 /* this MUST be >= 588 so that sector aligning can take place with one read */
56 #define CHUNK_OF_SAMPLES 2048
64 FLAC__bool outputfile_opened; /* true if we successfully opened the output file and we want it to be deleted if there is an error */
65 const char *inbasefilename;
66 const char *infilename;
67 const char *outfilename;
70 FLAC__uint64 until; /* a value of 0 mean end-of-stream (i.e. --until=-0) */
71 FLAC__bool treat_warnings_as_errors;
72 FLAC__bool continue_through_decode_errors;
73 FLAC__bool replay_gain;
75 unsigned bits_per_sample;
77 FLAC__uint64 unencoded_size;
78 FLAC__uint64 total_samples_to_encode;
79 FLAC__uint64 bytes_written;
80 FLAC__uint64 samples_written;
83 FLAC__StreamEncoder *encoder;
86 FLAC__StreamMetadata *seek_table_template;
89 /* this is data attached to the FLAC decoder when encoding from a FLAC file */
91 EncoderSession *encoder_session;
93 const FLAC__byte *lookahead;
94 unsigned lookahead_length;
95 size_t num_metadata_blocks;
96 FLAC__StreamMetadata *metadata_blocks[1024]; /*@@@ BAD MAGIC number */
97 FLAC__uint64 samples_left_to_process;
98 FLAC__bool fatal_error;
101 const int FLAC_ENCODE__DEFAULT_PADDING = 8192;
103 static FLAC__bool is_big_endian_host_;
105 static unsigned char ucbuffer_[CHUNK_OF_SAMPLES*FLAC__MAX_CHANNELS*((FLAC__REFERENCE_CODEC_MAX_BITS_PER_SAMPLE+7)/8)];
106 static signed char *scbuffer_ = (signed char *)ucbuffer_;
107 static FLAC__uint16 *usbuffer_ = (FLAC__uint16 *)ucbuffer_;
108 static FLAC__int16 *ssbuffer_ = (FLAC__int16 *)ucbuffer_;
110 static FLAC__int32 in_[FLAC__MAX_CHANNELS][CHUNK_OF_SAMPLES];
111 static FLAC__int32 *input_[FLAC__MAX_CHANNELS];
115 * unpublished debug routines from the FLAC libs
117 extern FLAC__bool FLAC__stream_encoder_disable_constant_subframes(FLAC__StreamEncoder *encoder, FLAC__bool value);
118 extern FLAC__bool FLAC__stream_encoder_disable_fixed_subframes(FLAC__StreamEncoder *encoder, FLAC__bool value);
119 extern FLAC__bool FLAC__stream_encoder_disable_verbatim_subframes(FLAC__StreamEncoder *encoder, FLAC__bool value);
120 extern FLAC__bool FLAC__stream_encoder_set_do_md5(FLAC__StreamEncoder *encoder, FLAC__bool value);
125 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);
126 static void EncoderSession_destroy(EncoderSession *e);
127 static int EncoderSession_finish_ok(EncoderSession *e, int info_align_carry, int info_align_zero, foreign_metadata_t *foreign_metadata);
128 static int EncoderSession_finish_error(EncoderSession *e);
129 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);
130 static FLAC__bool EncoderSession_process(EncoderSession *e, const FLAC__int32 * const buffer[], unsigned samples);
131 static FLAC__bool convert_to_seek_table_template(const char *requested_seek_points, int num_requested_seek_points, FLAC__StreamMetadata *cuesheet, EncoderSession *e);
132 static FLAC__bool canonicalize_until_specification(utils__SkipUntilSpecification *spec, const char *inbasefilename, unsigned sample_rate, FLAC__uint64 skip, FLAC__uint64 total_samples_in_input);
133 static FLAC__bool verify_metadata(const EncoderSession *e, FLAC__StreamMetadata **metadata, unsigned num_metadata);
134 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);
135 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);
136 static FLAC__StreamDecoderReadStatus flac_decoder_read_callback(const FLAC__StreamDecoder *decoder, FLAC__byte buffer[], size_t *bytes, void *client_data);
137 static FLAC__StreamDecoderSeekStatus flac_decoder_seek_callback(const FLAC__StreamDecoder *decoder, FLAC__uint64 absolute_byte_offset, void *client_data);
138 static FLAC__StreamDecoderTellStatus flac_decoder_tell_callback(const FLAC__StreamDecoder *decoder, FLAC__uint64 *absolute_byte_offset, void *client_data);
139 static FLAC__StreamDecoderLengthStatus flac_decoder_length_callback(const FLAC__StreamDecoder *decoder, FLAC__uint64 *stream_length, void *client_data);
140 static FLAC__bool flac_decoder_eof_callback(const FLAC__StreamDecoder *decoder, void *client_data);
141 static FLAC__StreamDecoderWriteStatus flac_decoder_write_callback(const FLAC__StreamDecoder *decoder, const FLAC__Frame *frame, const FLAC__int32 * const buffer[], void *client_data);
142 static void flac_decoder_metadata_callback(const FLAC__StreamDecoder *decoder, const FLAC__StreamMetadata *metadata, void *client_data);
143 static void flac_decoder_error_callback(const FLAC__StreamDecoder *decoder, FLAC__StreamDecoderErrorStatus status, void *client_data);
144 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);
145 static void print_stats(const EncoderSession *encoder_session);
146 static void print_error_with_init_status(const EncoderSession *e, const char *message, FLAC__StreamEncoderInitStatus init_status);
147 static void print_error_with_state(const EncoderSession *e, const char *message);
148 static void print_verify_error(EncoderSession *e);
149 static FLAC__bool read_little_endian_uint16(FILE *f, FLAC__uint16 *val, FLAC__bool eof_ok, const char *fn);
150 static FLAC__bool read_little_endian_uint32(FILE *f, FLAC__uint32 *val, FLAC__bool eof_ok, const char *fn);
151 static FLAC__bool read_big_endian_uint16(FILE *f, FLAC__uint16 *val, FLAC__bool eof_ok, const char *fn);
152 static FLAC__bool read_big_endian_uint32(FILE *f, FLAC__uint32 *val, FLAC__bool eof_ok, const char *fn);
153 static FLAC__bool read_sane_extended(FILE *f, FLAC__uint32 *val, FLAC__bool eof_ok, const char *fn);
154 static FLAC__bool fskip_ahead(FILE *f, FLAC__uint64 offset);
155 static unsigned count_channel_mask_bits(FLAC__uint32 mask);
157 static FLAC__uint32 limit_channel_mask(FLAC__uint32 mask, unsigned channels);
163 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)
165 EncoderSession encoder_session;
168 unsigned int channels= 0U, bps= 0U, shift= 0U, sample_rate= 0U, sample_frames= 0U;
169 size_t channel_map[FLAC__MAX_CHANNELS];
170 FLAC__bool got_comm_chunk= false, got_ssnd_chunk= false;
171 int info_align_carry= -1, info_align_zero= -1;
172 FLAC__bool is_big_endian_pcm = true;
174 (void)infilesize; /* silence compiler warning about unused parameter */
175 (void)lookahead; /* silence compiler warning about unused parameter */
176 (void)lookahead_length; /* silence compiler warning about unused parameter */
179 EncoderSession_construct(
182 options.common.use_ogg,
186 options.common.verify,
187 options.common.treat_warnings_as_errors,
188 options.common.continue_through_decode_errors,
196 /* initialize default channel map that preserves channel order */
199 for(i = 0; i < sizeof(channel_map)/sizeof(channel_map[0]); i++)
203 if(options.foreign_metadata) {
205 if(!flac__foreign_metadata_read_from_aiff(options.foreign_metadata, infilename, &error)) {
206 flac__utils_printf(stderr, 1, "%s: ERROR reading foreign metadata: %s\n", encoder_session.inbasefilename, error);
207 return EncoderSession_finish_error(&encoder_session);
211 /* lookahead[] already has "FORMxxxxAIFF", do sub-chunks */
215 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 */
217 /* chunk identifier; really conservative about behavior of fread() and feof() */
218 if(feof(infile) || ((c= fread(chunk_id, 1U, 4U, infile)), c==0U && feof(infile)))
220 else if(c<4U || feof(infile)) {
221 flac__utils_printf(stderr, 1, "%s: ERROR: incomplete chunk identifier\n", encoder_session.inbasefilename);
222 return EncoderSession_finish_error(&encoder_session);
225 if(got_comm_chunk==false && !memcmp(chunk_id, "COMM", 4)) { /* common chunk */
227 const FLAC__uint32 minimum_comm_size = (is_aifc? 22 : 18);
229 /* COMM chunk size */
230 if(!read_big_endian_uint32(infile, &xx, false, encoder_session.inbasefilename))
231 return EncoderSession_finish_error(&encoder_session);
232 else if(xx<minimum_comm_size) {
233 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);
234 return EncoderSession_finish_error(&encoder_session);
236 else if(!is_aifc && xx!=minimum_comm_size) {
237 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);
238 if(encoder_session.treat_warnings_as_errors)
239 return EncoderSession_finish_error(&encoder_session);
241 skip= (xx-minimum_comm_size)+(xx & 1U);
243 /* number of channels */
244 if(!read_big_endian_uint16(infile, &x, false, encoder_session.inbasefilename))
245 return EncoderSession_finish_error(&encoder_session);
246 else if(x==0U || x>FLAC__MAX_CHANNELS) {
247 flac__utils_printf(stderr, 1, "%s: ERROR: unsupported number channels %u\n", encoder_session.inbasefilename, (unsigned int)x);
248 return EncoderSession_finish_error(&encoder_session);
250 else if(x>2U && !options.common.channel_map_none) {
251 flac__utils_printf(stderr, 1, "%s: ERROR: unsupported number channels %u for AIFF\n", encoder_session.inbasefilename, (unsigned int)x);
252 return EncoderSession_finish_error(&encoder_session);
254 else if(options.common.sector_align && x!=2U) {
255 flac__utils_printf(stderr, 1, "%s: ERROR: file has %u channels, must be 2 for --sector-align\n", encoder_session.inbasefilename, (unsigned int)x);
256 return EncoderSession_finish_error(&encoder_session);
260 /* number of sample frames */
261 if(!read_big_endian_uint32(infile, &xx, false, encoder_session.inbasefilename))
262 return EncoderSession_finish_error(&encoder_session);
265 /* bits per sample */
266 if(!read_big_endian_uint16(infile, &x, false, encoder_session.inbasefilename))
267 return EncoderSession_finish_error(&encoder_session);
268 else if(x<4U || x>24U) {
269 flac__utils_printf(stderr, 1, "%s: ERROR: unsupported bits-per-sample %u\n", encoder_session.inbasefilename, (unsigned int)x);
270 return EncoderSession_finish_error(&encoder_session);
272 else if(options.common.sector_align && x!=16U) {
273 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);
274 return EncoderSession_finish_error(&encoder_session);
277 shift= (bps%8)? 8-(bps%8) : 0; /* SSND data is always byte-aligned, left-justified but format_input() will double-check */
281 if(!read_sane_extended(infile, &xx, false, encoder_session.inbasefilename))
282 return EncoderSession_finish_error(&encoder_session);
283 else if(!FLAC__format_sample_rate_is_valid(xx)) {
284 flac__utils_printf(stderr, 1, "%s: ERROR: unsupported sample rate %u\n", encoder_session.inbasefilename, (unsigned int)xx);
285 return EncoderSession_finish_error(&encoder_session);
287 else if(options.common.sector_align && xx!=44100U) {
288 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);
289 return EncoderSession_finish_error(&encoder_session);
293 /* check compression type for AIFF-C */
295 if(!read_big_endian_uint32(infile, &xx, false, encoder_session.inbasefilename))
296 return EncoderSession_finish_error(&encoder_session);
297 if(xx == 0x736F7774) /* "sowt" */
298 is_big_endian_pcm = false;
299 else if(xx == 0x4E4F4E45) /* "NONE" */
300 ; /* nothing to do, we already default to big-endian */
302 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));
303 return EncoderSession_finish_error(&encoder_session);
307 /* set channel mapping */
308 /* FLAC order follows SMPTE and WAVEFORMATEXTENSIBLE but with fewer channels, which are: */
309 /* front left, front right, center, LFE, back left, back right, surround left, surround right */
310 /* specs say the channel ordering is:
312 * ___________________________________________________
316 * quad (ambiguous with 4ch) Fl Fr Bl Br
319 * 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
320 * so we only have unambiguous mappings for 2, 3, and 5 channels
323 options.common.channel_map_none ||
324 channels == 1 || /* 1 channel: (mono) */
325 channels == 2 || /* 2 channels: left, right */
326 channels == 3 || /* 3 channels: left, right, center */
327 channels == 5 /* 5 channels: front left, front right, center, surround left, surround right */
329 /* keep default channel order */
332 flac__utils_printf(stderr, 1, "%s: ERROR: unsupported number channels %u for AIFF\n", encoder_session.inbasefilename, channels);
333 return EncoderSession_finish_error(&encoder_session);
336 /* skip any extra data in the COMM chunk */
337 if(!fskip_ahead(infile, skip)) {
338 flac__utils_printf(stderr, 1, "%s: ERROR during read while skipping extra COMM data\n", encoder_session.inbasefilename);
339 return EncoderSession_finish_error(&encoder_session);
343 * now that we know the sample rate, canonicalize the
344 * --skip string to a number of samples:
346 flac__utils_canonicalize_skip_until_specification(&options.common.skip_specification, sample_rate);
347 FLAC__ASSERT(options.common.skip_specification.value.samples >= 0);
348 encoder_session.skip = (FLAC__uint64)options.common.skip_specification.value.samples;
349 FLAC__ASSERT(!options.common.sector_align || encoder_session.skip == 0);
351 got_comm_chunk= true;
353 else if(got_ssnd_chunk==false && !memcmp(chunk_id, "SSND", 4)) { /* sound data chunk */
354 unsigned int offset= 0U, block_size= 0U, align_remainder= 0U, data_bytes;
355 const size_t bytes_per_frame= channels*(bps>>3);
356 FLAC__uint64 total_samples_in_input, trim = 0;
357 FLAC__bool pad= false;
359 if(got_comm_chunk==false) {
360 flac__utils_printf(stderr, 1, "%s: ERROR: got 'SSND' chunk before 'COMM' chunk\n", encoder_session.inbasefilename);
361 return EncoderSession_finish_error(&encoder_session);
364 /* SSND chunk size */
365 if(!read_big_endian_uint32(infile, &xx, false, encoder_session.inbasefilename))
366 return EncoderSession_finish_error(&encoder_session);
367 if(options.common.ignore_chunk_sizes) {
368 FLAC__ASSERT(!options.common.sector_align);
369 data_bytes = (unsigned)(-(int)bytes_per_frame); /* max out data_bytes; we'll use EOF as signal to stop reading */
373 data_bytes-= 8U; /* discount the offset and block size fields */
375 pad= (data_bytes & 1U) ? true : false;
378 if(!read_big_endian_uint32(infile, &xx, false, encoder_session.inbasefilename))
379 return EncoderSession_finish_error(&encoder_session);
384 if(!read_big_endian_uint32(infile, &xx, false, encoder_session.inbasefilename))
385 return EncoderSession_finish_error(&encoder_session);
387 flac__utils_printf(stderr, 1, "%s: ERROR: block size is %u; must be 0\n", encoder_session.inbasefilename, (unsigned int)xx);
388 return EncoderSession_finish_error(&encoder_session);
392 /* skip any SSND offset bytes */
393 FLAC__ASSERT(offset<=LONG_MAX);
394 if(!fskip_ahead(infile, offset)) {
395 flac__utils_printf(stderr, 1, "%s: ERROR: skipping offset in SSND chunk\n", encoder_session.inbasefilename);
396 return EncoderSession_finish_error(&encoder_session);
398 if(data_bytes!=(sample_frames*bytes_per_frame)) {
399 flac__utils_printf(stderr, 1, "%s: ERROR: SSND chunk size inconsistent with sample frame count\n", encoder_session.inbasefilename);
400 return EncoderSession_finish_error(&encoder_session);
403 /* *options.common.align_reservoir_samples will be 0 unless --sector-align is used */
404 FLAC__ASSERT(options.common.sector_align || *options.common.align_reservoir_samples == 0);
405 total_samples_in_input = data_bytes / bytes_per_frame + *options.common.align_reservoir_samples;
408 * now that we know the input size, canonicalize the
409 * --until string to an absolute sample number:
411 if(!canonicalize_until_specification(&options.common.until_specification, encoder_session.inbasefilename, sample_rate, encoder_session.skip, total_samples_in_input))
412 return EncoderSession_finish_error(&encoder_session);
413 encoder_session.until = (FLAC__uint64)options.common.until_specification.value.samples;
414 FLAC__ASSERT(!options.common.sector_align || encoder_session.until == 0);
416 if(encoder_session.skip>0U) {
417 if(!fskip_ahead(infile, encoder_session.skip*bytes_per_frame)) {
418 flac__utils_printf(stderr, 1, "%s: ERROR during read while skipping samples\n", encoder_session.inbasefilename);
419 return EncoderSession_finish_error(&encoder_session);
423 data_bytes-= (unsigned int)encoder_session.skip*bytes_per_frame; /*@@@ WATCHOUT: 4GB limit */
424 if(options.common.ignore_chunk_sizes) {
425 encoder_session.total_samples_to_encode= 0;
426 flac__utils_printf(stderr, 2, "(No runtime statistics possible; please wait for encoding to finish...)\n");
427 FLAC__ASSERT(0 == encoder_session.until);
430 encoder_session.total_samples_to_encode= total_samples_in_input - encoder_session.skip;
432 if(encoder_session.until > 0) {
433 trim = total_samples_in_input - encoder_session.until;
434 FLAC__ASSERT(total_samples_in_input > 0);
435 FLAC__ASSERT(!options.common.sector_align);
436 data_bytes-= (unsigned int)trim*bytes_per_frame;
437 encoder_session.total_samples_to_encode-= trim;
439 if(options.common.sector_align) {
440 align_remainder= (unsigned int)(encoder_session.total_samples_to_encode % 588U);
441 if(options.common.is_last_file)
442 encoder_session.total_samples_to_encode+= (588U-align_remainder); /* will pad with zeroes */
444 encoder_session.total_samples_to_encode-= align_remainder; /* will stop short and carry over to next file */
447 /* +54 for the size of the AIFF headers; this is just an estimate for the progress indicator and doesn't need to be exact */
448 encoder_session.unencoded_size= encoder_session.total_samples_to_encode*bytes_per_frame+54;
450 if(!EncoderSession_init_encoder(&encoder_session, options.common, /*channel_mask=*/0, channels, bps-shift, sample_rate, options.foreign_metadata, /*flac_decoder_data=*/0))
451 return EncoderSession_finish_error(&encoder_session);
453 /* first do any samples in the reservoir */
454 if(options.common.sector_align && *options.common.align_reservoir_samples>0U) {
456 if(!EncoderSession_process(&encoder_session, (const FLAC__int32 *const *)options.common.align_reservoir, *options.common.align_reservoir_samples)) {
457 print_error_with_state(&encoder_session, "ERROR during encoding");
458 return EncoderSession_finish_error(&encoder_session);
462 /* decrement the data_bytes counter if we need to align the file */
463 if(options.common.sector_align) {
464 if(options.common.is_last_file)
465 *options.common.align_reservoir_samples= 0U;
467 *options.common.align_reservoir_samples= align_remainder;
468 data_bytes-= (*options.common.align_reservoir_samples)*bytes_per_frame;
472 /* now do from the file */
473 while(data_bytes>0) {
474 size_t bytes_read= fread(ucbuffer_, 1U, min(data_bytes, CHUNK_OF_SAMPLES*bytes_per_frame), infile);
478 flac__utils_printf(stderr, 1, "%s: ERROR during read\n", encoder_session.inbasefilename);
479 return EncoderSession_finish_error(&encoder_session);
481 else if(feof(infile)) {
482 if(options.common.ignore_chunk_sizes) {
483 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);
486 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);
487 if(encoder_session.treat_warnings_as_errors)
488 return EncoderSession_finish_error(&encoder_session);
494 if(bytes_read % bytes_per_frame != 0U) {
495 flac__utils_printf(stderr, 1, "%s: ERROR: got partial sample\n", encoder_session.inbasefilename);
496 return EncoderSession_finish_error(&encoder_session);
499 unsigned int frames= bytes_read/bytes_per_frame;
500 if(!format_input(input_, frames, is_big_endian_pcm, /*is_unsigned_samples=*/false, channels, bps, shift, channel_map))
501 return EncoderSession_finish_error(&encoder_session);
503 if(!EncoderSession_process(&encoder_session, (const FLAC__int32 *const *)input_, frames)) {
504 print_error_with_state(&encoder_session, "ERROR during encoding");
505 return EncoderSession_finish_error(&encoder_session);
508 data_bytes-= bytes_read;
514 FLAC__ASSERT(!options.common.sector_align);
515 if(!fskip_ahead(infile, trim*bytes_per_frame)) {
516 flac__utils_printf(stderr, 1, "%s: ERROR during read while skipping samples\n", encoder_session.inbasefilename);
517 return EncoderSession_finish_error(&encoder_session);
521 /* now read unaligned samples into reservoir or pad with zeroes if necessary */
522 if(options.common.sector_align) {
523 if(options.common.is_last_file) {
524 unsigned int pad_frames= 588U-align_remainder;
526 if(pad_frames<588U) {
529 info_align_zero= pad_frames;
530 for(i= 0U; i<channels; ++i)
531 memset(input_[i], 0, sizeof(input_[0][0])*pad_frames);
533 if(!EncoderSession_process(&encoder_session, (const FLAC__int32 *const *)input_, pad_frames)) {
534 print_error_with_state(&encoder_session, "ERROR during encoding");
535 return EncoderSession_finish_error(&encoder_session);
540 if(*options.common.align_reservoir_samples > 0) {
541 size_t bytes_read= fread(ucbuffer_, 1U, (*options.common.align_reservoir_samples)*bytes_per_frame, infile);
543 FLAC__ASSERT(CHUNK_OF_SAMPLES>=588U);
544 if(bytes_read==0U && ferror(infile)) {
545 flac__utils_printf(stderr, 1, "%s: ERROR during read\n", encoder_session.inbasefilename);
546 return EncoderSession_finish_error(&encoder_session);
548 else if(bytes_read != (*options.common.align_reservoir_samples) * bytes_per_frame) {
549 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);
550 if(encoder_session.treat_warnings_as_errors)
551 return EncoderSession_finish_error(&encoder_session);
554 info_align_carry= *options.common.align_reservoir_samples;
555 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))
556 return EncoderSession_finish_error(&encoder_session);
565 if(fread(&tmp, 1U, 1U, infile)<1U) {
566 flac__utils_printf(stderr, 1, "%s: ERROR during read of SSND pad byte\n", encoder_session.inbasefilename);
567 return EncoderSession_finish_error(&encoder_session);
571 got_ssnd_chunk= true;
573 else { /* other chunk */
574 if(!memcmp(chunk_id, "COMM", 4)) {
575 flac__utils_printf(stderr, 1, "%s: WARNING: skipping extra 'COMM' chunk\n", encoder_session.inbasefilename);
576 if(encoder_session.treat_warnings_as_errors)
577 return EncoderSession_finish_error(&encoder_session);
579 else if(!memcmp(chunk_id, "SSND", 4)) {
580 flac__utils_printf(stderr, 1, "%s: WARNING: skipping extra 'SSND' chunk\n", encoder_session.inbasefilename);
581 if(encoder_session.treat_warnings_as_errors)
582 return EncoderSession_finish_error(&encoder_session);
584 else if(!options.foreign_metadata) {
585 flac__utils_printf(stderr, 1, "%s: WARNING: skipping unknown chunk '%s'\n", encoder_session.inbasefilename, chunk_id);
586 if(encoder_session.treat_warnings_as_errors)
587 return EncoderSession_finish_error(&encoder_session);
591 if(!read_big_endian_uint32(infile, &xx, false, encoder_session.inbasefilename))
592 return EncoderSession_finish_error(&encoder_session);
594 unsigned long skip= xx+(xx & 1U);
596 FLAC__ASSERT(skip<=LONG_MAX);
597 if(!fskip_ahead(infile, skip)) {
598 fprintf(stderr, "%s: ERROR during read while skipping unknown chunk\n", encoder_session.inbasefilename);
599 return EncoderSession_finish_error(&encoder_session);
605 if(got_ssnd_chunk==false && sample_frames!=0U) {
606 flac__utils_printf(stderr, 1, "%s: ERROR: missing SSND chunk\n", encoder_session.inbasefilename);
607 return EncoderSession_finish_error(&encoder_session);
610 return EncoderSession_finish_ok(&encoder_session, info_align_carry, info_align_zero, options.foreign_metadata);
613 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)
615 EncoderSession encoder_session;
616 FLAC__bool is_unsigned_samples = false;
617 unsigned channels = 0, bps = 0, sample_rate = 0, shift = 0;
619 size_t channel_map[FLAC__MAX_CHANNELS];
620 FLAC__uint16 x, format; /* format is the wFormatTag word from the 'fmt ' chunk */
621 FLAC__uint32 xx, channel_mask = 0;
622 FLAC__bool got_fmt_chunk = false, got_data_chunk = false;
623 unsigned align_remainder = 0;
624 int info_align_carry = -1, info_align_zero = -1;
628 (void)lookahead_length;
631 EncoderSession_construct(
634 options.common.use_ogg,
638 options.common.verify,
639 options.common.treat_warnings_as_errors,
640 options.common.continue_through_decode_errors,
648 /* initialize default channel map that preserves channel order */
651 for(i = 0; i < sizeof(channel_map)/sizeof(channel_map[0]); i++)
655 if(options.foreign_metadata) {
657 if(!flac__foreign_metadata_read_from_wave(options.foreign_metadata, infilename, &error)) {
658 flac__utils_printf(stderr, 1, "%s: ERROR reading foreign metadata: %s\n", encoder_session.inbasefilename, error);
659 return EncoderSession_finish_error(&encoder_session);
664 * lookahead[] already has "RIFFxxxxWAVE", do sub-chunks
666 while(!feof(infile)) {
667 if(!read_little_endian_uint32(infile, &xx, true, encoder_session.inbasefilename))
668 return EncoderSession_finish_error(&encoder_session);
671 if(xx == 0x20746d66 && !got_fmt_chunk) { /* "fmt " */
672 unsigned block_align, data_bytes;
675 * http://www-mmsp.ece.mcgill.ca/Documents/AudioFormats/WAVE/WAVE.html
676 * http://windowssdk.msdn.microsoft.com/en-us/library/ms713497.aspx
677 * 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
680 * 4 byte: subchunk size
681 * 2 byte: format type: 1 for WAVE_FORMAT_PCM, 65534 for WAVE_FORMAT_EXTENSIBLE
683 * 4 byte: sample rate (Hz)
684 * 4 byte: avg bytes per sec
685 * 2 byte: block align
686 * 2 byte: bits per sample (not necessarily all significant)
688 * 2 byte: extension size in bytes (usually 0 for WAVEFORMATEX and 22 for WAVEFORMATEXTENSIBLE with PCM)
689 * WAVEFORMATEXTENSIBLE adds
690 * 2 byte: valid bits per sample
691 * 4 byte: channel mask
692 * 16 byte: subformat GUID, first 2 bytes have format type, 1 being PCM
694 * Current spec says WAVEFORMATEX with PCM must have bps == 8 or 16, or any multiple of 8 for WAVEFORMATEXTENSIBLE.
695 * 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.
697 * Block align for WAVE_FORMAT_PCM or WAVE_FORMAT_EXTENSIBLE is also supposed to be channels*bps/8
699 * If the channel mask has more set bits than # of channels, the extra MSBs are ignored.
700 * If the channel mask has less set bits than # of channels, the extra channels are unassigned to any speaker.
702 * Data is supposed to be unsigned for bps <= 8 else signed.
705 /* fmt sub-chunk size */
706 if(!read_little_endian_uint32(infile, &xx, false, encoder_session.inbasefilename))
707 return EncoderSession_finish_error(&encoder_session);
709 if(data_bytes < 16) {
710 flac__utils_printf(stderr, 1, "%s: ERROR: found non-standard 'fmt ' sub-chunk which has length = %u\n", encoder_session.inbasefilename, data_bytes);
711 return EncoderSession_finish_error(&encoder_session);
714 if(!read_little_endian_uint16(infile, &format, false, encoder_session.inbasefilename))
715 return EncoderSession_finish_error(&encoder_session);
716 if(format != 1 /*WAVE_FORMAT_PCM*/ && format != 65534 /*WAVE_FORMAT_EXTENSIBLE*/) {
717 flac__utils_printf(stderr, 1, "%s: ERROR: unsupported format type %u\n", encoder_session.inbasefilename, (unsigned)format);
718 return EncoderSession_finish_error(&encoder_session);
720 /* number of channels */
721 if(!read_little_endian_uint16(infile, &x, false, encoder_session.inbasefilename))
722 return EncoderSession_finish_error(&encoder_session);
723 channels = (unsigned)x;
724 if(channels == 0 || channels > FLAC__MAX_CHANNELS) {
725 flac__utils_printf(stderr, 1, "%s: ERROR: unsupported number of channels %u\n", encoder_session.inbasefilename, channels);
726 return EncoderSession_finish_error(&encoder_session);
728 else if(options.common.sector_align && channels != 2) {
729 flac__utils_printf(stderr, 1, "%s: ERROR: file has %u channels, must be 2 for --sector-align\n", encoder_session.inbasefilename, channels);
730 return EncoderSession_finish_error(&encoder_session);
733 if(!read_little_endian_uint32(infile, &xx, false, encoder_session.inbasefilename))
734 return EncoderSession_finish_error(&encoder_session);
736 if(!FLAC__format_sample_rate_is_valid(sample_rate)) {
737 flac__utils_printf(stderr, 1, "%s: ERROR: unsupported sample rate %u\n", encoder_session.inbasefilename, sample_rate);
738 return EncoderSession_finish_error(&encoder_session);
740 else if(options.common.sector_align && sample_rate != 44100) {
741 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);
742 return EncoderSession_finish_error(&encoder_session);
744 /* avg bytes per second (ignored) */
745 if(!read_little_endian_uint32(infile, &xx, false, encoder_session.inbasefilename))
746 return EncoderSession_finish_error(&encoder_session);
748 if(!read_little_endian_uint16(infile, &x, false, encoder_session.inbasefilename))
749 return EncoderSession_finish_error(&encoder_session);
750 block_align = (unsigned)x;
751 /* bits per sample */
752 if(!read_little_endian_uint16(infile, &x, false, encoder_session.inbasefilename))
753 return EncoderSession_finish_error(&encoder_session);
755 is_unsigned_samples = (bps <= 8);
757 if(bps != 8 && bps != 16) {
758 if(bps == 24 || bps == 32) {
759 /* let these slide with a warning since they're unambiguous */
760 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);
761 if(encoder_session.treat_warnings_as_errors)
762 return EncoderSession_finish_error(&encoder_session);
765 /* @@@ we could add an option to specify left- or right-justified blocks so we knew how to set 'shift' */
766 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);
767 return EncoderSession_finish_error(&encoder_session);
770 #if 0 /* @@@ reinstate once we can get an answer about whether the samples are left- or right-justified */
771 if((bps+7)/8 * channels == block_align) {
773 /* assume legacy file is byte aligned with some LSBs zero; this is double-checked in format_input() */
774 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);
775 if(encoder_session.treat_warnings_as_errors)
776 return EncoderSession_finish_error(&encoder_session);
777 shift = 8 - (bps % 8);
784 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);
785 return EncoderSession_finish_error(&encoder_session);
790 if(channels > 2 && !options.common.channel_map_none) {
791 flac__utils_printf(stderr, 1, "%s: ERROR: WAVE has >2 channels but is not WAVE_FORMAT_EXTENSIBLE; cannot assign channels\n", encoder_session.inbasefilename);
792 return EncoderSession_finish_error(&encoder_session);
794 FLAC__ASSERT(data_bytes >= 16);
798 if(data_bytes < 40) {
799 flac__utils_printf(stderr, 1, "%s: ERROR: invalid WAVEFORMATEXTENSIBLE chunk with size %u\n", encoder_session.inbasefilename, data_bytes);
800 return EncoderSession_finish_error(&encoder_session);
803 if(!read_little_endian_uint16(infile, &x, false, encoder_session.inbasefilename))
804 return EncoderSession_finish_error(&encoder_session);
806 flac__utils_printf(stderr, 1, "%s: ERROR: invalid WAVEFORMATEXTENSIBLE chunk with cbSize %u\n", encoder_session.inbasefilename, (unsigned)x);
807 return EncoderSession_finish_error(&encoder_session);
810 if(!read_little_endian_uint16(infile, &x, false, encoder_session.inbasefilename))
811 return EncoderSession_finish_error(&encoder_session);
812 if((unsigned)x > bps) {
813 flac__utils_printf(stderr, 1, "%s: ERROR: invalid WAVEFORMATEXTENSIBLE chunk with wValidBitsPerSample (%u) > wBitsPerSample (%u)\n", encoder_session.inbasefilename, (unsigned)x, bps);
814 return EncoderSession_finish_error(&encoder_session);
816 shift = bps - (unsigned)x;
818 if(!read_little_endian_uint32(infile, &channel_mask, false, encoder_session.inbasefilename))
819 return EncoderSession_finish_error(&encoder_session);
820 /* for mono/stereo and unassigned channels, we fake the mask */
821 if(channel_mask == 0) {
823 channel_mask = 0x0001;
824 else if(channels == 2)
825 channel_mask = 0x0003;
827 /* set channel mapping */
828 /* FLAC order follows SMPTE and WAVEFORMATEXTENSIBLE but with fewer channels, which are: */
829 /* front left, front right, center, LFE, back left, back right, surround left, surround right */
830 /* the default mapping is sufficient for 1-6 channels and 7-8 are currently unspecified anyway */
832 /* @@@ example for dolby/vorbis order, for reference later in case it becomes important */
834 options.common.channel_map_none ||
835 channel_mask == 0x0001 || /* 1 channel: (mono) */
836 channel_mask == 0x0003 || /* 2 channels: front left, front right */
837 channel_mask == 0x0033 || /* 4 channels: front left, front right, back left, back right */
838 channel_mask == 0x0603 /* 4 channels: front left, front right, side left, side right */
840 /* keep default channel order */
843 channel_mask == 0x0007 || /* 3 channels: front left, front right, front center */
844 channel_mask == 0x0037 || /* 5 channels: front left, front right, front center, back left, back right */
845 channel_mask == 0x0607 /* 5 channels: front left, front right, front center, side left, side right */
847 /* to dolby order: front left, center, front right [, surround left, surround right ] */
852 channel_mask == 0x003f || /* 6 channels: front left, front right, front center, LFE, back left, back right */
853 channel_mask == 0x060f /* 6 channels: front left, front right, front center, LFE, side left, side right */
855 /* to dolby order: front left, center, front right, surround left, surround right, LFE */
864 options.common.channel_map_none ||
865 channel_mask == 0x0001 || /* 1 channel: (mono) */
866 channel_mask == 0x0003 || /* 2 channels: front left, front right */
867 channel_mask == 0x0007 || /* 3 channels: front left, front right, front center */
868 channel_mask == 0x0033 || /* 4 channels: front left, front right, back left, back right */
869 channel_mask == 0x0603 || /* 4 channels: front left, front right, side left, side right */
870 channel_mask == 0x0037 || /* 5 channels: front left, front right, front center, back left, back right */
871 channel_mask == 0x0607 || /* 5 channels: front left, front right, front center, side left, side right */
872 channel_mask == 0x003f || /* 6 channels: front left, front right, front center, LFE, back left, back right */
873 channel_mask == 0x060f /* 6 channels: front left, front right, front center, LFE, side left, side right */
875 /* keep default channel order */
879 flac__utils_printf(stderr, 1, "%s: ERROR: WAVEFORMATEXTENSIBLE chunk with unsupported channel mask=0x%04X\n", encoder_session.inbasefilename, (unsigned)channel_mask);
880 return EncoderSession_finish_error(&encoder_session);
882 if(!options.common.channel_map_none) {
883 if(count_channel_mask_bits(channel_mask) < channels) {
884 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);
885 return EncoderSession_finish_error(&encoder_session);
888 /* supporting this is too difficult with channel mapping; e.g. what if mask is 0x003f but #channels=4?
889 * there would be holes in the order that would have to be filled in, or the mask would have to be
890 * limited and the logic above rerun to see if it still fits into the FLAC mapping.
892 else if(count_channel_mask_bits(channel_mask) > channels)
893 channel_mask = limit_channel_mask(channel_mask, channels);
895 else if(count_channel_mask_bits(channel_mask) > channels) {
896 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);
897 return EncoderSession_finish_error(&encoder_session);
901 /* first part of GUID */
902 if(!read_little_endian_uint16(infile, &x, false, encoder_session.inbasefilename))
903 return EncoderSession_finish_error(&encoder_session);
905 flac__utils_printf(stderr, 1, "%s: ERROR: unsupported WAVEFORMATEXTENSIBLE chunk with non-PCM format %u\n", encoder_session.inbasefilename, (unsigned)x);
906 return EncoderSession_finish_error(&encoder_session);
911 if(bps-shift < 4 || bps-shift > 24) {
912 flac__utils_printf(stderr, 1, "%s: ERROR: unsupported bits-per-sample %u\n", encoder_session.inbasefilename, bps-shift);
913 return EncoderSession_finish_error(&encoder_session);
915 else if(options.common.sector_align && bps-shift != 16) {
916 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);
917 return EncoderSession_finish_error(&encoder_session);
920 /* skip any extra data in the fmt sub-chunk */
921 if(!fskip_ahead(infile, data_bytes)) {
922 flac__utils_printf(stderr, 1, "%s: ERROR during read while skipping extra 'fmt' data\n", encoder_session.inbasefilename);
923 return EncoderSession_finish_error(&encoder_session);
927 * now that we know the sample rate, canonicalize the
928 * --skip string to a number of samples:
930 flac__utils_canonicalize_skip_until_specification(&options.common.skip_specification, sample_rate);
931 FLAC__ASSERT(options.common.skip_specification.value.samples >= 0);
932 encoder_session.skip = (FLAC__uint64)options.common.skip_specification.value.samples;
933 FLAC__ASSERT(!options.common.sector_align || encoder_session.skip == 0);
935 got_fmt_chunk = true;
937 else if(xx == 0x61746164 && !got_data_chunk && got_fmt_chunk) { /* "data" */
938 FLAC__uint64 total_samples_in_input, trim = 0;
939 FLAC__bool pad = false;
940 const size_t bytes_per_wide_sample = channels * (bps >> 3);
944 if(!read_little_endian_uint32(infile, &xx, false, encoder_session.inbasefilename))
945 return EncoderSession_finish_error(&encoder_session);
946 if(options.common.ignore_chunk_sizes) {
947 FLAC__ASSERT(!options.common.sector_align);
948 data_bytes = (unsigned)(-(int)bytes_per_wide_sample); /* max out data_bytes; we'll use EOF as signal to stop reading */
952 if(0 == data_bytes) {
953 flac__utils_printf(stderr, 1, "%s: ERROR: 'data' subchunk has size of 0\n", encoder_session.inbasefilename);
954 return EncoderSession_finish_error(&encoder_session);
957 pad = (data_bytes & 1U) ? true : false;
959 /* *options.common.align_reservoir_samples will be 0 unless --sector-align is used */
960 FLAC__ASSERT(options.common.sector_align || *options.common.align_reservoir_samples == 0);
961 total_samples_in_input = data_bytes / bytes_per_wide_sample + *options.common.align_reservoir_samples;
964 * now that we know the input size, canonicalize the
965 * --until string to an absolute sample number:
967 if(!canonicalize_until_specification(&options.common.until_specification, encoder_session.inbasefilename, sample_rate, encoder_session.skip, total_samples_in_input))
968 return EncoderSession_finish_error(&encoder_session);
969 encoder_session.until = (FLAC__uint64)options.common.until_specification.value.samples;
970 FLAC__ASSERT(!options.common.sector_align || encoder_session.until == 0);
972 if(encoder_session.skip > 0) {
973 if(!fskip_ahead(infile, encoder_session.skip * bytes_per_wide_sample)) {
974 flac__utils_printf(stderr, 1, "%s: ERROR during read while skipping samples\n", encoder_session.inbasefilename);
975 return EncoderSession_finish_error(&encoder_session);
979 data_bytes -= (unsigned)encoder_session.skip * bytes_per_wide_sample; /*@@@ WATCHOUT: 4GB limit */
980 if(options.common.ignore_chunk_sizes) {
981 encoder_session.total_samples_to_encode = 0;
982 flac__utils_printf(stderr, 2, "(No runtime statistics possible; please wait for encoding to finish...)\n");
983 FLAC__ASSERT(0 == encoder_session.until);
986 encoder_session.total_samples_to_encode = total_samples_in_input - encoder_session.skip;
988 if(encoder_session.until > 0) {
989 trim = total_samples_in_input - encoder_session.until;
990 FLAC__ASSERT(total_samples_in_input > 0);
991 FLAC__ASSERT(!options.common.sector_align);
992 data_bytes -= (unsigned int)trim * bytes_per_wide_sample;
993 encoder_session.total_samples_to_encode -= trim;
995 if(options.common.sector_align) {
996 align_remainder = (unsigned)(encoder_session.total_samples_to_encode % 588);
997 if(options.common.is_last_file)
998 encoder_session.total_samples_to_encode += (588-align_remainder); /* will pad with zeroes */
1000 encoder_session.total_samples_to_encode -= align_remainder; /* will stop short and carry over to next file */
1003 /* +44 for the size of the WAV headers; this is just an estimate for the progress indicator and doesn't need to be exact */
1004 encoder_session.unencoded_size = encoder_session.total_samples_to_encode * bytes_per_wide_sample + 44;
1006 if(!EncoderSession_init_encoder(&encoder_session, options.common, channel_mask, channels, bps-shift, sample_rate, options.foreign_metadata, /*flac_decoder_data=*/0))
1007 return EncoderSession_finish_error(&encoder_session);
1010 * first do any samples in the reservoir
1012 if(options.common.sector_align && *options.common.align_reservoir_samples > 0) {
1013 if(!EncoderSession_process(&encoder_session, (const FLAC__int32 * const *)options.common.align_reservoir, *options.common.align_reservoir_samples)) {
1014 print_error_with_state(&encoder_session, "ERROR during encoding");
1015 return EncoderSession_finish_error(&encoder_session);
1020 * decrement the data_bytes counter if we need to align the file
1022 if(options.common.sector_align) {
1023 if(options.common.is_last_file) {
1024 *options.common.align_reservoir_samples = 0;
1027 *options.common.align_reservoir_samples = align_remainder;
1028 data_bytes -= (*options.common.align_reservoir_samples) * bytes_per_wide_sample;
1033 * now do from the file
1035 while(data_bytes > 0) {
1036 bytes_read = fread(ucbuffer_, sizeof(unsigned char), min(data_bytes, CHUNK_OF_SAMPLES * bytes_per_wide_sample), infile);
1037 if(bytes_read == 0) {
1038 if(ferror(infile)) {
1039 flac__utils_printf(stderr, 1, "%s: ERROR during read\n", encoder_session.inbasefilename);
1040 return EncoderSession_finish_error(&encoder_session);
1042 else if(feof(infile)) {
1043 if(options.common.ignore_chunk_sizes) {
1044 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);
1047 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);
1048 if(encoder_session.treat_warnings_as_errors)
1049 return EncoderSession_finish_error(&encoder_session);
1055 if(bytes_read % bytes_per_wide_sample != 0) {
1056 flac__utils_printf(stderr, 1, "%s: ERROR: got partial sample\n", encoder_session.inbasefilename);
1057 return EncoderSession_finish_error(&encoder_session);
1060 unsigned wide_samples = bytes_read / bytes_per_wide_sample;
1061 if(!format_input(input_, wide_samples, /*is_big_endian=*/false, is_unsigned_samples, channels, bps, shift, channel_map))
1062 return EncoderSession_finish_error(&encoder_session);
1064 if(!EncoderSession_process(&encoder_session, (const FLAC__int32 * const *)input_, wide_samples)) {
1065 print_error_with_state(&encoder_session, "ERROR during encoding");
1066 return EncoderSession_finish_error(&encoder_session);
1068 data_bytes -= bytes_read;
1074 FLAC__ASSERT(!options.common.sector_align);
1075 if(!fskip_ahead(infile, trim * bytes_per_wide_sample)) {
1076 flac__utils_printf(stderr, 1, "%s: ERROR during read while skipping samples\n", encoder_session.inbasefilename);
1077 return EncoderSession_finish_error(&encoder_session);
1082 * now read unaligned samples into reservoir or pad with zeroes if necessary
1084 if(options.common.sector_align) {
1085 if(options.common.is_last_file) {
1086 unsigned wide_samples = 588 - align_remainder;
1087 if(wide_samples < 588) {
1090 info_align_zero = wide_samples;
1091 for(channel = 0; channel < channels; channel++)
1092 memset(input_[channel], 0, sizeof(input_[0][0]) * wide_samples);
1094 if(!EncoderSession_process(&encoder_session, (const FLAC__int32 * const *)input_, wide_samples)) {
1095 print_error_with_state(&encoder_session, "ERROR during encoding");
1096 return EncoderSession_finish_error(&encoder_session);
1101 if(*options.common.align_reservoir_samples > 0) {
1102 FLAC__ASSERT(CHUNK_OF_SAMPLES >= 588);
1103 bytes_read = fread(ucbuffer_, sizeof(unsigned char), (*options.common.align_reservoir_samples) * bytes_per_wide_sample, infile);
1104 if(bytes_read == 0 && ferror(infile)) {
1105 flac__utils_printf(stderr, 1, "%s: ERROR during read\n", encoder_session.inbasefilename);
1106 return EncoderSession_finish_error(&encoder_session);
1108 else if(bytes_read != (*options.common.align_reservoir_samples) * bytes_per_wide_sample) {
1109 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);
1110 if(encoder_session.treat_warnings_as_errors)
1111 return EncoderSession_finish_error(&encoder_session);
1114 info_align_carry = *options.common.align_reservoir_samples;
1115 if(!format_input(options.common.align_reservoir, *options.common.align_reservoir_samples, /*is_big_endian=*/false, is_unsigned_samples, channels, bps, shift, channel_map))
1116 return EncoderSession_finish_error(&encoder_session);
1125 if(fread(&tmp, 1U, 1U, infile) < 1U) {
1126 flac__utils_printf(stderr, 1, "%s: ERROR during read of data pad byte\n", encoder_session.inbasefilename);
1127 return EncoderSession_finish_error(&encoder_session);
1131 got_data_chunk = true;
1134 if(xx == 0x20746d66 && got_fmt_chunk) { /* "fmt " */
1135 flac__utils_printf(stderr, 1, "%s: WARNING: skipping extra 'fmt ' sub-chunk\n", encoder_session.inbasefilename);
1136 if(encoder_session.treat_warnings_as_errors)
1137 return EncoderSession_finish_error(&encoder_session);
1139 else if(xx == 0x61746164) { /* "data" */
1140 if(got_data_chunk) {
1141 flac__utils_printf(stderr, 1, "%s: WARNING: skipping extra 'data' sub-chunk\n", encoder_session.inbasefilename);
1142 if(encoder_session.treat_warnings_as_errors)
1143 return EncoderSession_finish_error(&encoder_session);
1145 else if(!got_fmt_chunk) {
1146 flac__utils_printf(stderr, 1, "%s: ERROR: got 'data' sub-chunk before 'fmt' sub-chunk\n", encoder_session.inbasefilename);
1147 return EncoderSession_finish_error(&encoder_session);
1153 else if(!options.foreign_metadata) {
1154 flac__utils_printf(stderr, 1, "%s: WARNING: skipping unknown sub-chunk '%c%c%c%c'\n", encoder_session.inbasefilename, (char)(xx&255), (char)((xx>>8)&255), (char)((xx>>16)&255), (char)(xx>>24));
1155 if(encoder_session.treat_warnings_as_errors)
1156 return EncoderSession_finish_error(&encoder_session);
1158 /* sub-chunk size */
1159 if(!read_little_endian_uint32(infile, &xx, false, encoder_session.inbasefilename))
1160 return EncoderSession_finish_error(&encoder_session);
1162 unsigned long skip = xx+(xx & 1U);
1164 FLAC__ASSERT(skip<=LONG_MAX);
1165 if(!fskip_ahead(infile, skip)) {
1166 flac__utils_printf(stderr, 1, "%s: ERROR during read while skipping unsupported sub-chunk\n", encoder_session.inbasefilename);
1167 return EncoderSession_finish_error(&encoder_session);
1173 return EncoderSession_finish_ok(&encoder_session, info_align_carry, info_align_zero, options.foreign_metadata);
1176 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)
1178 EncoderSession encoder_session;
1180 const size_t bytes_per_wide_sample = options.channels * (options.bps >> 3);
1181 unsigned align_remainder = 0;
1182 int info_align_carry = -1, info_align_zero = -1;
1183 FLAC__uint64 total_samples_in_input = 0;
1185 FLAC__ASSERT(!options.common.sector_align || options.channels == 2);
1186 FLAC__ASSERT(!options.common.sector_align || options.bps == 16);
1187 FLAC__ASSERT(!options.common.sector_align || options.sample_rate == 44100);
1188 FLAC__ASSERT(!options.common.sector_align || infilesize >= 0);
1189 FLAC__ASSERT(!options.common.replay_gain || options.channels <= 2);
1190 FLAC__ASSERT(!options.common.replay_gain || grabbag__replaygain_is_valid_sample_frequency(options.sample_rate));
1193 EncoderSession_construct(
1196 options.common.use_ogg,
1200 options.common.verify,
1201 options.common.treat_warnings_as_errors,
1202 options.common.continue_through_decode_errors,
1211 * now that we know the sample rate, canonicalize the
1212 * --skip string to a number of samples:
1214 flac__utils_canonicalize_skip_until_specification(&options.common.skip_specification, options.sample_rate);
1215 FLAC__ASSERT(options.common.skip_specification.value.samples >= 0);
1216 encoder_session.skip = (FLAC__uint64)options.common.skip_specification.value.samples;
1217 FLAC__ASSERT(!options.common.sector_align || encoder_session.skip == 0);
1220 total_samples_in_input = 0;
1222 /* *options.common.align_reservoir_samples will be 0 unless --sector-align is used */
1223 FLAC__ASSERT(options.common.sector_align || *options.common.align_reservoir_samples == 0);
1224 total_samples_in_input = (FLAC__uint64)infilesize / bytes_per_wide_sample + *options.common.align_reservoir_samples;
1228 * now that we know the input size, canonicalize the
1229 * --until strings to a number of samples:
1231 if(!canonicalize_until_specification(&options.common.until_specification, encoder_session.inbasefilename, options.sample_rate, encoder_session.skip, total_samples_in_input))
1232 return EncoderSession_finish_error(&encoder_session);
1233 encoder_session.until = (FLAC__uint64)options.common.until_specification.value.samples;
1234 FLAC__ASSERT(!options.common.sector_align || encoder_session.until == 0);
1236 infilesize -= (off_t)encoder_session.skip * bytes_per_wide_sample;
1237 encoder_session.total_samples_to_encode = total_samples_in_input - encoder_session.skip;
1238 if(encoder_session.until > 0) {
1239 const FLAC__uint64 trim = total_samples_in_input - encoder_session.until;
1240 FLAC__ASSERT(total_samples_in_input > 0);
1241 FLAC__ASSERT(!options.common.sector_align);
1242 infilesize -= (off_t)trim * bytes_per_wide_sample;
1243 encoder_session.total_samples_to_encode -= trim;
1245 if(infilesize >= 0 && options.common.sector_align) {
1246 FLAC__ASSERT(encoder_session.skip == 0);
1247 align_remainder = (unsigned)(encoder_session.total_samples_to_encode % 588);
1248 if(options.common.is_last_file)
1249 encoder_session.total_samples_to_encode += (588-align_remainder); /* will pad with zeroes */
1251 encoder_session.total_samples_to_encode -= align_remainder; /* will stop short and carry over to next file */
1253 encoder_session.unencoded_size = encoder_session.total_samples_to_encode * bytes_per_wide_sample;
1255 if(encoder_session.total_samples_to_encode <= 0)
1256 flac__utils_printf(stderr, 2, "(No runtime statistics possible; please wait for encoding to finish...)\n");
1258 if(encoder_session.skip > 0) {
1259 unsigned skip_bytes = bytes_per_wide_sample * (unsigned)encoder_session.skip;
1260 if(skip_bytes > lookahead_length) {
1261 skip_bytes -= lookahead_length;
1262 lookahead_length = 0;
1263 if(!fskip_ahead(infile, skip_bytes)) {
1264 flac__utils_printf(stderr, 1, "%s: ERROR during read while skipping samples\n", encoder_session.inbasefilename);
1265 return EncoderSession_finish_error(&encoder_session);
1269 lookahead += skip_bytes;
1270 lookahead_length -= skip_bytes;
1274 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))
1275 return EncoderSession_finish_error(&encoder_session);
1278 * first do any samples in the reservoir
1280 if(options.common.sector_align && *options.common.align_reservoir_samples > 0) {
1281 if(!EncoderSession_process(&encoder_session, (const FLAC__int32 * const *)options.common.align_reservoir, *options.common.align_reservoir_samples)) {
1282 print_error_with_state(&encoder_session, "ERROR during encoding");
1283 return EncoderSession_finish_error(&encoder_session);
1288 * decrement infilesize if we need to align the file
1290 if(options.common.sector_align) {
1291 FLAC__ASSERT(infilesize >= 0);
1292 if(options.common.is_last_file) {
1293 *options.common.align_reservoir_samples = 0;
1296 *options.common.align_reservoir_samples = align_remainder;
1297 infilesize -= (off_t)((*options.common.align_reservoir_samples) * bytes_per_wide_sample);
1298 FLAC__ASSERT(infilesize >= 0);
1303 * now do from the file
1305 if(infilesize < 0) {
1306 while(!feof(infile)) {
1307 if(lookahead_length > 0) {
1308 FLAC__ASSERT(lookahead_length < CHUNK_OF_SAMPLES * bytes_per_wide_sample);
1309 memcpy(ucbuffer_, lookahead, lookahead_length);
1310 bytes_read = fread(ucbuffer_+lookahead_length, sizeof(unsigned char), CHUNK_OF_SAMPLES * bytes_per_wide_sample - lookahead_length, infile) + lookahead_length;
1311 if(ferror(infile)) {
1312 flac__utils_printf(stderr, 1, "%s: ERROR during read\n", encoder_session.inbasefilename);
1313 return EncoderSession_finish_error(&encoder_session);
1315 lookahead_length = 0;
1318 bytes_read = fread(ucbuffer_, sizeof(unsigned char), CHUNK_OF_SAMPLES * bytes_per_wide_sample, infile);
1320 if(bytes_read == 0) {
1321 if(ferror(infile)) {
1322 flac__utils_printf(stderr, 1, "%s: ERROR during read\n", encoder_session.inbasefilename);
1323 return EncoderSession_finish_error(&encoder_session);
1326 else if(bytes_read % bytes_per_wide_sample != 0) {
1327 flac__utils_printf(stderr, 1, "%s: ERROR: got partial sample\n", encoder_session.inbasefilename);
1328 return EncoderSession_finish_error(&encoder_session);
1331 unsigned wide_samples = bytes_read / bytes_per_wide_sample;
1332 if(!format_input(input_, wide_samples, options.is_big_endian, options.is_unsigned_samples, options.channels, options.bps, /*shift=*/0, /*channel_map=*/0))
1333 return EncoderSession_finish_error(&encoder_session);
1335 if(!EncoderSession_process(&encoder_session, (const FLAC__int32 * const *)input_, wide_samples)) {
1336 print_error_with_state(&encoder_session, "ERROR during encoding");
1337 return EncoderSession_finish_error(&encoder_session);
1343 const FLAC__uint64 max_input_bytes = infilesize;
1344 FLAC__uint64 total_input_bytes_read = 0;
1345 while(total_input_bytes_read < max_input_bytes) {
1347 size_t wanted = (CHUNK_OF_SAMPLES * bytes_per_wide_sample);
1348 wanted = (size_t) min((FLAC__uint64)wanted, max_input_bytes - total_input_bytes_read);
1350 if(lookahead_length > 0) {
1351 FLAC__ASSERT(lookahead_length <= wanted);
1352 memcpy(ucbuffer_, lookahead, lookahead_length);
1353 wanted -= lookahead_length;
1354 bytes_read = lookahead_length;
1356 bytes_read += fread(ucbuffer_+lookahead_length, sizeof(unsigned char), wanted, infile);
1357 if(ferror(infile)) {
1358 flac__utils_printf(stderr, 1, "%s: ERROR during read\n", encoder_session.inbasefilename);
1359 return EncoderSession_finish_error(&encoder_session);
1362 lookahead_length = 0;
1365 bytes_read = fread(ucbuffer_, sizeof(unsigned char), wanted, infile);
1368 if(bytes_read == 0) {
1369 if(ferror(infile)) {
1370 flac__utils_printf(stderr, 1, "%s: ERROR during read\n", encoder_session.inbasefilename);
1371 return EncoderSession_finish_error(&encoder_session);
1373 else if(feof(infile)) {
1374 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);
1375 if(encoder_session.treat_warnings_as_errors)
1376 return EncoderSession_finish_error(&encoder_session);
1377 total_input_bytes_read = max_input_bytes;
1381 if(bytes_read % bytes_per_wide_sample != 0) {
1382 flac__utils_printf(stderr, 1, "%s: ERROR: got partial sample\n", encoder_session.inbasefilename);
1383 return EncoderSession_finish_error(&encoder_session);
1386 unsigned wide_samples = bytes_read / bytes_per_wide_sample;
1387 if(!format_input(input_, wide_samples, options.is_big_endian, options.is_unsigned_samples, options.channels, options.bps, /*shift=*/0, /*channel_map=*/0))
1388 return EncoderSession_finish_error(&encoder_session);
1390 if(!EncoderSession_process(&encoder_session, (const FLAC__int32 * const *)input_, wide_samples)) {
1391 print_error_with_state(&encoder_session, "ERROR during encoding");
1392 return EncoderSession_finish_error(&encoder_session);
1394 total_input_bytes_read += bytes_read;
1401 * now read unaligned samples into reservoir or pad with zeroes if necessary
1403 if(options.common.sector_align) {
1404 if(options.common.is_last_file) {
1405 unsigned wide_samples = 588 - align_remainder;
1406 if(wide_samples < 588) {
1409 info_align_zero = wide_samples;
1410 for(channel = 0; channel < options.channels; channel++)
1411 memset(input_[channel], 0, sizeof(input_[0][0]) * wide_samples);
1413 if(!EncoderSession_process(&encoder_session, (const FLAC__int32 * const *)input_, wide_samples)) {
1414 print_error_with_state(&encoder_session, "ERROR during encoding");
1415 return EncoderSession_finish_error(&encoder_session);
1420 if(*options.common.align_reservoir_samples > 0) {
1421 FLAC__ASSERT(CHUNK_OF_SAMPLES >= 588);
1422 bytes_read = fread(ucbuffer_, sizeof(unsigned char), (*options.common.align_reservoir_samples) * bytes_per_wide_sample, infile);
1423 if(bytes_read == 0 && ferror(infile)) {
1424 flac__utils_printf(stderr, 1, "%s: ERROR during read\n", encoder_session.inbasefilename);
1425 return EncoderSession_finish_error(&encoder_session);
1427 else if(bytes_read != (*options.common.align_reservoir_samples) * bytes_per_wide_sample) {
1428 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);
1429 if(encoder_session.treat_warnings_as_errors)
1430 return EncoderSession_finish_error(&encoder_session);
1433 info_align_carry = *options.common.align_reservoir_samples;
1434 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))
1435 return EncoderSession_finish_error(&encoder_session);
1441 return EncoderSession_finish_ok(&encoder_session, info_align_carry, info_align_zero, /*foreign_metadata=*/0);
1444 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)
1446 EncoderSession encoder_session;
1447 FLAC__StreamDecoder *decoder = 0;
1448 FLACDecoderData decoder_data;
1453 EncoderSession_construct(
1456 options.common.use_ogg,
1460 options.common.verify,
1461 options.common.treat_warnings_as_errors,
1462 options.common.continue_through_decode_errors,
1470 decoder_data.encoder_session = &encoder_session;
1471 decoder_data.filesize = (infilesize == (off_t)(-1)? 0 : infilesize);
1472 decoder_data.lookahead = lookahead;
1473 decoder_data.lookahead_length = lookahead_length;
1474 decoder_data.num_metadata_blocks = 0;
1475 decoder_data.samples_left_to_process = 0;
1476 decoder_data.fatal_error = false;
1479 * set up FLAC decoder for the input
1481 if (0 == (decoder = FLAC__stream_decoder_new())) {
1482 flac__utils_printf(stderr, 1, "%s: ERROR: creating decoder for FLAC input\n", encoder_session.inbasefilename);
1483 return EncoderSession_finish_error(&encoder_session);
1486 FLAC__stream_decoder_set_md5_checking(decoder, false) &&
1487 FLAC__stream_decoder_set_metadata_respond_all(decoder)
1489 flac__utils_printf(stderr, 1, "%s: ERROR: setting up decoder for FLAC input\n", encoder_session.inbasefilename);
1490 goto fubar1; /*@@@ yuck */
1494 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) {
1495 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));
1496 goto fubar1; /*@@@ yuck */
1499 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) {
1500 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));
1501 goto fubar1; /*@@@ yuck */
1504 if (!FLAC__stream_decoder_process_until_end_of_metadata(decoder) || decoder_data.fatal_error) {
1505 if (decoder_data.fatal_error)
1506 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);
1508 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));
1509 goto fubar1; /*@@@ yuck */
1512 if (decoder_data.num_metadata_blocks == 0) {
1513 flac__utils_printf(stderr, 1, "%s: ERROR: reading metadata in FLAC input, got no metadata blocks\n", encoder_session.inbasefilename);
1514 goto fubar2; /*@@@ yuck */
1516 else if (decoder_data.metadata_blocks[0]->type != FLAC__METADATA_TYPE_STREAMINFO) {
1517 flac__utils_printf(stderr, 1, "%s: ERROR: reading metadata in FLAC input, first metadata block is not STREAMINFO\n", encoder_session.inbasefilename);
1518 goto fubar2; /*@@@ yuck */
1520 else if (decoder_data.metadata_blocks[0]->data.stream_info.total_samples == 0) {
1521 flac__utils_printf(stderr, 1, "%s: ERROR: FLAC input has STREAMINFO with unknown total samples which is not supported\n", encoder_session.inbasefilename);
1522 goto fubar2; /*@@@ yuck */
1526 * now that we have the STREAMINFO and know the sample rate,
1527 * canonicalize the --skip string to a number of samples:
1529 flac__utils_canonicalize_skip_until_specification(&options.common.skip_specification, decoder_data.metadata_blocks[0]->data.stream_info.sample_rate);
1530 FLAC__ASSERT(options.common.skip_specification.value.samples >= 0);
1531 encoder_session.skip = (FLAC__uint64)options.common.skip_specification.value.samples;
1532 FLAC__ASSERT(!options.common.sector_align); /* --sector-align with FLAC input is not supported */
1535 FLAC__uint64 total_samples_in_input, trim = 0;
1537 total_samples_in_input = decoder_data.metadata_blocks[0]->data.stream_info.total_samples;
1540 * now that we know the input size, canonicalize the
1541 * --until string to an absolute sample number:
1543 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))
1544 goto fubar2; /*@@@ yuck */
1545 encoder_session.until = (FLAC__uint64)options.common.until_specification.value.samples;
1547 encoder_session.total_samples_to_encode = total_samples_in_input - encoder_session.skip;
1548 if(encoder_session.until > 0) {
1549 trim = total_samples_in_input - encoder_session.until;
1550 FLAC__ASSERT(total_samples_in_input > 0);
1551 encoder_session.total_samples_to_encode -= trim;
1554 encoder_session.unencoded_size = decoder_data.filesize;
1556 /* (channel mask will get copied over from the source VORBIS_COMMENT if it exists) */
1557 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))
1558 goto fubar2; /*@@@ yuck */
1561 * have to wait until the FLAC encoder is set up for writing
1562 * before any seeking in the input FLAC file, because the seek
1563 * itself will usually call the decoder's write callback, and
1564 * our decoder's write callback passes samples to our FLAC
1567 decoder_data.samples_left_to_process = encoder_session.total_samples_to_encode;
1568 if(encoder_session.skip > 0) {
1569 if(!FLAC__stream_decoder_seek_absolute(decoder, encoder_session.skip)) {
1570 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));
1571 goto fubar2; /*@@@ yuck */
1576 * now do samples from the file
1578 while(!decoder_data.fatal_error && decoder_data.samples_left_to_process > 0) {
1579 /* We can also hit the end of stream without samples_left_to_process
1580 * going to 0 if there are errors and continue_through_decode_errors
1581 * is on, so we want to break in that case too:
1583 if(encoder_session.continue_through_decode_errors && FLAC__stream_decoder_get_state(decoder) == FLAC__STREAM_DECODER_END_OF_STREAM)
1585 if(!FLAC__stream_decoder_process_single(decoder)) {
1586 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));
1587 goto fubar2; /*@@@ yuck */
1590 if(decoder_data.fatal_error) {
1591 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));
1592 goto fubar2; /*@@@ yuck */
1596 FLAC__stream_decoder_delete(decoder);
1597 retval = EncoderSession_finish_ok(&encoder_session, -1, -1, /*foreign_metadata=*/0);
1598 /* have to wail until encoder is completely finished before deleting because of the final step of writing the seekpoint offsets */
1599 for(i = 0; i < decoder_data.num_metadata_blocks; i++)
1600 FLAC__metadata_object_delete(decoder_data.metadata_blocks[i]);
1604 for(i = 0; i < decoder_data.num_metadata_blocks; i++)
1605 FLAC__metadata_object_delete(decoder_data.metadata_blocks[i]);
1607 FLAC__stream_decoder_delete(decoder);
1608 return EncoderSession_finish_error(&encoder_session);
1611 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)
1614 FLAC__uint32 test = 1;
1617 * initialize globals
1620 is_big_endian_host_ = (*((FLAC__byte*)(&test)))? false : true;
1622 for(i = 0; i < FLAC__MAX_CHANNELS; i++)
1623 input_[i] = &(in_[i][0]);
1627 * initialize instance
1631 e->use_ogg = use_ogg;
1636 e->treat_warnings_as_errors = treat_warnings_as_errors;
1637 e->continue_through_decode_errors = continue_through_decode_errors;
1639 e->is_stdout = (0 == strcmp(outfilename, "-"));
1640 e->outputfile_opened = false;
1642 e->inbasefilename = grabbag__file_get_basename(infilename);
1643 e->infilename = infilename;
1644 e->outfilename = outfilename;
1646 e->skip = 0; /* filled in later after the sample_rate is known */
1647 e->unencoded_size = 0;
1648 e->total_samples_to_encode = 0;
1649 e->bytes_written = 0;
1650 e->samples_written = 0;
1656 e->seek_table_template = 0;
1658 if(0 == (e->seek_table_template = FLAC__metadata_object_new(FLAC__METADATA_TYPE_SEEKTABLE))) {
1659 flac__utils_printf(stderr, 1, "%s: ERROR allocating memory for seek table\n", e->inbasefilename);
1663 e->encoder = FLAC__stream_encoder_new();
1664 if(0 == e->encoder) {
1665 flac__utils_printf(stderr, 1, "%s: ERROR creating the encoder instance\n", e->inbasefilename);
1666 EncoderSession_destroy(e);
1673 void EncoderSession_destroy(EncoderSession *e)
1678 if(0 != e->encoder) {
1679 FLAC__stream_encoder_delete(e->encoder);
1683 if(0 != e->seek_table_template) {
1684 FLAC__metadata_object_delete(e->seek_table_template);
1685 e->seek_table_template = 0;
1689 int EncoderSession_finish_ok(EncoderSession *e, int info_align_carry, int info_align_zero, foreign_metadata_t *foreign_metadata)
1691 FLAC__StreamEncoderState fse_state = FLAC__STREAM_ENCODER_OK;
1693 FLAC__bool verify_error = false;
1696 fse_state = FLAC__stream_encoder_get_state(e->encoder);
1697 ret = FLAC__stream_encoder_finish(e->encoder)? 0 : 1;
1699 fse_state == FLAC__STREAM_ENCODER_VERIFY_MISMATCH_IN_AUDIO_DATA ||
1700 FLAC__stream_encoder_get_state(e->encoder) == FLAC__STREAM_ENCODER_VERIFY_MISMATCH_IN_AUDIO_DATA
1703 /* all errors except verify errors should interrupt the stats */
1704 if(ret && !verify_error)
1705 print_error_with_state(e, "ERROR during encoding");
1706 else if(e->total_samples_to_encode > 0) {
1708 flac__utils_printf(stderr, 2, "\n");
1712 print_verify_error(e);
1716 if(info_align_carry >= 0) {
1717 flac__utils_printf(stderr, 1, "%s: INFO: sector alignment causing %d samples to be carried over\n", e->inbasefilename, info_align_carry);
1719 if(info_align_zero >= 0) {
1720 flac__utils_printf(stderr, 1, "%s: INFO: sector alignment causing %d zero samples to be appended\n", e->inbasefilename, info_align_zero);
1724 /*@@@@@@ should this go here or somewhere else? */
1725 if(ret == 0 && foreign_metadata) {
1727 if(!flac__foreign_metadata_write_to_flac(foreign_metadata, e->infilename, e->outfilename, &error)) {
1728 flac__utils_printf(stderr, 1, "%s: ERROR: updating foreign metadata in FLAC file: %s\n", e->inbasefilename, error);
1733 EncoderSession_destroy(e);
1738 int EncoderSession_finish_error(EncoderSession *e)
1740 FLAC__ASSERT(e->encoder);
1742 if(e->total_samples_to_encode > 0)
1743 flac__utils_printf(stderr, 2, "\n");
1745 if(FLAC__stream_encoder_get_state(e->encoder) == FLAC__STREAM_ENCODER_VERIFY_MISMATCH_IN_AUDIO_DATA)
1746 print_verify_error(e);
1747 else if(e->outputfile_opened)
1748 /* only want to delete the file if we opened it; otherwise it could be an existing file and our overwrite failed */
1749 unlink(e->outfilename);
1751 EncoderSession_destroy(e);
1757 unsigned num_metadata;
1758 FLAC__bool *needs_delete;
1759 FLAC__StreamMetadata **metadata;
1760 FLAC__StreamMetadata *cuesheet; /* always needs to be deleted */
1761 } static_metadata_t;
1763 static void static_metadata_init(static_metadata_t *m)
1765 m->num_metadata = 0;
1766 m->needs_delete = 0;
1771 static void static_metadata_clear(static_metadata_t *m)
1774 for(i = 0; i < m->num_metadata; i++)
1775 if(m->needs_delete[i])
1776 FLAC__metadata_object_delete(m->metadata[i]);
1780 free(m->needs_delete);
1782 FLAC__metadata_object_delete(m->cuesheet);
1783 static_metadata_init(m);
1786 static FLAC__bool static_metadata_append(static_metadata_t *m, FLAC__StreamMetadata *d, FLAC__bool needs_delete)
1789 if(0 == (x = realloc(m->metadata, sizeof(*m->metadata)*m->num_metadata+1)))
1791 m->metadata = (FLAC__StreamMetadata**)x;
1792 if(0 == (x = realloc(m->needs_delete, sizeof(*m->needs_delete)*m->num_metadata+1)))
1794 m->needs_delete = (FLAC__bool*)x;
1795 m->metadata[m->num_metadata] = d;
1796 m->needs_delete[m->num_metadata] = needs_delete;
1801 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)
1803 FLAC__StreamMetadata padding;
1804 FLAC__StreamMetadata **metadata = 0;
1805 static_metadata_t static_metadata;
1806 unsigned num_metadata = 0, i;
1807 FLAC__StreamEncoderInitStatus init_status;
1808 const FLAC__bool is_cdda = (channels == 1 || channels == 2) && (bps == 16) && (sample_rate == 44100);
1809 char apodizations[2000];
1811 FLAC__ASSERT(sizeof(options.pictures)/sizeof(options.pictures[0]) <= 64);
1813 static_metadata_init(&static_metadata);
1815 e->replay_gain = options.replay_gain;
1816 e->channels = channels;
1817 e->bits_per_sample = bps;
1818 e->sample_rate = sample_rate;
1820 apodizations[0] = '\0';
1822 if(e->replay_gain) {
1823 if(channels != 1 && channels != 2) {
1824 flac__utils_printf(stderr, 1, "%s: ERROR, number of channels (%u) must be 1 or 2 for --replay-gain\n", e->inbasefilename, channels);
1827 if(!grabbag__replaygain_is_valid_sample_frequency(sample_rate)) {
1828 flac__utils_printf(stderr, 1, "%s: ERROR, invalid sample rate (%u) for --replay-gain\n", e->inbasefilename, sample_rate);
1831 if(options.is_first_file) {
1832 if(!grabbag__replaygain_init(sample_rate)) {
1833 flac__utils_printf(stderr, 1, "%s: ERROR initializing ReplayGain stage\n", e->inbasefilename);
1839 if(!parse_cuesheet(&static_metadata.cuesheet, options.cuesheet_filename, e->inbasefilename, is_cdda, e->total_samples_to_encode, e->treat_warnings_as_errors))
1842 if(!convert_to_seek_table_template(options.requested_seek_points, options.num_requested_seek_points, options.cued_seekpoints? static_metadata.cuesheet : 0, e)) {
1843 flac__utils_printf(stderr, 1, "%s: ERROR allocating memory for seek table\n", e->inbasefilename);
1844 static_metadata_clear(&static_metadata);
1848 /* build metadata */
1849 if(flac_decoder_data) {
1851 * we're encoding from FLAC so we will use the FLAC file's
1852 * metadata as the basis for the encoded file
1856 * first handle pictures: simple append any --pictures
1859 for(i = 0; i < options.num_pictures; i++) {
1860 FLAC__StreamMetadata *pic = FLAC__metadata_object_clone(options.pictures[i]);
1862 flac__utils_printf(stderr, 1, "%s: ERROR allocating memory for PICTURE block\n", e->inbasefilename);
1863 static_metadata_clear(&static_metadata);
1866 flac_decoder_data->metadata_blocks[flac_decoder_data->num_metadata_blocks++] = pic;
1871 * next handle vorbis comment: if any tags were specified
1872 * or there is no existing vorbis comment, we create a
1873 * new vorbis comment (discarding any existing one); else
1874 * we keep the existing one. also need to make sure to
1875 * propagate any channel mask tag.
1877 /* @@@ change to append -T values from options.vorbis_comment if input has VC already? */
1879 FLAC__bool vc_found = false;
1880 for(i = 0, j = 0; i < flac_decoder_data->num_metadata_blocks; i++) {
1881 if(flac_decoder_data->metadata_blocks[i]->type == FLAC__METADATA_TYPE_VORBIS_COMMENT)
1883 if(flac_decoder_data->metadata_blocks[i]->type == FLAC__METADATA_TYPE_VORBIS_COMMENT && options.vorbis_comment->data.vorbis_comment.num_comments > 0) {
1884 (void) flac__utils_get_channel_mask_tag(flac_decoder_data->metadata_blocks[i], &channel_mask);
1885 flac__utils_printf(stderr, 1, "%s: WARNING, replacing tags from input FLAC file with those given on the command-line\n", e->inbasefilename);
1886 if(e->treat_warnings_as_errors) {
1887 static_metadata_clear(&static_metadata);
1890 FLAC__metadata_object_delete(flac_decoder_data->metadata_blocks[i]);
1891 flac_decoder_data->metadata_blocks[i] = 0;
1894 flac_decoder_data->metadata_blocks[j++] = flac_decoder_data->metadata_blocks[i];
1896 flac_decoder_data->num_metadata_blocks = j;
1897 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])) {
1899 FLAC__StreamMetadata *vc = FLAC__metadata_object_clone(options.vorbis_comment);
1900 if(0 == vc || (channel_mask && !flac__utils_set_channel_mask_tag(vc, channel_mask))) {
1901 flac__utils_printf(stderr, 1, "%s: ERROR allocating memory for VORBIS_COMMENT block\n", e->inbasefilename);
1902 static_metadata_clear(&static_metadata);
1905 for(i = flac_decoder_data->num_metadata_blocks; i > 1; i--)
1906 flac_decoder_data->metadata_blocks[i] = flac_decoder_data->metadata_blocks[i-1];
1907 flac_decoder_data->metadata_blocks[1] = vc;
1908 flac_decoder_data->num_metadata_blocks++;
1913 * next handle cuesheet: if --cuesheet was specified, use
1914 * it; else if file has existing CUESHEET and cuesheet's
1915 * lead-out offset is correct, keep it; else no CUESHEET
1918 for(i = 0, j = 0; i < flac_decoder_data->num_metadata_blocks; i++) {
1919 FLAC__bool existing_cuesheet_is_bad = false;
1920 /* check if existing cuesheet matches the input audio */
1921 if(flac_decoder_data->metadata_blocks[i]->type == FLAC__METADATA_TYPE_CUESHEET && 0 == static_metadata.cuesheet) {
1922 const FLAC__StreamMetadata_CueSheet *cs = &flac_decoder_data->metadata_blocks[i]->data.cue_sheet;
1923 if(e->total_samples_to_encode == 0) {
1924 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);
1925 if(e->treat_warnings_as_errors) {
1926 static_metadata_clear(&static_metadata);
1929 existing_cuesheet_is_bad = true;
1931 else if(e->total_samples_to_encode != cs->tracks[cs->num_tracks-1].offset) {
1932 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);
1933 if(e->treat_warnings_as_errors) {
1934 static_metadata_clear(&static_metadata);
1937 existing_cuesheet_is_bad = true;
1940 if(flac_decoder_data->metadata_blocks[i]->type == FLAC__METADATA_TYPE_CUESHEET && (existing_cuesheet_is_bad || 0 != static_metadata.cuesheet)) {
1941 if(0 != static_metadata.cuesheet) {
1942 flac__utils_printf(stderr, 1, "%s: WARNING, replacing cuesheet in input FLAC file with the one given on the command-line\n", e->inbasefilename);
1943 if(e->treat_warnings_as_errors) {
1944 static_metadata_clear(&static_metadata);
1948 FLAC__metadata_object_delete(flac_decoder_data->metadata_blocks[i]);
1949 flac_decoder_data->metadata_blocks[i] = 0;
1952 flac_decoder_data->metadata_blocks[j++] = flac_decoder_data->metadata_blocks[i];
1954 flac_decoder_data->num_metadata_blocks = j;
1955 if(0 != static_metadata.cuesheet && flac_decoder_data->num_metadata_blocks < sizeof(flac_decoder_data->metadata_blocks)/sizeof(flac_decoder_data->metadata_blocks[0])) {
1957 FLAC__StreamMetadata *cs = FLAC__metadata_object_clone(static_metadata.cuesheet);
1959 flac__utils_printf(stderr, 1, "%s: ERROR allocating memory for CUESHEET block\n", e->inbasefilename);
1960 static_metadata_clear(&static_metadata);
1963 for(i = flac_decoder_data->num_metadata_blocks; i > 1; i--)
1964 flac_decoder_data->metadata_blocks[i] = flac_decoder_data->metadata_blocks[i-1];
1965 flac_decoder_data->metadata_blocks[1] = cs;
1966 flac_decoder_data->num_metadata_blocks++;
1971 * next handle seektable: if -S- was specified, no
1972 * SEEKTABLE; else if -S was specified, use it/them;
1973 * else if file has existing SEEKTABLE and input size is
1974 * preserved (no --skip/--until/etc specified), keep it;
1975 * else use default seektable options
1977 * note: meanings of num_requested_seek_points:
1978 * -1 : no -S option given, default to some value
1979 * 0 : -S- given (no seektable)
1980 * >0 : one or more -S options given
1983 FLAC__bool existing_seektable = false;
1984 for(i = 0, j = 0; i < flac_decoder_data->num_metadata_blocks; i++) {
1985 if(flac_decoder_data->metadata_blocks[i]->type == FLAC__METADATA_TYPE_SEEKTABLE)
1986 existing_seektable = true;
1987 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)) {
1988 if(options.num_requested_seek_points > 0) {
1989 flac__utils_printf(stderr, 1, "%s: WARNING, replacing seektable in input FLAC file with the one given on the command-line\n", e->inbasefilename);
1990 if(e->treat_warnings_as_errors) {
1991 static_metadata_clear(&static_metadata);
1995 else if(options.num_requested_seek_points == 0)
1996 ; /* no warning, silently delete existing SEEKTABLE since user specified --no-seektable (-S-) */
1998 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);
1999 if(e->treat_warnings_as_errors) {
2000 static_metadata_clear(&static_metadata);
2004 FLAC__metadata_object_delete(flac_decoder_data->metadata_blocks[i]);
2005 flac_decoder_data->metadata_blocks[i] = 0;
2006 existing_seektable = false;
2009 flac_decoder_data->metadata_blocks[j++] = flac_decoder_data->metadata_blocks[i];
2011 flac_decoder_data->num_metadata_blocks = j;
2012 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])) {
2014 FLAC__StreamMetadata *st = FLAC__metadata_object_clone(e->seek_table_template);
2016 flac__utils_printf(stderr, 1, "%s: ERROR allocating memory for SEEKTABLE block\n", e->inbasefilename);
2017 static_metadata_clear(&static_metadata);
2020 for(i = flac_decoder_data->num_metadata_blocks; i > 1; i--)
2021 flac_decoder_data->metadata_blocks[i] = flac_decoder_data->metadata_blocks[i-1];
2022 flac_decoder_data->metadata_blocks[1] = st;
2023 flac_decoder_data->num_metadata_blocks++;
2028 * finally handle padding: if --no-padding was specified,
2029 * then delete all padding; else if -P was specified,
2030 * use that instead of existing padding (if any); else
2031 * if existing file has padding, move all existing
2032 * padding blocks to one padding block at the end; else
2033 * use default padding.
2037 for(i = 0, j = 0; i < flac_decoder_data->num_metadata_blocks; i++) {
2038 if(flac_decoder_data->metadata_blocks[i]->type == FLAC__METADATA_TYPE_PADDING) {
2041 p += flac_decoder_data->metadata_blocks[i]->length;
2042 FLAC__metadata_object_delete(flac_decoder_data->metadata_blocks[i]);
2043 flac_decoder_data->metadata_blocks[i] = 0;
2046 flac_decoder_data->metadata_blocks[j++] = flac_decoder_data->metadata_blocks[i];
2048 flac_decoder_data->num_metadata_blocks = j;
2049 if(options.padding > 0)
2050 p = options.padding;
2052 p = e->total_samples_to_encode / e->sample_rate < 20*60? FLAC_ENCODE__DEFAULT_PADDING : FLAC_ENCODE__DEFAULT_PADDING*8;
2053 if(options.padding != 0) {
2054 if(p > 0 && flac_decoder_data->num_metadata_blocks < sizeof(flac_decoder_data->metadata_blocks)/sizeof(flac_decoder_data->metadata_blocks[0])) {
2055 flac_decoder_data->metadata_blocks[flac_decoder_data->num_metadata_blocks] = FLAC__metadata_object_new(FLAC__METADATA_TYPE_PADDING);
2056 if(0 == flac_decoder_data->metadata_blocks[flac_decoder_data->num_metadata_blocks]) {
2057 flac__utils_printf(stderr, 1, "%s: ERROR allocating memory for PADDING block\n", e->inbasefilename);
2058 static_metadata_clear(&static_metadata);
2061 flac_decoder_data->metadata_blocks[flac_decoder_data->num_metadata_blocks]->is_last = false; /* the encoder will set this for us */
2062 flac_decoder_data->metadata_blocks[flac_decoder_data->num_metadata_blocks]->length = p;
2063 flac_decoder_data->num_metadata_blocks++;
2067 metadata = &flac_decoder_data->metadata_blocks[1]; /* don't include STREAMINFO */
2068 num_metadata = flac_decoder_data->num_metadata_blocks - 1;
2072 * we're not encoding from FLAC so we will build the metadata
2075 if(e->seek_table_template->data.seek_table.num_points > 0) {
2076 e->seek_table_template->is_last = false; /* the encoder will set this for us */
2077 static_metadata_append(&static_metadata, e->seek_table_template, /*needs_delete=*/false);
2079 if(0 != static_metadata.cuesheet)
2080 static_metadata_append(&static_metadata, static_metadata.cuesheet, /*needs_delete=*/false);
2082 if(!flac__utils_set_channel_mask_tag(options.vorbis_comment, channel_mask)) {
2083 flac__utils_printf(stderr, 1, "%s: ERROR adding channel mask tag\n", e->inbasefilename);
2084 static_metadata_clear(&static_metadata);
2088 static_metadata_append(&static_metadata, options.vorbis_comment, /*needs_delete=*/false);
2089 for(i = 0; i < options.num_pictures; i++)
2090 static_metadata_append(&static_metadata, options.pictures[i], /*needs_delete=*/false);
2091 if(foreign_metadata) {
2092 for(i = 0; i < foreign_metadata->num_blocks; i++) {
2093 FLAC__StreamMetadata *p = FLAC__metadata_object_new(FLAC__METADATA_TYPE_PADDING);
2095 flac__utils_printf(stderr, 1, "%s: ERROR: out of memory\n", e->inbasefilename);
2096 static_metadata_clear(&static_metadata);
2099 static_metadata_append(&static_metadata, p, /*needs_delete=*/true);
2100 static_metadata.metadata[static_metadata.num_metadata-1]->length = FLAC__STREAM_METADATA_APPLICATION_ID_LEN/8 + foreign_metadata->blocks[i].size;
2101 /*fprintf(stderr,"@@@@@@ add PADDING=%u\n",static_metadata.metadata[static_metadata.num_metadata-1]->length);*/
2104 if(options.padding != 0) {
2105 padding.is_last = false; /* the encoder will set this for us */
2106 padding.type = FLAC__METADATA_TYPE_PADDING;
2107 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));
2108 static_metadata_append(&static_metadata, &padding, /*needs_delete=*/false);
2110 metadata = static_metadata.metadata;
2111 num_metadata = static_metadata.num_metadata;
2114 /* check for a few things that have not already been checked. the
2115 * FLAC__stream_encoder_init*() will check it but only return
2116 * FLAC__STREAM_ENCODER_INIT_STATUS_INVALID_METADATA so we check some
2117 * up front to give a better error message.
2119 if(!verify_metadata(e, metadata, num_metadata)) {
2120 static_metadata_clear(&static_metadata);
2124 FLAC__stream_encoder_set_verify(e->encoder, options.verify);
2125 FLAC__stream_encoder_set_streamable_subset(e->encoder, !options.lax);
2126 FLAC__stream_encoder_set_channels(e->encoder, channels);
2127 FLAC__stream_encoder_set_bits_per_sample(e->encoder, bps);
2128 FLAC__stream_encoder_set_sample_rate(e->encoder, sample_rate);
2129 for(i = 0; i < options.num_compression_settings; i++) {
2130 switch(options.compression_settings[i].type) {
2132 FLAC__stream_encoder_set_blocksize(e->encoder, options.compression_settings[i].value.t_unsigned);
2134 case CST_COMPRESSION_LEVEL:
2135 FLAC__stream_encoder_set_compression_level(e->encoder, options.compression_settings[i].value.t_unsigned);
2136 apodizations[0] = '\0';
2138 case CST_DO_MID_SIDE:
2139 FLAC__stream_encoder_set_do_mid_side_stereo(e->encoder, options.compression_settings[i].value.t_bool);
2141 case CST_LOOSE_MID_SIDE:
2142 FLAC__stream_encoder_set_loose_mid_side_stereo(e->encoder, options.compression_settings[i].value.t_bool);
2144 case CST_APODIZATION:
2145 if(strlen(apodizations)+strlen(options.compression_settings[i].value.t_string)+2 >= sizeof(apodizations)) {
2146 flac__utils_printf(stderr, 1, "%s: ERROR: too many apodization functions requested\n", e->inbasefilename);
2147 static_metadata_clear(&static_metadata);
2151 strcat(apodizations, options.compression_settings[i].value.t_string);
2152 strcat(apodizations, ";");
2155 case CST_MAX_LPC_ORDER:
2156 FLAC__stream_encoder_set_max_lpc_order(e->encoder, options.compression_settings[i].value.t_unsigned);
2158 case CST_QLP_COEFF_PRECISION:
2159 FLAC__stream_encoder_set_qlp_coeff_precision(e->encoder, options.compression_settings[i].value.t_unsigned);
2161 case CST_DO_QLP_COEFF_PREC_SEARCH:
2162 FLAC__stream_encoder_set_do_qlp_coeff_prec_search(e->encoder, options.compression_settings[i].value.t_bool);
2164 case CST_DO_ESCAPE_CODING:
2165 FLAC__stream_encoder_set_do_escape_coding(e->encoder, options.compression_settings[i].value.t_bool);
2167 case CST_DO_EXHAUSTIVE_MODEL_SEARCH:
2168 FLAC__stream_encoder_set_do_exhaustive_model_search(e->encoder, options.compression_settings[i].value.t_bool);
2170 case CST_MIN_RESIDUAL_PARTITION_ORDER:
2171 FLAC__stream_encoder_set_min_residual_partition_order(e->encoder, options.compression_settings[i].value.t_unsigned);
2173 case CST_MAX_RESIDUAL_PARTITION_ORDER:
2174 FLAC__stream_encoder_set_max_residual_partition_order(e->encoder, options.compression_settings[i].value.t_unsigned);
2176 case CST_RICE_PARAMETER_SEARCH_DIST:
2177 FLAC__stream_encoder_set_rice_parameter_search_dist(e->encoder, options.compression_settings[i].value.t_unsigned);
2182 FLAC__stream_encoder_set_apodization(e->encoder, apodizations);
2183 FLAC__stream_encoder_set_total_samples_estimate(e->encoder, e->total_samples_to_encode);
2184 FLAC__stream_encoder_set_metadata(e->encoder, (num_metadata > 0)? metadata : 0, num_metadata);
2186 FLAC__stream_encoder_disable_constant_subframes(e->encoder, options.debug.disable_constant_subframes);
2187 FLAC__stream_encoder_disable_fixed_subframes(e->encoder, options.debug.disable_fixed_subframes);
2188 FLAC__stream_encoder_disable_verbatim_subframes(e->encoder, options.debug.disable_verbatim_subframes);
2189 if(!options.debug.do_md5) {
2190 flac__utils_printf(stderr, 1, "%s: WARNING, MD5 computation disabled, resulting file will not have MD5 sum\n", e->inbasefilename);
2191 if(e->treat_warnings_as_errors) {
2192 static_metadata_clear(&static_metadata);
2195 FLAC__stream_encoder_set_do_md5(e->encoder, false);
2200 FLAC__stream_encoder_set_ogg_serial_number(e->encoder, options.serial_number);
2202 init_status = FLAC__stream_encoder_init_ogg_file(e->encoder, e->is_stdout? 0 : e->outfilename, encoder_progress_callback, /*client_data=*/e);
2207 init_status = FLAC__stream_encoder_init_file(e->encoder, e->is_stdout? 0 : e->outfilename, encoder_progress_callback, /*client_data=*/e);
2210 if(init_status != FLAC__STREAM_ENCODER_INIT_STATUS_OK) {
2211 print_error_with_init_status(e, "ERROR initializing encoder", init_status);
2212 if(FLAC__stream_encoder_get_state(e->encoder) != FLAC__STREAM_ENCODER_IO_ERROR)
2213 e->outputfile_opened = true;
2214 static_metadata_clear(&static_metadata);
2218 e->outputfile_opened = true;
2221 (FLAC__stream_encoder_get_do_exhaustive_model_search(e->encoder) && FLAC__stream_encoder_get_do_qlp_coeff_prec_search(e->encoder))? 0x07 :
2222 (FLAC__stream_encoder_get_do_exhaustive_model_search(e->encoder) || FLAC__stream_encoder_get_do_qlp_coeff_prec_search(e->encoder))? 0x0f :
2225 static_metadata_clear(&static_metadata);
2230 FLAC__bool EncoderSession_process(EncoderSession *e, const FLAC__int32 * const buffer[], unsigned samples)
2232 if(e->replay_gain) {
2233 if(!grabbag__replaygain_analyze(buffer, e->channels==2, e->bits_per_sample, samples)) {
2234 flac__utils_printf(stderr, 1, "%s: WARNING, error while calculating ReplayGain\n", e->inbasefilename);
2235 if(e->treat_warnings_as_errors)
2240 return FLAC__stream_encoder_process(e->encoder, buffer, samples);
2243 FLAC__bool convert_to_seek_table_template(const char *requested_seek_points, int num_requested_seek_points, FLAC__StreamMetadata *cuesheet, EncoderSession *e)
2245 const FLAC__bool only_placeholders = e->is_stdout;
2246 FLAC__bool has_real_points;
2248 if(num_requested_seek_points == 0 && 0 == cuesheet)
2251 if(num_requested_seek_points < 0) {
2253 /*@@@@@@ workaround ogg bug: too many seekpoints makes table not fit in one page */
2254 if(e->use_ogg && e->total_samples_to_encode > 0 && e->total_samples_to_encode / e->sample_rate / 10 > 230)
2255 requested_seek_points = "230x;";
2258 requested_seek_points = "10s;";
2259 num_requested_seek_points = 1;
2262 if(num_requested_seek_points > 0) {
2263 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))
2269 const FLAC__StreamMetadata_CueSheet *cs = &cuesheet->data.cue_sheet;
2270 for(i = 0; i < cs->num_tracks; i++) {
2271 const FLAC__StreamMetadata_CueSheet_Track *tr = cs->tracks+i;
2272 for(j = 0; j < tr->num_indices; j++) {
2273 if(!FLAC__metadata_object_seektable_template_append_point(e->seek_table_template, tr->offset + tr->indices[j].offset))
2275 has_real_points = true;
2279 if(!FLAC__metadata_object_seektable_template_sort(e->seek_table_template, /*compact=*/true))
2283 if(has_real_points) {
2285 flac__utils_printf(stderr, 1, "%s: WARNING, cannot write back seekpoints when encoding to stdout\n", e->inbasefilename);
2286 if(e->treat_warnings_as_errors)
2294 FLAC__bool canonicalize_until_specification(utils__SkipUntilSpecification *spec, const char *inbasefilename, unsigned sample_rate, FLAC__uint64 skip, FLAC__uint64 total_samples_in_input)
2296 /* convert from mm:ss.sss to sample number if necessary */
2297 flac__utils_canonicalize_skip_until_specification(spec, sample_rate);
2299 /* special case: if "--until=-0", use the special value '0' to mean "end-of-stream" */
2300 if(spec->is_relative && spec->value.samples == 0) {
2301 spec->is_relative = false;
2305 /* in any other case the total samples in the input must be known */
2306 if(total_samples_in_input == 0) {
2307 flac__utils_printf(stderr, 1, "%s: ERROR, cannot use --until when input length is unknown\n", inbasefilename);
2311 FLAC__ASSERT(spec->value_is_samples);
2313 /* convert relative specifications to absolute */
2314 if(spec->is_relative) {
2315 if(spec->value.samples <= 0)
2316 spec->value.samples += (FLAC__int64)total_samples_in_input;
2318 spec->value.samples += skip;
2319 spec->is_relative = false;
2323 if(spec->value.samples < 0) {
2324 flac__utils_printf(stderr, 1, "%s: ERROR, --until value is before beginning of input\n", inbasefilename);
2327 if((FLAC__uint64)spec->value.samples <= skip) {
2328 flac__utils_printf(stderr, 1, "%s: ERROR, --until value is before --skip point\n", inbasefilename);
2331 if((FLAC__uint64)spec->value.samples > total_samples_in_input) {
2332 flac__utils_printf(stderr, 1, "%s: ERROR, --until value is after end of input\n", inbasefilename);
2339 FLAC__bool verify_metadata(const EncoderSession *e, FLAC__StreamMetadata **metadata, unsigned num_metadata)
2341 FLAC__bool metadata_picture_has_type1 = false;
2342 FLAC__bool metadata_picture_has_type2 = false;
2345 FLAC__ASSERT(0 != metadata);
2346 for(i = 0; i < num_metadata; i++) {
2347 const FLAC__StreamMetadata *m = metadata[i];
2348 if(m->type == FLAC__METADATA_TYPE_SEEKTABLE) {
2349 if(!FLAC__format_seektable_is_legal(&m->data.seek_table)) {
2350 flac__utils_printf(stderr, 1, "%s: ERROR: SEEKTABLE metadata block is invalid\n", e->inbasefilename);
2354 else if(m->type == FLAC__METADATA_TYPE_CUESHEET) {
2355 if(!FLAC__format_cuesheet_is_legal(&m->data.cue_sheet, m->data.cue_sheet.is_cd, /*violation=*/0)) {
2356 flac__utils_printf(stderr, 1, "%s: ERROR: CUESHEET metadata block is invalid\n", e->inbasefilename);
2360 else if(m->type == FLAC__METADATA_TYPE_PICTURE) {
2361 const char *error = 0;
2362 if(!FLAC__format_picture_is_legal(&m->data.picture, &error)) {
2363 flac__utils_printf(stderr, 1, "%s: ERROR: PICTURE metadata block is invalid: %s\n", e->inbasefilename, error);
2366 if(m->data.picture.type == FLAC__STREAM_METADATA_PICTURE_TYPE_FILE_ICON_STANDARD) {
2367 if(metadata_picture_has_type1) {
2368 flac__utils_printf(stderr, 1, "%s: ERROR: there may only be one picture of type 1 (32x32 icon) in the file\n", e->inbasefilename);
2371 metadata_picture_has_type1 = true;
2373 else if(m->data.picture.type == FLAC__STREAM_METADATA_PICTURE_TYPE_FILE_ICON) {
2374 if(metadata_picture_has_type2) {
2375 flac__utils_printf(stderr, 1, "%s: ERROR: there may only be one picture of type 2 (icon) in the file\n", e->inbasefilename);
2378 metadata_picture_has_type2 = true;
2386 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)
2388 unsigned wide_sample, sample, channel, byte;
2389 FLAC__int32 *out[FLAC__MAX_CHANNELS];
2391 if(0 == channel_map) {
2392 for(channel = 0; channel < channels; channel++)
2393 out[channel] = dest[channel];
2396 for(channel = 0; channel < channels; channel++)
2397 out[channel] = dest[channel_map[channel]];
2401 if(is_unsigned_samples) {
2402 for(sample = wide_sample = 0; wide_sample < wide_samples; wide_sample++)
2403 for(channel = 0; channel < channels; channel++, sample++)
2404 out[channel][wide_sample] = (FLAC__int32)ucbuffer_[sample] - 0x80;
2407 for(sample = wide_sample = 0; wide_sample < wide_samples; wide_sample++)
2408 for(channel = 0; channel < channels; channel++, sample++)
2409 out[channel][wide_sample] = (FLAC__int32)scbuffer_[sample];
2412 else if(bps == 16) {
2413 if(is_big_endian != is_big_endian_host_) {
2415 const unsigned bytes = wide_samples * channels * (bps >> 3);
2416 for(byte = 0; byte < bytes; byte += 2) {
2417 tmp = ucbuffer_[byte];
2418 ucbuffer_[byte] = ucbuffer_[byte+1];
2419 ucbuffer_[byte+1] = tmp;
2422 if(is_unsigned_samples) {
2423 for(sample = wide_sample = 0; wide_sample < wide_samples; wide_sample++)
2424 for(channel = 0; channel < channels; channel++, sample++)
2425 out[channel][wide_sample] = (FLAC__int32)usbuffer_[sample] - 0x8000;
2428 for(sample = wide_sample = 0; wide_sample < wide_samples; wide_sample++)
2429 for(channel = 0; channel < channels; channel++, sample++)
2430 out[channel][wide_sample] = (FLAC__int32)ssbuffer_[sample];
2433 else if(bps == 24) {
2434 if(!is_big_endian) {
2436 const unsigned bytes = wide_samples * channels * (bps >> 3);
2437 for(byte = 0; byte < bytes; byte += 3) {
2438 tmp = ucbuffer_[byte];
2439 ucbuffer_[byte] = ucbuffer_[byte+2];
2440 ucbuffer_[byte+2] = tmp;
2443 if(is_unsigned_samples) {
2444 for(byte = sample = wide_sample = 0; wide_sample < wide_samples; wide_sample++)
2445 for(channel = 0; channel < channels; channel++, sample++) {
2446 out[channel][wide_sample] = ucbuffer_[byte++]; out[channel][wide_sample] <<= 8;
2447 out[channel][wide_sample] |= ucbuffer_[byte++]; out[channel][wide_sample] <<= 8;
2448 out[channel][wide_sample] |= ucbuffer_[byte++];
2449 out[channel][wide_sample] -= 0x800000;
2453 for(byte = sample = wide_sample = 0; wide_sample < wide_samples; wide_sample++)
2454 for(channel = 0; channel < channels; channel++, sample++) {
2455 out[channel][wide_sample] = scbuffer_[byte++]; out[channel][wide_sample] <<= 8;
2456 out[channel][wide_sample] |= ucbuffer_[byte++]; out[channel][wide_sample] <<= 8;
2457 out[channel][wide_sample] |= ucbuffer_[byte++];
2465 FLAC__int32 mask = (1<<shift)-1;
2466 for(wide_sample = 0; wide_sample < wide_samples; wide_sample++)
2467 for(channel = 0; channel < channels; channel++) {
2468 if(out[channel][wide_sample] & mask) {
2469 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);
2472 out[channel][wide_sample] >>= shift;
2478 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)
2480 EncoderSession *encoder_session = (EncoderSession*)client_data;
2482 (void)encoder, (void)total_frames_estimate;
2484 encoder_session->bytes_written = bytes_written;
2485 encoder_session->samples_written = samples_written;
2487 if(encoder_session->total_samples_to_encode > 0 && !((frames_written-1) & encoder_session->stats_mask))
2488 print_stats(encoder_session);
2491 FLAC__StreamDecoderReadStatus flac_decoder_read_callback(const FLAC__StreamDecoder *decoder, FLAC__byte buffer[], size_t *bytes, void *client_data)
2494 FLACDecoderData *data = (FLACDecoderData*)client_data;
2497 if (data->fatal_error)
2498 return FLAC__STREAM_DECODER_READ_STATUS_ABORT;
2500 /* use up lookahead first */
2501 if (data->lookahead_length) {
2502 n = min(data->lookahead_length, *bytes);
2503 memcpy(buffer, data->lookahead, n);
2505 data->lookahead += n;
2506 data->lookahead_length -= n;
2509 /* get the rest from file */
2511 *bytes = n + fread(buffer, 1, *bytes-n, data->encoder_session->fin);
2512 if(ferror(data->encoder_session->fin))
2513 return FLAC__STREAM_DECODER_READ_STATUS_ABORT;
2514 else if(0 == *bytes)
2515 return FLAC__STREAM_DECODER_READ_STATUS_END_OF_STREAM;
2517 return FLAC__STREAM_DECODER_READ_STATUS_CONTINUE;
2520 return FLAC__STREAM_DECODER_READ_STATUS_CONTINUE;
2523 FLAC__StreamDecoderSeekStatus flac_decoder_seek_callback(const FLAC__StreamDecoder *decoder, FLAC__uint64 absolute_byte_offset, void *client_data)
2525 FLACDecoderData *data = (FLACDecoderData*)client_data;
2528 if(fseeko(data->encoder_session->fin, (off_t)absolute_byte_offset, SEEK_SET) < 0)
2529 return FLAC__STREAM_DECODER_SEEK_STATUS_ERROR;
2531 return FLAC__STREAM_DECODER_SEEK_STATUS_OK;
2534 FLAC__StreamDecoderTellStatus flac_decoder_tell_callback(const FLAC__StreamDecoder *decoder, FLAC__uint64 *absolute_byte_offset, void *client_data)
2536 FLACDecoderData *data = (FLACDecoderData*)client_data;
2540 if((pos = ftello(data->encoder_session->fin)) < 0)
2541 return FLAC__STREAM_DECODER_TELL_STATUS_ERROR;
2543 *absolute_byte_offset = (FLAC__uint64)pos;
2544 return FLAC__STREAM_DECODER_TELL_STATUS_OK;
2548 FLAC__StreamDecoderLengthStatus flac_decoder_length_callback(const FLAC__StreamDecoder *decoder, FLAC__uint64 *stream_length, void *client_data)
2550 FLACDecoderData *data = (FLACDecoderData*)client_data;
2553 if(0 == data->filesize)
2554 return FLAC__STREAM_DECODER_LENGTH_STATUS_ERROR;
2556 *stream_length = (FLAC__uint64)data->filesize;
2557 return FLAC__STREAM_DECODER_LENGTH_STATUS_OK;
2561 FLAC__bool flac_decoder_eof_callback(const FLAC__StreamDecoder *decoder, void *client_data)
2563 FLACDecoderData *data = (FLACDecoderData*)client_data;
2566 return feof(data->encoder_session->fin)? true : false;
2569 FLAC__StreamDecoderWriteStatus flac_decoder_write_callback(const FLAC__StreamDecoder *decoder, const FLAC__Frame *frame, const FLAC__int32 * const buffer[], void *client_data)
2571 FLACDecoderData *data = (FLACDecoderData*)client_data;
2572 FLAC__uint64 n = min(data->samples_left_to_process, frame->header.blocksize);
2575 if(!EncoderSession_process(data->encoder_session, buffer, (unsigned)n)) {
2576 print_error_with_state(data->encoder_session, "ERROR during encoding");
2577 data->fatal_error = true;
2578 return FLAC__STREAM_DECODER_WRITE_STATUS_ABORT;
2581 data->samples_left_to_process -= n;
2582 return FLAC__STREAM_DECODER_WRITE_STATUS_CONTINUE;
2585 void flac_decoder_metadata_callback(const FLAC__StreamDecoder *decoder, const FLAC__StreamMetadata *metadata, void *client_data)
2587 FLACDecoderData *data = (FLACDecoderData*)client_data;
2590 if (data->fatal_error)
2594 data->num_metadata_blocks == sizeof(data->metadata_blocks)/sizeof(data->metadata_blocks[0]) ||
2595 0 == (data->metadata_blocks[data->num_metadata_blocks] = FLAC__metadata_object_clone(metadata))
2597 data->fatal_error = true;
2599 data->num_metadata_blocks++;
2602 void flac_decoder_error_callback(const FLAC__StreamDecoder *decoder, FLAC__StreamDecoderErrorStatus status, void *client_data)
2604 FLACDecoderData *data = (FLACDecoderData*)client_data;
2607 flac__utils_printf(stderr, 1, "%s: ERROR got %s while decoding FLAC input\n", data->encoder_session->inbasefilename, FLAC__StreamDecoderErrorStatusString[status]);
2608 if(!data->encoder_session->continue_through_decode_errors)
2609 data->fatal_error = true;
2612 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)
2615 unsigned last_line_read;
2616 const char *error_message;
2618 if(0 == cuesheet_filename)
2621 if(lead_out_offset == 0) {
2622 flac__utils_printf(stderr, 1, "%s: ERROR cannot import cuesheet when the number of input samples to encode is unknown\n", inbasefilename);
2626 if(0 == (f = fopen(cuesheet_filename, "r"))) {
2627 flac__utils_printf(stderr, 1, "%s: ERROR opening cuesheet \"%s\" for reading: %s\n", inbasefilename, cuesheet_filename, strerror(errno));
2631 *cuesheet = grabbag__cuesheet_parse(f, &error_message, &last_line_read, is_cdda, lead_out_offset);
2635 if(0 == *cuesheet) {
2636 flac__utils_printf(stderr, 1, "%s: ERROR parsing cuesheet \"%s\" on line %u: %s\n", inbasefilename, cuesheet_filename, last_line_read, error_message);
2640 if(!FLAC__format_cuesheet_is_legal(&(*cuesheet)->data.cue_sheet, /*check_cd_da_subset=*/false, &error_message)) {
2641 flac__utils_printf(stderr, 1, "%s: ERROR parsing cuesheet \"%s\": %s\n", inbasefilename, cuesheet_filename, error_message);
2645 /* if we're expecting CDDA, warn about non-compliance */
2646 if(is_cdda && !FLAC__format_cuesheet_is_legal(&(*cuesheet)->data.cue_sheet, /*check_cd_da_subset=*/true, &error_message)) {
2647 flac__utils_printf(stderr, 1, "%s: WARNING cuesheet \"%s\" is not audio CD compliant: %s\n", inbasefilename, cuesheet_filename, error_message);
2648 if(treat_warnings_as_errors)
2650 (*cuesheet)->data.cue_sheet.is_cd = false;
2656 void print_stats(const EncoderSession *encoder_session)
2658 const FLAC__uint64 samples_written = min(encoder_session->total_samples_to_encode, encoder_session->samples_written);
2659 #if defined _MSC_VER || defined __MINGW32__
2660 /* with MSVC you have to spoon feed it the casting */
2661 const double progress = (double)(FLAC__int64)samples_written / (double)(FLAC__int64)encoder_session->total_samples_to_encode;
2662 const double ratio = (double)(FLAC__int64)encoder_session->bytes_written / ((double)(FLAC__int64)encoder_session->unencoded_size * min(1.0, progress));
2664 const double progress = (double)samples_written / (double)encoder_session->total_samples_to_encode;
2665 const double ratio = (double)encoder_session->bytes_written / ((double)encoder_session->unencoded_size * min(1.0, progress));
2668 FLAC__ASSERT(encoder_session->total_samples_to_encode > 0);
2670 if(samples_written == encoder_session->total_samples_to_encode) {
2671 flac__utils_printf(stderr, 2, "\r%s:%s wrote %u bytes, ratio=%0.3f",
2672 encoder_session->inbasefilename,
2673 encoder_session->verify? " Verify OK," : "",
2674 (unsigned)encoder_session->bytes_written,
2679 flac__utils_printf(stderr, 2, "\r%s: %u%% complete, ratio=%0.3f", encoder_session->inbasefilename, (unsigned)floor(progress * 100.0 + 0.5), ratio);
2683 void print_error_with_init_status(const EncoderSession *e, const char *message, FLAC__StreamEncoderInitStatus init_status)
2685 const int ilen = strlen(e->inbasefilename) + 1;
2686 const char *state_string = "";
2688 flac__utils_printf(stderr, 1, "\n%s: %s\n", e->inbasefilename, message);
2690 flac__utils_printf(stderr, 1, "%*s init_status = %s\n", ilen, "", FLAC__StreamEncoderInitStatusString[init_status]);
2692 if(init_status == FLAC__STREAM_ENCODER_INIT_STATUS_ENCODER_ERROR) {
2693 state_string = FLAC__stream_encoder_get_resolved_state_string(e->encoder);
2695 flac__utils_printf(stderr, 1, "%*s state = %s\n", ilen, "", state_string);
2697 /* print out some more info for some errors: */
2698 if(0 == strcmp(state_string, FLAC__StreamEncoderStateString[FLAC__STREAM_ENCODER_CLIENT_ERROR])) {
2699 flac__utils_printf(stderr, 1,
2701 "An error occurred while writing; the most common cause is that the disk is full.\n"
2704 else if(0 == strcmp(state_string, FLAC__StreamEncoderStateString[FLAC__STREAM_ENCODER_IO_ERROR])) {
2705 flac__utils_printf(stderr, 1,
2707 "An error occurred opening the output file; it is likely that the output\n"
2708 "directory does not exist or is not writable, the output file already exists and\n"
2709 "is not writable, or the disk is full.\n"
2713 else if(init_status == FLAC__STREAM_ENCODER_INIT_STATUS_NOT_STREAMABLE) {
2714 flac__utils_printf(stderr, 1,
2716 "The encoding parameters specified do not conform to the FLAC Subset and may not\n"
2717 "be streamable or playable in hardware devices. If you really understand the\n"
2718 "consequences, you can add --lax to the command-line options to encode with\n"
2719 "these parameters anyway. See http://flac.sourceforge.net/format.html#subset\n"
2724 void print_error_with_state(const EncoderSession *e, const char *message)
2726 const int ilen = strlen(e->inbasefilename) + 1;
2727 const char *state_string;
2729 flac__utils_printf(stderr, 1, "\n%s: %s\n", e->inbasefilename, message);
2731 state_string = FLAC__stream_encoder_get_resolved_state_string(e->encoder);
2733 flac__utils_printf(stderr, 1, "%*s state = %s\n", ilen, "", state_string);
2735 /* print out some more info for some errors: */
2736 if(0 == strcmp(state_string, FLAC__StreamEncoderStateString[FLAC__STREAM_ENCODER_CLIENT_ERROR])) {
2737 flac__utils_printf(stderr, 1,
2739 "An error occurred while writing; the most common cause is that the disk is full.\n"
2744 void print_verify_error(EncoderSession *e)
2746 FLAC__uint64 absolute_sample;
2747 unsigned frame_number;
2750 FLAC__int32 expected;
2753 FLAC__stream_encoder_get_verify_decoder_error_stats(e->encoder, &absolute_sample, &frame_number, &channel, &sample, &expected, &got);
2755 flac__utils_printf(stderr, 1, "%s: ERROR: mismatch in decoded data, verify FAILED!\n", e->inbasefilename);
2756 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);
2757 flac__utils_printf(stderr, 1, " In all known cases, verify errors are caused by hardware problems,\n");
2758 flac__utils_printf(stderr, 1, " usually overclocking or bad RAM. Delete %s\n", e->outfilename);
2759 flac__utils_printf(stderr, 1, " and repeat the flac command exactly as before. If it does not give a\n");
2760 flac__utils_printf(stderr, 1, " verify error in the exact same place each time you try it, then there is\n");
2761 flac__utils_printf(stderr, 1, " a problem with your hardware; please see the FAQ:\n");
2762 flac__utils_printf(stderr, 1, " http://flac.sourceforge.net/faq.html#tools__hardware_prob\n");
2763 flac__utils_printf(stderr, 1, " If it does fail in the exact same place every time, keep\n");
2764 flac__utils_printf(stderr, 1, " %s and submit a bug report to:\n", e->outfilename);
2765 flac__utils_printf(stderr, 1, " https://sourceforge.net/bugs/?func=addbug&group_id=13478\n");
2766 flac__utils_printf(stderr, 1, " Make sure to upload the FLAC file and use the \"Monitor\" feature to\n");
2767 flac__utils_printf(stderr, 1, " monitor the bug status.\n");
2768 flac__utils_printf(stderr, 1, "Verify FAILED! Do not trust %s\n", e->outfilename);
2771 FLAC__bool read_little_endian_uint16(FILE *f, FLAC__uint16 *val, FLAC__bool eof_ok, const char *fn)
2773 size_t bytes_read = fread(val, 1, 2, f);
2775 if(bytes_read == 0) {
2777 flac__utils_printf(stderr, 1, "%s: ERROR: unexpected EOF\n", fn);
2783 else if(bytes_read < 2) {
2784 flac__utils_printf(stderr, 1, "%s: ERROR: unexpected EOF\n", fn);
2788 if(is_big_endian_host_) {
2789 FLAC__byte tmp, *b = (FLAC__byte*)val;
2790 tmp = b[1]; b[1] = b[0]; b[0] = tmp;
2796 FLAC__bool read_little_endian_uint32(FILE *f, FLAC__uint32 *val, FLAC__bool eof_ok, const char *fn)
2798 size_t bytes_read = fread(val, 1, 4, f);
2800 if(bytes_read == 0) {
2802 flac__utils_printf(stderr, 1, "%s: ERROR: unexpected EOF\n", fn);
2808 else if(bytes_read < 4) {
2809 flac__utils_printf(stderr, 1, "%s: ERROR: unexpected EOF\n", fn);
2813 if(is_big_endian_host_) {
2814 FLAC__byte tmp, *b = (FLAC__byte*)val;
2815 tmp = b[3]; b[3] = b[0]; b[0] = tmp;
2816 tmp = b[2]; b[2] = b[1]; b[1] = tmp;
2822 FLAC__bool read_big_endian_uint16(FILE *f, FLAC__uint16 *val, FLAC__bool eof_ok, const char *fn)
2824 unsigned char buf[4];
2825 size_t bytes_read= fread(buf, 1, 2, f);
2827 if(bytes_read==0U && eof_ok)
2829 else if(bytes_read<2U) {
2830 flac__utils_printf(stderr, 1, "%s: ERROR: unexpected EOF\n", fn);
2834 /* this is independent of host endianness */
2835 *val= (FLAC__uint16)(buf[0])<<8 | buf[1];
2840 FLAC__bool read_big_endian_uint32(FILE *f, FLAC__uint32 *val, FLAC__bool eof_ok, const char *fn)
2842 unsigned char buf[4];
2843 size_t bytes_read= fread(buf, 1, 4, f);
2845 if(bytes_read==0U && eof_ok)
2847 else if(bytes_read<4U) {
2848 flac__utils_printf(stderr, 1, "%s: ERROR: unexpected EOF\n", fn);
2852 /* this is independent of host endianness */
2853 *val= (FLAC__uint32)(buf[0])<<24 | (FLAC__uint32)(buf[1])<<16 |
2854 (FLAC__uint32)(buf[2])<<8 | buf[3];
2859 FLAC__bool read_sane_extended(FILE *f, FLAC__uint32 *val, FLAC__bool eof_ok, const char *fn)
2860 /* Read an IEEE 754 80-bit (aka SANE) extended floating point value from 'f',
2861 * convert it into an integral value and store in 'val'. Return false if only
2862 * between 1 and 9 bytes remain in 'f', if 0 bytes remain in 'f' and 'eof_ok' is
2863 * false, or if the value is negative, between zero and one, or too large to be
2864 * represented by 'val'; return true otherwise.
2868 unsigned char buf[10];
2869 size_t bytes_read= fread(buf, 1U, 10U, f);
2870 FLAC__int16 e= ((FLAC__uint16)(buf[0])<<8 | (FLAC__uint16)(buf[1]))-0x3FFF;
2871 FLAC__int16 shift= 63-e;
2874 if(bytes_read==0U && eof_ok)
2876 else if(bytes_read<10U) {
2877 flac__utils_printf(stderr, 1, "%s: ERROR: unexpected EOF\n", fn);
2880 else if((buf[0]>>7)==1U || e<0 || e>63) {
2881 flac__utils_printf(stderr, 1, "%s: ERROR: invalid floating-point value\n", fn);
2885 for(i= 0U; i<8U; ++i)
2886 p|= (FLAC__uint64)(buf[i+2])<<(56U-i*8);
2887 *val= (FLAC__uint32)((p>>shift)+(p>>(shift-1) & 0x1));
2892 FLAC__bool fskip_ahead(FILE *f, FLAC__uint64 offset)
2894 static unsigned char dump[8192];
2897 long need = (long)min(offset, LONG_MAX);
2898 if(fseeko(f, need, SEEK_CUR) < 0) {
2899 need = (long)min(offset, sizeof(dump));
2900 if((long)fread(dump, 1, need, f) < need)
2905 #if 0 /* pure non-fseek() version */
2907 const long need = (long)min(offset, sizeof(dump));
2908 if(fread(dump, 1, need, f) < need)
2916 unsigned count_channel_mask_bits(FLAC__uint32 mask)
2928 FLAC__uint32 limit_channel_mask(FLAC__uint32 mask, unsigned channels)
2930 FLAC__uint32 x = 0x80000000;
2931 unsigned count = count_channel_mask_bits(mask);
2932 while(x && count > channels) {
2939 FLAC__ASSERT(count_channel_mask_bits(mask) == channels);