1 /* flac - Command-line FLAC encoder/decoder
2 * Copyright (C) 2000,2001,2002,2003,2004,2005,2006 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 <= 1200 /* @@@ [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"
47 #include "OggFLAC/stream_encoder.h"
53 #define min(x,y) ((x)<(y)?(x):(y))
57 #define max(x,y) ((x)>(y)?(x):(y))
59 /* this MUST be >= 588 so that sector aligning can take place with one read */
60 #define CHUNK_OF_SAMPLES 2048
68 FLAC__bool outputfile_opened; /* true if we successfully opened the output file and we want it to be deleted if there is an error */
69 const char *inbasefilename;
70 const char *outfilename;
73 FLAC__uint64 until; /* a value of 0 mean end-of-stream (i.e. --until=-0) */
74 FLAC__bool replay_gain;
76 unsigned bits_per_sample;
78 FLAC__uint64 unencoded_size;
79 FLAC__uint64 total_samples_to_encode;
80 FLAC__uint64 bytes_written;
81 FLAC__uint64 samples_written;
86 FLAC__StreamEncoder *flac;
88 OggFLAC__StreamEncoder *ogg;
93 FLAC__StreamMetadata *seek_table_template;
96 /* this is data attached to the FLAC decoder when encoding from a FLAC file */
98 EncoderSession *encoder_session;
100 const FLAC__byte *lookahead;
101 unsigned lookahead_length;
102 size_t num_metadata_blocks;
103 FLAC__StreamMetadata *metadata_blocks[1024]; /*@@@ BAD MAGIC number */
104 FLAC__uint64 samples_left_to_process;
105 FLAC__bool fatal_error;
108 const int FLAC_ENCODE__DEFAULT_PADDING = 8192;
110 static FLAC__bool is_big_endian_host_;
112 static unsigned char ucbuffer_[CHUNK_OF_SAMPLES*FLAC__MAX_CHANNELS*((FLAC__REFERENCE_CODEC_MAX_BITS_PER_SAMPLE+7)/8)];
113 static signed char *scbuffer_ = (signed char *)ucbuffer_;
114 static FLAC__uint16 *usbuffer_ = (FLAC__uint16 *)ucbuffer_;
115 static FLAC__int16 *ssbuffer_ = (FLAC__int16 *)ucbuffer_;
117 static FLAC__int32 in_[FLAC__MAX_CHANNELS][CHUNK_OF_SAMPLES];
118 static FLAC__int32 *input_[FLAC__MAX_CHANNELS];
122 * unpublished debug routines from the FLAC libs
124 extern FLAC__bool FLAC__stream_encoder_disable_constant_subframes(FLAC__StreamEncoder *encoder, FLAC__bool value);
125 extern FLAC__bool FLAC__stream_encoder_disable_fixed_subframes(FLAC__StreamEncoder *encoder, FLAC__bool value);
126 extern FLAC__bool FLAC__stream_encoder_disable_verbatim_subframes(FLAC__StreamEncoder *encoder, FLAC__bool value);
128 extern FLAC__bool OggFLAC__stream_encoder_disable_constant_subframes(OggFLAC__StreamEncoder *encoder, FLAC__bool value);
129 extern FLAC__bool OggFLAC__stream_encoder_disable_fixed_subframes(OggFLAC__StreamEncoder *encoder, FLAC__bool value);
130 extern FLAC__bool OggFLAC__stream_encoder_disable_verbatim_subframes(OggFLAC__StreamEncoder *encoder, FLAC__bool value);
136 static FLAC__bool EncoderSession_construct(EncoderSession *e, FLAC__bool use_ogg, FLAC__bool verify, FILE *infile, const char *infilename, const char *outfilename);
137 static void EncoderSession_destroy(EncoderSession *e);
138 static int EncoderSession_finish_ok(EncoderSession *e, int info_align_carry, int info_align_zero);
139 static int EncoderSession_finish_error(EncoderSession *e);
140 static FLAC__bool EncoderSession_init_encoder(EncoderSession *e, encode_options_t options, FLAC__uint32 channel_mask, unsigned channels, unsigned bps, unsigned sample_rate, FLACDecoderData *flac_decoder_data);
141 static FLAC__bool EncoderSession_process(EncoderSession *e, const FLAC__int32 * const buffer[], unsigned samples);
142 static FLAC__bool convert_to_seek_table_template(const char *requested_seek_points, int num_requested_seek_points, FLAC__StreamMetadata *cuesheet, EncoderSession *e);
143 static FLAC__bool canonicalize_until_specification(utils__SkipUntilSpecification *spec, const char *inbasefilename, unsigned sample_rate, FLAC__uint64 skip, FLAC__uint64 total_samples_in_input);
144 static FLAC__bool verify_metadata(const EncoderSession *e, FLAC__StreamMetadata **metadata, unsigned num_metadata);
145 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);
146 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);
147 static FLAC__StreamDecoderReadStatus flac_decoder_read_callback(const FLAC__StreamDecoder *decoder, FLAC__byte buffer[], unsigned *bytes, void *client_data);
148 static FLAC__StreamDecoderSeekStatus flac_decoder_seek_callback(const FLAC__StreamDecoder *decoder, FLAC__uint64 absolute_byte_offset, void *client_data);
149 static FLAC__StreamDecoderTellStatus flac_decoder_tell_callback(const FLAC__StreamDecoder *decoder, FLAC__uint64 *absolute_byte_offset, void *client_data);
150 static FLAC__StreamDecoderLengthStatus flac_decoder_length_callback(const FLAC__StreamDecoder *decoder, FLAC__uint64 *stream_length, void *client_data);
151 static FLAC__bool flac_decoder_eof_callback(const FLAC__StreamDecoder *decoder, void *client_data);
152 static FLAC__StreamDecoderWriteStatus flac_decoder_write_callback(const FLAC__StreamDecoder *decoder, const FLAC__Frame *frame, const FLAC__int32 * const buffer[], void *client_data);
153 static void flac_decoder_metadata_callback(const FLAC__StreamDecoder *decoder, const FLAC__StreamMetadata *metadata, void *client_data);
154 static void flac_decoder_error_callback(const FLAC__StreamDecoder *decoder, FLAC__StreamDecoderErrorStatus status, void *client_data);
155 static FLAC__bool parse_cuesheet(FLAC__StreamMetadata **cuesheet, const char *cuesheet_filename, const char *inbasefilename, FLAC__bool is_cdda, FLAC__uint64 lead_out_offset);
156 static void print_stats(const EncoderSession *encoder_session);
157 static void print_error_with_init_status(const EncoderSession *e, const char *message, FLAC__StreamEncoderInitStatus init_status);
158 static void print_error_with_state(const EncoderSession *e, const char *message);
159 static void print_verify_error(EncoderSession *e);
160 static FLAC__bool read_little_endian_uint16(FILE *f, FLAC__uint16 *val, FLAC__bool eof_ok, const char *fn);
161 static FLAC__bool read_little_endian_uint32(FILE *f, FLAC__uint32 *val, FLAC__bool eof_ok, const char *fn);
162 static FLAC__bool read_big_endian_uint16(FILE *f, FLAC__uint16 *val, FLAC__bool eof_ok, const char *fn);
163 static FLAC__bool read_big_endian_uint32(FILE *f, FLAC__uint32 *val, FLAC__bool eof_ok, const char *fn);
164 static FLAC__bool read_sane_extended(FILE *f, FLAC__uint32 *val, FLAC__bool eof_ok, const char *fn);
165 static FLAC__bool fskip_ahead(FILE *f, FLAC__uint64 offset);
166 static unsigned count_channel_mask_bits(FLAC__uint32 mask);
167 static FLAC__uint32 limit_channel_mask(FLAC__uint32 mask, unsigned channels);
172 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)
174 EncoderSession encoder_session;
177 unsigned int channels= 0U, bps= 0U, shift= 0U, sample_rate= 0U, sample_frames= 0U;
178 size_t channel_map[FLAC__MAX_CHANNELS];
179 FLAC__bool got_comm_chunk= false, got_ssnd_chunk= false;
180 int info_align_carry= -1, info_align_zero= -1;
181 FLAC__bool is_big_endian_pcm = true;
183 (void)infilesize; /* silence compiler warning about unused parameter */
184 (void)lookahead; /* silence compiler warning about unused parameter */
185 (void)lookahead_length; /* silence compiler warning about unused parameter */
188 EncoderSession_construct(
191 options.common.use_ogg,
195 options.common.verify,
203 /* initialize default channel map that preserves channel order */
206 for(i = 0; i < sizeof(channel_map)/sizeof(channel_map[0]); i++)
210 /* lookahead[] already has "FORMxxxxAIFF", do sub-chunks */
214 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 */
216 /* chunk identifier; really conservative about behavior of fread() and feof() */
217 if(feof(infile) || ((c= fread(chunk_id, 1U, 4U, infile)), c==0U && feof(infile)))
219 else if(c<4U || feof(infile)) {
220 flac__utils_printf(stderr, 1, "%s: ERROR: incomplete chunk identifier\n", encoder_session.inbasefilename);
221 return EncoderSession_finish_error(&encoder_session);
224 if(got_comm_chunk==false && !memcmp(chunk_id, "COMM", 4)) { /* common chunk */
226 const FLAC__uint32 minimum_comm_size = (is_aifc? 22 : 18);
228 /* COMM chunk size */
229 if(!read_big_endian_uint32(infile, &xx, false, encoder_session.inbasefilename))
230 return EncoderSession_finish_error(&encoder_session);
231 else if(xx<minimum_comm_size) {
232 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);
233 return EncoderSession_finish_error(&encoder_session);
235 else if(!is_aifc && xx!=minimum_comm_size) {
236 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 skip= (xx-minimum_comm_size)+(xx & 1U);
240 /* number of channels */
241 if(!read_big_endian_uint16(infile, &x, false, encoder_session.inbasefilename))
242 return EncoderSession_finish_error(&encoder_session);
243 else if(x==0U || x>FLAC__MAX_CHANNELS) {
244 flac__utils_printf(stderr, 1, "%s: ERROR: unsupported number channels %u\n", encoder_session.inbasefilename, (unsigned int)x);
245 return EncoderSession_finish_error(&encoder_session);
247 else if(x>2U && !options.common.channel_map_none) {
248 flac__utils_printf(stderr, 1, "%s: ERROR: unsupported number channels %u for AIFF\n", encoder_session.inbasefilename, (unsigned int)x);
249 return EncoderSession_finish_error(&encoder_session);
251 else if(options.common.sector_align && x!=2U) {
252 flac__utils_printf(stderr, 1, "%s: ERROR: file has %u channels, must be 2 for --sector-align\n", encoder_session.inbasefilename, (unsigned int)x);
253 return EncoderSession_finish_error(&encoder_session);
257 /* number of sample frames */
258 if(!read_big_endian_uint32(infile, &xx, false, encoder_session.inbasefilename))
259 return EncoderSession_finish_error(&encoder_session);
262 /* bits per sample */
263 if(!read_big_endian_uint16(infile, &x, false, encoder_session.inbasefilename))
264 return EncoderSession_finish_error(&encoder_session);
265 else if(x<4U || x>24U) {
266 flac__utils_printf(stderr, 1, "%s: ERROR: unsupported bits-per-sample %u\n", encoder_session.inbasefilename, (unsigned int)x);
267 return EncoderSession_finish_error(&encoder_session);
269 else if(options.common.sector_align && x!=16U) {
270 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);
271 return EncoderSession_finish_error(&encoder_session);
274 shift= (bps%8)? 8-(bps%8) : 0; /* SSND data is always byte-aligned, left-justified but format_input() will double-check */
278 if(!read_sane_extended(infile, &xx, false, encoder_session.inbasefilename))
279 return EncoderSession_finish_error(&encoder_session);
280 else if(!FLAC__format_sample_rate_is_valid(xx)) {
281 flac__utils_printf(stderr, 1, "%s: ERROR: unsupported sample rate %u\n", encoder_session.inbasefilename, (unsigned int)xx);
282 return EncoderSession_finish_error(&encoder_session);
284 else if(options.common.sector_align && xx!=44100U) {
285 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);
286 return EncoderSession_finish_error(&encoder_session);
290 /* check compression type for AIFF-C */
292 if(!read_big_endian_uint32(infile, &xx, false, encoder_session.inbasefilename))
293 return EncoderSession_finish_error(&encoder_session);
294 if(xx == 0x736F7774) /* "sowt" */
295 is_big_endian_pcm = false;
296 else if(xx == 0x4E4F4E45) /* "NONE" */
297 ; /* nothing to do, we already default to big-endian */
299 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));
300 return EncoderSession_finish_error(&encoder_session);
304 /* set channel mapping */
305 /* FLAC order follows SMPTE and WAVEFORMATEXTENSIBLE but with fewer channels, which are: */
306 /* front left, front right, center, LFE, back left, back right, surround left, surround right */
307 /* specs say the channel ordering is:
309 * ___________________________________________________
313 * quad (ambiguous with 4ch) Fl Fr Bl Br
316 * 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
317 * so we only have unambiguous mappings for 2, 3, and 5 channels
320 options.common.channel_map_none ||
321 channels == 1 || /* 1 channel: (mono) */
322 channels == 2 || /* 2 channels: left, right */
323 channels == 3 || /* 3 channels: left, right, center */
324 channels == 5 /* 5 channels: front left, front right, center, surround left, surround right */
326 /* keep default channel order */
329 flac__utils_printf(stderr, 1, "%s: ERROR: unsupported number channels %u for AIFF\n", encoder_session.inbasefilename, channels);
330 return EncoderSession_finish_error(&encoder_session);
333 /* skip any extra data in the COMM chunk */
334 if(!fskip_ahead(infile, skip)) {
335 flac__utils_printf(stderr, 1, "%s: ERROR during read while skipping extra COMM data\n", encoder_session.inbasefilename);
336 return EncoderSession_finish_error(&encoder_session);
340 * now that we know the sample rate, canonicalize the
341 * --skip string to a number of samples:
343 flac__utils_canonicalize_skip_until_specification(&options.common.skip_specification, sample_rate);
344 FLAC__ASSERT(options.common.skip_specification.value.samples >= 0);
345 encoder_session.skip = (FLAC__uint64)options.common.skip_specification.value.samples;
346 FLAC__ASSERT(!options.common.sector_align || encoder_session.skip == 0);
348 got_comm_chunk= true;
350 else if(got_ssnd_chunk==false && !memcmp(chunk_id, "SSND", 4)) { /* sound data chunk */
351 unsigned int offset= 0U, block_size= 0U, align_remainder= 0U, data_bytes;
352 size_t bytes_per_frame= channels*(bps>>3);
353 FLAC__uint64 total_samples_in_input, trim = 0;
354 FLAC__bool pad= false;
356 if(got_comm_chunk==false) {
357 flac__utils_printf(stderr, 1, "%s: ERROR: got 'SSND' chunk before 'COMM' chunk\n", encoder_session.inbasefilename);
358 return EncoderSession_finish_error(&encoder_session);
361 /* SSND chunk size */
362 if(!read_big_endian_uint32(infile, &xx, false, encoder_session.inbasefilename))
363 return EncoderSession_finish_error(&encoder_session);
365 pad= (data_bytes & 1U) ? true : false;
366 data_bytes-= 8U; /* discount the offset and block size fields */
369 if(!read_big_endian_uint32(infile, &xx, false, encoder_session.inbasefilename))
370 return EncoderSession_finish_error(&encoder_session);
375 if(!read_big_endian_uint32(infile, &xx, false, encoder_session.inbasefilename))
376 return EncoderSession_finish_error(&encoder_session);
378 flac__utils_printf(stderr, 1, "%s: ERROR: block size is %u; must be 0\n", encoder_session.inbasefilename, (unsigned int)xx);
379 return EncoderSession_finish_error(&encoder_session);
383 /* skip any SSND offset bytes */
384 FLAC__ASSERT(offset<=LONG_MAX);
385 if(!fskip_ahead(infile, offset)) {
386 flac__utils_printf(stderr, 1, "%s: ERROR: skipping offset in SSND chunk\n", encoder_session.inbasefilename);
387 return EncoderSession_finish_error(&encoder_session);
389 if(data_bytes!=(sample_frames*bytes_per_frame)) {
390 flac__utils_printf(stderr, 1, "%s: ERROR: SSND chunk size inconsistent with sample frame count\n", encoder_session.inbasefilename);
391 return EncoderSession_finish_error(&encoder_session);
394 /* *options.common.align_reservoir_samples will be 0 unless --sector-align is used */
395 FLAC__ASSERT(options.common.sector_align || *options.common.align_reservoir_samples == 0);
396 total_samples_in_input = data_bytes / bytes_per_frame + *options.common.align_reservoir_samples;
399 * now that we know the input size, canonicalize the
400 * --until string to an absolute sample number:
402 if(!canonicalize_until_specification(&options.common.until_specification, encoder_session.inbasefilename, sample_rate, encoder_session.skip, total_samples_in_input))
403 return EncoderSession_finish_error(&encoder_session);
404 encoder_session.until = (FLAC__uint64)options.common.until_specification.value.samples;
405 FLAC__ASSERT(!options.common.sector_align || encoder_session.until == 0);
407 if(encoder_session.skip>0U) {
408 if(!fskip_ahead(infile, encoder_session.skip*bytes_per_frame)) {
409 flac__utils_printf(stderr, 1, "%s: ERROR during read while skipping samples\n", encoder_session.inbasefilename);
410 return EncoderSession_finish_error(&encoder_session);
414 data_bytes-= (unsigned int)encoder_session.skip*bytes_per_frame; /*@@@ WATCHOUT: 4GB limit */
415 encoder_session.total_samples_to_encode= total_samples_in_input - encoder_session.skip;
416 if(encoder_session.until > 0) {
417 trim = total_samples_in_input - encoder_session.until;
418 FLAC__ASSERT(total_samples_in_input > 0);
419 FLAC__ASSERT(!options.common.sector_align);
420 data_bytes-= (unsigned int)trim*bytes_per_frame;
421 encoder_session.total_samples_to_encode-= trim;
423 if(options.common.sector_align) {
424 align_remainder= (unsigned int)(encoder_session.total_samples_to_encode % 588U);
425 if(options.common.is_last_file)
426 encoder_session.total_samples_to_encode+= (588U-align_remainder); /* will pad with zeroes */
428 encoder_session.total_samples_to_encode-= align_remainder; /* will stop short and carry over to next file */
431 /* +54 for the size of the AIFF headers; this is just an estimate for the progress indicator and doesn't need to be exact */
432 encoder_session.unencoded_size= encoder_session.total_samples_to_encode*bytes_per_frame+54;
434 if(!EncoderSession_init_encoder(&encoder_session, options.common, /*channel_mask=*/0, channels, bps-shift, sample_rate, /*flac_decoder_data=*/0))
435 return EncoderSession_finish_error(&encoder_session);
437 /* first do any samples in the reservoir */
438 if(options.common.sector_align && *options.common.align_reservoir_samples>0U) {
440 if(!EncoderSession_process(&encoder_session, (const FLAC__int32 *const *)options.common.align_reservoir, *options.common.align_reservoir_samples)) {
441 print_error_with_state(&encoder_session, "ERROR during encoding");
442 return EncoderSession_finish_error(&encoder_session);
446 /* decrement the data_bytes counter if we need to align the file */
447 if(options.common.sector_align) {
448 if(options.common.is_last_file)
449 *options.common.align_reservoir_samples= 0U;
451 *options.common.align_reservoir_samples= align_remainder;
452 data_bytes-= (*options.common.align_reservoir_samples)*bytes_per_frame;
456 /* now do from the file */
457 while(data_bytes>0) {
458 size_t bytes_read= fread(ucbuffer_, 1U, min(data_bytes, CHUNK_OF_SAMPLES*bytes_per_frame), infile);
462 flac__utils_printf(stderr, 1, "%s: ERROR during read\n", encoder_session.inbasefilename);
463 return EncoderSession_finish_error(&encoder_session);
465 else if(feof(infile)) {
466 flac__utils_printf(stderr, 1, "%s: WARNING: unexpected EOF; expected %u samples, got %u samples\n", encoder_session.inbasefilename, (unsigned int)encoder_session.total_samples_to_encode, (unsigned int)encoder_session.samples_written);
471 if(bytes_read % bytes_per_frame != 0U) {
472 flac__utils_printf(stderr, 1, "%s: ERROR: got partial sample\n", encoder_session.inbasefilename);
473 return EncoderSession_finish_error(&encoder_session);
476 unsigned int frames= bytes_read/bytes_per_frame;
477 if(!format_input(input_, frames, is_big_endian_pcm, /*is_unsigned_samples=*/false, channels, bps, shift, channel_map))
478 return EncoderSession_finish_error(&encoder_session);
480 if(!EncoderSession_process(&encoder_session, (const FLAC__int32 *const *)input_, frames)) {
481 print_error_with_state(&encoder_session, "ERROR during encoding");
482 return EncoderSession_finish_error(&encoder_session);
485 data_bytes-= bytes_read;
491 FLAC__ASSERT(!options.common.sector_align);
492 if(!fskip_ahead(infile, trim*bytes_per_frame)) {
493 flac__utils_printf(stderr, 1, "%s: ERROR during read while skipping samples\n", encoder_session.inbasefilename);
494 return EncoderSession_finish_error(&encoder_session);
498 /* now read unaligned samples into reservoir or pad with zeroes if necessary */
499 if(options.common.sector_align) {
500 if(options.common.is_last_file) {
501 unsigned int pad_frames= 588U-align_remainder;
503 if(pad_frames<588U) {
506 info_align_zero= pad_frames;
507 for(i= 0U; i<channels; ++i)
508 memset(input_[i], 0, sizeof(input_[0][0])*pad_frames);
510 if(!EncoderSession_process(&encoder_session, (const FLAC__int32 *const *)input_, pad_frames)) {
511 print_error_with_state(&encoder_session, "ERROR during encoding");
512 return EncoderSession_finish_error(&encoder_session);
517 if(*options.common.align_reservoir_samples > 0) {
518 size_t bytes_read= fread(ucbuffer_, 1U, (*options.common.align_reservoir_samples)*bytes_per_frame, infile);
520 FLAC__ASSERT(CHUNK_OF_SAMPLES>=588U);
521 if(bytes_read==0U && ferror(infile)) {
522 flac__utils_printf(stderr, 1, "%s: ERROR during read\n", encoder_session.inbasefilename);
523 return EncoderSession_finish_error(&encoder_session);
525 else if(bytes_read != (*options.common.align_reservoir_samples) * bytes_per_frame) {
526 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);
529 info_align_carry= *options.common.align_reservoir_samples;
530 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))
531 return EncoderSession_finish_error(&encoder_session);
540 if(fread(&tmp, 1U, 1U, infile)<1U) {
541 flac__utils_printf(stderr, 1, "%s: ERROR during read of SSND pad byte\n", encoder_session.inbasefilename);
542 return EncoderSession_finish_error(&encoder_session);
546 got_ssnd_chunk= true;
548 else { /* other chunk */
549 if(!memcmp(chunk_id, "COMM", 4)) {
550 flac__utils_printf(stderr, 1, "%s: WARNING: skipping extra 'COMM' chunk\n", encoder_session.inbasefilename);
552 else if(!memcmp(chunk_id, "SSND", 4)) {
553 flac__utils_printf(stderr, 1, "%s: WARNING: skipping extra 'SSND' chunk\n", encoder_session.inbasefilename);
556 flac__utils_printf(stderr, 1, "%s: WARNING: skipping unknown chunk '%s'\n", encoder_session.inbasefilename, chunk_id);
560 if(!read_big_endian_uint32(infile, &xx, false, encoder_session.inbasefilename))
561 return EncoderSession_finish_error(&encoder_session);
563 unsigned long skip= xx+(xx & 1U);
565 FLAC__ASSERT(skip<=LONG_MAX);
566 if(!fskip_ahead(infile, skip)) {
567 fprintf(stderr, "%s: ERROR during read while skipping unknown chunk\n", encoder_session.inbasefilename);
568 return EncoderSession_finish_error(&encoder_session);
574 if(got_ssnd_chunk==false && sample_frames!=0U) {
575 flac__utils_printf(stderr, 1, "%s: ERROR: missing SSND chunk\n", encoder_session.inbasefilename);
576 return EncoderSession_finish_error(&encoder_session);
579 return EncoderSession_finish_ok(&encoder_session, info_align_carry, info_align_zero);
582 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)
584 EncoderSession encoder_session;
585 FLAC__bool is_unsigned_samples = false;
586 unsigned channels = 0, bps = 0, sample_rate = 0, shift = 0;
587 size_t bytes_per_wide_sample, bytes_read;
588 size_t channel_map[FLAC__MAX_CHANNELS];
589 FLAC__uint16 x, format; /* format is the wFormatTag word from the 'fmt ' chunk */
590 FLAC__uint32 xx, channel_mask = 0;
591 FLAC__bool got_fmt_chunk = false, got_data_chunk = false;
592 unsigned align_remainder = 0;
593 int info_align_carry = -1, info_align_zero = -1;
597 (void)lookahead_length;
600 EncoderSession_construct(
603 options.common.use_ogg,
607 options.common.verify,
615 /* initialize default channel map that preserves channel order */
618 for(i = 0; i < sizeof(channel_map)/sizeof(channel_map[0]); i++)
623 * lookahead[] already has "RIFFxxxxWAVE", do sub-chunks
625 while(!feof(infile)) {
626 if(!read_little_endian_uint32(infile, &xx, true, encoder_session.inbasefilename))
627 return EncoderSession_finish_error(&encoder_session);
630 if(xx == 0x20746d66 && !got_fmt_chunk) { /* "fmt " */
631 unsigned block_align, data_bytes;
634 * http://www-mmsp.ece.mcgill.ca/Documents/AudioFormats/WAVE/WAVE.html
635 * http://windowssdk.msdn.microsoft.com/en-us/library/ms713497.aspx
636 * 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
639 * 4 byte: subchunk size
640 * 2 byte: format type: 1 for WAVE_FORMAT_PCM, 65534 for WAVE_FORMAT_EXTENSIBLE
642 * 4 byte: sample rate (Hz)
643 * 4 byte: avg bytes per sec
644 * 2 byte: block align
645 * 2 byte: bits per sample (not necessarily all significant)
647 * 2 byte: extension size in bytes (usually 0 for WAVEFORMATEX and 22 for WAVEFORMATEXTENSIBLE with PCM)
648 * WAVEFORMATEXTENSIBLE adds
649 * 2 byte: valid bits per sample
650 * 4 byte: channel mask
651 * 16 byte: subformat GUID, first 2 bytes have format type, 1 being PCM
653 * Current spec says WAVEFORMATEX with PCM must have bps == 8 or 16, or any multiple of 8 for WAVEFORMATEXTENSIBLE.
654 * 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.
656 * Block align for WAVE_FORMAT_PCM or WAVE_FORMAT_EXTENSIBLE is also supposed to be channels*bps/8
658 * If the channel mask has more set bits than # of channels, the extra MSBs are ignored.
659 * If the channel mask has less set bits than # of channels, the extra channels are unassigned to any speaker.
661 * Data is supposed to be unsigned for bps <= 8 else signed.
664 /* fmt sub-chunk size */
665 if(!read_little_endian_uint32(infile, &xx, false, encoder_session.inbasefilename))
666 return EncoderSession_finish_error(&encoder_session);
668 if(data_bytes < 16) {
669 flac__utils_printf(stderr, 1, "%s: ERROR: found non-standard 'fmt ' sub-chunk which has length = %u\n", encoder_session.inbasefilename, data_bytes);
670 return EncoderSession_finish_error(&encoder_session);
673 if(!read_little_endian_uint16(infile, &format, false, encoder_session.inbasefilename))
674 return EncoderSession_finish_error(&encoder_session);
675 if(format != 1 /*WAVE_FORMAT_PCM*/ && format != 65534 /*WAVE_FORMAT_EXTENSIBLE*/) {
676 flac__utils_printf(stderr, 1, "%s: ERROR: unsupported format type %u\n", encoder_session.inbasefilename, (unsigned)format);
677 return EncoderSession_finish_error(&encoder_session);
679 /* number of channels */
680 if(!read_little_endian_uint16(infile, &x, false, encoder_session.inbasefilename))
681 return EncoderSession_finish_error(&encoder_session);
682 channels = (unsigned)x;
683 if(channels == 0 || channels > FLAC__MAX_CHANNELS) {
684 flac__utils_printf(stderr, 1, "%s: ERROR: unsupported number of channels %u\n", encoder_session.inbasefilename, channels);
685 return EncoderSession_finish_error(&encoder_session);
687 else if(options.common.sector_align && channels != 2) {
688 flac__utils_printf(stderr, 1, "%s: ERROR: file has %u channels, must be 2 for --sector-align\n", encoder_session.inbasefilename, channels);
689 return EncoderSession_finish_error(&encoder_session);
692 if(!read_little_endian_uint32(infile, &xx, false, encoder_session.inbasefilename))
693 return EncoderSession_finish_error(&encoder_session);
695 if(!FLAC__format_sample_rate_is_valid(sample_rate)) {
696 flac__utils_printf(stderr, 1, "%s: ERROR: unsupported sample rate %u\n", encoder_session.inbasefilename, sample_rate);
697 return EncoderSession_finish_error(&encoder_session);
699 else if(options.common.sector_align && sample_rate != 44100) {
700 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);
701 return EncoderSession_finish_error(&encoder_session);
703 /* avg bytes per second (ignored) */
704 if(!read_little_endian_uint32(infile, &xx, false, encoder_session.inbasefilename))
705 return EncoderSession_finish_error(&encoder_session);
707 if(!read_little_endian_uint16(infile, &x, false, encoder_session.inbasefilename))
708 return EncoderSession_finish_error(&encoder_session);
709 block_align = (unsigned)x;
710 /* bits per sample */
711 if(!read_little_endian_uint16(infile, &x, false, encoder_session.inbasefilename))
712 return EncoderSession_finish_error(&encoder_session);
714 is_unsigned_samples = (bps <= 8);
716 if(bps != 8 && bps != 16) {
717 if(bps == 24 || bps == 32) {
718 /* let these slide with a warning since they're unambiguous */
719 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);
722 /* @@@ we could add an option to specify left- or right-justified blocks so we knew how to set 'shift' */
723 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);
724 return EncoderSession_finish_error(&encoder_session);
727 #if 0 /* @@@ reinstate once we can get an answer about whether the samples are left- or right-justified */
728 if((bps+7)/8 * channels == block_align) {
730 /* assume legacy file is byte aligned with some LSBs zero; this is double-checked in format_input() */
731 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);
732 shift = 8 - (bps % 8);
739 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);
740 return EncoderSession_finish_error(&encoder_session);
745 if(channels > 2 && !options.common.channel_map_none) {
746 flac__utils_printf(stderr, 1, "%s: ERROR: WAVE has >2 channels but is not WAVE_FORMAT_EXTENSIBLE; cannot assign channels\n", encoder_session.inbasefilename);
747 return EncoderSession_finish_error(&encoder_session);
749 FLAC__ASSERT(data_bytes >= 16);
753 if(data_bytes < 40) {
754 flac__utils_printf(stderr, 1, "%s: ERROR: invalid WAVEFORMATEXTENSIBLE chunk with size %u\n", encoder_session.inbasefilename, data_bytes);
755 return EncoderSession_finish_error(&encoder_session);
758 if(!read_little_endian_uint16(infile, &x, false, encoder_session.inbasefilename))
759 return EncoderSession_finish_error(&encoder_session);
761 flac__utils_printf(stderr, 1, "%s: ERROR: invalid WAVEFORMATEXTENSIBLE chunk with cbSize %u\n", encoder_session.inbasefilename, (unsigned)x);
762 return EncoderSession_finish_error(&encoder_session);
765 if(!read_little_endian_uint16(infile, &x, false, encoder_session.inbasefilename))
766 return EncoderSession_finish_error(&encoder_session);
767 if((unsigned)x > bps) {
768 flac__utils_printf(stderr, 1, "%s: ERROR: invalid WAVEFORMATEXTENSIBLE chunk with wValidBitsPerSample (%u) > wBitsPerSample (%u)\n", encoder_session.inbasefilename, (unsigned)x, bps);
769 return EncoderSession_finish_error(&encoder_session);
771 shift = bps - (unsigned)x;
773 if(!read_little_endian_uint32(infile, &channel_mask, false, encoder_session.inbasefilename))
774 return EncoderSession_finish_error(&encoder_session);
775 /* for mono/stereo and unassigned channels, we fake the mask */
776 if(channel_mask == 0) {
778 channel_mask = 0x0001;
779 else if(channels == 2)
780 channel_mask = 0x0003;
782 /* set channel mapping */
783 /* FLAC order follows SMPTE and WAVEFORMATEXTENSIBLE but with fewer channels, which are: */
784 /* front left, front right, center, LFE, back left, back right, surround left, surround right */
785 /* the default mapping is sufficient for 1-6 channels and 7-8 are currently unspecified anyway */
787 /* @@@ example for dolby/vorbis order, for reference later in case it becomes important */
789 options.common.channel_map_none ||
790 channel_mask == 0x0001 || /* 1 channel: (mono) */
791 channel_mask == 0x0003 || /* 2 channels: front left, front right */
792 channel_mask == 0x0033 || /* 4 channels: front left, front right, back left, back right */
793 channel_mask == 0x0603 /* 4 channels: front left, front right, side left, side right */
795 /* keep default channel order */
798 channel_mask == 0x0007 || /* 3 channels: front left, front right, front center */
799 channel_mask == 0x0037 || /* 5 channels: front left, front right, front center, back left, back right */
800 channel_mask == 0x0607 /* 5 channels: front left, front right, front center, side left, side right */
802 /* to dolby order: front left, center, front right [, surround left, surround right ] */
807 channel_mask == 0x003f || /* 6 channels: front left, front right, front center, LFE, back left, back right */
808 channel_mask == 0x060f /* 6 channels: front left, front right, front center, LFE, side left, side right */
810 /* to dolby order: front left, center, front right, surround left, surround right, LFE */
819 options.common.channel_map_none ||
820 channel_mask == 0x0001 || /* 1 channel: (mono) */
821 channel_mask == 0x0003 || /* 2 channels: front left, front right */
822 channel_mask == 0x0007 || /* 3 channels: front left, front right, front center */
823 channel_mask == 0x0033 || /* 4 channels: front left, front right, back left, back right */
824 channel_mask == 0x0603 || /* 4 channels: front left, front right, side left, side right */
825 channel_mask == 0x0037 || /* 5 channels: front left, front right, front center, back left, back right */
826 channel_mask == 0x0607 || /* 5 channels: front left, front right, front center, side left, side right */
827 channel_mask == 0x003f || /* 6 channels: front left, front right, front center, LFE, back left, back right */
828 channel_mask == 0x060f /* 6 channels: front left, front right, front center, LFE, side left, side right */
830 /* keep default channel order */
834 flac__utils_printf(stderr, 1, "%s: ERROR: WAVEFORMATEXTENSIBLE chunk with unsupported channel mask=0x%04X\n", encoder_session.inbasefilename, (unsigned)channel_mask);
835 return EncoderSession_finish_error(&encoder_session);
837 if(!options.common.channel_map_none) {
838 if(count_channel_mask_bits(channel_mask) < channels) {
839 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);
840 return EncoderSession_finish_error(&encoder_session);
843 /* supporting this is too difficult with channel mapping; e.g. what if mask is 0x003f but #channels=4?
844 * there would be holes in the order that would have to be filled in, or the mask would have to be
845 * limited and the logic above rerun to see if it still fits into the FLAC mapping.
847 else if(count_channel_mask_bits(channel_mask) > channels)
848 channel_mask = limit_channel_mask(channel_mask, channels);
850 else if(count_channel_mask_bits(channel_mask) > channels) {
851 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);
852 return EncoderSession_finish_error(&encoder_session);
856 /* first part of GUID */
857 if(!read_little_endian_uint16(infile, &x, false, encoder_session.inbasefilename))
858 return EncoderSession_finish_error(&encoder_session);
860 flac__utils_printf(stderr, 1, "%s: ERROR: unsupported WAVEFORMATEXTENSIBLE chunk with non-PCM format %u\n", encoder_session.inbasefilename, (unsigned)x);
861 return EncoderSession_finish_error(&encoder_session);
866 if(bps-shift < 4 || bps-shift > 24) {
867 flac__utils_printf(stderr, 1, "%s: ERROR: unsupported bits-per-sample %u\n", encoder_session.inbasefilename, bps-shift);
868 return EncoderSession_finish_error(&encoder_session);
870 else if(options.common.sector_align && bps-shift != 16) {
871 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);
872 return EncoderSession_finish_error(&encoder_session);
875 /* skip any extra data in the fmt sub-chunk */
876 if(!fskip_ahead(infile, data_bytes)) {
877 flac__utils_printf(stderr, 1, "%s: ERROR during read while skipping extra 'fmt' data\n", encoder_session.inbasefilename);
878 return EncoderSession_finish_error(&encoder_session);
882 * now that we know the sample rate, canonicalize the
883 * --skip string to a number of samples:
885 flac__utils_canonicalize_skip_until_specification(&options.common.skip_specification, sample_rate);
886 FLAC__ASSERT(options.common.skip_specification.value.samples >= 0);
887 encoder_session.skip = (FLAC__uint64)options.common.skip_specification.value.samples;
888 FLAC__ASSERT(!options.common.sector_align || encoder_session.skip == 0);
890 got_fmt_chunk = true;
892 else if(xx == 0x61746164 && !got_data_chunk && got_fmt_chunk) { /* "data" */
893 FLAC__uint64 total_samples_in_input, trim = 0;
894 FLAC__bool pad = false;
898 if(!read_little_endian_uint32(infile, &xx, false, encoder_session.inbasefilename))
899 return EncoderSession_finish_error(&encoder_session);
901 pad = (data_bytes & 1U) ? true : false;
903 bytes_per_wide_sample = channels * (bps >> 3);
905 /* *options.common.align_reservoir_samples will be 0 unless --sector-align is used */
906 FLAC__ASSERT(options.common.sector_align || *options.common.align_reservoir_samples == 0);
907 total_samples_in_input = data_bytes / bytes_per_wide_sample + *options.common.align_reservoir_samples;
910 * now that we know the input size, canonicalize the
911 * --until string to an absolute sample number:
913 if(!canonicalize_until_specification(&options.common.until_specification, encoder_session.inbasefilename, sample_rate, encoder_session.skip, total_samples_in_input))
914 return EncoderSession_finish_error(&encoder_session);
915 encoder_session.until = (FLAC__uint64)options.common.until_specification.value.samples;
916 FLAC__ASSERT(!options.common.sector_align || encoder_session.until == 0);
918 if(encoder_session.skip > 0) {
919 if(!fskip_ahead(infile, encoder_session.skip * bytes_per_wide_sample)) {
920 flac__utils_printf(stderr, 1, "%s: ERROR during read while skipping samples\n", encoder_session.inbasefilename);
921 return EncoderSession_finish_error(&encoder_session);
925 data_bytes -= (unsigned)encoder_session.skip * bytes_per_wide_sample; /*@@@ WATCHOUT: 4GB limit */
926 encoder_session.total_samples_to_encode = total_samples_in_input - encoder_session.skip;
927 if(encoder_session.until > 0) {
928 trim = total_samples_in_input - encoder_session.until;
929 FLAC__ASSERT(total_samples_in_input > 0);
930 FLAC__ASSERT(!options.common.sector_align);
931 data_bytes -= (unsigned int)trim * bytes_per_wide_sample;
932 encoder_session.total_samples_to_encode -= trim;
934 if(options.common.sector_align) {
935 align_remainder = (unsigned)(encoder_session.total_samples_to_encode % 588);
936 if(options.common.is_last_file)
937 encoder_session.total_samples_to_encode += (588-align_remainder); /* will pad with zeroes */
939 encoder_session.total_samples_to_encode -= align_remainder; /* will stop short and carry over to next file */
942 /* +44 for the size of the WAV headers; this is just an estimate for the progress indicator and doesn't need to be exact */
943 encoder_session.unencoded_size = encoder_session.total_samples_to_encode * bytes_per_wide_sample + 44;
945 if(!EncoderSession_init_encoder(&encoder_session, options.common, channel_mask, channels, bps-shift, sample_rate, /*flac_decoder_data=*/0))
946 return EncoderSession_finish_error(&encoder_session);
949 * first do any samples in the reservoir
951 if(options.common.sector_align && *options.common.align_reservoir_samples > 0) {
952 if(!EncoderSession_process(&encoder_session, (const FLAC__int32 * const *)options.common.align_reservoir, *options.common.align_reservoir_samples)) {
953 print_error_with_state(&encoder_session, "ERROR during encoding");
954 return EncoderSession_finish_error(&encoder_session);
959 * decrement the data_bytes counter if we need to align the file
961 if(options.common.sector_align) {
962 if(options.common.is_last_file) {
963 *options.common.align_reservoir_samples = 0;
966 *options.common.align_reservoir_samples = align_remainder;
967 data_bytes -= (*options.common.align_reservoir_samples) * bytes_per_wide_sample;
972 * now do from the file
974 while(data_bytes > 0) {
975 bytes_read = fread(ucbuffer_, sizeof(unsigned char), min(data_bytes, CHUNK_OF_SAMPLES * bytes_per_wide_sample), infile);
976 if(bytes_read == 0) {
978 flac__utils_printf(stderr, 1, "%s: ERROR during read\n", encoder_session.inbasefilename);
979 return EncoderSession_finish_error(&encoder_session);
981 else if(feof(infile)) {
982 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);
987 if(bytes_read % bytes_per_wide_sample != 0) {
988 flac__utils_printf(stderr, 1, "%s: ERROR: got partial sample\n", encoder_session.inbasefilename);
989 return EncoderSession_finish_error(&encoder_session);
992 unsigned wide_samples = bytes_read / bytes_per_wide_sample;
993 if(!format_input(input_, wide_samples, /*is_big_endian=*/false, is_unsigned_samples, channels, bps, shift, channel_map))
994 return EncoderSession_finish_error(&encoder_session);
996 if(!EncoderSession_process(&encoder_session, (const FLAC__int32 * const *)input_, wide_samples)) {
997 print_error_with_state(&encoder_session, "ERROR during encoding");
998 return EncoderSession_finish_error(&encoder_session);
1000 data_bytes -= bytes_read;
1006 FLAC__ASSERT(!options.common.sector_align);
1007 if(!fskip_ahead(infile, trim * bytes_per_wide_sample)) {
1008 flac__utils_printf(stderr, 1, "%s: ERROR during read while skipping samples\n", encoder_session.inbasefilename);
1009 return EncoderSession_finish_error(&encoder_session);
1014 * now read unaligned samples into reservoir or pad with zeroes if necessary
1016 if(options.common.sector_align) {
1017 if(options.common.is_last_file) {
1018 unsigned wide_samples = 588 - align_remainder;
1019 if(wide_samples < 588) {
1022 info_align_zero = wide_samples;
1023 for(channel = 0; channel < channels; channel++)
1024 memset(input_[channel], 0, sizeof(input_[0][0]) * wide_samples);
1026 if(!EncoderSession_process(&encoder_session, (const FLAC__int32 * const *)input_, wide_samples)) {
1027 print_error_with_state(&encoder_session, "ERROR during encoding");
1028 return EncoderSession_finish_error(&encoder_session);
1033 if(*options.common.align_reservoir_samples > 0) {
1034 FLAC__ASSERT(CHUNK_OF_SAMPLES >= 588);
1035 bytes_read = fread(ucbuffer_, sizeof(unsigned char), (*options.common.align_reservoir_samples) * bytes_per_wide_sample, infile);
1036 if(bytes_read == 0 && ferror(infile)) {
1037 flac__utils_printf(stderr, 1, "%s: ERROR during read\n", encoder_session.inbasefilename);
1038 return EncoderSession_finish_error(&encoder_session);
1040 else if(bytes_read != (*options.common.align_reservoir_samples) * bytes_per_wide_sample) {
1041 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);
1044 info_align_carry = *options.common.align_reservoir_samples;
1045 if(!format_input(options.common.align_reservoir, *options.common.align_reservoir_samples, /*is_big_endian=*/false, is_unsigned_samples, channels, bps, shift, channel_map))
1046 return EncoderSession_finish_error(&encoder_session);
1055 if(fread(&tmp, 1U, 1U, infile) < 1U) {
1056 flac__utils_printf(stderr, 1, "%s: ERROR during read of data pad byte\n", encoder_session.inbasefilename);
1057 return EncoderSession_finish_error(&encoder_session);
1061 got_data_chunk = true;
1064 if(xx == 0x20746d66 && got_fmt_chunk) { /* "fmt " */
1065 flac__utils_printf(stderr, 1, "%s: WARNING: skipping extra 'fmt ' sub-chunk\n", encoder_session.inbasefilename);
1067 else if(xx == 0x61746164) { /* "data" */
1068 if(got_data_chunk) {
1069 flac__utils_printf(stderr, 1, "%s: WARNING: skipping extra 'data' sub-chunk\n", encoder_session.inbasefilename);
1071 else if(!got_fmt_chunk) {
1072 flac__utils_printf(stderr, 1, "%s: ERROR: got 'data' sub-chunk before 'fmt' sub-chunk\n", encoder_session.inbasefilename);
1073 return EncoderSession_finish_error(&encoder_session);
1080 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));
1082 /* sub-chunk size */
1083 if(!read_little_endian_uint32(infile, &xx, false, encoder_session.inbasefilename))
1084 return EncoderSession_finish_error(&encoder_session);
1086 unsigned long skip = xx+(xx & 1U);
1088 FLAC__ASSERT(skip<=LONG_MAX);
1089 if(!fskip_ahead(infile, skip)) {
1090 flac__utils_printf(stderr, 1, "%s: ERROR during read while skipping unsupported sub-chunk\n", encoder_session.inbasefilename);
1091 return EncoderSession_finish_error(&encoder_session);
1097 return EncoderSession_finish_ok(&encoder_session, info_align_carry, info_align_zero);
1100 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)
1102 EncoderSession encoder_session;
1104 const size_t bytes_per_wide_sample = options.channels * (options.bps >> 3);
1105 unsigned align_remainder = 0;
1106 int info_align_carry = -1, info_align_zero = -1;
1107 FLAC__uint64 total_samples_in_input = 0;
1109 FLAC__ASSERT(!options.common.sector_align || options.channels == 2);
1110 FLAC__ASSERT(!options.common.sector_align || options.bps == 16);
1111 FLAC__ASSERT(!options.common.sector_align || options.sample_rate == 44100);
1112 FLAC__ASSERT(!options.common.sector_align || infilesize >= 0);
1113 FLAC__ASSERT(!options.common.replay_gain || options.channels <= 2);
1114 FLAC__ASSERT(!options.common.replay_gain || grabbag__replaygain_is_valid_sample_frequency(options.sample_rate));
1117 EncoderSession_construct(
1119 #ifdef FLAC__HAS_OGG
1120 options.common.use_ogg,
1124 options.common.verify,
1133 * now that we know the sample rate, canonicalize the
1134 * --skip string to a number of samples:
1136 flac__utils_canonicalize_skip_until_specification(&options.common.skip_specification, options.sample_rate);
1137 FLAC__ASSERT(options.common.skip_specification.value.samples >= 0);
1138 encoder_session.skip = (FLAC__uint64)options.common.skip_specification.value.samples;
1139 FLAC__ASSERT(!options.common.sector_align || encoder_session.skip == 0);
1142 total_samples_in_input = 0;
1144 /* *options.common.align_reservoir_samples will be 0 unless --sector-align is used */
1145 FLAC__ASSERT(options.common.sector_align || *options.common.align_reservoir_samples == 0);
1146 total_samples_in_input = (FLAC__uint64)infilesize / bytes_per_wide_sample + *options.common.align_reservoir_samples;
1150 * now that we know the input size, canonicalize the
1151 * --until strings to a number of samples:
1153 if(!canonicalize_until_specification(&options.common.until_specification, encoder_session.inbasefilename, options.sample_rate, encoder_session.skip, total_samples_in_input))
1154 return EncoderSession_finish_error(&encoder_session);
1155 encoder_session.until = (FLAC__uint64)options.common.until_specification.value.samples;
1156 FLAC__ASSERT(!options.common.sector_align || encoder_session.until == 0);
1158 infilesize -= (off_t)encoder_session.skip * bytes_per_wide_sample;
1159 encoder_session.total_samples_to_encode = total_samples_in_input - encoder_session.skip;
1160 if(encoder_session.until > 0) {
1161 const FLAC__uint64 trim = total_samples_in_input - encoder_session.until;
1162 FLAC__ASSERT(total_samples_in_input > 0);
1163 FLAC__ASSERT(!options.common.sector_align);
1164 infilesize -= (off_t)trim * bytes_per_wide_sample;
1165 encoder_session.total_samples_to_encode -= trim;
1167 if(infilesize >= 0 && options.common.sector_align) {
1168 FLAC__ASSERT(encoder_session.skip == 0);
1169 align_remainder = (unsigned)(encoder_session.total_samples_to_encode % 588);
1170 if(options.common.is_last_file)
1171 encoder_session.total_samples_to_encode += (588-align_remainder); /* will pad with zeroes */
1173 encoder_session.total_samples_to_encode -= align_remainder; /* will stop short and carry over to next file */
1175 encoder_session.unencoded_size = encoder_session.total_samples_to_encode * bytes_per_wide_sample;
1177 if(encoder_session.total_samples_to_encode <= 0)
1178 flac__utils_printf(stderr, 2, "(No runtime statistics possible; please wait for encoding to finish...)\n");
1180 if(encoder_session.skip > 0) {
1181 unsigned skip_bytes = bytes_per_wide_sample * (unsigned)encoder_session.skip;
1182 if(skip_bytes > lookahead_length) {
1183 skip_bytes -= lookahead_length;
1184 lookahead_length = 0;
1185 if(!fskip_ahead(infile, skip_bytes)) {
1186 flac__utils_printf(stderr, 1, "%s: ERROR during read while skipping samples\n", encoder_session.inbasefilename);
1187 return EncoderSession_finish_error(&encoder_session);
1191 lookahead += skip_bytes;
1192 lookahead_length -= skip_bytes;
1196 if(!EncoderSession_init_encoder(&encoder_session, options.common, /*channel_mask=*/0, options.channels, options.bps, options.sample_rate, /*flac_decoder_data=*/0))
1197 return EncoderSession_finish_error(&encoder_session);
1200 * first do any samples in the reservoir
1202 if(options.common.sector_align && *options.common.align_reservoir_samples > 0) {
1203 if(!EncoderSession_process(&encoder_session, (const FLAC__int32 * const *)options.common.align_reservoir, *options.common.align_reservoir_samples)) {
1204 print_error_with_state(&encoder_session, "ERROR during encoding");
1205 return EncoderSession_finish_error(&encoder_session);
1210 * decrement infilesize if we need to align the file
1212 if(options.common.sector_align) {
1213 FLAC__ASSERT(infilesize >= 0);
1214 if(options.common.is_last_file) {
1215 *options.common.align_reservoir_samples = 0;
1218 *options.common.align_reservoir_samples = align_remainder;
1219 infilesize -= (off_t)((*options.common.align_reservoir_samples) * bytes_per_wide_sample);
1220 FLAC__ASSERT(infilesize >= 0);
1225 * now do from the file
1227 if(infilesize < 0) {
1228 while(!feof(infile)) {
1229 if(lookahead_length > 0) {
1230 FLAC__ASSERT(lookahead_length < CHUNK_OF_SAMPLES * bytes_per_wide_sample);
1231 memcpy(ucbuffer_, lookahead, lookahead_length);
1232 bytes_read = fread(ucbuffer_+lookahead_length, sizeof(unsigned char), CHUNK_OF_SAMPLES * bytes_per_wide_sample - lookahead_length, infile) + lookahead_length;
1233 if(ferror(infile)) {
1234 flac__utils_printf(stderr, 1, "%s: ERROR during read\n", encoder_session.inbasefilename);
1235 return EncoderSession_finish_error(&encoder_session);
1237 lookahead_length = 0;
1240 bytes_read = fread(ucbuffer_, sizeof(unsigned char), CHUNK_OF_SAMPLES * bytes_per_wide_sample, infile);
1242 if(bytes_read == 0) {
1243 if(ferror(infile)) {
1244 flac__utils_printf(stderr, 1, "%s: ERROR during read\n", encoder_session.inbasefilename);
1245 return EncoderSession_finish_error(&encoder_session);
1248 else if(bytes_read % bytes_per_wide_sample != 0) {
1249 flac__utils_printf(stderr, 1, "%s: ERROR: got partial sample\n", encoder_session.inbasefilename);
1250 return EncoderSession_finish_error(&encoder_session);
1253 unsigned wide_samples = bytes_read / bytes_per_wide_sample;
1254 if(!format_input(input_, wide_samples, options.is_big_endian, options.is_unsigned_samples, options.channels, options.bps, /*shift=*/0, /*channel_map=*/0))
1255 return EncoderSession_finish_error(&encoder_session);
1257 if(!EncoderSession_process(&encoder_session, (const FLAC__int32 * const *)input_, wide_samples)) {
1258 print_error_with_state(&encoder_session, "ERROR during encoding");
1259 return EncoderSession_finish_error(&encoder_session);
1265 const FLAC__uint64 max_input_bytes = infilesize;
1266 FLAC__uint64 total_input_bytes_read = 0;
1267 while(total_input_bytes_read < max_input_bytes) {
1269 size_t wanted = (CHUNK_OF_SAMPLES * bytes_per_wide_sample);
1270 wanted = (size_t) min((FLAC__uint64)wanted, max_input_bytes - total_input_bytes_read);
1272 if(lookahead_length > 0) {
1273 FLAC__ASSERT(lookahead_length <= wanted);
1274 memcpy(ucbuffer_, lookahead, lookahead_length);
1275 wanted -= lookahead_length;
1276 bytes_read = lookahead_length;
1278 bytes_read += fread(ucbuffer_+lookahead_length, sizeof(unsigned char), wanted, infile);
1279 if(ferror(infile)) {
1280 flac__utils_printf(stderr, 1, "%s: ERROR during read\n", encoder_session.inbasefilename);
1281 return EncoderSession_finish_error(&encoder_session);
1284 lookahead_length = 0;
1287 bytes_read = fread(ucbuffer_, sizeof(unsigned char), wanted, infile);
1290 if(bytes_read == 0) {
1291 if(ferror(infile)) {
1292 flac__utils_printf(stderr, 1, "%s: ERROR during read\n", encoder_session.inbasefilename);
1293 return EncoderSession_finish_error(&encoder_session);
1295 else if(feof(infile)) {
1296 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);
1297 total_input_bytes_read = max_input_bytes;
1301 if(bytes_read % bytes_per_wide_sample != 0) {
1302 flac__utils_printf(stderr, 1, "%s: ERROR: got partial sample\n", encoder_session.inbasefilename);
1303 return EncoderSession_finish_error(&encoder_session);
1306 unsigned wide_samples = bytes_read / bytes_per_wide_sample;
1307 if(!format_input(input_, wide_samples, options.is_big_endian, options.is_unsigned_samples, options.channels, options.bps, /*shift=*/0, /*channel_map=*/0))
1308 return EncoderSession_finish_error(&encoder_session);
1310 if(!EncoderSession_process(&encoder_session, (const FLAC__int32 * const *)input_, wide_samples)) {
1311 print_error_with_state(&encoder_session, "ERROR during encoding");
1312 return EncoderSession_finish_error(&encoder_session);
1314 total_input_bytes_read += bytes_read;
1321 * now read unaligned samples into reservoir or pad with zeroes if necessary
1323 if(options.common.sector_align) {
1324 if(options.common.is_last_file) {
1325 unsigned wide_samples = 588 - align_remainder;
1326 if(wide_samples < 588) {
1329 info_align_zero = wide_samples;
1330 for(channel = 0; channel < options.channels; channel++)
1331 memset(input_[channel], 0, sizeof(input_[0][0]) * wide_samples);
1333 if(!EncoderSession_process(&encoder_session, (const FLAC__int32 * const *)input_, wide_samples)) {
1334 print_error_with_state(&encoder_session, "ERROR during encoding");
1335 return EncoderSession_finish_error(&encoder_session);
1340 if(*options.common.align_reservoir_samples > 0) {
1341 FLAC__ASSERT(CHUNK_OF_SAMPLES >= 588);
1342 bytes_read = fread(ucbuffer_, sizeof(unsigned char), (*options.common.align_reservoir_samples) * bytes_per_wide_sample, infile);
1343 if(bytes_read == 0 && ferror(infile)) {
1344 flac__utils_printf(stderr, 1, "%s: ERROR during read\n", encoder_session.inbasefilename);
1345 return EncoderSession_finish_error(&encoder_session);
1347 else if(bytes_read != (*options.common.align_reservoir_samples) * bytes_per_wide_sample) {
1348 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);
1351 info_align_carry = *options.common.align_reservoir_samples;
1352 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))
1353 return EncoderSession_finish_error(&encoder_session);
1359 return EncoderSession_finish_ok(&encoder_session, info_align_carry, info_align_zero);
1362 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)
1364 EncoderSession encoder_session;
1365 FLAC__StreamDecoder *decoder = 0;
1366 FLACDecoderData decoder_data;
1371 EncoderSession_construct(
1373 #ifdef FLAC__HAS_OGG
1374 options.common.use_ogg,
1378 options.common.verify,
1386 decoder_data.encoder_session = &encoder_session;
1387 decoder_data.filesize = (infilesize == (off_t)(-1)? 0 : infilesize);
1388 decoder_data.lookahead = lookahead;
1389 decoder_data.lookahead_length = lookahead_length;
1390 decoder_data.num_metadata_blocks = 0;
1391 decoder_data.samples_left_to_process = 0;
1392 decoder_data.fatal_error = false;
1395 * set up FLAC decoder for the input
1397 if (0 == (decoder = FLAC__stream_decoder_new())) {
1398 flac__utils_printf(stderr, 1, "%s: ERROR: creating decoder for FLAC input\n", encoder_session.inbasefilename);
1399 return EncoderSession_finish_error(&encoder_session);
1402 FLAC__stream_decoder_set_md5_checking(decoder, false) &&
1403 FLAC__stream_decoder_set_metadata_respond_all(decoder)
1405 flac__utils_printf(stderr, 1, "%s: ERROR: setting up decoder for FLAC input\n", encoder_session.inbasefilename);
1406 goto fubar1; /*@@@ yuck */
1409 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) {
1410 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));
1411 goto fubar1; /*@@@ yuck */
1414 if (!FLAC__stream_decoder_process_until_end_of_metadata(decoder) || decoder_data.fatal_error) {
1415 if (decoder_data.fatal_error)
1416 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);
1418 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));
1419 goto fubar1; /*@@@ yuck */
1422 if (decoder_data.num_metadata_blocks == 0) {
1423 flac__utils_printf(stderr, 1, "%s: ERROR: reading metadata in FLAC input, got no metadata blocks\n", encoder_session.inbasefilename);
1424 goto fubar2; /*@@@ yuck */
1426 else if (decoder_data.metadata_blocks[0]->type != FLAC__METADATA_TYPE_STREAMINFO) {
1427 flac__utils_printf(stderr, 1, "%s: ERROR: reading metadata in FLAC input, first metadata block is not STREAMINFO\n", encoder_session.inbasefilename);
1428 goto fubar2; /*@@@ yuck */
1430 else if (decoder_data.metadata_blocks[0]->data.stream_info.total_samples == 0) {
1431 flac__utils_printf(stderr, 1, "%s: ERROR: FLAC input has STREAMINFO with unknown total samples which is not supported\n", encoder_session.inbasefilename);
1432 goto fubar2; /*@@@ yuck */
1436 * now that we have the STREAMINFO and know the sample rate,
1437 * canonicalize the --skip string to a number of samples:
1439 flac__utils_canonicalize_skip_until_specification(&options.common.skip_specification, decoder_data.metadata_blocks[0]->data.stream_info.sample_rate);
1440 FLAC__ASSERT(options.common.skip_specification.value.samples >= 0);
1441 encoder_session.skip = (FLAC__uint64)options.common.skip_specification.value.samples;
1442 FLAC__ASSERT(!options.common.sector_align); /* --sector-align with FLAC input is not supported */
1445 FLAC__uint64 total_samples_in_input, trim = 0;
1447 total_samples_in_input = decoder_data.metadata_blocks[0]->data.stream_info.total_samples;
1450 * now that we know the input size, canonicalize the
1451 * --until string to an absolute sample number:
1453 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))
1454 goto fubar2; /*@@@ yuck */
1455 encoder_session.until = (FLAC__uint64)options.common.until_specification.value.samples;
1457 encoder_session.total_samples_to_encode = total_samples_in_input - encoder_session.skip;
1458 if(encoder_session.until > 0) {
1459 trim = total_samples_in_input - encoder_session.until;
1460 FLAC__ASSERT(total_samples_in_input > 0);
1461 encoder_session.total_samples_to_encode -= trim;
1464 encoder_session.unencoded_size = decoder_data.filesize;
1466 /* (channel mask will get copied over from the source VORBIS_COMMENT if it exists) */
1467 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, &decoder_data))
1468 return EncoderSession_finish_error(&encoder_session);
1471 * have to wait until the FLAC encoder is set up for writing
1472 * before any seeking in the input FLAC file, because the seek
1473 * itself will usually call the decoder's write callback, and
1474 * our decoder's write callback passes samples to our FLAC
1477 decoder_data.samples_left_to_process = encoder_session.total_samples_to_encode;
1478 if(encoder_session.skip > 0) {
1479 if(!FLAC__stream_decoder_seek_absolute(decoder, encoder_session.skip)) {
1480 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));
1481 goto fubar2; /*@@@ yuck */
1486 * now do samples from the file
1488 while(!decoder_data.fatal_error && decoder_data.samples_left_to_process > 0) {
1489 if(!FLAC__stream_decoder_process_single(decoder)) {
1490 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));
1491 goto fubar2; /*@@@ yuck */
1496 FLAC__stream_decoder_delete(decoder);
1497 retval = EncoderSession_finish_ok(&encoder_session, -1, -1);
1498 /* have to wail until encoder is completely finished before deleting because of the final step of writing the seekpoint offsets */
1499 for(i = 0; i < decoder_data.num_metadata_blocks; i++)
1500 free(decoder_data.metadata_blocks[i]);
1504 for(i = 0; i < decoder_data.num_metadata_blocks; i++)
1505 free(decoder_data.metadata_blocks[i]);
1507 FLAC__stream_decoder_delete(decoder);
1508 return EncoderSession_finish_error(&encoder_session);
1511 FLAC__bool EncoderSession_construct(EncoderSession *e, FLAC__bool use_ogg, FLAC__bool verify, FILE *infile, const char *infilename, const char *outfilename)
1514 FLAC__uint32 test = 1;
1517 * initialize globals
1520 is_big_endian_host_ = (*((FLAC__byte*)(&test)))? false : true;
1522 for(i = 0; i < FLAC__MAX_CHANNELS; i++)
1523 input_[i] = &(in_[i][0]);
1527 * initialize instance
1530 #ifdef FLAC__HAS_OGG
1531 e->use_ogg = use_ogg;
1537 e->is_stdout = (0 == strcmp(outfilename, "-"));
1538 e->outputfile_opened = false;
1540 e->inbasefilename = grabbag__file_get_basename(infilename);
1541 e->outfilename = outfilename;
1543 e->skip = 0; /* filled in later after the sample_rate is known */
1544 e->unencoded_size = 0;
1545 e->total_samples_to_encode = 0;
1546 e->bytes_written = 0;
1547 e->samples_written = 0;
1551 e->encoder.flac = 0;
1552 #ifdef FLAC__HAS_OGG
1557 e->seek_table_template = 0;
1559 if(0 == (e->seek_table_template = FLAC__metadata_object_new(FLAC__METADATA_TYPE_SEEKTABLE))) {
1560 flac__utils_printf(stderr, 1, "%s: ERROR allocating memory for seek table\n", e->inbasefilename);
1564 #ifdef FLAC__HAS_OGG
1566 e->encoder.ogg = OggFLAC__stream_encoder_new();
1567 if(0 == e->encoder.ogg) {
1568 flac__utils_printf(stderr, 1, "%s: ERROR creating the encoder instance\n", e->inbasefilename);
1569 EncoderSession_destroy(e);
1575 e->encoder.flac = FLAC__stream_encoder_new();
1576 if(0 == e->encoder.flac) {
1577 flac__utils_printf(stderr, 1, "%s: ERROR creating the encoder instance\n", e->inbasefilename);
1578 EncoderSession_destroy(e);
1585 void EncoderSession_destroy(EncoderSession *e)
1590 #ifdef FLAC__HAS_OGG
1592 if(0 != e->encoder.ogg) {
1593 OggFLAC__stream_encoder_delete(e->encoder.ogg);
1599 if(0 != e->encoder.flac) {
1600 FLAC__stream_encoder_delete(e->encoder.flac);
1601 e->encoder.flac = 0;
1604 if(0 != e->seek_table_template) {
1605 FLAC__metadata_object_delete(e->seek_table_template);
1606 e->seek_table_template = 0;
1610 int EncoderSession_finish_ok(EncoderSession *e, int info_align_carry, int info_align_zero)
1612 FLAC__StreamEncoderState fse_state = FLAC__STREAM_ENCODER_OK;
1615 #ifdef FLAC__HAS_OGG
1617 if(e->encoder.ogg) {
1618 fse_state = OggFLAC__stream_encoder_get_FLAC_stream_encoder_state(e->encoder.ogg);
1619 OggFLAC__stream_encoder_finish(e->encoder.ogg);
1624 if(e->encoder.flac) {
1625 fse_state = FLAC__stream_encoder_get_state(e->encoder.flac);
1626 FLAC__stream_encoder_finish(e->encoder.flac);
1629 if(e->total_samples_to_encode > 0) {
1631 flac__utils_printf(stderr, 2, "\n");
1634 if(fse_state == FLAC__STREAM_ENCODER_VERIFY_MISMATCH_IN_AUDIO_DATA) {
1635 print_verify_error(e);
1639 if(info_align_carry >= 0) {
1640 flac__utils_printf(stderr, 1, "%s: INFO: sector alignment causing %d samples to be carried over\n", e->inbasefilename, info_align_carry);
1642 if(info_align_zero >= 0) {
1643 flac__utils_printf(stderr, 1, "%s: INFO: sector alignment causing %d zero samples to be appended\n", e->inbasefilename, info_align_zero);
1647 EncoderSession_destroy(e);
1652 int EncoderSession_finish_error(EncoderSession *e)
1654 FLAC__StreamEncoderState fse_state;
1656 #ifdef FLAC__HAS_OGG
1657 FLAC__ASSERT(e->encoder.ogg || e->encoder.flac);
1659 FLAC__ASSERT(e->encoder.flac);
1662 if(e->total_samples_to_encode > 0)
1663 flac__utils_printf(stderr, 2, "\n");
1665 #ifdef FLAC__HAS_OGG
1667 fse_state = OggFLAC__stream_encoder_get_FLAC_stream_encoder_state(e->encoder.ogg);
1672 fse_state = FLAC__stream_encoder_get_state(e->encoder.flac);
1675 if(fse_state == FLAC__STREAM_ENCODER_VERIFY_MISMATCH_IN_AUDIO_DATA)
1676 print_verify_error(e);
1677 else if(e->outputfile_opened)
1678 /* only want to delete the file if we opened it; otherwise it could be an existing file and our overwrite failed */
1679 unlink(e->outfilename);
1681 EncoderSession_destroy(e);
1686 FLAC__bool EncoderSession_init_encoder(EncoderSession *e, encode_options_t options, FLAC__uint32 channel_mask, unsigned channels, unsigned bps, unsigned sample_rate, FLACDecoderData *flac_decoder_data)
1688 unsigned num_metadata, i;
1689 FLAC__StreamMetadata padding, *cuesheet = 0;
1690 FLAC__StreamMetadata *static_metadata[4+64]; /* MAGIC +64 is for pictures metadata in options.pictures */
1691 FLAC__StreamMetadata **metadata = static_metadata;
1692 FLAC__StreamEncoderInitStatus init_status;
1693 const FLAC__bool is_cdda = (channels == 1 || channels == 2) && (bps == 16) && (sample_rate == 44100);
1695 FLAC__ASSERT(sizeof(options.pictures)/sizeof(options.pictures[0]) <= 64);
1697 e->replay_gain = options.replay_gain;
1698 e->channels = channels;
1699 e->bits_per_sample = bps;
1700 e->sample_rate = sample_rate;
1702 if(e->replay_gain) {
1703 if(channels != 1 && channels != 2) {
1704 flac__utils_printf(stderr, 1, "%s: ERROR, number of channels (%u) must be 1 or 2 for --replay-gain\n", e->inbasefilename, channels);
1707 if(!grabbag__replaygain_is_valid_sample_frequency(sample_rate)) {
1708 flac__utils_printf(stderr, 1, "%s: ERROR, invalid sample rate (%u) for --replay-gain\n", e->inbasefilename, sample_rate);
1711 if(options.is_first_file) {
1712 if(!grabbag__replaygain_init(sample_rate)) {
1713 flac__utils_printf(stderr, 1, "%s: ERROR initializing ReplayGain stage\n", e->inbasefilename);
1720 options.do_mid_side = options.loose_mid_side = false;
1722 if(!parse_cuesheet(&cuesheet, options.cuesheet_filename, e->inbasefilename, is_cdda, e->total_samples_to_encode))
1725 if(!convert_to_seek_table_template(options.requested_seek_points, options.num_requested_seek_points, options.cued_seekpoints? cuesheet : 0, e)) {
1726 flac__utils_printf(stderr, 1, "%s: ERROR allocating memory for seek table\n", e->inbasefilename);
1728 FLAC__metadata_object_delete(cuesheet);
1732 if(flac_decoder_data) {
1734 * we're encoding from FLAC so we will use the FLAC file's
1735 * metadata as the basic for the encoded file
1739 * first handle padding: if --no-padding was specified,
1740 * then delete all padding; else if -P was specified,
1741 * use that instead of existing padding (if any); else
1742 * if existing file has padding, move all existing
1743 * padding blocks to one padding block at the end; else
1744 * use default padding.
1748 for(i = 0, j = 0; i < flac_decoder_data->num_metadata_blocks; i++) {
1749 if(flac_decoder_data->metadata_blocks[i]->type == FLAC__METADATA_TYPE_PADDING) {
1752 p += flac_decoder_data->metadata_blocks[i]->length;
1753 FLAC__metadata_object_delete(flac_decoder_data->metadata_blocks[i]);
1754 flac_decoder_data->metadata_blocks[i] = 0;
1757 flac_decoder_data->metadata_blocks[j++] = flac_decoder_data->metadata_blocks[i];
1759 flac_decoder_data->num_metadata_blocks = j;
1760 if(options.padding > 0)
1761 p = options.padding;
1763 p = e->total_samples_to_encode / e->sample_rate < 20*60? FLAC_ENCODE__DEFAULT_PADDING : FLAC_ENCODE__DEFAULT_PADDING*8;
1764 if(options.padding != 0) {
1765 if(p > 0 && flac_decoder_data->num_metadata_blocks < sizeof(flac_decoder_data->metadata_blocks)/sizeof(flac_decoder_data->metadata_blocks[0])) {
1766 flac_decoder_data->metadata_blocks[flac_decoder_data->num_metadata_blocks] = FLAC__metadata_object_new(FLAC__METADATA_TYPE_PADDING);
1767 if(0 == flac_decoder_data->metadata_blocks[flac_decoder_data->num_metadata_blocks]) {
1768 flac__utils_printf(stderr, 1, "%s: ERROR allocating memory for PADDING block\n", e->inbasefilename);
1770 FLAC__metadata_object_delete(cuesheet);
1773 flac_decoder_data->metadata_blocks[flac_decoder_data->num_metadata_blocks]->is_last = false; /* the encoder will set this for us */
1774 flac_decoder_data->metadata_blocks[flac_decoder_data->num_metadata_blocks]->length = p;
1775 flac_decoder_data->num_metadata_blocks++;
1781 * next handle vorbis comment: if any tags were specified
1782 * or there is no existing vorbis comment, we create a
1783 * new vorbis comment (discarding any existing one); else
1784 * we keep the existing one. also need to make sure to
1785 * propagate any channel mask tag.
1788 FLAC__bool vc_found = false;
1789 for(i = 0, j = 0; i < flac_decoder_data->num_metadata_blocks; i++) {
1790 if(flac_decoder_data->metadata_blocks[i]->type == FLAC__METADATA_TYPE_VORBIS_COMMENT)
1792 if(flac_decoder_data->metadata_blocks[i]->type == FLAC__METADATA_TYPE_VORBIS_COMMENT && options.vorbis_comment->data.vorbis_comment.num_comments > 0) {
1793 (void) flac__utils_get_channel_mask_tag(flac_decoder_data->metadata_blocks[i], &channel_mask);
1794 flac__utils_printf(stderr, 1, "%s: WARNING, replacing tags from input FLAC file with those given on the command-line\n", e->inbasefilename);
1795 FLAC__metadata_object_delete(flac_decoder_data->metadata_blocks[i]);
1796 flac_decoder_data->metadata_blocks[i] = 0;
1799 flac_decoder_data->metadata_blocks[j++] = flac_decoder_data->metadata_blocks[i];
1801 flac_decoder_data->num_metadata_blocks = j;
1802 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])) {
1804 FLAC__StreamMetadata *vc = FLAC__metadata_object_clone(options.vorbis_comment);
1805 if(0 == vc || (channel_mask && !flac__utils_set_channel_mask_tag(vc, channel_mask))) {
1806 flac__utils_printf(stderr, 1, "%s: ERROR allocating memory for VORBIS_COMMENT block\n", e->inbasefilename);
1808 FLAC__metadata_object_delete(cuesheet);
1811 for(i = flac_decoder_data->num_metadata_blocks; i > 1; i--)
1812 flac_decoder_data->metadata_blocks[i] = flac_decoder_data->metadata_blocks[i-1];
1813 flac_decoder_data->metadata_blocks[1] = vc;
1814 flac_decoder_data->num_metadata_blocks++;
1819 * next handle cuesheet: if --cuesheet was specified, use
1820 * it; else if file has existing CUESHEET and cuesheet's
1821 * lead-out offset is correct, keep it; else no CUESHEET
1824 for(i = 0, j = 0; i < flac_decoder_data->num_metadata_blocks; i++) {
1825 FLAC__bool existing_cuesheet_is_bad = false;
1826 /* check if existing cuesheet matches the input audio */
1827 if(flac_decoder_data->metadata_blocks[i]->type == FLAC__METADATA_TYPE_CUESHEET && 0 == cuesheet) {
1828 const FLAC__StreamMetadata_CueSheet *cs = &flac_decoder_data->metadata_blocks[i]->data.cue_sheet;
1829 if(e->total_samples_to_encode == 0) {
1830 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);
1831 existing_cuesheet_is_bad = true;
1833 else if(e->total_samples_to_encode != cs->tracks[cs->num_tracks-1].offset) {
1834 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);
1835 existing_cuesheet_is_bad = true;
1838 if(flac_decoder_data->metadata_blocks[i]->type == FLAC__METADATA_TYPE_CUESHEET && (existing_cuesheet_is_bad || 0 != cuesheet)) {
1840 flac__utils_printf(stderr, 1, "%s: WARNING, replacing cuesheet in input FLAC file with the one given on the command-line\n", e->inbasefilename);
1841 FLAC__metadata_object_delete(flac_decoder_data->metadata_blocks[i]);
1842 flac_decoder_data->metadata_blocks[i] = 0;
1845 flac_decoder_data->metadata_blocks[j++] = flac_decoder_data->metadata_blocks[i];
1847 flac_decoder_data->num_metadata_blocks = j;
1848 if(0 != cuesheet && flac_decoder_data->num_metadata_blocks < sizeof(flac_decoder_data->metadata_blocks)/sizeof(flac_decoder_data->metadata_blocks[0])) {
1850 FLAC__StreamMetadata *cs = FLAC__metadata_object_clone(cuesheet);
1852 flac__utils_printf(stderr, 1, "%s: ERROR allocating memory for CUESHEET block\n", e->inbasefilename);
1854 FLAC__metadata_object_delete(cuesheet);
1857 for(i = flac_decoder_data->num_metadata_blocks; i > 1; i--)
1858 flac_decoder_data->metadata_blocks[i] = flac_decoder_data->metadata_blocks[i-1];
1859 flac_decoder_data->metadata_blocks[1] = cs;
1860 flac_decoder_data->num_metadata_blocks++;
1865 * finally handle seektable: if -S- was specified, no
1866 * SEEKTABLE; else if -S was specified, use it/them;
1867 * else if file has existing SEEKTABLE and input size is
1868 * preserved (no --skip/--until/etc specified), keep it;
1869 * else use default seektable options
1871 * note: meanings of num_requested_seek_points:
1872 * -1 : no -S option given, default to some value
1873 * 0 : -S- given (no seektable)
1874 * >0 : one or more -S options given
1877 FLAC__bool existing_seektable = false;
1878 for(i = 0, j = 0; i < flac_decoder_data->num_metadata_blocks; i++) {
1879 if(flac_decoder_data->metadata_blocks[i]->type == FLAC__METADATA_TYPE_SEEKTABLE)
1880 existing_seektable = true;
1881 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)) {
1882 if(options.num_requested_seek_points > 0)
1883 flac__utils_printf(stderr, 1, "%s: WARNING, replacing seektable in input FLAC file with the one given on the command-line\n", e->inbasefilename);
1884 else if(options.num_requested_seek_points == 0)
1885 ; /* no warning, silently delete existing SEEKTABLE since user specified --no-seektable (-S-) */
1887 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);
1888 FLAC__metadata_object_delete(flac_decoder_data->metadata_blocks[i]);
1889 flac_decoder_data->metadata_blocks[i] = 0;
1890 existing_seektable = false;
1893 flac_decoder_data->metadata_blocks[j++] = flac_decoder_data->metadata_blocks[i];
1895 flac_decoder_data->num_metadata_blocks = j;
1896 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])) {
1898 FLAC__StreamMetadata *st = FLAC__metadata_object_clone(e->seek_table_template);
1900 flac__utils_printf(stderr, 1, "%s: ERROR allocating memory for SEEKTABLE block\n", e->inbasefilename);
1902 FLAC__metadata_object_delete(cuesheet);
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] = st;
1908 flac_decoder_data->num_metadata_blocks++;
1911 metadata = &flac_decoder_data->metadata_blocks[1]; /* don't include STREAMINFO */
1912 num_metadata = flac_decoder_data->num_metadata_blocks - 1;
1916 * we're not encoding from FLAC so we will build the metadata
1920 if(e->seek_table_template->data.seek_table.num_points > 0) {
1921 e->seek_table_template->is_last = false; /* the encoder will set this for us */
1922 metadata[num_metadata++] = e->seek_table_template;
1925 metadata[num_metadata++] = cuesheet;
1927 if(!flac__utils_set_channel_mask_tag(options.vorbis_comment, channel_mask)) {
1928 flac__utils_printf(stderr, 1, "%s: ERROR adding channel mask tag\n", e->inbasefilename);
1930 FLAC__metadata_object_delete(cuesheet);
1934 metadata[num_metadata++] = options.vorbis_comment;
1935 for(i = 0; i < options.num_pictures; i++)
1936 metadata[num_metadata++] = options.pictures[i];
1937 if(options.padding != 0) {
1938 padding.is_last = false; /* the encoder will set this for us */
1939 padding.type = FLAC__METADATA_TYPE_PADDING;
1940 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));
1941 metadata[num_metadata++] = &padding;
1945 /* check for a few things that have not already been checked. the
1946 * FLAC__stream_encoder_init*() will check it but only return
1947 * FLAC__STREAM_ENCODER_INIT_STATUS_INVALID_METADATA so we check some
1948 * up front to give a better error message.
1950 if(!verify_metadata(e, metadata, num_metadata)) {
1952 FLAC__metadata_object_delete(cuesheet);
1956 e->blocksize = options.blocksize;
1957 e->stats_mask = (options.do_exhaustive_model_search || options.do_qlp_coeff_prec_search)? 0x0f : 0x3f;
1959 #ifdef FLAC__HAS_OGG
1961 OggFLAC__stream_encoder_set_serial_number(e->encoder.ogg, options.serial_number);
1962 OggFLAC__stream_encoder_set_verify(e->encoder.ogg, options.verify);
1963 OggFLAC__stream_encoder_set_streamable_subset(e->encoder.ogg, !options.lax);
1964 OggFLAC__stream_encoder_set_do_mid_side_stereo(e->encoder.ogg, options.do_mid_side);
1965 OggFLAC__stream_encoder_set_loose_mid_side_stereo(e->encoder.ogg, options.loose_mid_side);
1966 OggFLAC__stream_encoder_set_channels(e->encoder.ogg, channels);
1967 OggFLAC__stream_encoder_set_bits_per_sample(e->encoder.ogg, bps);
1968 OggFLAC__stream_encoder_set_sample_rate(e->encoder.ogg, sample_rate);
1969 OggFLAC__stream_encoder_set_blocksize(e->encoder.ogg, options.blocksize);
1970 OggFLAC__stream_encoder_set_apodization(e->encoder.ogg, options.apodizations);
1971 OggFLAC__stream_encoder_set_max_lpc_order(e->encoder.ogg, options.max_lpc_order);
1972 OggFLAC__stream_encoder_set_qlp_coeff_precision(e->encoder.ogg, options.qlp_coeff_precision);
1973 OggFLAC__stream_encoder_set_do_qlp_coeff_prec_search(e->encoder.ogg, options.do_qlp_coeff_prec_search);
1974 OggFLAC__stream_encoder_set_do_escape_coding(e->encoder.ogg, options.do_escape_coding);
1975 OggFLAC__stream_encoder_set_do_exhaustive_model_search(e->encoder.ogg, options.do_exhaustive_model_search);
1976 OggFLAC__stream_encoder_set_min_residual_partition_order(e->encoder.ogg, options.min_residual_partition_order);
1977 OggFLAC__stream_encoder_set_max_residual_partition_order(e->encoder.ogg, options.max_residual_partition_order);
1978 OggFLAC__stream_encoder_set_rice_parameter_search_dist(e->encoder.ogg, options.rice_parameter_search_dist);
1979 OggFLAC__stream_encoder_set_total_samples_estimate(e->encoder.ogg, e->total_samples_to_encode);
1980 OggFLAC__stream_encoder_set_metadata(e->encoder.ogg, (num_metadata > 0)? metadata : 0, num_metadata);
1982 OggFLAC__stream_encoder_disable_constant_subframes(e->encoder.ogg, options.debug.disable_constant_subframes);
1983 OggFLAC__stream_encoder_disable_fixed_subframes(e->encoder.ogg, options.debug.disable_fixed_subframes);
1984 OggFLAC__stream_encoder_disable_verbatim_subframes(e->encoder.ogg, options.debug.disable_verbatim_subframes);
1986 init_status = OggFLAC__stream_encoder_init_file(e->encoder.ogg, e->is_stdout? 0 : e->outfilename, encoder_progress_callback, /*client_data=*/e);
1987 if(init_status != FLAC__STREAM_ENCODER_INIT_STATUS_OK) {
1988 print_error_with_init_status(e, "ERROR initializing encoder", init_status);
1989 if(OggFLAC__stream_encoder_get_state(e->encoder.ogg) != OggFLAC__STREAM_ENCODER_IO_ERROR)
1990 e->outputfile_opened = true;
1992 FLAC__metadata_object_delete(cuesheet);
1996 e->outputfile_opened = true;
2001 FLAC__stream_encoder_set_verify(e->encoder.flac, options.verify);
2002 FLAC__stream_encoder_set_streamable_subset(e->encoder.flac, !options.lax);
2003 FLAC__stream_encoder_set_do_mid_side_stereo(e->encoder.flac, options.do_mid_side);
2004 FLAC__stream_encoder_set_loose_mid_side_stereo(e->encoder.flac, options.loose_mid_side);
2005 FLAC__stream_encoder_set_channels(e->encoder.flac, channels);
2006 FLAC__stream_encoder_set_bits_per_sample(e->encoder.flac, bps);
2007 FLAC__stream_encoder_set_sample_rate(e->encoder.flac, sample_rate);
2008 FLAC__stream_encoder_set_blocksize(e->encoder.flac, options.blocksize);
2009 FLAC__stream_encoder_set_apodization(e->encoder.flac, options.apodizations);
2010 FLAC__stream_encoder_set_max_lpc_order(e->encoder.flac, options.max_lpc_order);
2011 FLAC__stream_encoder_set_qlp_coeff_precision(e->encoder.flac, options.qlp_coeff_precision);
2012 FLAC__stream_encoder_set_do_qlp_coeff_prec_search(e->encoder.flac, options.do_qlp_coeff_prec_search);
2013 FLAC__stream_encoder_set_do_escape_coding(e->encoder.flac, options.do_escape_coding);
2014 FLAC__stream_encoder_set_do_exhaustive_model_search(e->encoder.flac, options.do_exhaustive_model_search);
2015 FLAC__stream_encoder_set_min_residual_partition_order(e->encoder.flac, options.min_residual_partition_order);
2016 FLAC__stream_encoder_set_max_residual_partition_order(e->encoder.flac, options.max_residual_partition_order);
2017 FLAC__stream_encoder_set_rice_parameter_search_dist(e->encoder.flac, options.rice_parameter_search_dist);
2018 FLAC__stream_encoder_set_total_samples_estimate(e->encoder.flac, e->total_samples_to_encode);
2019 FLAC__stream_encoder_set_metadata(e->encoder.flac, (num_metadata > 0)? metadata : 0, num_metadata);
2021 FLAC__stream_encoder_disable_constant_subframes(e->encoder.flac, options.debug.disable_constant_subframes);
2022 FLAC__stream_encoder_disable_fixed_subframes(e->encoder.flac, options.debug.disable_fixed_subframes);
2023 FLAC__stream_encoder_disable_verbatim_subframes(e->encoder.flac, options.debug.disable_verbatim_subframes);
2025 init_status = FLAC__stream_encoder_init_file(e->encoder.flac, e->is_stdout? 0 : e->outfilename, encoder_progress_callback, /*client_data=*/e);
2026 if(init_status != FLAC__STREAM_ENCODER_INIT_STATUS_OK) {
2027 print_error_with_init_status(e, "ERROR initializing encoder", init_status);
2028 if(FLAC__stream_encoder_get_state(e->encoder.flac) != FLAC__STREAM_ENCODER_IO_ERROR)
2029 e->outputfile_opened = true;
2031 FLAC__metadata_object_delete(cuesheet);
2035 e->outputfile_opened = true;
2039 FLAC__metadata_object_delete(cuesheet);
2044 FLAC__bool EncoderSession_process(EncoderSession *e, const FLAC__int32 * const buffer[], unsigned samples)
2046 if(e->replay_gain) {
2047 if(!grabbag__replaygain_analyze(buffer, e->channels==2, e->bits_per_sample, samples)) {
2048 flac__utils_printf(stderr, 1, "%s: WARNING, error while calculating ReplayGain\n", e->inbasefilename);
2052 #ifdef FLAC__HAS_OGG
2054 return OggFLAC__stream_encoder_process(e->encoder.ogg, buffer, samples);
2057 return FLAC__stream_encoder_process(e->encoder.flac, buffer, samples);
2060 FLAC__bool convert_to_seek_table_template(const char *requested_seek_points, int num_requested_seek_points, FLAC__StreamMetadata *cuesheet, EncoderSession *e)
2062 const FLAC__bool only_placeholders = e->is_stdout;
2063 FLAC__bool has_real_points;
2065 if(num_requested_seek_points == 0 && 0 == cuesheet)
2068 if(num_requested_seek_points < 0) {
2069 requested_seek_points = "10s;";
2070 num_requested_seek_points = 1;
2073 if(num_requested_seek_points > 0) {
2074 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))
2080 const FLAC__StreamMetadata_CueSheet *cs = &cuesheet->data.cue_sheet;
2081 for(i = 0; i < cs->num_tracks; i++) {
2082 const FLAC__StreamMetadata_CueSheet_Track *tr = cs->tracks+i;
2083 for(j = 0; j < tr->num_indices; j++) {
2084 if(!FLAC__metadata_object_seektable_template_append_point(e->seek_table_template, tr->offset + tr->indices[j].offset))
2086 has_real_points = true;
2090 if(!FLAC__metadata_object_seektable_template_sort(e->seek_table_template, /*compact=*/true))
2094 if(has_real_points) {
2096 flac__utils_printf(stderr, 1, "%s: WARNING, cannot write back seekpoints when encoding to stdout\n", e->inbasefilename);
2103 FLAC__bool canonicalize_until_specification(utils__SkipUntilSpecification *spec, const char *inbasefilename, unsigned sample_rate, FLAC__uint64 skip, FLAC__uint64 total_samples_in_input)
2105 /* convert from mm:ss.sss to sample number if necessary */
2106 flac__utils_canonicalize_skip_until_specification(spec, sample_rate);
2108 /* special case: if "--until=-0", use the special value '0' to mean "end-of-stream" */
2109 if(spec->is_relative && spec->value.samples == 0) {
2110 spec->is_relative = false;
2114 /* in any other case the total samples in the input must be known */
2115 if(total_samples_in_input == 0) {
2116 flac__utils_printf(stderr, 1, "%s: ERROR, cannot use --until when input length is unknown\n", inbasefilename);
2120 FLAC__ASSERT(spec->value_is_samples);
2122 /* convert relative specifications to absolute */
2123 if(spec->is_relative) {
2124 if(spec->value.samples <= 0)
2125 spec->value.samples += (FLAC__int64)total_samples_in_input;
2127 spec->value.samples += skip;
2128 spec->is_relative = false;
2132 if(spec->value.samples < 0) {
2133 flac__utils_printf(stderr, 1, "%s: ERROR, --until value is before beginning of input\n", inbasefilename);
2136 if((FLAC__uint64)spec->value.samples <= skip) {
2137 flac__utils_printf(stderr, 1, "%s: ERROR, --until value is before --skip point\n", inbasefilename);
2140 if((FLAC__uint64)spec->value.samples > total_samples_in_input) {
2141 flac__utils_printf(stderr, 1, "%s: ERROR, --until value is after end of input\n", inbasefilename);
2148 FLAC__bool verify_metadata(const EncoderSession *e, FLAC__StreamMetadata **metadata, unsigned num_metadata)
2150 FLAC__bool metadata_picture_has_type1 = false;
2151 FLAC__bool metadata_picture_has_type2 = false;
2154 FLAC__ASSERT(0 != metadata);
2155 for(i = 0; i < num_metadata; i++) {
2156 const FLAC__StreamMetadata *m = metadata[i];
2157 if(m->type == FLAC__METADATA_TYPE_SEEKTABLE) {
2158 if(!FLAC__format_seektable_is_legal(&m->data.seek_table)) {
2159 flac__utils_printf(stderr, 1, "%s: ERROR: SEEKTABLE metadata block is invalid\n", e->inbasefilename);
2163 else if(m->type == FLAC__METADATA_TYPE_CUESHEET) {
2164 if(!FLAC__format_cuesheet_is_legal(&m->data.cue_sheet, m->data.cue_sheet.is_cd, /*violation=*/0)) {
2165 flac__utils_printf(stderr, 1, "%s: ERROR: CUESHEET metadata block is invalid\n", e->inbasefilename);
2169 else if(m->type == FLAC__METADATA_TYPE_PICTURE) {
2170 const char *error = 0;
2171 if(!FLAC__format_picture_is_legal(&m->data.picture, &error)) {
2172 flac__utils_printf(stderr, 1, "%s: ERROR: PICTURE metadata block is invalid: %s\n", e->inbasefilename, error);
2175 if(m->data.picture.type == FLAC__STREAM_METADATA_PICTURE_TYPE_FILE_ICON_STANDARD) {
2176 if(metadata_picture_has_type1) {
2177 flac__utils_printf(stderr, 1, "%s: ERROR: there may only be one picture of type 1 (32x32 icon) in the file\n", e->inbasefilename);
2180 metadata_picture_has_type1 = true;
2182 else if(m->data.picture.type == FLAC__STREAM_METADATA_PICTURE_TYPE_FILE_ICON) {
2183 if(metadata_picture_has_type2) {
2184 flac__utils_printf(stderr, 1, "%s: ERROR: there may only be one picture of type 2 (icon) in the file\n", e->inbasefilename);
2187 metadata_picture_has_type2 = true;
2195 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)
2197 unsigned wide_sample, sample, channel, byte;
2198 FLAC__int32 *out[FLAC__MAX_CHANNELS];
2200 if(0 == channel_map) {
2201 for(channel = 0; channel < channels; channel++)
2202 out[channel] = dest[channel];
2205 for(channel = 0; channel < channels; channel++)
2206 out[channel] = dest[channel_map[channel]];
2210 if(is_unsigned_samples) {
2211 for(sample = wide_sample = 0; wide_sample < wide_samples; wide_sample++)
2212 for(channel = 0; channel < channels; channel++, sample++)
2213 out[channel][wide_sample] = (FLAC__int32)ucbuffer_[sample] - 0x80;
2216 for(sample = wide_sample = 0; wide_sample < wide_samples; wide_sample++)
2217 for(channel = 0; channel < channels; channel++, sample++)
2218 out[channel][wide_sample] = (FLAC__int32)scbuffer_[sample];
2221 else if(bps == 16) {
2222 if(is_big_endian != is_big_endian_host_) {
2224 const unsigned bytes = wide_samples * channels * (bps >> 3);
2225 for(byte = 0; byte < bytes; byte += 2) {
2226 tmp = ucbuffer_[byte];
2227 ucbuffer_[byte] = ucbuffer_[byte+1];
2228 ucbuffer_[byte+1] = tmp;
2231 if(is_unsigned_samples) {
2232 for(sample = wide_sample = 0; wide_sample < wide_samples; wide_sample++)
2233 for(channel = 0; channel < channels; channel++, sample++)
2234 out[channel][wide_sample] = (FLAC__int32)usbuffer_[sample] - 0x8000;
2237 for(sample = wide_sample = 0; wide_sample < wide_samples; wide_sample++)
2238 for(channel = 0; channel < channels; channel++, sample++)
2239 out[channel][wide_sample] = (FLAC__int32)ssbuffer_[sample];
2242 else if(bps == 24) {
2243 if(!is_big_endian) {
2245 const unsigned bytes = wide_samples * channels * (bps >> 3);
2246 for(byte = 0; byte < bytes; byte += 3) {
2247 tmp = ucbuffer_[byte];
2248 ucbuffer_[byte] = ucbuffer_[byte+2];
2249 ucbuffer_[byte+2] = tmp;
2252 if(is_unsigned_samples) {
2253 for(byte = sample = wide_sample = 0; wide_sample < wide_samples; wide_sample++)
2254 for(channel = 0; channel < channels; channel++, sample++) {
2255 out[channel][wide_sample] = ucbuffer_[byte++]; out[channel][wide_sample] <<= 8;
2256 out[channel][wide_sample] |= ucbuffer_[byte++]; out[channel][wide_sample] <<= 8;
2257 out[channel][wide_sample] |= ucbuffer_[byte++];
2258 out[channel][wide_sample] -= 0x800000;
2262 for(byte = sample = wide_sample = 0; wide_sample < wide_samples; wide_sample++)
2263 for(channel = 0; channel < channels; channel++, sample++) {
2264 out[channel][wide_sample] = scbuffer_[byte++]; out[channel][wide_sample] <<= 8;
2265 out[channel][wide_sample] |= ucbuffer_[byte++]; out[channel][wide_sample] <<= 8;
2266 out[channel][wide_sample] |= ucbuffer_[byte++];
2274 FLAC__int32 mask = (1<<shift)-1;
2275 for(wide_sample = 0; wide_sample < wide_samples; wide_sample++)
2276 for(channel = 0; channel < channels; channel++) {
2277 if(out[channel][wide_sample] & mask) {
2278 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);
2281 out[channel][wide_sample] >>= shift;
2287 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)
2289 EncoderSession *encoder_session = (EncoderSession*)client_data;
2291 (void)encoder, (void)total_frames_estimate;
2293 encoder_session->bytes_written = bytes_written;
2294 encoder_session->samples_written = samples_written;
2296 if(encoder_session->total_samples_to_encode > 0 && !((frames_written-1) & encoder_session->stats_mask))
2297 print_stats(encoder_session);
2300 FLAC__StreamDecoderReadStatus flac_decoder_read_callback(const FLAC__StreamDecoder *decoder, FLAC__byte buffer[], unsigned *bytes, void *client_data)
2303 FLACDecoderData *data = (FLACDecoderData*)client_data;
2306 if (data->fatal_error)
2307 return FLAC__STREAM_DECODER_READ_STATUS_ABORT;
2309 /* use up lookahead first */
2310 if (data->lookahead_length) {
2311 n = min(data->lookahead_length, *bytes);
2312 memcpy(buffer, data->lookahead, n);
2314 data->lookahead += n;
2315 data->lookahead_length -= n;
2318 /* get the rest from file */
2320 *bytes = n + fread(buffer, 1, *bytes-n, data->encoder_session->fin);
2321 return ferror(data->encoder_session->fin)? FLAC__STREAM_DECODER_READ_STATUS_ABORT : FLAC__STREAM_DECODER_READ_STATUS_CONTINUE;
2324 return FLAC__STREAM_DECODER_READ_STATUS_CONTINUE;
2327 FLAC__StreamDecoderSeekStatus flac_decoder_seek_callback(const FLAC__StreamDecoder *decoder, FLAC__uint64 absolute_byte_offset, void *client_data)
2329 FLACDecoderData *data = (FLACDecoderData*)client_data;
2332 if(fseeko(data->encoder_session->fin, (off_t)absolute_byte_offset, SEEK_SET) < 0)
2333 return FLAC__STREAM_DECODER_SEEK_STATUS_ERROR;
2335 return FLAC__STREAM_DECODER_SEEK_STATUS_OK;
2338 FLAC__StreamDecoderTellStatus flac_decoder_tell_callback(const FLAC__StreamDecoder *decoder, FLAC__uint64 *absolute_byte_offset, void *client_data)
2340 FLACDecoderData *data = (FLACDecoderData*)client_data;
2344 if((pos = ftello(data->encoder_session->fin)) < 0)
2345 return FLAC__STREAM_DECODER_TELL_STATUS_ERROR;
2347 *absolute_byte_offset = (FLAC__uint64)pos;
2348 return FLAC__STREAM_DECODER_TELL_STATUS_OK;
2352 FLAC__StreamDecoderLengthStatus flac_decoder_length_callback(const FLAC__StreamDecoder *decoder, FLAC__uint64 *stream_length, void *client_data)
2354 FLACDecoderData *data = (FLACDecoderData*)client_data;
2357 if(0 == data->filesize)
2358 return FLAC__STREAM_DECODER_LENGTH_STATUS_ERROR;
2360 *stream_length = (FLAC__uint64)data->filesize;
2361 return FLAC__STREAM_DECODER_LENGTH_STATUS_OK;
2365 FLAC__bool flac_decoder_eof_callback(const FLAC__StreamDecoder *decoder, void *client_data)
2367 FLACDecoderData *data = (FLACDecoderData*)client_data;
2370 return feof(data->encoder_session->fin)? true : false;
2373 FLAC__StreamDecoderWriteStatus flac_decoder_write_callback(const FLAC__StreamDecoder *decoder, const FLAC__Frame *frame, const FLAC__int32 * const buffer[], void *client_data)
2375 FLACDecoderData *data = (FLACDecoderData*)client_data;
2376 FLAC__uint64 n = min(data->samples_left_to_process, frame->header.blocksize);
2379 if(!EncoderSession_process(data->encoder_session, buffer, (unsigned)n)) {
2380 print_error_with_state(data->encoder_session, "ERROR during encoding");
2381 data->fatal_error = true;
2382 return FLAC__STREAM_DECODER_WRITE_STATUS_ABORT;
2385 data->samples_left_to_process -= n;
2386 return FLAC__STREAM_DECODER_WRITE_STATUS_CONTINUE;
2389 void flac_decoder_metadata_callback(const FLAC__StreamDecoder *decoder, const FLAC__StreamMetadata *metadata, void *client_data)
2391 FLACDecoderData *data = (FLACDecoderData*)client_data;
2394 if (data->fatal_error)
2398 data->num_metadata_blocks == sizeof(data->metadata_blocks)/sizeof(data->metadata_blocks[0]) ||
2399 0 == (data->metadata_blocks[data->num_metadata_blocks] = FLAC__metadata_object_clone(metadata))
2401 data->fatal_error = true;
2403 data->num_metadata_blocks++;
2406 void flac_decoder_error_callback(const FLAC__StreamDecoder *decoder, FLAC__StreamDecoderErrorStatus status, void *client_data)
2408 FLACDecoderData *data = (FLACDecoderData*)client_data;
2411 flac__utils_printf(stderr, 1, "%s: ERROR got %s while decoding FLAC input\n", data->encoder_session->inbasefilename, FLAC__StreamDecoderErrorStatusString[status]);
2412 data->fatal_error = true;
2415 FLAC__bool parse_cuesheet(FLAC__StreamMetadata **cuesheet, const char *cuesheet_filename, const char *inbasefilename, FLAC__bool is_cdda, FLAC__uint64 lead_out_offset)
2418 unsigned last_line_read;
2419 const char *error_message;
2421 if(0 == cuesheet_filename)
2424 if(lead_out_offset == 0) {
2425 flac__utils_printf(stderr, 1, "%s: ERROR cannot import cuesheet when the number of input samples to encode is unknown\n", inbasefilename);
2429 if(0 == (f = fopen(cuesheet_filename, "r"))) {
2430 flac__utils_printf(stderr, 1, "%s: ERROR opening cuesheet \"%s\" for reading: %s\n", inbasefilename, cuesheet_filename, strerror(errno));
2434 *cuesheet = grabbag__cuesheet_parse(f, &error_message, &last_line_read, is_cdda, lead_out_offset);
2438 if(0 == *cuesheet) {
2439 flac__utils_printf(stderr, 1, "%s: ERROR parsing cuesheet \"%s\" on line %u: %s\n", inbasefilename, cuesheet_filename, last_line_read, error_message);
2443 if(!FLAC__format_cuesheet_is_legal(&(*cuesheet)->data.cue_sheet, /*check_cd_da_subset=*/false, &error_message)) {
2444 flac__utils_printf(stderr, 1, "%s: ERROR parsing cuesheet \"%s\": %s\n", inbasefilename, cuesheet_filename, error_message);
2448 /* if we're expecting CDDA, warn about non-compliance */
2449 if(is_cdda && !FLAC__format_cuesheet_is_legal(&(*cuesheet)->data.cue_sheet, /*check_cd_da_subset=*/true, &error_message)) {
2450 flac__utils_printf(stderr, 1, "%s: WARNING cuesheet \"%s\" is not audio CD compliant: %s\n", inbasefilename, cuesheet_filename, error_message);
2451 (*cuesheet)->data.cue_sheet.is_cd = false;
2457 void print_stats(const EncoderSession *encoder_session)
2459 const FLAC__uint64 samples_written = min(encoder_session->total_samples_to_encode, encoder_session->samples_written);
2460 #if defined _MSC_VER || defined __MINGW32__
2461 /* with MSVC you have to spoon feed it the casting */
2462 const double progress = (double)(FLAC__int64)samples_written / (double)(FLAC__int64)encoder_session->total_samples_to_encode;
2463 const double ratio = (double)(FLAC__int64)encoder_session->bytes_written / ((double)(FLAC__int64)encoder_session->unencoded_size * min(1.0, progress));
2465 const double progress = (double)samples_written / (double)encoder_session->total_samples_to_encode;
2466 const double ratio = (double)encoder_session->bytes_written / ((double)encoder_session->unencoded_size * min(1.0, progress));
2470 if(samples_written == encoder_session->total_samples_to_encode) {
2471 flac__utils_printf(stderr, 2, "\r%s:%s wrote %u bytes, ratio=%0.3f",
2472 encoder_session->inbasefilename,
2473 encoder_session->verify? " Verify OK," : "",
2474 (unsigned)encoder_session->bytes_written,
2479 flac__utils_printf(stderr, 2, "\r%s: %u%% complete, ratio=%0.3f", encoder_session->inbasefilename, (unsigned)floor(progress * 100.0 + 0.5), ratio);
2483 void print_error_with_init_status(const EncoderSession *e, const char *message, FLAC__StreamEncoderInitStatus init_status)
2485 const int ilen = strlen(e->inbasefilename) + 1;
2486 const char *state_string = "";
2488 flac__utils_printf(stderr, 1, "\n%s: %s\n", e->inbasefilename, message);
2490 flac__utils_printf(stderr, 1, "%*s init_status = %s\n", ilen, "", FLAC__StreamEncoderInitStatusString[init_status]);
2492 if(init_status == FLAC__STREAM_ENCODER_INIT_STATUS_ENCODER_ERROR) {
2493 #ifdef FLAC__HAS_OGG
2495 state_string = OggFLAC__stream_encoder_get_resolved_state_string(e->encoder.ogg);
2498 state_string = FLAC__stream_encoder_get_resolved_state_string(e->encoder.flac);
2500 flac__utils_printf(stderr, 1, "%*s state = %s\n", ilen, "", state_string);
2502 /* print out some more info for some errors: */
2504 0 == strcmp(state_string, FLAC__StreamEncoderStateString[FLAC__STREAM_ENCODER_CLIENT_ERROR])
2505 #ifdef FLAC__HAS_OGG
2506 || 0 == strcmp(state_string, OggFLAC__StreamEncoderStateString[OggFLAC__STREAM_ENCODER_CLIENT_ERROR])
2509 flac__utils_printf(stderr, 1,
2511 "An error occurred while writing; the most common cause is that the disk is full.\n"
2515 0 == strcmp(state_string, FLAC__StreamEncoderStateString[FLAC__STREAM_ENCODER_IO_ERROR])
2516 #ifdef FLAC__HAS_OGG
2517 || 0 == strcmp(state_string, OggFLAC__StreamEncoderStateString[OggFLAC__STREAM_ENCODER_IO_ERROR])
2520 flac__utils_printf(stderr, 1,
2522 "An error occurred opening the output file; it is likely that the output\n"
2523 "directory does not exist or is not writable, the output file already exists and\n"
2524 "is not writable, or the disk is full.\n"
2528 else if(init_status == FLAC__STREAM_ENCODER_INIT_STATUS_NOT_STREAMABLE) {
2529 flac__utils_printf(stderr, 1,
2531 "The encoding parameters specified do not conform to the FLAC Subset and may not\n"
2532 "be streamable or playable in hardware devices. If you really understand the\n"
2533 "consequences, you can add --lax to the command-line options to encode with\n"
2534 "these parameters anyway. See http://flac.sourceforge.net/format.html#subset\n"
2539 void print_error_with_state(const EncoderSession *e, const char *message)
2541 const int ilen = strlen(e->inbasefilename) + 1;
2542 const char *state_string;
2544 flac__utils_printf(stderr, 1, "\n%s: %s\n", e->inbasefilename, message);
2546 #ifdef FLAC__HAS_OGG
2548 state_string = OggFLAC__stream_encoder_get_resolved_state_string(e->encoder.ogg);
2551 state_string = FLAC__stream_encoder_get_resolved_state_string(e->encoder.flac);
2553 flac__utils_printf(stderr, 1, "%*s state = %s\n", ilen, "", state_string);
2555 /* print out some more info for some errors: */
2557 0 == strcmp(state_string, FLAC__StreamEncoderStateString[FLAC__STREAM_ENCODER_CLIENT_ERROR])
2558 #ifdef FLAC__HAS_OGG
2559 || 0 == strcmp(state_string, OggFLAC__StreamEncoderStateString[OggFLAC__STREAM_ENCODER_CLIENT_ERROR])
2562 flac__utils_printf(stderr, 1,
2564 "An error occurred while writing; the most common cause is that the disk is full.\n"
2569 void print_verify_error(EncoderSession *e)
2571 FLAC__uint64 absolute_sample;
2572 unsigned frame_number;
2575 FLAC__int32 expected;
2578 #ifdef FLAC__HAS_OGG
2580 OggFLAC__stream_encoder_get_verify_decoder_error_stats(e->encoder.ogg, &absolute_sample, &frame_number, &channel, &sample, &expected, &got);
2583 FLAC__stream_encoder_get_verify_decoder_error_stats(e->encoder.flac, &absolute_sample, &frame_number, &channel, &sample, &expected, &got);
2585 flac__utils_printf(stderr, 1, "%s: ERROR: mismatch in decoded data, verify FAILED!\n", e->inbasefilename);
2586 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);
2587 flac__utils_printf(stderr, 1, " In all known cases, verify errors are caused by hardware problems,\n");
2588 flac__utils_printf(stderr, 1, " usually overclocking or bad RAM. Delete %s\n", e->outfilename);
2589 flac__utils_printf(stderr, 1, " and repeat the flac command exactly as before. If it does not give a\n");
2590 flac__utils_printf(stderr, 1, " verify error in the exact same place each time you try it, then there is\n");
2591 flac__utils_printf(stderr, 1, " a problem with your hardware; please see the FAQ:\n");
2592 flac__utils_printf(stderr, 1, " http://flac.sourceforge.net/faq.html#tools__hardware_prob\n");
2593 flac__utils_printf(stderr, 1, " If it does fail in the exact same place every time, keep\n");
2594 flac__utils_printf(stderr, 1, " %s and submit a bug report to:\n", e->outfilename);
2595 flac__utils_printf(stderr, 1, " https://sourceforge.net/bugs/?func=addbug&group_id=13478\n");
2596 flac__utils_printf(stderr, 1, " Make sure to upload the FLAC file and use the \"Monitor\" feature to\n");
2597 flac__utils_printf(stderr, 1, " monitor the bug status.\n");
2598 flac__utils_printf(stderr, 1, "Verify FAILED! Do not trust %s\n", e->outfilename);
2601 FLAC__bool read_little_endian_uint16(FILE *f, FLAC__uint16 *val, FLAC__bool eof_ok, const char *fn)
2603 size_t bytes_read = fread(val, 1, 2, f);
2605 if(bytes_read == 0) {
2607 flac__utils_printf(stderr, 1, "%s: ERROR: unexpected EOF\n", fn);
2613 else if(bytes_read < 2) {
2614 flac__utils_printf(stderr, 1, "%s: ERROR: unexpected EOF\n", fn);
2618 if(is_big_endian_host_) {
2619 FLAC__byte tmp, *b = (FLAC__byte*)val;
2620 tmp = b[1]; b[1] = b[0]; b[0] = tmp;
2626 FLAC__bool read_little_endian_uint32(FILE *f, FLAC__uint32 *val, FLAC__bool eof_ok, const char *fn)
2628 size_t bytes_read = fread(val, 1, 4, f);
2630 if(bytes_read == 0) {
2632 flac__utils_printf(stderr, 1, "%s: ERROR: unexpected EOF\n", fn);
2638 else if(bytes_read < 4) {
2639 flac__utils_printf(stderr, 1, "%s: ERROR: unexpected EOF\n", fn);
2643 if(is_big_endian_host_) {
2644 FLAC__byte tmp, *b = (FLAC__byte*)val;
2645 tmp = b[3]; b[3] = b[0]; b[0] = tmp;
2646 tmp = b[2]; b[2] = b[1]; b[1] = tmp;
2652 FLAC__bool read_big_endian_uint16(FILE *f, FLAC__uint16 *val, FLAC__bool eof_ok, const char *fn)
2654 unsigned char buf[4];
2655 size_t bytes_read= fread(buf, 1, 2, f);
2657 if(bytes_read==0U && eof_ok)
2659 else if(bytes_read<2U) {
2660 flac__utils_printf(stderr, 1, "%s: ERROR: unexpected EOF\n", fn);
2664 /* this is independent of host endianness */
2665 *val= (FLAC__uint16)(buf[0])<<8 | buf[1];
2670 FLAC__bool read_big_endian_uint32(FILE *f, FLAC__uint32 *val, FLAC__bool eof_ok, const char *fn)
2672 unsigned char buf[4];
2673 size_t bytes_read= fread(buf, 1, 4, f);
2675 if(bytes_read==0U && eof_ok)
2677 else if(bytes_read<4U) {
2678 flac__utils_printf(stderr, 1, "%s: ERROR: unexpected EOF\n", fn);
2682 /* this is independent of host endianness */
2683 *val= (FLAC__uint32)(buf[0])<<24 | (FLAC__uint32)(buf[1])<<16 |
2684 (FLAC__uint32)(buf[2])<<8 | buf[3];
2689 FLAC__bool read_sane_extended(FILE *f, FLAC__uint32 *val, FLAC__bool eof_ok, const char *fn)
2690 /* Read an IEEE 754 80-bit (aka SANE) extended floating point value from 'f',
2691 * convert it into an integral value and store in 'val'. Return false if only
2692 * between 1 and 9 bytes remain in 'f', if 0 bytes remain in 'f' and 'eof_ok' is
2693 * false, or if the value is negative, between zero and one, or too large to be
2694 * represented by 'val'; return true otherwise.
2698 unsigned char buf[10];
2699 size_t bytes_read= fread(buf, 1U, 10U, f);
2700 FLAC__int16 e= ((FLAC__uint16)(buf[0])<<8 | (FLAC__uint16)(buf[1]))-0x3FFF;
2701 FLAC__int16 shift= 63-e;
2704 if(bytes_read==0U && eof_ok)
2706 else if(bytes_read<10U) {
2707 flac__utils_printf(stderr, 1, "%s: ERROR: unexpected EOF\n", fn);
2710 else if((buf[0]>>7)==1U || e<0 || e>63) {
2711 flac__utils_printf(stderr, 1, "%s: ERROR: invalid floating-point value\n", fn);
2715 for(i= 0U; i<8U; ++i)
2716 p|= (FLAC__uint64)(buf[i+2])<<(56U-i*8);
2717 *val= (FLAC__uint32)((p>>shift)+(p>>(shift-1) & 0x1));
2722 FLAC__bool fskip_ahead(FILE *f, FLAC__uint64 offset)
2724 static unsigned char dump[8192];
2727 long need = (long)min(offset, LONG_MAX);
2728 if(fseeko(f, need, SEEK_CUR) < 0) {
2729 need = (long)min(offset, sizeof(dump));
2730 if((long)fread(dump, 1, need, f) < need)
2735 #if 0 /* pure non-fseek() version */
2737 const long need = (long)min(offset, sizeof(dump));
2738 if(fread(dump, 1, need, f) < need)
2746 unsigned count_channel_mask_bits(FLAC__uint32 mask)
2757 FLAC__uint32 limit_channel_mask(FLAC__uint32 mask, unsigned channels)
2759 FLAC__uint32 x = 0x80000000;
2760 unsigned count = count_channel_mask_bits(mask);
2761 while(x && count > channels) {
2768 FLAC__ASSERT(count_channel_mask_bits(mask) == channels);