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"
49 #define min(x,y) ((x)<(y)?(x):(y))
53 #define max(x,y) ((x)>(y)?(x):(y))
55 /* this MUST be >= 588 so that sector aligning can take place with one read */
56 #define CHUNK_OF_SAMPLES 2048
64 FLAC__bool outputfile_opened; /* true if we successfully opened the output file and we want it to be deleted if there is an error */
65 const char *inbasefilename;
66 const char *outfilename;
69 FLAC__uint64 until; /* a value of 0 mean end-of-stream (i.e. --until=-0) */
70 FLAC__bool continue_through_decode_errors;
71 FLAC__bool replay_gain;
73 unsigned bits_per_sample;
75 FLAC__uint64 unencoded_size;
76 FLAC__uint64 total_samples_to_encode;
77 FLAC__uint64 bytes_written;
78 FLAC__uint64 samples_written;
81 FLAC__StreamEncoder *encoder;
84 FLAC__StreamMetadata *seek_table_template;
87 /* this is data attached to the FLAC decoder when encoding from a FLAC file */
89 EncoderSession *encoder_session;
91 const FLAC__byte *lookahead;
92 unsigned lookahead_length;
93 size_t num_metadata_blocks;
94 FLAC__StreamMetadata *metadata_blocks[1024]; /*@@@ BAD MAGIC number */
95 FLAC__uint64 samples_left_to_process;
96 FLAC__bool fatal_error;
99 const int FLAC_ENCODE__DEFAULT_PADDING = 8192;
101 static FLAC__bool is_big_endian_host_;
103 static unsigned char ucbuffer_[CHUNK_OF_SAMPLES*FLAC__MAX_CHANNELS*((FLAC__REFERENCE_CODEC_MAX_BITS_PER_SAMPLE+7)/8)];
104 static signed char *scbuffer_ = (signed char *)ucbuffer_;
105 static FLAC__uint16 *usbuffer_ = (FLAC__uint16 *)ucbuffer_;
106 static FLAC__int16 *ssbuffer_ = (FLAC__int16 *)ucbuffer_;
108 static FLAC__int32 in_[FLAC__MAX_CHANNELS][CHUNK_OF_SAMPLES];
109 static FLAC__int32 *input_[FLAC__MAX_CHANNELS];
113 * unpublished debug routines from the FLAC libs
115 extern FLAC__bool FLAC__stream_encoder_disable_constant_subframes(FLAC__StreamEncoder *encoder, FLAC__bool value);
116 extern FLAC__bool FLAC__stream_encoder_disable_fixed_subframes(FLAC__StreamEncoder *encoder, FLAC__bool value);
117 extern FLAC__bool FLAC__stream_encoder_disable_verbatim_subframes(FLAC__StreamEncoder *encoder, FLAC__bool value);
122 static FLAC__bool EncoderSession_construct(EncoderSession *e, FLAC__bool use_ogg, FLAC__bool verify, FLAC__bool continue_through_decode_errors, FILE *infile, const char *infilename, const char *outfilename);
123 static void EncoderSession_destroy(EncoderSession *e);
124 static int EncoderSession_finish_ok(EncoderSession *e, int info_align_carry, int info_align_zero);
125 static int EncoderSession_finish_error(EncoderSession *e);
126 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);
127 static FLAC__bool EncoderSession_process(EncoderSession *e, const FLAC__int32 * const buffer[], unsigned samples);
128 static FLAC__bool convert_to_seek_table_template(const char *requested_seek_points, int num_requested_seek_points, FLAC__StreamMetadata *cuesheet, EncoderSession *e);
129 static FLAC__bool canonicalize_until_specification(utils__SkipUntilSpecification *spec, const char *inbasefilename, unsigned sample_rate, FLAC__uint64 skip, FLAC__uint64 total_samples_in_input);
130 static FLAC__bool verify_metadata(const EncoderSession *e, FLAC__StreamMetadata **metadata, unsigned num_metadata);
131 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);
132 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);
133 static FLAC__StreamDecoderReadStatus flac_decoder_read_callback(const FLAC__StreamDecoder *decoder, FLAC__byte buffer[], size_t *bytes, void *client_data);
134 static FLAC__StreamDecoderSeekStatus flac_decoder_seek_callback(const FLAC__StreamDecoder *decoder, FLAC__uint64 absolute_byte_offset, void *client_data);
135 static FLAC__StreamDecoderTellStatus flac_decoder_tell_callback(const FLAC__StreamDecoder *decoder, FLAC__uint64 *absolute_byte_offset, void *client_data);
136 static FLAC__StreamDecoderLengthStatus flac_decoder_length_callback(const FLAC__StreamDecoder *decoder, FLAC__uint64 *stream_length, void *client_data);
137 static FLAC__bool flac_decoder_eof_callback(const FLAC__StreamDecoder *decoder, void *client_data);
138 static FLAC__StreamDecoderWriteStatus flac_decoder_write_callback(const FLAC__StreamDecoder *decoder, const FLAC__Frame *frame, const FLAC__int32 * const buffer[], void *client_data);
139 static void flac_decoder_metadata_callback(const FLAC__StreamDecoder *decoder, const FLAC__StreamMetadata *metadata, void *client_data);
140 static void flac_decoder_error_callback(const FLAC__StreamDecoder *decoder, FLAC__StreamDecoderErrorStatus status, void *client_data);
141 static FLAC__bool parse_cuesheet(FLAC__StreamMetadata **cuesheet, const char *cuesheet_filename, const char *inbasefilename, FLAC__bool is_cdda, FLAC__uint64 lead_out_offset);
142 static void print_stats(const EncoderSession *encoder_session);
143 static void print_error_with_init_status(const EncoderSession *e, const char *message, FLAC__StreamEncoderInitStatus init_status);
144 static void print_error_with_state(const EncoderSession *e, const char *message);
145 static void print_verify_error(EncoderSession *e);
146 static FLAC__bool read_little_endian_uint16(FILE *f, FLAC__uint16 *val, FLAC__bool eof_ok, const char *fn);
147 static FLAC__bool read_little_endian_uint32(FILE *f, FLAC__uint32 *val, FLAC__bool eof_ok, const char *fn);
148 static FLAC__bool read_big_endian_uint16(FILE *f, FLAC__uint16 *val, FLAC__bool eof_ok, const char *fn);
149 static FLAC__bool read_big_endian_uint32(FILE *f, FLAC__uint32 *val, FLAC__bool eof_ok, const char *fn);
150 static FLAC__bool read_sane_extended(FILE *f, FLAC__uint32 *val, FLAC__bool eof_ok, const char *fn);
151 static FLAC__bool fskip_ahead(FILE *f, FLAC__uint64 offset);
152 static unsigned count_channel_mask_bits(FLAC__uint32 mask);
153 static FLAC__uint32 limit_channel_mask(FLAC__uint32 mask, unsigned channels);
158 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)
160 EncoderSession encoder_session;
163 unsigned int channels= 0U, bps= 0U, shift= 0U, sample_rate= 0U, sample_frames= 0U;
164 size_t channel_map[FLAC__MAX_CHANNELS];
165 FLAC__bool got_comm_chunk= false, got_ssnd_chunk= false;
166 int info_align_carry= -1, info_align_zero= -1;
167 FLAC__bool is_big_endian_pcm = true;
169 (void)infilesize; /* silence compiler warning about unused parameter */
170 (void)lookahead; /* silence compiler warning about unused parameter */
171 (void)lookahead_length; /* silence compiler warning about unused parameter */
174 EncoderSession_construct(
177 options.common.use_ogg,
181 options.common.verify,
182 options.common.continue_through_decode_errors,
190 /* initialize default channel map that preserves channel order */
193 for(i = 0; i < sizeof(channel_map)/sizeof(channel_map[0]); i++)
197 /* lookahead[] already has "FORMxxxxAIFF", do sub-chunks */
201 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 */
203 /* chunk identifier; really conservative about behavior of fread() and feof() */
204 if(feof(infile) || ((c= fread(chunk_id, 1U, 4U, infile)), c==0U && feof(infile)))
206 else if(c<4U || feof(infile)) {
207 flac__utils_printf(stderr, 1, "%s: ERROR: incomplete chunk identifier\n", encoder_session.inbasefilename);
208 return EncoderSession_finish_error(&encoder_session);
211 if(got_comm_chunk==false && !memcmp(chunk_id, "COMM", 4)) { /* common chunk */
213 const FLAC__uint32 minimum_comm_size = (is_aifc? 22 : 18);
215 /* COMM chunk size */
216 if(!read_big_endian_uint32(infile, &xx, false, encoder_session.inbasefilename))
217 return EncoderSession_finish_error(&encoder_session);
218 else if(xx<minimum_comm_size) {
219 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);
220 return EncoderSession_finish_error(&encoder_session);
222 else if(!is_aifc && xx!=minimum_comm_size) {
223 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);
225 skip= (xx-minimum_comm_size)+(xx & 1U);
227 /* number of channels */
228 if(!read_big_endian_uint16(infile, &x, false, encoder_session.inbasefilename))
229 return EncoderSession_finish_error(&encoder_session);
230 else if(x==0U || x>FLAC__MAX_CHANNELS) {
231 flac__utils_printf(stderr, 1, "%s: ERROR: unsupported number channels %u\n", encoder_session.inbasefilename, (unsigned int)x);
232 return EncoderSession_finish_error(&encoder_session);
234 else if(x>2U && !options.common.channel_map_none) {
235 flac__utils_printf(stderr, 1, "%s: ERROR: unsupported number channels %u for AIFF\n", encoder_session.inbasefilename, (unsigned int)x);
236 return EncoderSession_finish_error(&encoder_session);
238 else if(options.common.sector_align && x!=2U) {
239 flac__utils_printf(stderr, 1, "%s: ERROR: file has %u channels, must be 2 for --sector-align\n", encoder_session.inbasefilename, (unsigned int)x);
240 return EncoderSession_finish_error(&encoder_session);
244 /* number of sample frames */
245 if(!read_big_endian_uint32(infile, &xx, false, encoder_session.inbasefilename))
246 return EncoderSession_finish_error(&encoder_session);
249 /* bits per sample */
250 if(!read_big_endian_uint16(infile, &x, false, encoder_session.inbasefilename))
251 return EncoderSession_finish_error(&encoder_session);
252 else if(x<4U || x>24U) {
253 flac__utils_printf(stderr, 1, "%s: ERROR: unsupported bits-per-sample %u\n", encoder_session.inbasefilename, (unsigned int)x);
254 return EncoderSession_finish_error(&encoder_session);
256 else if(options.common.sector_align && x!=16U) {
257 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);
258 return EncoderSession_finish_error(&encoder_session);
261 shift= (bps%8)? 8-(bps%8) : 0; /* SSND data is always byte-aligned, left-justified but format_input() will double-check */
265 if(!read_sane_extended(infile, &xx, false, encoder_session.inbasefilename))
266 return EncoderSession_finish_error(&encoder_session);
267 else if(!FLAC__format_sample_rate_is_valid(xx)) {
268 flac__utils_printf(stderr, 1, "%s: ERROR: unsupported sample rate %u\n", encoder_session.inbasefilename, (unsigned int)xx);
269 return EncoderSession_finish_error(&encoder_session);
271 else if(options.common.sector_align && xx!=44100U) {
272 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);
273 return EncoderSession_finish_error(&encoder_session);
277 /* check compression type for AIFF-C */
279 if(!read_big_endian_uint32(infile, &xx, false, encoder_session.inbasefilename))
280 return EncoderSession_finish_error(&encoder_session);
281 if(xx == 0x736F7774) /* "sowt" */
282 is_big_endian_pcm = false;
283 else if(xx == 0x4E4F4E45) /* "NONE" */
284 ; /* nothing to do, we already default to big-endian */
286 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));
287 return EncoderSession_finish_error(&encoder_session);
291 /* set channel mapping */
292 /* FLAC order follows SMPTE and WAVEFORMATEXTENSIBLE but with fewer channels, which are: */
293 /* front left, front right, center, LFE, back left, back right, surround left, surround right */
294 /* specs say the channel ordering is:
296 * ___________________________________________________
300 * quad (ambiguous with 4ch) Fl Fr Bl Br
303 * 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
304 * so we only have unambiguous mappings for 2, 3, and 5 channels
307 options.common.channel_map_none ||
308 channels == 1 || /* 1 channel: (mono) */
309 channels == 2 || /* 2 channels: left, right */
310 channels == 3 || /* 3 channels: left, right, center */
311 channels == 5 /* 5 channels: front left, front right, center, surround left, surround right */
313 /* keep default channel order */
316 flac__utils_printf(stderr, 1, "%s: ERROR: unsupported number channels %u for AIFF\n", encoder_session.inbasefilename, channels);
317 return EncoderSession_finish_error(&encoder_session);
320 /* skip any extra data in the COMM chunk */
321 if(!fskip_ahead(infile, skip)) {
322 flac__utils_printf(stderr, 1, "%s: ERROR during read while skipping extra COMM data\n", encoder_session.inbasefilename);
323 return EncoderSession_finish_error(&encoder_session);
327 * now that we know the sample rate, canonicalize the
328 * --skip string to a number of samples:
330 flac__utils_canonicalize_skip_until_specification(&options.common.skip_specification, sample_rate);
331 FLAC__ASSERT(options.common.skip_specification.value.samples >= 0);
332 encoder_session.skip = (FLAC__uint64)options.common.skip_specification.value.samples;
333 FLAC__ASSERT(!options.common.sector_align || encoder_session.skip == 0);
335 got_comm_chunk= true;
337 else if(got_ssnd_chunk==false && !memcmp(chunk_id, "SSND", 4)) { /* sound data chunk */
338 unsigned int offset= 0U, block_size= 0U, align_remainder= 0U, data_bytes;
339 size_t bytes_per_frame= channels*(bps>>3);
340 FLAC__uint64 total_samples_in_input, trim = 0;
341 FLAC__bool pad= false;
343 if(got_comm_chunk==false) {
344 flac__utils_printf(stderr, 1, "%s: ERROR: got 'SSND' chunk before 'COMM' chunk\n", encoder_session.inbasefilename);
345 return EncoderSession_finish_error(&encoder_session);
348 /* SSND chunk size */
349 if(!read_big_endian_uint32(infile, &xx, false, encoder_session.inbasefilename))
350 return EncoderSession_finish_error(&encoder_session);
352 pad= (data_bytes & 1U) ? true : false;
353 data_bytes-= 8U; /* discount the offset and block size fields */
356 if(!read_big_endian_uint32(infile, &xx, false, encoder_session.inbasefilename))
357 return EncoderSession_finish_error(&encoder_session);
362 if(!read_big_endian_uint32(infile, &xx, false, encoder_session.inbasefilename))
363 return EncoderSession_finish_error(&encoder_session);
365 flac__utils_printf(stderr, 1, "%s: ERROR: block size is %u; must be 0\n", encoder_session.inbasefilename, (unsigned int)xx);
366 return EncoderSession_finish_error(&encoder_session);
370 /* skip any SSND offset bytes */
371 FLAC__ASSERT(offset<=LONG_MAX);
372 if(!fskip_ahead(infile, offset)) {
373 flac__utils_printf(stderr, 1, "%s: ERROR: skipping offset in SSND chunk\n", encoder_session.inbasefilename);
374 return EncoderSession_finish_error(&encoder_session);
376 if(data_bytes!=(sample_frames*bytes_per_frame)) {
377 flac__utils_printf(stderr, 1, "%s: ERROR: SSND chunk size inconsistent with sample frame count\n", encoder_session.inbasefilename);
378 return EncoderSession_finish_error(&encoder_session);
381 /* *options.common.align_reservoir_samples will be 0 unless --sector-align is used */
382 FLAC__ASSERT(options.common.sector_align || *options.common.align_reservoir_samples == 0);
383 total_samples_in_input = data_bytes / bytes_per_frame + *options.common.align_reservoir_samples;
386 * now that we know the input size, canonicalize the
387 * --until string to an absolute sample number:
389 if(!canonicalize_until_specification(&options.common.until_specification, encoder_session.inbasefilename, sample_rate, encoder_session.skip, total_samples_in_input))
390 return EncoderSession_finish_error(&encoder_session);
391 encoder_session.until = (FLAC__uint64)options.common.until_specification.value.samples;
392 FLAC__ASSERT(!options.common.sector_align || encoder_session.until == 0);
394 if(encoder_session.skip>0U) {
395 if(!fskip_ahead(infile, encoder_session.skip*bytes_per_frame)) {
396 flac__utils_printf(stderr, 1, "%s: ERROR during read while skipping samples\n", encoder_session.inbasefilename);
397 return EncoderSession_finish_error(&encoder_session);
401 data_bytes-= (unsigned int)encoder_session.skip*bytes_per_frame; /*@@@ WATCHOUT: 4GB limit */
402 encoder_session.total_samples_to_encode= total_samples_in_input - encoder_session.skip;
403 if(encoder_session.until > 0) {
404 trim = total_samples_in_input - encoder_session.until;
405 FLAC__ASSERT(total_samples_in_input > 0);
406 FLAC__ASSERT(!options.common.sector_align);
407 data_bytes-= (unsigned int)trim*bytes_per_frame;
408 encoder_session.total_samples_to_encode-= trim;
410 if(options.common.sector_align) {
411 align_remainder= (unsigned int)(encoder_session.total_samples_to_encode % 588U);
412 if(options.common.is_last_file)
413 encoder_session.total_samples_to_encode+= (588U-align_remainder); /* will pad with zeroes */
415 encoder_session.total_samples_to_encode-= align_remainder; /* will stop short and carry over to next file */
418 /* +54 for the size of the AIFF headers; this is just an estimate for the progress indicator and doesn't need to be exact */
419 encoder_session.unencoded_size= encoder_session.total_samples_to_encode*bytes_per_frame+54;
421 if(!EncoderSession_init_encoder(&encoder_session, options.common, /*channel_mask=*/0, channels, bps-shift, sample_rate, /*flac_decoder_data=*/0))
422 return EncoderSession_finish_error(&encoder_session);
424 /* first do any samples in the reservoir */
425 if(options.common.sector_align && *options.common.align_reservoir_samples>0U) {
427 if(!EncoderSession_process(&encoder_session, (const FLAC__int32 *const *)options.common.align_reservoir, *options.common.align_reservoir_samples)) {
428 print_error_with_state(&encoder_session, "ERROR during encoding");
429 return EncoderSession_finish_error(&encoder_session);
433 /* decrement the data_bytes counter if we need to align the file */
434 if(options.common.sector_align) {
435 if(options.common.is_last_file)
436 *options.common.align_reservoir_samples= 0U;
438 *options.common.align_reservoir_samples= align_remainder;
439 data_bytes-= (*options.common.align_reservoir_samples)*bytes_per_frame;
443 /* now do from the file */
444 while(data_bytes>0) {
445 size_t bytes_read= fread(ucbuffer_, 1U, min(data_bytes, CHUNK_OF_SAMPLES*bytes_per_frame), infile);
449 flac__utils_printf(stderr, 1, "%s: ERROR during read\n", encoder_session.inbasefilename);
450 return EncoderSession_finish_error(&encoder_session);
452 else if(feof(infile)) {
453 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);
458 if(bytes_read % bytes_per_frame != 0U) {
459 flac__utils_printf(stderr, 1, "%s: ERROR: got partial sample\n", encoder_session.inbasefilename);
460 return EncoderSession_finish_error(&encoder_session);
463 unsigned int frames= bytes_read/bytes_per_frame;
464 if(!format_input(input_, frames, is_big_endian_pcm, /*is_unsigned_samples=*/false, channels, bps, shift, channel_map))
465 return EncoderSession_finish_error(&encoder_session);
467 if(!EncoderSession_process(&encoder_session, (const FLAC__int32 *const *)input_, frames)) {
468 print_error_with_state(&encoder_session, "ERROR during encoding");
469 return EncoderSession_finish_error(&encoder_session);
472 data_bytes-= bytes_read;
478 FLAC__ASSERT(!options.common.sector_align);
479 if(!fskip_ahead(infile, trim*bytes_per_frame)) {
480 flac__utils_printf(stderr, 1, "%s: ERROR during read while skipping samples\n", encoder_session.inbasefilename);
481 return EncoderSession_finish_error(&encoder_session);
485 /* now read unaligned samples into reservoir or pad with zeroes if necessary */
486 if(options.common.sector_align) {
487 if(options.common.is_last_file) {
488 unsigned int pad_frames= 588U-align_remainder;
490 if(pad_frames<588U) {
493 info_align_zero= pad_frames;
494 for(i= 0U; i<channels; ++i)
495 memset(input_[i], 0, sizeof(input_[0][0])*pad_frames);
497 if(!EncoderSession_process(&encoder_session, (const FLAC__int32 *const *)input_, pad_frames)) {
498 print_error_with_state(&encoder_session, "ERROR during encoding");
499 return EncoderSession_finish_error(&encoder_session);
504 if(*options.common.align_reservoir_samples > 0) {
505 size_t bytes_read= fread(ucbuffer_, 1U, (*options.common.align_reservoir_samples)*bytes_per_frame, infile);
507 FLAC__ASSERT(CHUNK_OF_SAMPLES>=588U);
508 if(bytes_read==0U && ferror(infile)) {
509 flac__utils_printf(stderr, 1, "%s: ERROR during read\n", encoder_session.inbasefilename);
510 return EncoderSession_finish_error(&encoder_session);
512 else if(bytes_read != (*options.common.align_reservoir_samples) * bytes_per_frame) {
513 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);
516 info_align_carry= *options.common.align_reservoir_samples;
517 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))
518 return EncoderSession_finish_error(&encoder_session);
527 if(fread(&tmp, 1U, 1U, infile)<1U) {
528 flac__utils_printf(stderr, 1, "%s: ERROR during read of SSND pad byte\n", encoder_session.inbasefilename);
529 return EncoderSession_finish_error(&encoder_session);
533 got_ssnd_chunk= true;
535 else { /* other chunk */
536 if(!memcmp(chunk_id, "COMM", 4)) {
537 flac__utils_printf(stderr, 1, "%s: WARNING: skipping extra 'COMM' chunk\n", encoder_session.inbasefilename);
539 else if(!memcmp(chunk_id, "SSND", 4)) {
540 flac__utils_printf(stderr, 1, "%s: WARNING: skipping extra 'SSND' chunk\n", encoder_session.inbasefilename);
543 flac__utils_printf(stderr, 1, "%s: WARNING: skipping unknown chunk '%s'\n", encoder_session.inbasefilename, chunk_id);
547 if(!read_big_endian_uint32(infile, &xx, false, encoder_session.inbasefilename))
548 return EncoderSession_finish_error(&encoder_session);
550 unsigned long skip= xx+(xx & 1U);
552 FLAC__ASSERT(skip<=LONG_MAX);
553 if(!fskip_ahead(infile, skip)) {
554 fprintf(stderr, "%s: ERROR during read while skipping unknown chunk\n", encoder_session.inbasefilename);
555 return EncoderSession_finish_error(&encoder_session);
561 if(got_ssnd_chunk==false && sample_frames!=0U) {
562 flac__utils_printf(stderr, 1, "%s: ERROR: missing SSND chunk\n", encoder_session.inbasefilename);
563 return EncoderSession_finish_error(&encoder_session);
566 return EncoderSession_finish_ok(&encoder_session, info_align_carry, info_align_zero);
569 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)
571 EncoderSession encoder_session;
572 FLAC__bool is_unsigned_samples = false;
573 unsigned channels = 0, bps = 0, sample_rate = 0, shift = 0;
574 size_t bytes_per_wide_sample, bytes_read;
575 size_t channel_map[FLAC__MAX_CHANNELS];
576 FLAC__uint16 x, format; /* format is the wFormatTag word from the 'fmt ' chunk */
577 FLAC__uint32 xx, channel_mask = 0;
578 FLAC__bool got_fmt_chunk = false, got_data_chunk = false;
579 unsigned align_remainder = 0;
580 int info_align_carry = -1, info_align_zero = -1;
584 (void)lookahead_length;
587 EncoderSession_construct(
590 options.common.use_ogg,
594 options.common.verify,
595 options.common.continue_through_decode_errors,
603 /* initialize default channel map that preserves channel order */
606 for(i = 0; i < sizeof(channel_map)/sizeof(channel_map[0]); i++)
611 * lookahead[] already has "RIFFxxxxWAVE", do sub-chunks
613 while(!feof(infile)) {
614 if(!read_little_endian_uint32(infile, &xx, true, encoder_session.inbasefilename))
615 return EncoderSession_finish_error(&encoder_session);
618 if(xx == 0x20746d66 && !got_fmt_chunk) { /* "fmt " */
619 unsigned block_align, data_bytes;
622 * http://www-mmsp.ece.mcgill.ca/Documents/AudioFormats/WAVE/WAVE.html
623 * http://windowssdk.msdn.microsoft.com/en-us/library/ms713497.aspx
624 * 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
627 * 4 byte: subchunk size
628 * 2 byte: format type: 1 for WAVE_FORMAT_PCM, 65534 for WAVE_FORMAT_EXTENSIBLE
630 * 4 byte: sample rate (Hz)
631 * 4 byte: avg bytes per sec
632 * 2 byte: block align
633 * 2 byte: bits per sample (not necessarily all significant)
635 * 2 byte: extension size in bytes (usually 0 for WAVEFORMATEX and 22 for WAVEFORMATEXTENSIBLE with PCM)
636 * WAVEFORMATEXTENSIBLE adds
637 * 2 byte: valid bits per sample
638 * 4 byte: channel mask
639 * 16 byte: subformat GUID, first 2 bytes have format type, 1 being PCM
641 * Current spec says WAVEFORMATEX with PCM must have bps == 8 or 16, or any multiple of 8 for WAVEFORMATEXTENSIBLE.
642 * 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.
644 * Block align for WAVE_FORMAT_PCM or WAVE_FORMAT_EXTENSIBLE is also supposed to be channels*bps/8
646 * If the channel mask has more set bits than # of channels, the extra MSBs are ignored.
647 * If the channel mask has less set bits than # of channels, the extra channels are unassigned to any speaker.
649 * Data is supposed to be unsigned for bps <= 8 else signed.
652 /* fmt sub-chunk size */
653 if(!read_little_endian_uint32(infile, &xx, false, encoder_session.inbasefilename))
654 return EncoderSession_finish_error(&encoder_session);
656 if(data_bytes < 16) {
657 flac__utils_printf(stderr, 1, "%s: ERROR: found non-standard 'fmt ' sub-chunk which has length = %u\n", encoder_session.inbasefilename, data_bytes);
658 return EncoderSession_finish_error(&encoder_session);
661 if(!read_little_endian_uint16(infile, &format, false, encoder_session.inbasefilename))
662 return EncoderSession_finish_error(&encoder_session);
663 if(format != 1 /*WAVE_FORMAT_PCM*/ && format != 65534 /*WAVE_FORMAT_EXTENSIBLE*/) {
664 flac__utils_printf(stderr, 1, "%s: ERROR: unsupported format type %u\n", encoder_session.inbasefilename, (unsigned)format);
665 return EncoderSession_finish_error(&encoder_session);
667 /* number of channels */
668 if(!read_little_endian_uint16(infile, &x, false, encoder_session.inbasefilename))
669 return EncoderSession_finish_error(&encoder_session);
670 channels = (unsigned)x;
671 if(channels == 0 || channels > FLAC__MAX_CHANNELS) {
672 flac__utils_printf(stderr, 1, "%s: ERROR: unsupported number of channels %u\n", encoder_session.inbasefilename, channels);
673 return EncoderSession_finish_error(&encoder_session);
675 else if(options.common.sector_align && channels != 2) {
676 flac__utils_printf(stderr, 1, "%s: ERROR: file has %u channels, must be 2 for --sector-align\n", encoder_session.inbasefilename, channels);
677 return EncoderSession_finish_error(&encoder_session);
680 if(!read_little_endian_uint32(infile, &xx, false, encoder_session.inbasefilename))
681 return EncoderSession_finish_error(&encoder_session);
683 if(!FLAC__format_sample_rate_is_valid(sample_rate)) {
684 flac__utils_printf(stderr, 1, "%s: ERROR: unsupported sample rate %u\n", encoder_session.inbasefilename, sample_rate);
685 return EncoderSession_finish_error(&encoder_session);
687 else if(options.common.sector_align && sample_rate != 44100) {
688 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);
689 return EncoderSession_finish_error(&encoder_session);
691 /* avg bytes per second (ignored) */
692 if(!read_little_endian_uint32(infile, &xx, false, encoder_session.inbasefilename))
693 return EncoderSession_finish_error(&encoder_session);
695 if(!read_little_endian_uint16(infile, &x, false, encoder_session.inbasefilename))
696 return EncoderSession_finish_error(&encoder_session);
697 block_align = (unsigned)x;
698 /* bits per sample */
699 if(!read_little_endian_uint16(infile, &x, false, encoder_session.inbasefilename))
700 return EncoderSession_finish_error(&encoder_session);
702 is_unsigned_samples = (bps <= 8);
704 if(bps != 8 && bps != 16) {
705 if(bps == 24 || bps == 32) {
706 /* let these slide with a warning since they're unambiguous */
707 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);
710 /* @@@ we could add an option to specify left- or right-justified blocks so we knew how to set 'shift' */
711 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);
712 return EncoderSession_finish_error(&encoder_session);
715 #if 0 /* @@@ reinstate once we can get an answer about whether the samples are left- or right-justified */
716 if((bps+7)/8 * channels == block_align) {
718 /* assume legacy file is byte aligned with some LSBs zero; this is double-checked in format_input() */
719 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);
720 shift = 8 - (bps % 8);
727 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);
728 return EncoderSession_finish_error(&encoder_session);
733 if(channels > 2 && !options.common.channel_map_none) {
734 flac__utils_printf(stderr, 1, "%s: ERROR: WAVE has >2 channels but is not WAVE_FORMAT_EXTENSIBLE; cannot assign channels\n", encoder_session.inbasefilename);
735 return EncoderSession_finish_error(&encoder_session);
737 FLAC__ASSERT(data_bytes >= 16);
741 if(data_bytes < 40) {
742 flac__utils_printf(stderr, 1, "%s: ERROR: invalid WAVEFORMATEXTENSIBLE chunk with size %u\n", encoder_session.inbasefilename, data_bytes);
743 return EncoderSession_finish_error(&encoder_session);
746 if(!read_little_endian_uint16(infile, &x, false, encoder_session.inbasefilename))
747 return EncoderSession_finish_error(&encoder_session);
749 flac__utils_printf(stderr, 1, "%s: ERROR: invalid WAVEFORMATEXTENSIBLE chunk with cbSize %u\n", encoder_session.inbasefilename, (unsigned)x);
750 return EncoderSession_finish_error(&encoder_session);
753 if(!read_little_endian_uint16(infile, &x, false, encoder_session.inbasefilename))
754 return EncoderSession_finish_error(&encoder_session);
755 if((unsigned)x > bps) {
756 flac__utils_printf(stderr, 1, "%s: ERROR: invalid WAVEFORMATEXTENSIBLE chunk with wValidBitsPerSample (%u) > wBitsPerSample (%u)\n", encoder_session.inbasefilename, (unsigned)x, bps);
757 return EncoderSession_finish_error(&encoder_session);
759 shift = bps - (unsigned)x;
761 if(!read_little_endian_uint32(infile, &channel_mask, false, encoder_session.inbasefilename))
762 return EncoderSession_finish_error(&encoder_session);
763 /* for mono/stereo and unassigned channels, we fake the mask */
764 if(channel_mask == 0) {
766 channel_mask = 0x0001;
767 else if(channels == 2)
768 channel_mask = 0x0003;
770 /* set channel mapping */
771 /* FLAC order follows SMPTE and WAVEFORMATEXTENSIBLE but with fewer channels, which are: */
772 /* front left, front right, center, LFE, back left, back right, surround left, surround right */
773 /* the default mapping is sufficient for 1-6 channels and 7-8 are currently unspecified anyway */
775 /* @@@ example for dolby/vorbis order, for reference later in case it becomes important */
777 options.common.channel_map_none ||
778 channel_mask == 0x0001 || /* 1 channel: (mono) */
779 channel_mask == 0x0003 || /* 2 channels: front left, front right */
780 channel_mask == 0x0033 || /* 4 channels: front left, front right, back left, back right */
781 channel_mask == 0x0603 /* 4 channels: front left, front right, side left, side right */
783 /* keep default channel order */
786 channel_mask == 0x0007 || /* 3 channels: front left, front right, front center */
787 channel_mask == 0x0037 || /* 5 channels: front left, front right, front center, back left, back right */
788 channel_mask == 0x0607 /* 5 channels: front left, front right, front center, side left, side right */
790 /* to dolby order: front left, center, front right [, surround left, surround right ] */
795 channel_mask == 0x003f || /* 6 channels: front left, front right, front center, LFE, back left, back right */
796 channel_mask == 0x060f /* 6 channels: front left, front right, front center, LFE, side left, side right */
798 /* to dolby order: front left, center, front right, surround left, surround right, LFE */
807 options.common.channel_map_none ||
808 channel_mask == 0x0001 || /* 1 channel: (mono) */
809 channel_mask == 0x0003 || /* 2 channels: front left, front right */
810 channel_mask == 0x0007 || /* 3 channels: front left, front right, front center */
811 channel_mask == 0x0033 || /* 4 channels: front left, front right, back left, back right */
812 channel_mask == 0x0603 || /* 4 channels: front left, front right, side left, side right */
813 channel_mask == 0x0037 || /* 5 channels: front left, front right, front center, back left, back right */
814 channel_mask == 0x0607 || /* 5 channels: front left, front right, front center, side left, side right */
815 channel_mask == 0x003f || /* 6 channels: front left, front right, front center, LFE, back left, back right */
816 channel_mask == 0x060f /* 6 channels: front left, front right, front center, LFE, side left, side right */
818 /* keep default channel order */
822 flac__utils_printf(stderr, 1, "%s: ERROR: WAVEFORMATEXTENSIBLE chunk with unsupported channel mask=0x%04X\n", encoder_session.inbasefilename, (unsigned)channel_mask);
823 return EncoderSession_finish_error(&encoder_session);
825 if(!options.common.channel_map_none) {
826 if(count_channel_mask_bits(channel_mask) < channels) {
827 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);
828 return EncoderSession_finish_error(&encoder_session);
831 /* supporting this is too difficult with channel mapping; e.g. what if mask is 0x003f but #channels=4?
832 * there would be holes in the order that would have to be filled in, or the mask would have to be
833 * limited and the logic above rerun to see if it still fits into the FLAC mapping.
835 else if(count_channel_mask_bits(channel_mask) > channels)
836 channel_mask = limit_channel_mask(channel_mask, channels);
838 else if(count_channel_mask_bits(channel_mask) > channels) {
839 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);
840 return EncoderSession_finish_error(&encoder_session);
844 /* first part of GUID */
845 if(!read_little_endian_uint16(infile, &x, false, encoder_session.inbasefilename))
846 return EncoderSession_finish_error(&encoder_session);
848 flac__utils_printf(stderr, 1, "%s: ERROR: unsupported WAVEFORMATEXTENSIBLE chunk with non-PCM format %u\n", encoder_session.inbasefilename, (unsigned)x);
849 return EncoderSession_finish_error(&encoder_session);
854 if(bps-shift < 4 || bps-shift > 24) {
855 flac__utils_printf(stderr, 1, "%s: ERROR: unsupported bits-per-sample %u\n", encoder_session.inbasefilename, bps-shift);
856 return EncoderSession_finish_error(&encoder_session);
858 else if(options.common.sector_align && bps-shift != 16) {
859 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);
860 return EncoderSession_finish_error(&encoder_session);
863 /* skip any extra data in the fmt sub-chunk */
864 if(!fskip_ahead(infile, data_bytes)) {
865 flac__utils_printf(stderr, 1, "%s: ERROR during read while skipping extra 'fmt' data\n", encoder_session.inbasefilename);
866 return EncoderSession_finish_error(&encoder_session);
870 * now that we know the sample rate, canonicalize the
871 * --skip string to a number of samples:
873 flac__utils_canonicalize_skip_until_specification(&options.common.skip_specification, sample_rate);
874 FLAC__ASSERT(options.common.skip_specification.value.samples >= 0);
875 encoder_session.skip = (FLAC__uint64)options.common.skip_specification.value.samples;
876 FLAC__ASSERT(!options.common.sector_align || encoder_session.skip == 0);
878 got_fmt_chunk = true;
880 else if(xx == 0x61746164 && !got_data_chunk && got_fmt_chunk) { /* "data" */
881 FLAC__uint64 total_samples_in_input, trim = 0;
882 FLAC__bool pad = false;
886 if(!read_little_endian_uint32(infile, &xx, false, encoder_session.inbasefilename))
887 return EncoderSession_finish_error(&encoder_session);
889 if(0 == data_bytes) {
890 flac__utils_printf(stderr, 1, "%s: ERROR: 'data' subchunk has size of 0\n", encoder_session.inbasefilename);
891 return EncoderSession_finish_error(&encoder_session);
893 pad = (data_bytes & 1U) ? true : false;
895 bytes_per_wide_sample = channels * (bps >> 3);
897 /* *options.common.align_reservoir_samples will be 0 unless --sector-align is used */
898 FLAC__ASSERT(options.common.sector_align || *options.common.align_reservoir_samples == 0);
899 total_samples_in_input = data_bytes / bytes_per_wide_sample + *options.common.align_reservoir_samples;
902 * now that we know the input size, canonicalize the
903 * --until string to an absolute sample number:
905 if(!canonicalize_until_specification(&options.common.until_specification, encoder_session.inbasefilename, sample_rate, encoder_session.skip, total_samples_in_input))
906 return EncoderSession_finish_error(&encoder_session);
907 encoder_session.until = (FLAC__uint64)options.common.until_specification.value.samples;
908 FLAC__ASSERT(!options.common.sector_align || encoder_session.until == 0);
910 if(encoder_session.skip > 0) {
911 if(!fskip_ahead(infile, encoder_session.skip * bytes_per_wide_sample)) {
912 flac__utils_printf(stderr, 1, "%s: ERROR during read while skipping samples\n", encoder_session.inbasefilename);
913 return EncoderSession_finish_error(&encoder_session);
917 data_bytes -= (unsigned)encoder_session.skip * bytes_per_wide_sample; /*@@@ WATCHOUT: 4GB limit */
918 encoder_session.total_samples_to_encode = total_samples_in_input - encoder_session.skip;
919 if(encoder_session.until > 0) {
920 trim = total_samples_in_input - encoder_session.until;
921 FLAC__ASSERT(total_samples_in_input > 0);
922 FLAC__ASSERT(!options.common.sector_align);
923 data_bytes -= (unsigned int)trim * bytes_per_wide_sample;
924 encoder_session.total_samples_to_encode -= trim;
926 if(options.common.sector_align) {
927 align_remainder = (unsigned)(encoder_session.total_samples_to_encode % 588);
928 if(options.common.is_last_file)
929 encoder_session.total_samples_to_encode += (588-align_remainder); /* will pad with zeroes */
931 encoder_session.total_samples_to_encode -= align_remainder; /* will stop short and carry over to next file */
934 /* +44 for the size of the WAV headers; this is just an estimate for the progress indicator and doesn't need to be exact */
935 encoder_session.unencoded_size = encoder_session.total_samples_to_encode * bytes_per_wide_sample + 44;
937 if(!EncoderSession_init_encoder(&encoder_session, options.common, channel_mask, channels, bps-shift, sample_rate, /*flac_decoder_data=*/0))
938 return EncoderSession_finish_error(&encoder_session);
941 * first do any samples in the reservoir
943 if(options.common.sector_align && *options.common.align_reservoir_samples > 0) {
944 if(!EncoderSession_process(&encoder_session, (const FLAC__int32 * const *)options.common.align_reservoir, *options.common.align_reservoir_samples)) {
945 print_error_with_state(&encoder_session, "ERROR during encoding");
946 return EncoderSession_finish_error(&encoder_session);
951 * decrement the data_bytes counter if we need to align the file
953 if(options.common.sector_align) {
954 if(options.common.is_last_file) {
955 *options.common.align_reservoir_samples = 0;
958 *options.common.align_reservoir_samples = align_remainder;
959 data_bytes -= (*options.common.align_reservoir_samples) * bytes_per_wide_sample;
964 * now do from the file
966 while(data_bytes > 0) {
967 bytes_read = fread(ucbuffer_, sizeof(unsigned char), min(data_bytes, CHUNK_OF_SAMPLES * bytes_per_wide_sample), infile);
968 if(bytes_read == 0) {
970 flac__utils_printf(stderr, 1, "%s: ERROR during read\n", encoder_session.inbasefilename);
971 return EncoderSession_finish_error(&encoder_session);
973 else if(feof(infile)) {
974 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);
979 if(bytes_read % bytes_per_wide_sample != 0) {
980 flac__utils_printf(stderr, 1, "%s: ERROR: got partial sample\n", encoder_session.inbasefilename);
981 return EncoderSession_finish_error(&encoder_session);
984 unsigned wide_samples = bytes_read / bytes_per_wide_sample;
985 if(!format_input(input_, wide_samples, /*is_big_endian=*/false, is_unsigned_samples, channels, bps, shift, channel_map))
986 return EncoderSession_finish_error(&encoder_session);
988 if(!EncoderSession_process(&encoder_session, (const FLAC__int32 * const *)input_, wide_samples)) {
989 print_error_with_state(&encoder_session, "ERROR during encoding");
990 return EncoderSession_finish_error(&encoder_session);
992 data_bytes -= bytes_read;
998 FLAC__ASSERT(!options.common.sector_align);
999 if(!fskip_ahead(infile, trim * bytes_per_wide_sample)) {
1000 flac__utils_printf(stderr, 1, "%s: ERROR during read while skipping samples\n", encoder_session.inbasefilename);
1001 return EncoderSession_finish_error(&encoder_session);
1006 * now read unaligned samples into reservoir or pad with zeroes if necessary
1008 if(options.common.sector_align) {
1009 if(options.common.is_last_file) {
1010 unsigned wide_samples = 588 - align_remainder;
1011 if(wide_samples < 588) {
1014 info_align_zero = wide_samples;
1015 for(channel = 0; channel < channels; channel++)
1016 memset(input_[channel], 0, sizeof(input_[0][0]) * wide_samples);
1018 if(!EncoderSession_process(&encoder_session, (const FLAC__int32 * const *)input_, wide_samples)) {
1019 print_error_with_state(&encoder_session, "ERROR during encoding");
1020 return EncoderSession_finish_error(&encoder_session);
1025 if(*options.common.align_reservoir_samples > 0) {
1026 FLAC__ASSERT(CHUNK_OF_SAMPLES >= 588);
1027 bytes_read = fread(ucbuffer_, sizeof(unsigned char), (*options.common.align_reservoir_samples) * bytes_per_wide_sample, infile);
1028 if(bytes_read == 0 && ferror(infile)) {
1029 flac__utils_printf(stderr, 1, "%s: ERROR during read\n", encoder_session.inbasefilename);
1030 return EncoderSession_finish_error(&encoder_session);
1032 else if(bytes_read != (*options.common.align_reservoir_samples) * bytes_per_wide_sample) {
1033 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);
1036 info_align_carry = *options.common.align_reservoir_samples;
1037 if(!format_input(options.common.align_reservoir, *options.common.align_reservoir_samples, /*is_big_endian=*/false, is_unsigned_samples, channels, bps, shift, channel_map))
1038 return EncoderSession_finish_error(&encoder_session);
1047 if(fread(&tmp, 1U, 1U, infile) < 1U) {
1048 flac__utils_printf(stderr, 1, "%s: ERROR during read of data pad byte\n", encoder_session.inbasefilename);
1049 return EncoderSession_finish_error(&encoder_session);
1053 got_data_chunk = true;
1056 if(xx == 0x20746d66 && got_fmt_chunk) { /* "fmt " */
1057 flac__utils_printf(stderr, 1, "%s: WARNING: skipping extra 'fmt ' sub-chunk\n", encoder_session.inbasefilename);
1059 else if(xx == 0x61746164) { /* "data" */
1060 if(got_data_chunk) {
1061 flac__utils_printf(stderr, 1, "%s: WARNING: skipping extra 'data' sub-chunk\n", encoder_session.inbasefilename);
1063 else if(!got_fmt_chunk) {
1064 flac__utils_printf(stderr, 1, "%s: ERROR: got 'data' sub-chunk before 'fmt' sub-chunk\n", encoder_session.inbasefilename);
1065 return EncoderSession_finish_error(&encoder_session);
1072 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));
1074 /* sub-chunk size */
1075 if(!read_little_endian_uint32(infile, &xx, false, encoder_session.inbasefilename))
1076 return EncoderSession_finish_error(&encoder_session);
1078 unsigned long skip = xx+(xx & 1U);
1080 FLAC__ASSERT(skip<=LONG_MAX);
1081 if(!fskip_ahead(infile, skip)) {
1082 flac__utils_printf(stderr, 1, "%s: ERROR during read while skipping unsupported sub-chunk\n", encoder_session.inbasefilename);
1083 return EncoderSession_finish_error(&encoder_session);
1089 return EncoderSession_finish_ok(&encoder_session, info_align_carry, info_align_zero);
1092 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)
1094 EncoderSession encoder_session;
1096 const size_t bytes_per_wide_sample = options.channels * (options.bps >> 3);
1097 unsigned align_remainder = 0;
1098 int info_align_carry = -1, info_align_zero = -1;
1099 FLAC__uint64 total_samples_in_input = 0;
1101 FLAC__ASSERT(!options.common.sector_align || options.channels == 2);
1102 FLAC__ASSERT(!options.common.sector_align || options.bps == 16);
1103 FLAC__ASSERT(!options.common.sector_align || options.sample_rate == 44100);
1104 FLAC__ASSERT(!options.common.sector_align || infilesize >= 0);
1105 FLAC__ASSERT(!options.common.replay_gain || options.channels <= 2);
1106 FLAC__ASSERT(!options.common.replay_gain || grabbag__replaygain_is_valid_sample_frequency(options.sample_rate));
1109 EncoderSession_construct(
1112 options.common.use_ogg,
1116 options.common.verify,
1117 options.common.continue_through_decode_errors,
1126 * now that we know the sample rate, canonicalize the
1127 * --skip string to a number of samples:
1129 flac__utils_canonicalize_skip_until_specification(&options.common.skip_specification, options.sample_rate);
1130 FLAC__ASSERT(options.common.skip_specification.value.samples >= 0);
1131 encoder_session.skip = (FLAC__uint64)options.common.skip_specification.value.samples;
1132 FLAC__ASSERT(!options.common.sector_align || encoder_session.skip == 0);
1135 total_samples_in_input = 0;
1137 /* *options.common.align_reservoir_samples will be 0 unless --sector-align is used */
1138 FLAC__ASSERT(options.common.sector_align || *options.common.align_reservoir_samples == 0);
1139 total_samples_in_input = (FLAC__uint64)infilesize / bytes_per_wide_sample + *options.common.align_reservoir_samples;
1143 * now that we know the input size, canonicalize the
1144 * --until strings to a number of samples:
1146 if(!canonicalize_until_specification(&options.common.until_specification, encoder_session.inbasefilename, options.sample_rate, encoder_session.skip, total_samples_in_input))
1147 return EncoderSession_finish_error(&encoder_session);
1148 encoder_session.until = (FLAC__uint64)options.common.until_specification.value.samples;
1149 FLAC__ASSERT(!options.common.sector_align || encoder_session.until == 0);
1151 infilesize -= (off_t)encoder_session.skip * bytes_per_wide_sample;
1152 encoder_session.total_samples_to_encode = total_samples_in_input - encoder_session.skip;
1153 if(encoder_session.until > 0) {
1154 const FLAC__uint64 trim = total_samples_in_input - encoder_session.until;
1155 FLAC__ASSERT(total_samples_in_input > 0);
1156 FLAC__ASSERT(!options.common.sector_align);
1157 infilesize -= (off_t)trim * bytes_per_wide_sample;
1158 encoder_session.total_samples_to_encode -= trim;
1160 if(infilesize >= 0 && options.common.sector_align) {
1161 FLAC__ASSERT(encoder_session.skip == 0);
1162 align_remainder = (unsigned)(encoder_session.total_samples_to_encode % 588);
1163 if(options.common.is_last_file)
1164 encoder_session.total_samples_to_encode += (588-align_remainder); /* will pad with zeroes */
1166 encoder_session.total_samples_to_encode -= align_remainder; /* will stop short and carry over to next file */
1168 encoder_session.unencoded_size = encoder_session.total_samples_to_encode * bytes_per_wide_sample;
1170 if(encoder_session.total_samples_to_encode <= 0)
1171 flac__utils_printf(stderr, 2, "(No runtime statistics possible; please wait for encoding to finish...)\n");
1173 if(encoder_session.skip > 0) {
1174 unsigned skip_bytes = bytes_per_wide_sample * (unsigned)encoder_session.skip;
1175 if(skip_bytes > lookahead_length) {
1176 skip_bytes -= lookahead_length;
1177 lookahead_length = 0;
1178 if(!fskip_ahead(infile, skip_bytes)) {
1179 flac__utils_printf(stderr, 1, "%s: ERROR during read while skipping samples\n", encoder_session.inbasefilename);
1180 return EncoderSession_finish_error(&encoder_session);
1184 lookahead += skip_bytes;
1185 lookahead_length -= skip_bytes;
1189 if(!EncoderSession_init_encoder(&encoder_session, options.common, /*channel_mask=*/0, options.channels, options.bps, options.sample_rate, /*flac_decoder_data=*/0))
1190 return EncoderSession_finish_error(&encoder_session);
1193 * first do any samples in the reservoir
1195 if(options.common.sector_align && *options.common.align_reservoir_samples > 0) {
1196 if(!EncoderSession_process(&encoder_session, (const FLAC__int32 * const *)options.common.align_reservoir, *options.common.align_reservoir_samples)) {
1197 print_error_with_state(&encoder_session, "ERROR during encoding");
1198 return EncoderSession_finish_error(&encoder_session);
1203 * decrement infilesize if we need to align the file
1205 if(options.common.sector_align) {
1206 FLAC__ASSERT(infilesize >= 0);
1207 if(options.common.is_last_file) {
1208 *options.common.align_reservoir_samples = 0;
1211 *options.common.align_reservoir_samples = align_remainder;
1212 infilesize -= (off_t)((*options.common.align_reservoir_samples) * bytes_per_wide_sample);
1213 FLAC__ASSERT(infilesize >= 0);
1218 * now do from the file
1220 if(infilesize < 0) {
1221 while(!feof(infile)) {
1222 if(lookahead_length > 0) {
1223 FLAC__ASSERT(lookahead_length < CHUNK_OF_SAMPLES * bytes_per_wide_sample);
1224 memcpy(ucbuffer_, lookahead, lookahead_length);
1225 bytes_read = fread(ucbuffer_+lookahead_length, sizeof(unsigned char), CHUNK_OF_SAMPLES * bytes_per_wide_sample - lookahead_length, infile) + lookahead_length;
1226 if(ferror(infile)) {
1227 flac__utils_printf(stderr, 1, "%s: ERROR during read\n", encoder_session.inbasefilename);
1228 return EncoderSession_finish_error(&encoder_session);
1230 lookahead_length = 0;
1233 bytes_read = fread(ucbuffer_, sizeof(unsigned char), CHUNK_OF_SAMPLES * bytes_per_wide_sample, infile);
1235 if(bytes_read == 0) {
1236 if(ferror(infile)) {
1237 flac__utils_printf(stderr, 1, "%s: ERROR during read\n", encoder_session.inbasefilename);
1238 return EncoderSession_finish_error(&encoder_session);
1241 else if(bytes_read % bytes_per_wide_sample != 0) {
1242 flac__utils_printf(stderr, 1, "%s: ERROR: got partial sample\n", encoder_session.inbasefilename);
1243 return EncoderSession_finish_error(&encoder_session);
1246 unsigned wide_samples = bytes_read / bytes_per_wide_sample;
1247 if(!format_input(input_, wide_samples, options.is_big_endian, options.is_unsigned_samples, options.channels, options.bps, /*shift=*/0, /*channel_map=*/0))
1248 return EncoderSession_finish_error(&encoder_session);
1250 if(!EncoderSession_process(&encoder_session, (const FLAC__int32 * const *)input_, wide_samples)) {
1251 print_error_with_state(&encoder_session, "ERROR during encoding");
1252 return EncoderSession_finish_error(&encoder_session);
1258 const FLAC__uint64 max_input_bytes = infilesize;
1259 FLAC__uint64 total_input_bytes_read = 0;
1260 while(total_input_bytes_read < max_input_bytes) {
1262 size_t wanted = (CHUNK_OF_SAMPLES * bytes_per_wide_sample);
1263 wanted = (size_t) min((FLAC__uint64)wanted, max_input_bytes - total_input_bytes_read);
1265 if(lookahead_length > 0) {
1266 FLAC__ASSERT(lookahead_length <= wanted);
1267 memcpy(ucbuffer_, lookahead, lookahead_length);
1268 wanted -= lookahead_length;
1269 bytes_read = lookahead_length;
1271 bytes_read += fread(ucbuffer_+lookahead_length, sizeof(unsigned char), wanted, infile);
1272 if(ferror(infile)) {
1273 flac__utils_printf(stderr, 1, "%s: ERROR during read\n", encoder_session.inbasefilename);
1274 return EncoderSession_finish_error(&encoder_session);
1277 lookahead_length = 0;
1280 bytes_read = fread(ucbuffer_, sizeof(unsigned char), wanted, infile);
1283 if(bytes_read == 0) {
1284 if(ferror(infile)) {
1285 flac__utils_printf(stderr, 1, "%s: ERROR during read\n", encoder_session.inbasefilename);
1286 return EncoderSession_finish_error(&encoder_session);
1288 else if(feof(infile)) {
1289 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);
1290 total_input_bytes_read = max_input_bytes;
1294 if(bytes_read % bytes_per_wide_sample != 0) {
1295 flac__utils_printf(stderr, 1, "%s: ERROR: got partial sample\n", encoder_session.inbasefilename);
1296 return EncoderSession_finish_error(&encoder_session);
1299 unsigned wide_samples = bytes_read / bytes_per_wide_sample;
1300 if(!format_input(input_, wide_samples, options.is_big_endian, options.is_unsigned_samples, options.channels, options.bps, /*shift=*/0, /*channel_map=*/0))
1301 return EncoderSession_finish_error(&encoder_session);
1303 if(!EncoderSession_process(&encoder_session, (const FLAC__int32 * const *)input_, wide_samples)) {
1304 print_error_with_state(&encoder_session, "ERROR during encoding");
1305 return EncoderSession_finish_error(&encoder_session);
1307 total_input_bytes_read += bytes_read;
1314 * now read unaligned samples into reservoir or pad with zeroes if necessary
1316 if(options.common.sector_align) {
1317 if(options.common.is_last_file) {
1318 unsigned wide_samples = 588 - align_remainder;
1319 if(wide_samples < 588) {
1322 info_align_zero = wide_samples;
1323 for(channel = 0; channel < options.channels; channel++)
1324 memset(input_[channel], 0, sizeof(input_[0][0]) * wide_samples);
1326 if(!EncoderSession_process(&encoder_session, (const FLAC__int32 * const *)input_, wide_samples)) {
1327 print_error_with_state(&encoder_session, "ERROR during encoding");
1328 return EncoderSession_finish_error(&encoder_session);
1333 if(*options.common.align_reservoir_samples > 0) {
1334 FLAC__ASSERT(CHUNK_OF_SAMPLES >= 588);
1335 bytes_read = fread(ucbuffer_, sizeof(unsigned char), (*options.common.align_reservoir_samples) * bytes_per_wide_sample, infile);
1336 if(bytes_read == 0 && ferror(infile)) {
1337 flac__utils_printf(stderr, 1, "%s: ERROR during read\n", encoder_session.inbasefilename);
1338 return EncoderSession_finish_error(&encoder_session);
1340 else if(bytes_read != (*options.common.align_reservoir_samples) * bytes_per_wide_sample) {
1341 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);
1344 info_align_carry = *options.common.align_reservoir_samples;
1345 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))
1346 return EncoderSession_finish_error(&encoder_session);
1352 return EncoderSession_finish_ok(&encoder_session, info_align_carry, info_align_zero);
1355 int flac__encode_flac(FILE *infile, off_t infilesize, const char *infilename, const char *outfilename, const FLAC__byte *lookahead, unsigned lookahead_length, flac_encode_options_t options, FLAC__bool input_is_ogg)
1357 EncoderSession encoder_session;
1358 FLAC__StreamDecoder *decoder = 0;
1359 FLACDecoderData decoder_data;
1364 EncoderSession_construct(
1367 options.common.use_ogg,
1371 options.common.verify,
1372 options.common.continue_through_decode_errors,
1380 decoder_data.encoder_session = &encoder_session;
1381 decoder_data.filesize = (infilesize == (off_t)(-1)? 0 : infilesize);
1382 decoder_data.lookahead = lookahead;
1383 decoder_data.lookahead_length = lookahead_length;
1384 decoder_data.num_metadata_blocks = 0;
1385 decoder_data.samples_left_to_process = 0;
1386 decoder_data.fatal_error = false;
1389 * set up FLAC decoder for the input
1391 if (0 == (decoder = FLAC__stream_decoder_new())) {
1392 flac__utils_printf(stderr, 1, "%s: ERROR: creating decoder for FLAC input\n", encoder_session.inbasefilename);
1393 return EncoderSession_finish_error(&encoder_session);
1396 FLAC__stream_decoder_set_md5_checking(decoder, false) &&
1397 FLAC__stream_decoder_set_metadata_respond_all(decoder)
1399 flac__utils_printf(stderr, 1, "%s: ERROR: setting up decoder for FLAC input\n", encoder_session.inbasefilename);
1400 goto fubar1; /*@@@ yuck */
1404 if (FLAC__stream_decoder_init_ogg_stream(decoder, flac_decoder_read_callback, flac_decoder_seek_callback, flac_decoder_tell_callback, flac_decoder_length_callback, flac_decoder_eof_callback, flac_decoder_write_callback, flac_decoder_metadata_callback, flac_decoder_error_callback, /*client_data=*/&decoder_data) != FLAC__STREAM_DECODER_INIT_STATUS_OK) {
1405 flac__utils_printf(stderr, 1, "%s: ERROR: initializing decoder for Ogg FLAC input, state = %s\n", encoder_session.inbasefilename, FLAC__stream_decoder_get_resolved_state_string(decoder));
1406 goto fubar1; /*@@@ yuck */
1409 else if (FLAC__stream_decoder_init_stream(decoder, flac_decoder_read_callback, flac_decoder_seek_callback, flac_decoder_tell_callback, flac_decoder_length_callback, flac_decoder_eof_callback, flac_decoder_write_callback, flac_decoder_metadata_callback, flac_decoder_error_callback, /*client_data=*/&decoder_data) != FLAC__STREAM_DECODER_INIT_STATUS_OK) {
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 /* We can also hit the end of stream without samples_left_to_process
1490 * going to 0 if there are errors and continue_through_decode_errors
1491 * is on, so we want to break in that case too:
1493 if(encoder_session.continue_through_decode_errors && FLAC__stream_decoder_get_state(decoder) == FLAC__STREAM_DECODER_END_OF_STREAM)
1495 if(!FLAC__stream_decoder_process_single(decoder)) {
1496 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));
1497 goto fubar2; /*@@@ yuck */
1500 if(decoder_data.fatal_error) {
1501 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));
1502 goto fubar2; /*@@@ yuck */
1506 FLAC__stream_decoder_delete(decoder);
1507 retval = EncoderSession_finish_ok(&encoder_session, -1, -1);
1508 /* have to wail until encoder is completely finished before deleting because of the final step of writing the seekpoint offsets */
1509 for(i = 0; i < decoder_data.num_metadata_blocks; i++)
1510 free(decoder_data.metadata_blocks[i]);
1514 for(i = 0; i < decoder_data.num_metadata_blocks; i++)
1515 free(decoder_data.metadata_blocks[i]);
1517 FLAC__stream_decoder_delete(decoder);
1518 return EncoderSession_finish_error(&encoder_session);
1521 FLAC__bool EncoderSession_construct(EncoderSession *e, FLAC__bool use_ogg, FLAC__bool verify, FLAC__bool continue_through_decode_errors, FILE *infile, const char *infilename, const char *outfilename)
1524 FLAC__uint32 test = 1;
1527 * initialize globals
1530 is_big_endian_host_ = (*((FLAC__byte*)(&test)))? false : true;
1532 for(i = 0; i < FLAC__MAX_CHANNELS; i++)
1533 input_[i] = &(in_[i][0]);
1537 * initialize instance
1541 e->use_ogg = use_ogg;
1546 e->continue_through_decode_errors = continue_through_decode_errors;
1548 e->is_stdout = (0 == strcmp(outfilename, "-"));
1549 e->outputfile_opened = false;
1551 e->inbasefilename = grabbag__file_get_basename(infilename);
1552 e->outfilename = outfilename;
1554 e->skip = 0; /* filled in later after the sample_rate is known */
1555 e->unencoded_size = 0;
1556 e->total_samples_to_encode = 0;
1557 e->bytes_written = 0;
1558 e->samples_written = 0;
1564 e->seek_table_template = 0;
1566 if(0 == (e->seek_table_template = FLAC__metadata_object_new(FLAC__METADATA_TYPE_SEEKTABLE))) {
1567 flac__utils_printf(stderr, 1, "%s: ERROR allocating memory for seek table\n", e->inbasefilename);
1571 e->encoder = FLAC__stream_encoder_new();
1572 if(0 == e->encoder) {
1573 flac__utils_printf(stderr, 1, "%s: ERROR creating the encoder instance\n", e->inbasefilename);
1574 EncoderSession_destroy(e);
1581 void EncoderSession_destroy(EncoderSession *e)
1586 if(0 != e->encoder) {
1587 FLAC__stream_encoder_delete(e->encoder);
1591 if(0 != e->seek_table_template) {
1592 FLAC__metadata_object_delete(e->seek_table_template);
1593 e->seek_table_template = 0;
1597 int EncoderSession_finish_ok(EncoderSession *e, int info_align_carry, int info_align_zero)
1599 FLAC__StreamEncoderState fse_state = FLAC__STREAM_ENCODER_OK;
1601 FLAC__bool verify_error = false;
1604 fse_state = FLAC__stream_encoder_get_state(e->encoder);
1605 ret = FLAC__stream_encoder_finish(e->encoder)? 0 : 1;
1607 fse_state == FLAC__STREAM_ENCODER_VERIFY_MISMATCH_IN_AUDIO_DATA ||
1608 FLAC__stream_encoder_get_state(e->encoder) == FLAC__STREAM_ENCODER_VERIFY_MISMATCH_IN_AUDIO_DATA
1611 /* all errors except verify errors should interrupt the stats */
1612 if(ret && !verify_error)
1613 print_error_with_state(e, "ERROR during encoding");
1614 else if(e->total_samples_to_encode > 0) {
1616 flac__utils_printf(stderr, 2, "\n");
1620 print_verify_error(e);
1624 if(info_align_carry >= 0) {
1625 flac__utils_printf(stderr, 1, "%s: INFO: sector alignment causing %d samples to be carried over\n", e->inbasefilename, info_align_carry);
1627 if(info_align_zero >= 0) {
1628 flac__utils_printf(stderr, 1, "%s: INFO: sector alignment causing %d zero samples to be appended\n", e->inbasefilename, info_align_zero);
1632 EncoderSession_destroy(e);
1637 int EncoderSession_finish_error(EncoderSession *e)
1639 FLAC__ASSERT(e->encoder);
1641 if(e->total_samples_to_encode > 0)
1642 flac__utils_printf(stderr, 2, "\n");
1644 if(FLAC__stream_encoder_get_state(e->encoder) == FLAC__STREAM_ENCODER_VERIFY_MISMATCH_IN_AUDIO_DATA)
1645 print_verify_error(e);
1646 else if(e->outputfile_opened)
1647 /* only want to delete the file if we opened it; otherwise it could be an existing file and our overwrite failed */
1648 unlink(e->outfilename);
1650 EncoderSession_destroy(e);
1655 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)
1657 unsigned num_metadata, i;
1658 FLAC__StreamMetadata padding, *cuesheet = 0;
1659 FLAC__StreamMetadata *static_metadata[4+64]; /* MAGIC +64 is for pictures metadata in options.pictures */
1660 FLAC__StreamMetadata **metadata = static_metadata;
1661 FLAC__StreamEncoderInitStatus init_status;
1662 const FLAC__bool is_cdda = (channels == 1 || channels == 2) && (bps == 16) && (sample_rate == 44100);
1663 char apodizations[2000];
1665 FLAC__ASSERT(sizeof(options.pictures)/sizeof(options.pictures[0]) <= 64);
1667 e->replay_gain = options.replay_gain;
1668 e->channels = channels;
1669 e->bits_per_sample = bps;
1670 e->sample_rate = sample_rate;
1672 apodizations[0] = '\0';
1674 if(e->replay_gain) {
1675 if(channels != 1 && channels != 2) {
1676 flac__utils_printf(stderr, 1, "%s: ERROR, number of channels (%u) must be 1 or 2 for --replay-gain\n", e->inbasefilename, channels);
1679 if(!grabbag__replaygain_is_valid_sample_frequency(sample_rate)) {
1680 flac__utils_printf(stderr, 1, "%s: ERROR, invalid sample rate (%u) for --replay-gain\n", e->inbasefilename, sample_rate);
1683 if(options.is_first_file) {
1684 if(!grabbag__replaygain_init(sample_rate)) {
1685 flac__utils_printf(stderr, 1, "%s: ERROR initializing ReplayGain stage\n", e->inbasefilename);
1691 if(!parse_cuesheet(&cuesheet, options.cuesheet_filename, e->inbasefilename, is_cdda, e->total_samples_to_encode))
1694 if(!convert_to_seek_table_template(options.requested_seek_points, options.num_requested_seek_points, options.cued_seekpoints? cuesheet : 0, e)) {
1695 flac__utils_printf(stderr, 1, "%s: ERROR allocating memory for seek table\n", e->inbasefilename);
1697 FLAC__metadata_object_delete(cuesheet);
1701 if(flac_decoder_data) {
1703 * we're encoding from FLAC so we will use the FLAC file's
1704 * metadata as the basic for the encoded file
1708 * first handle padding: if --no-padding was specified,
1709 * then delete all padding; else if -P was specified,
1710 * use that instead of existing padding (if any); else
1711 * if existing file has padding, move all existing
1712 * padding blocks to one padding block at the end; else
1713 * use default padding.
1717 for(i = 0, j = 0; i < flac_decoder_data->num_metadata_blocks; i++) {
1718 if(flac_decoder_data->metadata_blocks[i]->type == FLAC__METADATA_TYPE_PADDING) {
1721 p += flac_decoder_data->metadata_blocks[i]->length;
1722 FLAC__metadata_object_delete(flac_decoder_data->metadata_blocks[i]);
1723 flac_decoder_data->metadata_blocks[i] = 0;
1726 flac_decoder_data->metadata_blocks[j++] = flac_decoder_data->metadata_blocks[i];
1728 flac_decoder_data->num_metadata_blocks = j;
1729 if(options.padding > 0)
1730 p = options.padding;
1732 p = e->total_samples_to_encode / e->sample_rate < 20*60? FLAC_ENCODE__DEFAULT_PADDING : FLAC_ENCODE__DEFAULT_PADDING*8;
1733 if(options.padding != 0) {
1734 if(p > 0 && flac_decoder_data->num_metadata_blocks < sizeof(flac_decoder_data->metadata_blocks)/sizeof(flac_decoder_data->metadata_blocks[0])) {
1735 flac_decoder_data->metadata_blocks[flac_decoder_data->num_metadata_blocks] = FLAC__metadata_object_new(FLAC__METADATA_TYPE_PADDING);
1736 if(0 == flac_decoder_data->metadata_blocks[flac_decoder_data->num_metadata_blocks]) {
1737 flac__utils_printf(stderr, 1, "%s: ERROR allocating memory for PADDING block\n", e->inbasefilename);
1739 FLAC__metadata_object_delete(cuesheet);
1742 flac_decoder_data->metadata_blocks[flac_decoder_data->num_metadata_blocks]->is_last = false; /* the encoder will set this for us */
1743 flac_decoder_data->metadata_blocks[flac_decoder_data->num_metadata_blocks]->length = p;
1744 flac_decoder_data->num_metadata_blocks++;
1750 * next handle vorbis comment: if any tags were specified
1751 * or there is no existing vorbis comment, we create a
1752 * new vorbis comment (discarding any existing one); else
1753 * we keep the existing one. also need to make sure to
1754 * propagate any channel mask tag.
1757 FLAC__bool vc_found = false;
1758 for(i = 0, j = 0; i < flac_decoder_data->num_metadata_blocks; i++) {
1759 if(flac_decoder_data->metadata_blocks[i]->type == FLAC__METADATA_TYPE_VORBIS_COMMENT)
1761 if(flac_decoder_data->metadata_blocks[i]->type == FLAC__METADATA_TYPE_VORBIS_COMMENT && options.vorbis_comment->data.vorbis_comment.num_comments > 0) {
1762 (void) flac__utils_get_channel_mask_tag(flac_decoder_data->metadata_blocks[i], &channel_mask);
1763 flac__utils_printf(stderr, 1, "%s: WARNING, replacing tags from input FLAC file with those given on the command-line\n", e->inbasefilename);
1764 FLAC__metadata_object_delete(flac_decoder_data->metadata_blocks[i]);
1765 flac_decoder_data->metadata_blocks[i] = 0;
1768 flac_decoder_data->metadata_blocks[j++] = flac_decoder_data->metadata_blocks[i];
1770 flac_decoder_data->num_metadata_blocks = j;
1771 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])) {
1773 FLAC__StreamMetadata *vc = FLAC__metadata_object_clone(options.vorbis_comment);
1774 if(0 == vc || (channel_mask && !flac__utils_set_channel_mask_tag(vc, channel_mask))) {
1775 flac__utils_printf(stderr, 1, "%s: ERROR allocating memory for VORBIS_COMMENT block\n", e->inbasefilename);
1777 FLAC__metadata_object_delete(cuesheet);
1780 for(i = flac_decoder_data->num_metadata_blocks; i > 1; i--)
1781 flac_decoder_data->metadata_blocks[i] = flac_decoder_data->metadata_blocks[i-1];
1782 flac_decoder_data->metadata_blocks[1] = vc;
1783 flac_decoder_data->num_metadata_blocks++;
1788 * next handle cuesheet: if --cuesheet was specified, use
1789 * it; else if file has existing CUESHEET and cuesheet's
1790 * lead-out offset is correct, keep it; else no CUESHEET
1793 for(i = 0, j = 0; i < flac_decoder_data->num_metadata_blocks; i++) {
1794 FLAC__bool existing_cuesheet_is_bad = false;
1795 /* check if existing cuesheet matches the input audio */
1796 if(flac_decoder_data->metadata_blocks[i]->type == FLAC__METADATA_TYPE_CUESHEET && 0 == cuesheet) {
1797 const FLAC__StreamMetadata_CueSheet *cs = &flac_decoder_data->metadata_blocks[i]->data.cue_sheet;
1798 if(e->total_samples_to_encode == 0) {
1799 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);
1800 existing_cuesheet_is_bad = true;
1802 else if(e->total_samples_to_encode != cs->tracks[cs->num_tracks-1].offset) {
1803 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);
1804 existing_cuesheet_is_bad = true;
1807 if(flac_decoder_data->metadata_blocks[i]->type == FLAC__METADATA_TYPE_CUESHEET && (existing_cuesheet_is_bad || 0 != cuesheet)) {
1809 flac__utils_printf(stderr, 1, "%s: WARNING, replacing cuesheet in input FLAC file with the one given on the command-line\n", e->inbasefilename);
1810 FLAC__metadata_object_delete(flac_decoder_data->metadata_blocks[i]);
1811 flac_decoder_data->metadata_blocks[i] = 0;
1814 flac_decoder_data->metadata_blocks[j++] = flac_decoder_data->metadata_blocks[i];
1816 flac_decoder_data->num_metadata_blocks = j;
1817 if(0 != cuesheet && flac_decoder_data->num_metadata_blocks < sizeof(flac_decoder_data->metadata_blocks)/sizeof(flac_decoder_data->metadata_blocks[0])) {
1819 FLAC__StreamMetadata *cs = FLAC__metadata_object_clone(cuesheet);
1821 flac__utils_printf(stderr, 1, "%s: ERROR allocating memory for CUESHEET block\n", e->inbasefilename);
1823 FLAC__metadata_object_delete(cuesheet);
1826 for(i = flac_decoder_data->num_metadata_blocks; i > 1; i--)
1827 flac_decoder_data->metadata_blocks[i] = flac_decoder_data->metadata_blocks[i-1];
1828 flac_decoder_data->metadata_blocks[1] = cs;
1829 flac_decoder_data->num_metadata_blocks++;
1834 * finally handle seektable: if -S- was specified, no
1835 * SEEKTABLE; else if -S was specified, use it/them;
1836 * else if file has existing SEEKTABLE and input size is
1837 * preserved (no --skip/--until/etc specified), keep it;
1838 * else use default seektable options
1840 * note: meanings of num_requested_seek_points:
1841 * -1 : no -S option given, default to some value
1842 * 0 : -S- given (no seektable)
1843 * >0 : one or more -S options given
1846 FLAC__bool existing_seektable = false;
1847 for(i = 0, j = 0; i < flac_decoder_data->num_metadata_blocks; i++) {
1848 if(flac_decoder_data->metadata_blocks[i]->type == FLAC__METADATA_TYPE_SEEKTABLE)
1849 existing_seektable = true;
1850 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)) {
1851 if(options.num_requested_seek_points > 0)
1852 flac__utils_printf(stderr, 1, "%s: WARNING, replacing seektable in input FLAC file with the one given on the command-line\n", e->inbasefilename);
1853 else if(options.num_requested_seek_points == 0)
1854 ; /* no warning, silently delete existing SEEKTABLE since user specified --no-seektable (-S-) */
1856 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);
1857 FLAC__metadata_object_delete(flac_decoder_data->metadata_blocks[i]);
1858 flac_decoder_data->metadata_blocks[i] = 0;
1859 existing_seektable = false;
1862 flac_decoder_data->metadata_blocks[j++] = flac_decoder_data->metadata_blocks[i];
1864 flac_decoder_data->num_metadata_blocks = j;
1865 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])) {
1867 FLAC__StreamMetadata *st = FLAC__metadata_object_clone(e->seek_table_template);
1869 flac__utils_printf(stderr, 1, "%s: ERROR allocating memory for SEEKTABLE block\n", e->inbasefilename);
1871 FLAC__metadata_object_delete(cuesheet);
1874 for(i = flac_decoder_data->num_metadata_blocks; i > 1; i--)
1875 flac_decoder_data->metadata_blocks[i] = flac_decoder_data->metadata_blocks[i-1];
1876 flac_decoder_data->metadata_blocks[1] = st;
1877 flac_decoder_data->num_metadata_blocks++;
1880 metadata = &flac_decoder_data->metadata_blocks[1]; /* don't include STREAMINFO */
1881 num_metadata = flac_decoder_data->num_metadata_blocks - 1;
1885 * we're not encoding from FLAC so we will build the metadata
1889 if(e->seek_table_template->data.seek_table.num_points > 0) {
1890 e->seek_table_template->is_last = false; /* the encoder will set this for us */
1891 metadata[num_metadata++] = e->seek_table_template;
1894 metadata[num_metadata++] = cuesheet;
1896 if(!flac__utils_set_channel_mask_tag(options.vorbis_comment, channel_mask)) {
1897 flac__utils_printf(stderr, 1, "%s: ERROR adding channel mask tag\n", e->inbasefilename);
1899 FLAC__metadata_object_delete(cuesheet);
1903 metadata[num_metadata++] = options.vorbis_comment;
1904 for(i = 0; i < options.num_pictures; i++)
1905 metadata[num_metadata++] = options.pictures[i];
1906 if(options.padding != 0) {
1907 padding.is_last = false; /* the encoder will set this for us */
1908 padding.type = FLAC__METADATA_TYPE_PADDING;
1909 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));
1910 metadata[num_metadata++] = &padding;
1914 /* check for a few things that have not already been checked. the
1915 * FLAC__stream_encoder_init*() will check it but only return
1916 * FLAC__STREAM_ENCODER_INIT_STATUS_INVALID_METADATA so we check some
1917 * up front to give a better error message.
1919 if(!verify_metadata(e, metadata, num_metadata)) {
1921 FLAC__metadata_object_delete(cuesheet);
1925 FLAC__stream_encoder_set_verify(e->encoder, options.verify);
1926 FLAC__stream_encoder_set_streamable_subset(e->encoder, !options.lax);
1927 FLAC__stream_encoder_set_channels(e->encoder, channels);
1928 FLAC__stream_encoder_set_bits_per_sample(e->encoder, bps);
1929 FLAC__stream_encoder_set_sample_rate(e->encoder, sample_rate);
1930 for(i = 0; i < options.num_compression_settings; i++) {
1931 switch(options.compression_settings[i].type) {
1933 FLAC__stream_encoder_set_blocksize(e->encoder, options.compression_settings[i].value.t_unsigned);
1935 case CST_COMPRESSION_LEVEL:
1936 FLAC__stream_encoder_set_compression_level(e->encoder, options.compression_settings[i].value.t_unsigned);
1937 apodizations[0] = '\0';
1939 case CST_DO_MID_SIDE:
1940 FLAC__stream_encoder_set_do_mid_side_stereo(e->encoder, options.compression_settings[i].value.t_bool);
1942 case CST_LOOSE_MID_SIDE:
1943 FLAC__stream_encoder_set_loose_mid_side_stereo(e->encoder, options.compression_settings[i].value.t_bool);
1945 case CST_APODIZATION:
1946 if(strlen(apodizations)+strlen(options.compression_settings[i].value.t_string)+2 >= sizeof(apodizations)) {
1947 flac__utils_printf(stderr, 1, "%s: ERROR: too many apodization functions requested\n", e->inbasefilename);
1949 FLAC__metadata_object_delete(cuesheet);
1953 strcat(apodizations, options.compression_settings[i].value.t_string);
1954 strcat(apodizations, ";");
1957 case CST_MAX_LPC_ORDER:
1958 FLAC__stream_encoder_set_max_lpc_order(e->encoder, options.compression_settings[i].value.t_unsigned);
1960 case CST_QLP_COEFF_PRECISION:
1961 FLAC__stream_encoder_set_qlp_coeff_precision(e->encoder, options.compression_settings[i].value.t_unsigned);
1963 case CST_DO_QLP_COEFF_PREC_SEARCH:
1964 FLAC__stream_encoder_set_do_qlp_coeff_prec_search(e->encoder, options.compression_settings[i].value.t_bool);
1966 case CST_DO_ESCAPE_CODING:
1967 FLAC__stream_encoder_set_do_escape_coding(e->encoder, options.compression_settings[i].value.t_bool);
1969 case CST_DO_EXHAUSTIVE_MODEL_SEARCH:
1970 FLAC__stream_encoder_set_do_exhaustive_model_search(e->encoder, options.compression_settings[i].value.t_bool);
1972 case CST_MIN_RESIDUAL_PARTITION_ORDER:
1973 FLAC__stream_encoder_set_min_residual_partition_order(e->encoder, options.compression_settings[i].value.t_unsigned);
1975 case CST_MAX_RESIDUAL_PARTITION_ORDER:
1976 FLAC__stream_encoder_set_max_residual_partition_order(e->encoder, options.compression_settings[i].value.t_unsigned);
1978 case CST_RICE_PARAMETER_SEARCH_DIST:
1979 FLAC__stream_encoder_set_rice_parameter_search_dist(e->encoder, options.compression_settings[i].value.t_unsigned);
1984 FLAC__stream_encoder_set_apodization(e->encoder, apodizations);
1985 FLAC__stream_encoder_set_total_samples_estimate(e->encoder, e->total_samples_to_encode);
1986 FLAC__stream_encoder_set_metadata(e->encoder, (num_metadata > 0)? metadata : 0, num_metadata);
1988 FLAC__stream_encoder_disable_constant_subframes(e->encoder, options.debug.disable_constant_subframes);
1989 FLAC__stream_encoder_disable_fixed_subframes(e->encoder, options.debug.disable_fixed_subframes);
1990 FLAC__stream_encoder_disable_verbatim_subframes(e->encoder, options.debug.disable_verbatim_subframes);
1994 FLAC__stream_encoder_set_ogg_serial_number(e->encoder, options.serial_number);
1996 init_status = FLAC__stream_encoder_init_ogg_file(e->encoder, e->is_stdout? 0 : e->outfilename, encoder_progress_callback, /*client_data=*/e);
2001 init_status = FLAC__stream_encoder_init_file(e->encoder, e->is_stdout? 0 : e->outfilename, encoder_progress_callback, /*client_data=*/e);
2004 if(init_status != FLAC__STREAM_ENCODER_INIT_STATUS_OK) {
2005 print_error_with_init_status(e, "ERROR initializing encoder", init_status);
2006 if(FLAC__stream_encoder_get_state(e->encoder) != FLAC__STREAM_ENCODER_IO_ERROR)
2007 e->outputfile_opened = true;
2009 FLAC__metadata_object_delete(cuesheet);
2013 e->outputfile_opened = true;
2016 (FLAC__stream_encoder_get_do_exhaustive_model_search(e->encoder) && FLAC__stream_encoder_get_do_qlp_coeff_prec_search(e->encoder))? 0x07 :
2017 (FLAC__stream_encoder_get_do_exhaustive_model_search(e->encoder) || FLAC__stream_encoder_get_do_qlp_coeff_prec_search(e->encoder))? 0x0f :
2021 FLAC__metadata_object_delete(cuesheet);
2026 FLAC__bool EncoderSession_process(EncoderSession *e, const FLAC__int32 * const buffer[], unsigned samples)
2028 if(e->replay_gain) {
2029 if(!grabbag__replaygain_analyze(buffer, e->channels==2, e->bits_per_sample, samples)) {
2030 flac__utils_printf(stderr, 1, "%s: WARNING, error while calculating ReplayGain\n", e->inbasefilename);
2034 return FLAC__stream_encoder_process(e->encoder, buffer, samples);
2037 FLAC__bool convert_to_seek_table_template(const char *requested_seek_points, int num_requested_seek_points, FLAC__StreamMetadata *cuesheet, EncoderSession *e)
2039 const FLAC__bool only_placeholders = e->is_stdout;
2040 FLAC__bool has_real_points;
2042 if(num_requested_seek_points == 0 && 0 == cuesheet)
2045 if(num_requested_seek_points < 0) {
2046 requested_seek_points = "10s;";
2047 num_requested_seek_points = 1;
2050 if(num_requested_seek_points > 0) {
2051 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))
2057 const FLAC__StreamMetadata_CueSheet *cs = &cuesheet->data.cue_sheet;
2058 for(i = 0; i < cs->num_tracks; i++) {
2059 const FLAC__StreamMetadata_CueSheet_Track *tr = cs->tracks+i;
2060 for(j = 0; j < tr->num_indices; j++) {
2061 if(!FLAC__metadata_object_seektable_template_append_point(e->seek_table_template, tr->offset + tr->indices[j].offset))
2063 has_real_points = true;
2067 if(!FLAC__metadata_object_seektable_template_sort(e->seek_table_template, /*compact=*/true))
2071 if(has_real_points) {
2073 flac__utils_printf(stderr, 1, "%s: WARNING, cannot write back seekpoints when encoding to stdout\n", e->inbasefilename);
2080 FLAC__bool canonicalize_until_specification(utils__SkipUntilSpecification *spec, const char *inbasefilename, unsigned sample_rate, FLAC__uint64 skip, FLAC__uint64 total_samples_in_input)
2082 /* convert from mm:ss.sss to sample number if necessary */
2083 flac__utils_canonicalize_skip_until_specification(spec, sample_rate);
2085 /* special case: if "--until=-0", use the special value '0' to mean "end-of-stream" */
2086 if(spec->is_relative && spec->value.samples == 0) {
2087 spec->is_relative = false;
2091 /* in any other case the total samples in the input must be known */
2092 if(total_samples_in_input == 0) {
2093 flac__utils_printf(stderr, 1, "%s: ERROR, cannot use --until when input length is unknown\n", inbasefilename);
2097 FLAC__ASSERT(spec->value_is_samples);
2099 /* convert relative specifications to absolute */
2100 if(spec->is_relative) {
2101 if(spec->value.samples <= 0)
2102 spec->value.samples += (FLAC__int64)total_samples_in_input;
2104 spec->value.samples += skip;
2105 spec->is_relative = false;
2109 if(spec->value.samples < 0) {
2110 flac__utils_printf(stderr, 1, "%s: ERROR, --until value is before beginning of input\n", inbasefilename);
2113 if((FLAC__uint64)spec->value.samples <= skip) {
2114 flac__utils_printf(stderr, 1, "%s: ERROR, --until value is before --skip point\n", inbasefilename);
2117 if((FLAC__uint64)spec->value.samples > total_samples_in_input) {
2118 flac__utils_printf(stderr, 1, "%s: ERROR, --until value is after end of input\n", inbasefilename);
2125 FLAC__bool verify_metadata(const EncoderSession *e, FLAC__StreamMetadata **metadata, unsigned num_metadata)
2127 FLAC__bool metadata_picture_has_type1 = false;
2128 FLAC__bool metadata_picture_has_type2 = false;
2131 FLAC__ASSERT(0 != metadata);
2132 for(i = 0; i < num_metadata; i++) {
2133 const FLAC__StreamMetadata *m = metadata[i];
2134 if(m->type == FLAC__METADATA_TYPE_SEEKTABLE) {
2135 if(!FLAC__format_seektable_is_legal(&m->data.seek_table)) {
2136 flac__utils_printf(stderr, 1, "%s: ERROR: SEEKTABLE metadata block is invalid\n", e->inbasefilename);
2140 else if(m->type == FLAC__METADATA_TYPE_CUESHEET) {
2141 if(!FLAC__format_cuesheet_is_legal(&m->data.cue_sheet, m->data.cue_sheet.is_cd, /*violation=*/0)) {
2142 flac__utils_printf(stderr, 1, "%s: ERROR: CUESHEET metadata block is invalid\n", e->inbasefilename);
2146 else if(m->type == FLAC__METADATA_TYPE_PICTURE) {
2147 const char *error = 0;
2148 if(!FLAC__format_picture_is_legal(&m->data.picture, &error)) {
2149 flac__utils_printf(stderr, 1, "%s: ERROR: PICTURE metadata block is invalid: %s\n", e->inbasefilename, error);
2152 if(m->data.picture.type == FLAC__STREAM_METADATA_PICTURE_TYPE_FILE_ICON_STANDARD) {
2153 if(metadata_picture_has_type1) {
2154 flac__utils_printf(stderr, 1, "%s: ERROR: there may only be one picture of type 1 (32x32 icon) in the file\n", e->inbasefilename);
2157 metadata_picture_has_type1 = true;
2159 else if(m->data.picture.type == FLAC__STREAM_METADATA_PICTURE_TYPE_FILE_ICON) {
2160 if(metadata_picture_has_type2) {
2161 flac__utils_printf(stderr, 1, "%s: ERROR: there may only be one picture of type 2 (icon) in the file\n", e->inbasefilename);
2164 metadata_picture_has_type2 = true;
2172 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)
2174 unsigned wide_sample, sample, channel, byte;
2175 FLAC__int32 *out[FLAC__MAX_CHANNELS];
2177 if(0 == channel_map) {
2178 for(channel = 0; channel < channels; channel++)
2179 out[channel] = dest[channel];
2182 for(channel = 0; channel < channels; channel++)
2183 out[channel] = dest[channel_map[channel]];
2187 if(is_unsigned_samples) {
2188 for(sample = wide_sample = 0; wide_sample < wide_samples; wide_sample++)
2189 for(channel = 0; channel < channels; channel++, sample++)
2190 out[channel][wide_sample] = (FLAC__int32)ucbuffer_[sample] - 0x80;
2193 for(sample = wide_sample = 0; wide_sample < wide_samples; wide_sample++)
2194 for(channel = 0; channel < channels; channel++, sample++)
2195 out[channel][wide_sample] = (FLAC__int32)scbuffer_[sample];
2198 else if(bps == 16) {
2199 if(is_big_endian != is_big_endian_host_) {
2201 const unsigned bytes = wide_samples * channels * (bps >> 3);
2202 for(byte = 0; byte < bytes; byte += 2) {
2203 tmp = ucbuffer_[byte];
2204 ucbuffer_[byte] = ucbuffer_[byte+1];
2205 ucbuffer_[byte+1] = tmp;
2208 if(is_unsigned_samples) {
2209 for(sample = wide_sample = 0; wide_sample < wide_samples; wide_sample++)
2210 for(channel = 0; channel < channels; channel++, sample++)
2211 out[channel][wide_sample] = (FLAC__int32)usbuffer_[sample] - 0x8000;
2214 for(sample = wide_sample = 0; wide_sample < wide_samples; wide_sample++)
2215 for(channel = 0; channel < channels; channel++, sample++)
2216 out[channel][wide_sample] = (FLAC__int32)ssbuffer_[sample];
2219 else if(bps == 24) {
2220 if(!is_big_endian) {
2222 const unsigned bytes = wide_samples * channels * (bps >> 3);
2223 for(byte = 0; byte < bytes; byte += 3) {
2224 tmp = ucbuffer_[byte];
2225 ucbuffer_[byte] = ucbuffer_[byte+2];
2226 ucbuffer_[byte+2] = tmp;
2229 if(is_unsigned_samples) {
2230 for(byte = sample = wide_sample = 0; wide_sample < wide_samples; wide_sample++)
2231 for(channel = 0; channel < channels; channel++, sample++) {
2232 out[channel][wide_sample] = ucbuffer_[byte++]; out[channel][wide_sample] <<= 8;
2233 out[channel][wide_sample] |= ucbuffer_[byte++]; out[channel][wide_sample] <<= 8;
2234 out[channel][wide_sample] |= ucbuffer_[byte++];
2235 out[channel][wide_sample] -= 0x800000;
2239 for(byte = sample = wide_sample = 0; wide_sample < wide_samples; wide_sample++)
2240 for(channel = 0; channel < channels; channel++, sample++) {
2241 out[channel][wide_sample] = scbuffer_[byte++]; out[channel][wide_sample] <<= 8;
2242 out[channel][wide_sample] |= ucbuffer_[byte++]; out[channel][wide_sample] <<= 8;
2243 out[channel][wide_sample] |= ucbuffer_[byte++];
2251 FLAC__int32 mask = (1<<shift)-1;
2252 for(wide_sample = 0; wide_sample < wide_samples; wide_sample++)
2253 for(channel = 0; channel < channels; channel++) {
2254 if(out[channel][wide_sample] & mask) {
2255 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);
2258 out[channel][wide_sample] >>= shift;
2264 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)
2266 EncoderSession *encoder_session = (EncoderSession*)client_data;
2268 (void)encoder, (void)total_frames_estimate;
2270 encoder_session->bytes_written = bytes_written;
2271 encoder_session->samples_written = samples_written;
2273 if(encoder_session->total_samples_to_encode > 0 && !((frames_written-1) & encoder_session->stats_mask))
2274 print_stats(encoder_session);
2277 FLAC__StreamDecoderReadStatus flac_decoder_read_callback(const FLAC__StreamDecoder *decoder, FLAC__byte buffer[], size_t *bytes, void *client_data)
2280 FLACDecoderData *data = (FLACDecoderData*)client_data;
2283 if (data->fatal_error)
2284 return FLAC__STREAM_DECODER_READ_STATUS_ABORT;
2286 /* use up lookahead first */
2287 if (data->lookahead_length) {
2288 n = min(data->lookahead_length, *bytes);
2289 memcpy(buffer, data->lookahead, n);
2291 data->lookahead += n;
2292 data->lookahead_length -= n;
2295 /* get the rest from file */
2297 *bytes = n + fread(buffer, 1, *bytes-n, data->encoder_session->fin);
2298 if(ferror(data->encoder_session->fin))
2299 return FLAC__STREAM_DECODER_READ_STATUS_ABORT;
2300 else if(0 == *bytes)
2301 return FLAC__STREAM_DECODER_READ_STATUS_END_OF_STREAM;
2303 return FLAC__STREAM_DECODER_READ_STATUS_CONTINUE;
2306 return FLAC__STREAM_DECODER_READ_STATUS_CONTINUE;
2309 FLAC__StreamDecoderSeekStatus flac_decoder_seek_callback(const FLAC__StreamDecoder *decoder, FLAC__uint64 absolute_byte_offset, void *client_data)
2311 FLACDecoderData *data = (FLACDecoderData*)client_data;
2314 if(fseeko(data->encoder_session->fin, (off_t)absolute_byte_offset, SEEK_SET) < 0)
2315 return FLAC__STREAM_DECODER_SEEK_STATUS_ERROR;
2317 return FLAC__STREAM_DECODER_SEEK_STATUS_OK;
2320 FLAC__StreamDecoderTellStatus flac_decoder_tell_callback(const FLAC__StreamDecoder *decoder, FLAC__uint64 *absolute_byte_offset, void *client_data)
2322 FLACDecoderData *data = (FLACDecoderData*)client_data;
2326 if((pos = ftello(data->encoder_session->fin)) < 0)
2327 return FLAC__STREAM_DECODER_TELL_STATUS_ERROR;
2329 *absolute_byte_offset = (FLAC__uint64)pos;
2330 return FLAC__STREAM_DECODER_TELL_STATUS_OK;
2334 FLAC__StreamDecoderLengthStatus flac_decoder_length_callback(const FLAC__StreamDecoder *decoder, FLAC__uint64 *stream_length, void *client_data)
2336 FLACDecoderData *data = (FLACDecoderData*)client_data;
2339 if(0 == data->filesize)
2340 return FLAC__STREAM_DECODER_LENGTH_STATUS_ERROR;
2342 *stream_length = (FLAC__uint64)data->filesize;
2343 return FLAC__STREAM_DECODER_LENGTH_STATUS_OK;
2347 FLAC__bool flac_decoder_eof_callback(const FLAC__StreamDecoder *decoder, void *client_data)
2349 FLACDecoderData *data = (FLACDecoderData*)client_data;
2352 return feof(data->encoder_session->fin)? true : false;
2355 FLAC__StreamDecoderWriteStatus flac_decoder_write_callback(const FLAC__StreamDecoder *decoder, const FLAC__Frame *frame, const FLAC__int32 * const buffer[], void *client_data)
2357 FLACDecoderData *data = (FLACDecoderData*)client_data;
2358 FLAC__uint64 n = min(data->samples_left_to_process, frame->header.blocksize);
2361 if(!EncoderSession_process(data->encoder_session, buffer, (unsigned)n)) {
2362 print_error_with_state(data->encoder_session, "ERROR during encoding");
2363 data->fatal_error = true;
2364 return FLAC__STREAM_DECODER_WRITE_STATUS_ABORT;
2367 data->samples_left_to_process -= n;
2368 return FLAC__STREAM_DECODER_WRITE_STATUS_CONTINUE;
2371 void flac_decoder_metadata_callback(const FLAC__StreamDecoder *decoder, const FLAC__StreamMetadata *metadata, void *client_data)
2373 FLACDecoderData *data = (FLACDecoderData*)client_data;
2376 if (data->fatal_error)
2380 data->num_metadata_blocks == sizeof(data->metadata_blocks)/sizeof(data->metadata_blocks[0]) ||
2381 0 == (data->metadata_blocks[data->num_metadata_blocks] = FLAC__metadata_object_clone(metadata))
2383 data->fatal_error = true;
2385 data->num_metadata_blocks++;
2388 void flac_decoder_error_callback(const FLAC__StreamDecoder *decoder, FLAC__StreamDecoderErrorStatus status, void *client_data)
2390 FLACDecoderData *data = (FLACDecoderData*)client_data;
2393 flac__utils_printf(stderr, 1, "%s: ERROR got %s while decoding FLAC input\n", data->encoder_session->inbasefilename, FLAC__StreamDecoderErrorStatusString[status]);
2394 if(!data->encoder_session->continue_through_decode_errors)
2395 data->fatal_error = true;
2398 FLAC__bool parse_cuesheet(FLAC__StreamMetadata **cuesheet, const char *cuesheet_filename, const char *inbasefilename, FLAC__bool is_cdda, FLAC__uint64 lead_out_offset)
2401 unsigned last_line_read;
2402 const char *error_message;
2404 if(0 == cuesheet_filename)
2407 if(lead_out_offset == 0) {
2408 flac__utils_printf(stderr, 1, "%s: ERROR cannot import cuesheet when the number of input samples to encode is unknown\n", inbasefilename);
2412 if(0 == (f = fopen(cuesheet_filename, "r"))) {
2413 flac__utils_printf(stderr, 1, "%s: ERROR opening cuesheet \"%s\" for reading: %s\n", inbasefilename, cuesheet_filename, strerror(errno));
2417 *cuesheet = grabbag__cuesheet_parse(f, &error_message, &last_line_read, is_cdda, lead_out_offset);
2421 if(0 == *cuesheet) {
2422 flac__utils_printf(stderr, 1, "%s: ERROR parsing cuesheet \"%s\" on line %u: %s\n", inbasefilename, cuesheet_filename, last_line_read, error_message);
2426 if(!FLAC__format_cuesheet_is_legal(&(*cuesheet)->data.cue_sheet, /*check_cd_da_subset=*/false, &error_message)) {
2427 flac__utils_printf(stderr, 1, "%s: ERROR parsing cuesheet \"%s\": %s\n", inbasefilename, cuesheet_filename, error_message);
2431 /* if we're expecting CDDA, warn about non-compliance */
2432 if(is_cdda && !FLAC__format_cuesheet_is_legal(&(*cuesheet)->data.cue_sheet, /*check_cd_da_subset=*/true, &error_message)) {
2433 flac__utils_printf(stderr, 1, "%s: WARNING cuesheet \"%s\" is not audio CD compliant: %s\n", inbasefilename, cuesheet_filename, error_message);
2434 (*cuesheet)->data.cue_sheet.is_cd = false;
2440 void print_stats(const EncoderSession *encoder_session)
2442 const FLAC__uint64 samples_written = min(encoder_session->total_samples_to_encode, encoder_session->samples_written);
2443 #if defined _MSC_VER || defined __MINGW32__
2444 /* with MSVC you have to spoon feed it the casting */
2445 const double progress = (double)(FLAC__int64)samples_written / (double)(FLAC__int64)encoder_session->total_samples_to_encode;
2446 const double ratio = (double)(FLAC__int64)encoder_session->bytes_written / ((double)(FLAC__int64)encoder_session->unencoded_size * min(1.0, progress));
2448 const double progress = (double)samples_written / (double)encoder_session->total_samples_to_encode;
2449 const double ratio = (double)encoder_session->bytes_written / ((double)encoder_session->unencoded_size * min(1.0, progress));
2452 if(samples_written == encoder_session->total_samples_to_encode) {
2453 flac__utils_printf(stderr, 2, "\r%s:%s wrote %u bytes, ratio=%0.3f",
2454 encoder_session->inbasefilename,
2455 encoder_session->verify? " Verify OK," : "",
2456 (unsigned)encoder_session->bytes_written,
2461 flac__utils_printf(stderr, 2, "\r%s: %u%% complete, ratio=%0.3f", encoder_session->inbasefilename, (unsigned)floor(progress * 100.0 + 0.5), ratio);
2465 void print_error_with_init_status(const EncoderSession *e, const char *message, FLAC__StreamEncoderInitStatus init_status)
2467 const int ilen = strlen(e->inbasefilename) + 1;
2468 const char *state_string = "";
2470 flac__utils_printf(stderr, 1, "\n%s: %s\n", e->inbasefilename, message);
2472 flac__utils_printf(stderr, 1, "%*s init_status = %s\n", ilen, "", FLAC__StreamEncoderInitStatusString[init_status]);
2474 if(init_status == FLAC__STREAM_ENCODER_INIT_STATUS_ENCODER_ERROR) {
2475 state_string = FLAC__stream_encoder_get_resolved_state_string(e->encoder);
2477 flac__utils_printf(stderr, 1, "%*s state = %s\n", ilen, "", state_string);
2479 /* print out some more info for some errors: */
2480 if(0 == strcmp(state_string, FLAC__StreamEncoderStateString[FLAC__STREAM_ENCODER_CLIENT_ERROR])) {
2481 flac__utils_printf(stderr, 1,
2483 "An error occurred while writing; the most common cause is that the disk is full.\n"
2486 else if(0 == strcmp(state_string, FLAC__StreamEncoderStateString[FLAC__STREAM_ENCODER_IO_ERROR])) {
2487 flac__utils_printf(stderr, 1,
2489 "An error occurred opening the output file; it is likely that the output\n"
2490 "directory does not exist or is not writable, the output file already exists and\n"
2491 "is not writable, or the disk is full.\n"
2495 else if(init_status == FLAC__STREAM_ENCODER_INIT_STATUS_NOT_STREAMABLE) {
2496 flac__utils_printf(stderr, 1,
2498 "The encoding parameters specified do not conform to the FLAC Subset and may not\n"
2499 "be streamable or playable in hardware devices. If you really understand the\n"
2500 "consequences, you can add --lax to the command-line options to encode with\n"
2501 "these parameters anyway. See http://flac.sourceforge.net/format.html#subset\n"
2506 void print_error_with_state(const EncoderSession *e, const char *message)
2508 const int ilen = strlen(e->inbasefilename) + 1;
2509 const char *state_string;
2511 flac__utils_printf(stderr, 1, "\n%s: %s\n", e->inbasefilename, message);
2513 state_string = FLAC__stream_encoder_get_resolved_state_string(e->encoder);
2515 flac__utils_printf(stderr, 1, "%*s state = %s\n", ilen, "", state_string);
2517 /* print out some more info for some errors: */
2518 if(0 == strcmp(state_string, FLAC__StreamEncoderStateString[FLAC__STREAM_ENCODER_CLIENT_ERROR])) {
2519 flac__utils_printf(stderr, 1,
2521 "An error occurred while writing; the most common cause is that the disk is full.\n"
2526 void print_verify_error(EncoderSession *e)
2528 FLAC__uint64 absolute_sample;
2529 unsigned frame_number;
2532 FLAC__int32 expected;
2535 FLAC__stream_encoder_get_verify_decoder_error_stats(e->encoder, &absolute_sample, &frame_number, &channel, &sample, &expected, &got);
2537 flac__utils_printf(stderr, 1, "%s: ERROR: mismatch in decoded data, verify FAILED!\n", e->inbasefilename);
2538 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);
2539 flac__utils_printf(stderr, 1, " In all known cases, verify errors are caused by hardware problems,\n");
2540 flac__utils_printf(stderr, 1, " usually overclocking or bad RAM. Delete %s\n", e->outfilename);
2541 flac__utils_printf(stderr, 1, " and repeat the flac command exactly as before. If it does not give a\n");
2542 flac__utils_printf(stderr, 1, " verify error in the exact same place each time you try it, then there is\n");
2543 flac__utils_printf(stderr, 1, " a problem with your hardware; please see the FAQ:\n");
2544 flac__utils_printf(stderr, 1, " http://flac.sourceforge.net/faq.html#tools__hardware_prob\n");
2545 flac__utils_printf(stderr, 1, " If it does fail in the exact same place every time, keep\n");
2546 flac__utils_printf(stderr, 1, " %s and submit a bug report to:\n", e->outfilename);
2547 flac__utils_printf(stderr, 1, " https://sourceforge.net/bugs/?func=addbug&group_id=13478\n");
2548 flac__utils_printf(stderr, 1, " Make sure to upload the FLAC file and use the \"Monitor\" feature to\n");
2549 flac__utils_printf(stderr, 1, " monitor the bug status.\n");
2550 flac__utils_printf(stderr, 1, "Verify FAILED! Do not trust %s\n", e->outfilename);
2553 FLAC__bool read_little_endian_uint16(FILE *f, FLAC__uint16 *val, FLAC__bool eof_ok, const char *fn)
2555 size_t bytes_read = fread(val, 1, 2, f);
2557 if(bytes_read == 0) {
2559 flac__utils_printf(stderr, 1, "%s: ERROR: unexpected EOF\n", fn);
2565 else if(bytes_read < 2) {
2566 flac__utils_printf(stderr, 1, "%s: ERROR: unexpected EOF\n", fn);
2570 if(is_big_endian_host_) {
2571 FLAC__byte tmp, *b = (FLAC__byte*)val;
2572 tmp = b[1]; b[1] = b[0]; b[0] = tmp;
2578 FLAC__bool read_little_endian_uint32(FILE *f, FLAC__uint32 *val, FLAC__bool eof_ok, const char *fn)
2580 size_t bytes_read = fread(val, 1, 4, f);
2582 if(bytes_read == 0) {
2584 flac__utils_printf(stderr, 1, "%s: ERROR: unexpected EOF\n", fn);
2590 else if(bytes_read < 4) {
2591 flac__utils_printf(stderr, 1, "%s: ERROR: unexpected EOF\n", fn);
2595 if(is_big_endian_host_) {
2596 FLAC__byte tmp, *b = (FLAC__byte*)val;
2597 tmp = b[3]; b[3] = b[0]; b[0] = tmp;
2598 tmp = b[2]; b[2] = b[1]; b[1] = tmp;
2604 FLAC__bool read_big_endian_uint16(FILE *f, FLAC__uint16 *val, FLAC__bool eof_ok, const char *fn)
2606 unsigned char buf[4];
2607 size_t bytes_read= fread(buf, 1, 2, f);
2609 if(bytes_read==0U && eof_ok)
2611 else if(bytes_read<2U) {
2612 flac__utils_printf(stderr, 1, "%s: ERROR: unexpected EOF\n", fn);
2616 /* this is independent of host endianness */
2617 *val= (FLAC__uint16)(buf[0])<<8 | buf[1];
2622 FLAC__bool read_big_endian_uint32(FILE *f, FLAC__uint32 *val, FLAC__bool eof_ok, const char *fn)
2624 unsigned char buf[4];
2625 size_t bytes_read= fread(buf, 1, 4, f);
2627 if(bytes_read==0U && eof_ok)
2629 else if(bytes_read<4U) {
2630 flac__utils_printf(stderr, 1, "%s: ERROR: unexpected EOF\n", fn);
2634 /* this is independent of host endianness */
2635 *val= (FLAC__uint32)(buf[0])<<24 | (FLAC__uint32)(buf[1])<<16 |
2636 (FLAC__uint32)(buf[2])<<8 | buf[3];
2641 FLAC__bool read_sane_extended(FILE *f, FLAC__uint32 *val, FLAC__bool eof_ok, const char *fn)
2642 /* Read an IEEE 754 80-bit (aka SANE) extended floating point value from 'f',
2643 * convert it into an integral value and store in 'val'. Return false if only
2644 * between 1 and 9 bytes remain in 'f', if 0 bytes remain in 'f' and 'eof_ok' is
2645 * false, or if the value is negative, between zero and one, or too large to be
2646 * represented by 'val'; return true otherwise.
2650 unsigned char buf[10];
2651 size_t bytes_read= fread(buf, 1U, 10U, f);
2652 FLAC__int16 e= ((FLAC__uint16)(buf[0])<<8 | (FLAC__uint16)(buf[1]))-0x3FFF;
2653 FLAC__int16 shift= 63-e;
2656 if(bytes_read==0U && eof_ok)
2658 else if(bytes_read<10U) {
2659 flac__utils_printf(stderr, 1, "%s: ERROR: unexpected EOF\n", fn);
2662 else if((buf[0]>>7)==1U || e<0 || e>63) {
2663 flac__utils_printf(stderr, 1, "%s: ERROR: invalid floating-point value\n", fn);
2667 for(i= 0U; i<8U; ++i)
2668 p|= (FLAC__uint64)(buf[i+2])<<(56U-i*8);
2669 *val= (FLAC__uint32)((p>>shift)+(p>>(shift-1) & 0x1));
2674 FLAC__bool fskip_ahead(FILE *f, FLAC__uint64 offset)
2676 static unsigned char dump[8192];
2679 long need = (long)min(offset, LONG_MAX);
2680 if(fseeko(f, need, SEEK_CUR) < 0) {
2681 need = (long)min(offset, sizeof(dump));
2682 if((long)fread(dump, 1, need, f) < need)
2687 #if 0 /* pure non-fseek() version */
2689 const long need = (long)min(offset, sizeof(dump));
2690 if(fread(dump, 1, need, f) < need)
2698 unsigned count_channel_mask_bits(FLAC__uint32 mask)
2709 FLAC__uint32 limit_channel_mask(FLAC__uint32 mask, unsigned channels)
2711 FLAC__uint32 x = 0x80000000;
2712 unsigned count = count_channel_mask_bits(mask);
2713 while(x && count > channels) {
2720 FLAC__ASSERT(count_channel_mask_bits(mask) == channels);