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 replay_gain;
72 unsigned bits_per_sample;
74 FLAC__uint64 unencoded_size;
75 FLAC__uint64 total_samples_to_encode;
76 FLAC__uint64 bytes_written;
77 FLAC__uint64 samples_written;
80 FLAC__StreamEncoder *encoder;
83 FLAC__StreamMetadata *seek_table_template;
86 /* this is data attached to the FLAC decoder when encoding from a FLAC file */
88 EncoderSession *encoder_session;
90 const FLAC__byte *lookahead;
91 unsigned lookahead_length;
92 size_t num_metadata_blocks;
93 FLAC__StreamMetadata *metadata_blocks[1024]; /*@@@ BAD MAGIC number */
94 FLAC__uint64 samples_left_to_process;
95 FLAC__bool fatal_error;
98 const int FLAC_ENCODE__DEFAULT_PADDING = 8192;
100 static FLAC__bool is_big_endian_host_;
102 static unsigned char ucbuffer_[CHUNK_OF_SAMPLES*FLAC__MAX_CHANNELS*((FLAC__REFERENCE_CODEC_MAX_BITS_PER_SAMPLE+7)/8)];
103 static signed char *scbuffer_ = (signed char *)ucbuffer_;
104 static FLAC__uint16 *usbuffer_ = (FLAC__uint16 *)ucbuffer_;
105 static FLAC__int16 *ssbuffer_ = (FLAC__int16 *)ucbuffer_;
107 static FLAC__int32 in_[FLAC__MAX_CHANNELS][CHUNK_OF_SAMPLES];
108 static FLAC__int32 *input_[FLAC__MAX_CHANNELS];
112 * unpublished debug routines from the FLAC libs
114 extern FLAC__bool FLAC__stream_encoder_disable_constant_subframes(FLAC__StreamEncoder *encoder, FLAC__bool value);
115 extern FLAC__bool FLAC__stream_encoder_disable_fixed_subframes(FLAC__StreamEncoder *encoder, FLAC__bool value);
116 extern FLAC__bool FLAC__stream_encoder_disable_verbatim_subframes(FLAC__StreamEncoder *encoder, FLAC__bool value);
121 static FLAC__bool EncoderSession_construct(EncoderSession *e, FLAC__bool use_ogg, FLAC__bool verify, FILE *infile, const char *infilename, const char *outfilename);
122 static void EncoderSession_destroy(EncoderSession *e);
123 static int EncoderSession_finish_ok(EncoderSession *e, int info_align_carry, int info_align_zero);
124 static int EncoderSession_finish_error(EncoderSession *e);
125 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);
126 static FLAC__bool EncoderSession_process(EncoderSession *e, const FLAC__int32 * const buffer[], unsigned samples);
127 static FLAC__bool convert_to_seek_table_template(const char *requested_seek_points, int num_requested_seek_points, FLAC__StreamMetadata *cuesheet, EncoderSession *e);
128 static FLAC__bool canonicalize_until_specification(utils__SkipUntilSpecification *spec, const char *inbasefilename, unsigned sample_rate, FLAC__uint64 skip, FLAC__uint64 total_samples_in_input);
129 static FLAC__bool verify_metadata(const EncoderSession *e, FLAC__StreamMetadata **metadata, unsigned num_metadata);
130 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);
131 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);
132 static FLAC__StreamDecoderReadStatus flac_decoder_read_callback(const FLAC__StreamDecoder *decoder, FLAC__byte buffer[], size_t *bytes, void *client_data);
133 static FLAC__StreamDecoderSeekStatus flac_decoder_seek_callback(const FLAC__StreamDecoder *decoder, FLAC__uint64 absolute_byte_offset, void *client_data);
134 static FLAC__StreamDecoderTellStatus flac_decoder_tell_callback(const FLAC__StreamDecoder *decoder, FLAC__uint64 *absolute_byte_offset, void *client_data);
135 static FLAC__StreamDecoderLengthStatus flac_decoder_length_callback(const FLAC__StreamDecoder *decoder, FLAC__uint64 *stream_length, void *client_data);
136 static FLAC__bool flac_decoder_eof_callback(const FLAC__StreamDecoder *decoder, void *client_data);
137 static FLAC__StreamDecoderWriteStatus flac_decoder_write_callback(const FLAC__StreamDecoder *decoder, const FLAC__Frame *frame, const FLAC__int32 * const buffer[], void *client_data);
138 static void flac_decoder_metadata_callback(const FLAC__StreamDecoder *decoder, const FLAC__StreamMetadata *metadata, void *client_data);
139 static void flac_decoder_error_callback(const FLAC__StreamDecoder *decoder, FLAC__StreamDecoderErrorStatus status, void *client_data);
140 static FLAC__bool parse_cuesheet(FLAC__StreamMetadata **cuesheet, const char *cuesheet_filename, const char *inbasefilename, FLAC__bool is_cdda, FLAC__uint64 lead_out_offset);
141 static void print_stats(const EncoderSession *encoder_session);
142 static void print_error_with_init_status(const EncoderSession *e, const char *message, FLAC__StreamEncoderInitStatus init_status);
143 static void print_error_with_state(const EncoderSession *e, const char *message);
144 static void print_verify_error(EncoderSession *e);
145 static FLAC__bool read_little_endian_uint16(FILE *f, FLAC__uint16 *val, FLAC__bool eof_ok, const char *fn);
146 static FLAC__bool read_little_endian_uint32(FILE *f, FLAC__uint32 *val, FLAC__bool eof_ok, const char *fn);
147 static FLAC__bool read_big_endian_uint16(FILE *f, FLAC__uint16 *val, FLAC__bool eof_ok, const char *fn);
148 static FLAC__bool read_big_endian_uint32(FILE *f, FLAC__uint32 *val, FLAC__bool eof_ok, const char *fn);
149 static FLAC__bool read_sane_extended(FILE *f, FLAC__uint32 *val, FLAC__bool eof_ok, const char *fn);
150 static FLAC__bool fskip_ahead(FILE *f, FLAC__uint64 offset);
151 static unsigned count_channel_mask_bits(FLAC__uint32 mask);
152 static FLAC__uint32 limit_channel_mask(FLAC__uint32 mask, unsigned channels);
157 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)
159 EncoderSession encoder_session;
162 unsigned int channels= 0U, bps= 0U, shift= 0U, sample_rate= 0U, sample_frames= 0U;
163 size_t channel_map[FLAC__MAX_CHANNELS];
164 FLAC__bool got_comm_chunk= false, got_ssnd_chunk= false;
165 int info_align_carry= -1, info_align_zero= -1;
166 FLAC__bool is_big_endian_pcm = true;
168 (void)infilesize; /* silence compiler warning about unused parameter */
169 (void)lookahead; /* silence compiler warning about unused parameter */
170 (void)lookahead_length; /* silence compiler warning about unused parameter */
173 EncoderSession_construct(
176 options.common.use_ogg,
180 options.common.verify,
188 /* initialize default channel map that preserves channel order */
191 for(i = 0; i < sizeof(channel_map)/sizeof(channel_map[0]); i++)
195 /* lookahead[] already has "FORMxxxxAIFF", do sub-chunks */
199 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 */
201 /* chunk identifier; really conservative about behavior of fread() and feof() */
202 if(feof(infile) || ((c= fread(chunk_id, 1U, 4U, infile)), c==0U && feof(infile)))
204 else if(c<4U || feof(infile)) {
205 flac__utils_printf(stderr, 1, "%s: ERROR: incomplete chunk identifier\n", encoder_session.inbasefilename);
206 return EncoderSession_finish_error(&encoder_session);
209 if(got_comm_chunk==false && !memcmp(chunk_id, "COMM", 4)) { /* common chunk */
211 const FLAC__uint32 minimum_comm_size = (is_aifc? 22 : 18);
213 /* COMM chunk size */
214 if(!read_big_endian_uint32(infile, &xx, false, encoder_session.inbasefilename))
215 return EncoderSession_finish_error(&encoder_session);
216 else if(xx<minimum_comm_size) {
217 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);
218 return EncoderSession_finish_error(&encoder_session);
220 else if(!is_aifc && xx!=minimum_comm_size) {
221 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);
223 skip= (xx-minimum_comm_size)+(xx & 1U);
225 /* number of channels */
226 if(!read_big_endian_uint16(infile, &x, false, encoder_session.inbasefilename))
227 return EncoderSession_finish_error(&encoder_session);
228 else if(x==0U || x>FLAC__MAX_CHANNELS) {
229 flac__utils_printf(stderr, 1, "%s: ERROR: unsupported number channels %u\n", encoder_session.inbasefilename, (unsigned int)x);
230 return EncoderSession_finish_error(&encoder_session);
232 else if(x>2U && !options.common.channel_map_none) {
233 flac__utils_printf(stderr, 1, "%s: ERROR: unsupported number channels %u for AIFF\n", encoder_session.inbasefilename, (unsigned int)x);
234 return EncoderSession_finish_error(&encoder_session);
236 else if(options.common.sector_align && x!=2U) {
237 flac__utils_printf(stderr, 1, "%s: ERROR: file has %u channels, must be 2 for --sector-align\n", encoder_session.inbasefilename, (unsigned int)x);
238 return EncoderSession_finish_error(&encoder_session);
242 /* number of sample frames */
243 if(!read_big_endian_uint32(infile, &xx, false, encoder_session.inbasefilename))
244 return EncoderSession_finish_error(&encoder_session);
247 /* bits per sample */
248 if(!read_big_endian_uint16(infile, &x, false, encoder_session.inbasefilename))
249 return EncoderSession_finish_error(&encoder_session);
250 else if(x<4U || x>24U) {
251 flac__utils_printf(stderr, 1, "%s: ERROR: unsupported bits-per-sample %u\n", encoder_session.inbasefilename, (unsigned int)x);
252 return EncoderSession_finish_error(&encoder_session);
254 else if(options.common.sector_align && x!=16U) {
255 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);
256 return EncoderSession_finish_error(&encoder_session);
259 shift= (bps%8)? 8-(bps%8) : 0; /* SSND data is always byte-aligned, left-justified but format_input() will double-check */
263 if(!read_sane_extended(infile, &xx, false, encoder_session.inbasefilename))
264 return EncoderSession_finish_error(&encoder_session);
265 else if(!FLAC__format_sample_rate_is_valid(xx)) {
266 flac__utils_printf(stderr, 1, "%s: ERROR: unsupported sample rate %u\n", encoder_session.inbasefilename, (unsigned int)xx);
267 return EncoderSession_finish_error(&encoder_session);
269 else if(options.common.sector_align && xx!=44100U) {
270 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);
271 return EncoderSession_finish_error(&encoder_session);
275 /* check compression type for AIFF-C */
277 if(!read_big_endian_uint32(infile, &xx, false, encoder_session.inbasefilename))
278 return EncoderSession_finish_error(&encoder_session);
279 if(xx == 0x736F7774) /* "sowt" */
280 is_big_endian_pcm = false;
281 else if(xx == 0x4E4F4E45) /* "NONE" */
282 ; /* nothing to do, we already default to big-endian */
284 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));
285 return EncoderSession_finish_error(&encoder_session);
289 /* set channel mapping */
290 /* FLAC order follows SMPTE and WAVEFORMATEXTENSIBLE but with fewer channels, which are: */
291 /* front left, front right, center, LFE, back left, back right, surround left, surround right */
292 /* specs say the channel ordering is:
294 * ___________________________________________________
298 * quad (ambiguous with 4ch) Fl Fr Bl Br
301 * 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
302 * so we only have unambiguous mappings for 2, 3, and 5 channels
305 options.common.channel_map_none ||
306 channels == 1 || /* 1 channel: (mono) */
307 channels == 2 || /* 2 channels: left, right */
308 channels == 3 || /* 3 channels: left, right, center */
309 channels == 5 /* 5 channels: front left, front right, center, surround left, surround right */
311 /* keep default channel order */
314 flac__utils_printf(stderr, 1, "%s: ERROR: unsupported number channels %u for AIFF\n", encoder_session.inbasefilename, channels);
315 return EncoderSession_finish_error(&encoder_session);
318 /* skip any extra data in the COMM chunk */
319 if(!fskip_ahead(infile, skip)) {
320 flac__utils_printf(stderr, 1, "%s: ERROR during read while skipping extra COMM data\n", encoder_session.inbasefilename);
321 return EncoderSession_finish_error(&encoder_session);
325 * now that we know the sample rate, canonicalize the
326 * --skip string to a number of samples:
328 flac__utils_canonicalize_skip_until_specification(&options.common.skip_specification, sample_rate);
329 FLAC__ASSERT(options.common.skip_specification.value.samples >= 0);
330 encoder_session.skip = (FLAC__uint64)options.common.skip_specification.value.samples;
331 FLAC__ASSERT(!options.common.sector_align || encoder_session.skip == 0);
333 got_comm_chunk= true;
335 else if(got_ssnd_chunk==false && !memcmp(chunk_id, "SSND", 4)) { /* sound data chunk */
336 unsigned int offset= 0U, block_size= 0U, align_remainder= 0U, data_bytes;
337 size_t bytes_per_frame= channels*(bps>>3);
338 FLAC__uint64 total_samples_in_input, trim = 0;
339 FLAC__bool pad= false;
341 if(got_comm_chunk==false) {
342 flac__utils_printf(stderr, 1, "%s: ERROR: got 'SSND' chunk before 'COMM' chunk\n", encoder_session.inbasefilename);
343 return EncoderSession_finish_error(&encoder_session);
346 /* SSND chunk size */
347 if(!read_big_endian_uint32(infile, &xx, false, encoder_session.inbasefilename))
348 return EncoderSession_finish_error(&encoder_session);
350 pad= (data_bytes & 1U) ? true : false;
351 data_bytes-= 8U; /* discount the offset and block size fields */
354 if(!read_big_endian_uint32(infile, &xx, false, encoder_session.inbasefilename))
355 return EncoderSession_finish_error(&encoder_session);
360 if(!read_big_endian_uint32(infile, &xx, false, encoder_session.inbasefilename))
361 return EncoderSession_finish_error(&encoder_session);
363 flac__utils_printf(stderr, 1, "%s: ERROR: block size is %u; must be 0\n", encoder_session.inbasefilename, (unsigned int)xx);
364 return EncoderSession_finish_error(&encoder_session);
368 /* skip any SSND offset bytes */
369 FLAC__ASSERT(offset<=LONG_MAX);
370 if(!fskip_ahead(infile, offset)) {
371 flac__utils_printf(stderr, 1, "%s: ERROR: skipping offset in SSND chunk\n", encoder_session.inbasefilename);
372 return EncoderSession_finish_error(&encoder_session);
374 if(data_bytes!=(sample_frames*bytes_per_frame)) {
375 flac__utils_printf(stderr, 1, "%s: ERROR: SSND chunk size inconsistent with sample frame count\n", encoder_session.inbasefilename);
376 return EncoderSession_finish_error(&encoder_session);
379 /* *options.common.align_reservoir_samples will be 0 unless --sector-align is used */
380 FLAC__ASSERT(options.common.sector_align || *options.common.align_reservoir_samples == 0);
381 total_samples_in_input = data_bytes / bytes_per_frame + *options.common.align_reservoir_samples;
384 * now that we know the input size, canonicalize the
385 * --until string to an absolute sample number:
387 if(!canonicalize_until_specification(&options.common.until_specification, encoder_session.inbasefilename, sample_rate, encoder_session.skip, total_samples_in_input))
388 return EncoderSession_finish_error(&encoder_session);
389 encoder_session.until = (FLAC__uint64)options.common.until_specification.value.samples;
390 FLAC__ASSERT(!options.common.sector_align || encoder_session.until == 0);
392 if(encoder_session.skip>0U) {
393 if(!fskip_ahead(infile, encoder_session.skip*bytes_per_frame)) {
394 flac__utils_printf(stderr, 1, "%s: ERROR during read while skipping samples\n", encoder_session.inbasefilename);
395 return EncoderSession_finish_error(&encoder_session);
399 data_bytes-= (unsigned int)encoder_session.skip*bytes_per_frame; /*@@@ WATCHOUT: 4GB limit */
400 encoder_session.total_samples_to_encode= total_samples_in_input - encoder_session.skip;
401 if(encoder_session.until > 0) {
402 trim = total_samples_in_input - encoder_session.until;
403 FLAC__ASSERT(total_samples_in_input > 0);
404 FLAC__ASSERT(!options.common.sector_align);
405 data_bytes-= (unsigned int)trim*bytes_per_frame;
406 encoder_session.total_samples_to_encode-= trim;
408 if(options.common.sector_align) {
409 align_remainder= (unsigned int)(encoder_session.total_samples_to_encode % 588U);
410 if(options.common.is_last_file)
411 encoder_session.total_samples_to_encode+= (588U-align_remainder); /* will pad with zeroes */
413 encoder_session.total_samples_to_encode-= align_remainder; /* will stop short and carry over to next file */
416 /* +54 for the size of the AIFF headers; this is just an estimate for the progress indicator and doesn't need to be exact */
417 encoder_session.unencoded_size= encoder_session.total_samples_to_encode*bytes_per_frame+54;
419 if(!EncoderSession_init_encoder(&encoder_session, options.common, /*channel_mask=*/0, channels, bps-shift, sample_rate, /*flac_decoder_data=*/0))
420 return EncoderSession_finish_error(&encoder_session);
422 /* first do any samples in the reservoir */
423 if(options.common.sector_align && *options.common.align_reservoir_samples>0U) {
425 if(!EncoderSession_process(&encoder_session, (const FLAC__int32 *const *)options.common.align_reservoir, *options.common.align_reservoir_samples)) {
426 print_error_with_state(&encoder_session, "ERROR during encoding");
427 return EncoderSession_finish_error(&encoder_session);
431 /* decrement the data_bytes counter if we need to align the file */
432 if(options.common.sector_align) {
433 if(options.common.is_last_file)
434 *options.common.align_reservoir_samples= 0U;
436 *options.common.align_reservoir_samples= align_remainder;
437 data_bytes-= (*options.common.align_reservoir_samples)*bytes_per_frame;
441 /* now do from the file */
442 while(data_bytes>0) {
443 size_t bytes_read= fread(ucbuffer_, 1U, min(data_bytes, CHUNK_OF_SAMPLES*bytes_per_frame), infile);
447 flac__utils_printf(stderr, 1, "%s: ERROR during read\n", encoder_session.inbasefilename);
448 return EncoderSession_finish_error(&encoder_session);
450 else if(feof(infile)) {
451 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);
456 if(bytes_read % bytes_per_frame != 0U) {
457 flac__utils_printf(stderr, 1, "%s: ERROR: got partial sample\n", encoder_session.inbasefilename);
458 return EncoderSession_finish_error(&encoder_session);
461 unsigned int frames= bytes_read/bytes_per_frame;
462 if(!format_input(input_, frames, is_big_endian_pcm, /*is_unsigned_samples=*/false, channels, bps, shift, channel_map))
463 return EncoderSession_finish_error(&encoder_session);
465 if(!EncoderSession_process(&encoder_session, (const FLAC__int32 *const *)input_, frames)) {
466 print_error_with_state(&encoder_session, "ERROR during encoding");
467 return EncoderSession_finish_error(&encoder_session);
470 data_bytes-= bytes_read;
476 FLAC__ASSERT(!options.common.sector_align);
477 if(!fskip_ahead(infile, trim*bytes_per_frame)) {
478 flac__utils_printf(stderr, 1, "%s: ERROR during read while skipping samples\n", encoder_session.inbasefilename);
479 return EncoderSession_finish_error(&encoder_session);
483 /* now read unaligned samples into reservoir or pad with zeroes if necessary */
484 if(options.common.sector_align) {
485 if(options.common.is_last_file) {
486 unsigned int pad_frames= 588U-align_remainder;
488 if(pad_frames<588U) {
491 info_align_zero= pad_frames;
492 for(i= 0U; i<channels; ++i)
493 memset(input_[i], 0, sizeof(input_[0][0])*pad_frames);
495 if(!EncoderSession_process(&encoder_session, (const FLAC__int32 *const *)input_, pad_frames)) {
496 print_error_with_state(&encoder_session, "ERROR during encoding");
497 return EncoderSession_finish_error(&encoder_session);
502 if(*options.common.align_reservoir_samples > 0) {
503 size_t bytes_read= fread(ucbuffer_, 1U, (*options.common.align_reservoir_samples)*bytes_per_frame, infile);
505 FLAC__ASSERT(CHUNK_OF_SAMPLES>=588U);
506 if(bytes_read==0U && ferror(infile)) {
507 flac__utils_printf(stderr, 1, "%s: ERROR during read\n", encoder_session.inbasefilename);
508 return EncoderSession_finish_error(&encoder_session);
510 else if(bytes_read != (*options.common.align_reservoir_samples) * bytes_per_frame) {
511 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);
514 info_align_carry= *options.common.align_reservoir_samples;
515 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))
516 return EncoderSession_finish_error(&encoder_session);
525 if(fread(&tmp, 1U, 1U, infile)<1U) {
526 flac__utils_printf(stderr, 1, "%s: ERROR during read of SSND pad byte\n", encoder_session.inbasefilename);
527 return EncoderSession_finish_error(&encoder_session);
531 got_ssnd_chunk= true;
533 else { /* other chunk */
534 if(!memcmp(chunk_id, "COMM", 4)) {
535 flac__utils_printf(stderr, 1, "%s: WARNING: skipping extra 'COMM' chunk\n", encoder_session.inbasefilename);
537 else if(!memcmp(chunk_id, "SSND", 4)) {
538 flac__utils_printf(stderr, 1, "%s: WARNING: skipping extra 'SSND' chunk\n", encoder_session.inbasefilename);
541 flac__utils_printf(stderr, 1, "%s: WARNING: skipping unknown chunk '%s'\n", encoder_session.inbasefilename, chunk_id);
545 if(!read_big_endian_uint32(infile, &xx, false, encoder_session.inbasefilename))
546 return EncoderSession_finish_error(&encoder_session);
548 unsigned long skip= xx+(xx & 1U);
550 FLAC__ASSERT(skip<=LONG_MAX);
551 if(!fskip_ahead(infile, skip)) {
552 fprintf(stderr, "%s: ERROR during read while skipping unknown chunk\n", encoder_session.inbasefilename);
553 return EncoderSession_finish_error(&encoder_session);
559 if(got_ssnd_chunk==false && sample_frames!=0U) {
560 flac__utils_printf(stderr, 1, "%s: ERROR: missing SSND chunk\n", encoder_session.inbasefilename);
561 return EncoderSession_finish_error(&encoder_session);
564 return EncoderSession_finish_ok(&encoder_session, info_align_carry, info_align_zero);
567 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)
569 EncoderSession encoder_session;
570 FLAC__bool is_unsigned_samples = false;
571 unsigned channels = 0, bps = 0, sample_rate = 0, shift = 0;
572 size_t bytes_per_wide_sample, bytes_read;
573 size_t channel_map[FLAC__MAX_CHANNELS];
574 FLAC__uint16 x, format; /* format is the wFormatTag word from the 'fmt ' chunk */
575 FLAC__uint32 xx, channel_mask = 0;
576 FLAC__bool got_fmt_chunk = false, got_data_chunk = false;
577 unsigned align_remainder = 0;
578 int info_align_carry = -1, info_align_zero = -1;
582 (void)lookahead_length;
585 EncoderSession_construct(
588 options.common.use_ogg,
592 options.common.verify,
600 /* initialize default channel map that preserves channel order */
603 for(i = 0; i < sizeof(channel_map)/sizeof(channel_map[0]); i++)
608 * lookahead[] already has "RIFFxxxxWAVE", do sub-chunks
610 while(!feof(infile)) {
611 if(!read_little_endian_uint32(infile, &xx, true, encoder_session.inbasefilename))
612 return EncoderSession_finish_error(&encoder_session);
615 if(xx == 0x20746d66 && !got_fmt_chunk) { /* "fmt " */
616 unsigned block_align, data_bytes;
619 * http://www-mmsp.ece.mcgill.ca/Documents/AudioFormats/WAVE/WAVE.html
620 * http://windowssdk.msdn.microsoft.com/en-us/library/ms713497.aspx
621 * 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
624 * 4 byte: subchunk size
625 * 2 byte: format type: 1 for WAVE_FORMAT_PCM, 65534 for WAVE_FORMAT_EXTENSIBLE
627 * 4 byte: sample rate (Hz)
628 * 4 byte: avg bytes per sec
629 * 2 byte: block align
630 * 2 byte: bits per sample (not necessarily all significant)
632 * 2 byte: extension size in bytes (usually 0 for WAVEFORMATEX and 22 for WAVEFORMATEXTENSIBLE with PCM)
633 * WAVEFORMATEXTENSIBLE adds
634 * 2 byte: valid bits per sample
635 * 4 byte: channel mask
636 * 16 byte: subformat GUID, first 2 bytes have format type, 1 being PCM
638 * Current spec says WAVEFORMATEX with PCM must have bps == 8 or 16, or any multiple of 8 for WAVEFORMATEXTENSIBLE.
639 * 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.
641 * Block align for WAVE_FORMAT_PCM or WAVE_FORMAT_EXTENSIBLE is also supposed to be channels*bps/8
643 * If the channel mask has more set bits than # of channels, the extra MSBs are ignored.
644 * If the channel mask has less set bits than # of channels, the extra channels are unassigned to any speaker.
646 * Data is supposed to be unsigned for bps <= 8 else signed.
649 /* fmt sub-chunk size */
650 if(!read_little_endian_uint32(infile, &xx, false, encoder_session.inbasefilename))
651 return EncoderSession_finish_error(&encoder_session);
653 if(data_bytes < 16) {
654 flac__utils_printf(stderr, 1, "%s: ERROR: found non-standard 'fmt ' sub-chunk which has length = %u\n", encoder_session.inbasefilename, data_bytes);
655 return EncoderSession_finish_error(&encoder_session);
658 if(!read_little_endian_uint16(infile, &format, false, encoder_session.inbasefilename))
659 return EncoderSession_finish_error(&encoder_session);
660 if(format != 1 /*WAVE_FORMAT_PCM*/ && format != 65534 /*WAVE_FORMAT_EXTENSIBLE*/) {
661 flac__utils_printf(stderr, 1, "%s: ERROR: unsupported format type %u\n", encoder_session.inbasefilename, (unsigned)format);
662 return EncoderSession_finish_error(&encoder_session);
664 /* number of channels */
665 if(!read_little_endian_uint16(infile, &x, false, encoder_session.inbasefilename))
666 return EncoderSession_finish_error(&encoder_session);
667 channels = (unsigned)x;
668 if(channels == 0 || channels > FLAC__MAX_CHANNELS) {
669 flac__utils_printf(stderr, 1, "%s: ERROR: unsupported number of channels %u\n", encoder_session.inbasefilename, channels);
670 return EncoderSession_finish_error(&encoder_session);
672 else if(options.common.sector_align && channels != 2) {
673 flac__utils_printf(stderr, 1, "%s: ERROR: file has %u channels, must be 2 for --sector-align\n", encoder_session.inbasefilename, channels);
674 return EncoderSession_finish_error(&encoder_session);
677 if(!read_little_endian_uint32(infile, &xx, false, encoder_session.inbasefilename))
678 return EncoderSession_finish_error(&encoder_session);
680 if(!FLAC__format_sample_rate_is_valid(sample_rate)) {
681 flac__utils_printf(stderr, 1, "%s: ERROR: unsupported sample rate %u\n", encoder_session.inbasefilename, sample_rate);
682 return EncoderSession_finish_error(&encoder_session);
684 else if(options.common.sector_align && sample_rate != 44100) {
685 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);
686 return EncoderSession_finish_error(&encoder_session);
688 /* avg bytes per second (ignored) */
689 if(!read_little_endian_uint32(infile, &xx, false, encoder_session.inbasefilename))
690 return EncoderSession_finish_error(&encoder_session);
692 if(!read_little_endian_uint16(infile, &x, false, encoder_session.inbasefilename))
693 return EncoderSession_finish_error(&encoder_session);
694 block_align = (unsigned)x;
695 /* bits per sample */
696 if(!read_little_endian_uint16(infile, &x, false, encoder_session.inbasefilename))
697 return EncoderSession_finish_error(&encoder_session);
699 is_unsigned_samples = (bps <= 8);
701 if(bps != 8 && bps != 16) {
702 if(bps == 24 || bps == 32) {
703 /* let these slide with a warning since they're unambiguous */
704 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);
707 /* @@@ we could add an option to specify left- or right-justified blocks so we knew how to set 'shift' */
708 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);
709 return EncoderSession_finish_error(&encoder_session);
712 #if 0 /* @@@ reinstate once we can get an answer about whether the samples are left- or right-justified */
713 if((bps+7)/8 * channels == block_align) {
715 /* assume legacy file is byte aligned with some LSBs zero; this is double-checked in format_input() */
716 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);
717 shift = 8 - (bps % 8);
724 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);
725 return EncoderSession_finish_error(&encoder_session);
730 if(channels > 2 && !options.common.channel_map_none) {
731 flac__utils_printf(stderr, 1, "%s: ERROR: WAVE has >2 channels but is not WAVE_FORMAT_EXTENSIBLE; cannot assign channels\n", encoder_session.inbasefilename);
732 return EncoderSession_finish_error(&encoder_session);
734 FLAC__ASSERT(data_bytes >= 16);
738 if(data_bytes < 40) {
739 flac__utils_printf(stderr, 1, "%s: ERROR: invalid WAVEFORMATEXTENSIBLE chunk with size %u\n", encoder_session.inbasefilename, data_bytes);
740 return EncoderSession_finish_error(&encoder_session);
743 if(!read_little_endian_uint16(infile, &x, false, encoder_session.inbasefilename))
744 return EncoderSession_finish_error(&encoder_session);
746 flac__utils_printf(stderr, 1, "%s: ERROR: invalid WAVEFORMATEXTENSIBLE chunk with cbSize %u\n", encoder_session.inbasefilename, (unsigned)x);
747 return EncoderSession_finish_error(&encoder_session);
750 if(!read_little_endian_uint16(infile, &x, false, encoder_session.inbasefilename))
751 return EncoderSession_finish_error(&encoder_session);
752 if((unsigned)x > bps) {
753 flac__utils_printf(stderr, 1, "%s: ERROR: invalid WAVEFORMATEXTENSIBLE chunk with wValidBitsPerSample (%u) > wBitsPerSample (%u)\n", encoder_session.inbasefilename, (unsigned)x, bps);
754 return EncoderSession_finish_error(&encoder_session);
756 shift = bps - (unsigned)x;
758 if(!read_little_endian_uint32(infile, &channel_mask, false, encoder_session.inbasefilename))
759 return EncoderSession_finish_error(&encoder_session);
760 /* for mono/stereo and unassigned channels, we fake the mask */
761 if(channel_mask == 0) {
763 channel_mask = 0x0001;
764 else if(channels == 2)
765 channel_mask = 0x0003;
767 /* set channel mapping */
768 /* FLAC order follows SMPTE and WAVEFORMATEXTENSIBLE but with fewer channels, which are: */
769 /* front left, front right, center, LFE, back left, back right, surround left, surround right */
770 /* the default mapping is sufficient for 1-6 channels and 7-8 are currently unspecified anyway */
772 /* @@@ example for dolby/vorbis order, for reference later in case it becomes important */
774 options.common.channel_map_none ||
775 channel_mask == 0x0001 || /* 1 channel: (mono) */
776 channel_mask == 0x0003 || /* 2 channels: front left, front right */
777 channel_mask == 0x0033 || /* 4 channels: front left, front right, back left, back right */
778 channel_mask == 0x0603 /* 4 channels: front left, front right, side left, side right */
780 /* keep default channel order */
783 channel_mask == 0x0007 || /* 3 channels: front left, front right, front center */
784 channel_mask == 0x0037 || /* 5 channels: front left, front right, front center, back left, back right */
785 channel_mask == 0x0607 /* 5 channels: front left, front right, front center, side left, side right */
787 /* to dolby order: front left, center, front right [, surround left, surround right ] */
792 channel_mask == 0x003f || /* 6 channels: front left, front right, front center, LFE, back left, back right */
793 channel_mask == 0x060f /* 6 channels: front left, front right, front center, LFE, side left, side right */
795 /* to dolby order: front left, center, front right, surround left, surround right, LFE */
804 options.common.channel_map_none ||
805 channel_mask == 0x0001 || /* 1 channel: (mono) */
806 channel_mask == 0x0003 || /* 2 channels: front left, front right */
807 channel_mask == 0x0007 || /* 3 channels: front left, front right, front center */
808 channel_mask == 0x0033 || /* 4 channels: front left, front right, back left, back right */
809 channel_mask == 0x0603 || /* 4 channels: front left, front right, side left, side right */
810 channel_mask == 0x0037 || /* 5 channels: front left, front right, front center, back left, back right */
811 channel_mask == 0x0607 || /* 5 channels: front left, front right, front center, side left, side right */
812 channel_mask == 0x003f || /* 6 channels: front left, front right, front center, LFE, back left, back right */
813 channel_mask == 0x060f /* 6 channels: front left, front right, front center, LFE, side left, side right */
815 /* keep default channel order */
819 flac__utils_printf(stderr, 1, "%s: ERROR: WAVEFORMATEXTENSIBLE chunk with unsupported channel mask=0x%04X\n", encoder_session.inbasefilename, (unsigned)channel_mask);
820 return EncoderSession_finish_error(&encoder_session);
822 if(!options.common.channel_map_none) {
823 if(count_channel_mask_bits(channel_mask) < channels) {
824 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);
825 return EncoderSession_finish_error(&encoder_session);
828 /* supporting this is too difficult with channel mapping; e.g. what if mask is 0x003f but #channels=4?
829 * there would be holes in the order that would have to be filled in, or the mask would have to be
830 * limited and the logic above rerun to see if it still fits into the FLAC mapping.
832 else if(count_channel_mask_bits(channel_mask) > channels)
833 channel_mask = limit_channel_mask(channel_mask, channels);
835 else if(count_channel_mask_bits(channel_mask) > channels) {
836 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);
837 return EncoderSession_finish_error(&encoder_session);
841 /* first part of GUID */
842 if(!read_little_endian_uint16(infile, &x, false, encoder_session.inbasefilename))
843 return EncoderSession_finish_error(&encoder_session);
845 flac__utils_printf(stderr, 1, "%s: ERROR: unsupported WAVEFORMATEXTENSIBLE chunk with non-PCM format %u\n", encoder_session.inbasefilename, (unsigned)x);
846 return EncoderSession_finish_error(&encoder_session);
851 if(bps-shift < 4 || bps-shift > 24) {
852 flac__utils_printf(stderr, 1, "%s: ERROR: unsupported bits-per-sample %u\n", encoder_session.inbasefilename, bps-shift);
853 return EncoderSession_finish_error(&encoder_session);
855 else if(options.common.sector_align && bps-shift != 16) {
856 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);
857 return EncoderSession_finish_error(&encoder_session);
860 /* skip any extra data in the fmt sub-chunk */
861 if(!fskip_ahead(infile, data_bytes)) {
862 flac__utils_printf(stderr, 1, "%s: ERROR during read while skipping extra 'fmt' data\n", encoder_session.inbasefilename);
863 return EncoderSession_finish_error(&encoder_session);
867 * now that we know the sample rate, canonicalize the
868 * --skip string to a number of samples:
870 flac__utils_canonicalize_skip_until_specification(&options.common.skip_specification, sample_rate);
871 FLAC__ASSERT(options.common.skip_specification.value.samples >= 0);
872 encoder_session.skip = (FLAC__uint64)options.common.skip_specification.value.samples;
873 FLAC__ASSERT(!options.common.sector_align || encoder_session.skip == 0);
875 got_fmt_chunk = true;
877 else if(xx == 0x61746164 && !got_data_chunk && got_fmt_chunk) { /* "data" */
878 FLAC__uint64 total_samples_in_input, trim = 0;
879 FLAC__bool pad = false;
883 if(!read_little_endian_uint32(infile, &xx, false, encoder_session.inbasefilename))
884 return EncoderSession_finish_error(&encoder_session);
886 if(0 == data_bytes) {
887 flac__utils_printf(stderr, 1, "%s: ERROR: 'data' subchunk has size of 0\n", encoder_session.inbasefilename);
888 return EncoderSession_finish_error(&encoder_session);
890 pad = (data_bytes & 1U) ? true : false;
892 bytes_per_wide_sample = channels * (bps >> 3);
894 /* *options.common.align_reservoir_samples will be 0 unless --sector-align is used */
895 FLAC__ASSERT(options.common.sector_align || *options.common.align_reservoir_samples == 0);
896 total_samples_in_input = data_bytes / bytes_per_wide_sample + *options.common.align_reservoir_samples;
899 * now that we know the input size, canonicalize the
900 * --until string to an absolute sample number:
902 if(!canonicalize_until_specification(&options.common.until_specification, encoder_session.inbasefilename, sample_rate, encoder_session.skip, total_samples_in_input))
903 return EncoderSession_finish_error(&encoder_session);
904 encoder_session.until = (FLAC__uint64)options.common.until_specification.value.samples;
905 FLAC__ASSERT(!options.common.sector_align || encoder_session.until == 0);
907 if(encoder_session.skip > 0) {
908 if(!fskip_ahead(infile, encoder_session.skip * bytes_per_wide_sample)) {
909 flac__utils_printf(stderr, 1, "%s: ERROR during read while skipping samples\n", encoder_session.inbasefilename);
910 return EncoderSession_finish_error(&encoder_session);
914 data_bytes -= (unsigned)encoder_session.skip * bytes_per_wide_sample; /*@@@ WATCHOUT: 4GB limit */
915 encoder_session.total_samples_to_encode = total_samples_in_input - encoder_session.skip;
916 if(encoder_session.until > 0) {
917 trim = total_samples_in_input - encoder_session.until;
918 FLAC__ASSERT(total_samples_in_input > 0);
919 FLAC__ASSERT(!options.common.sector_align);
920 data_bytes -= (unsigned int)trim * bytes_per_wide_sample;
921 encoder_session.total_samples_to_encode -= trim;
923 if(options.common.sector_align) {
924 align_remainder = (unsigned)(encoder_session.total_samples_to_encode % 588);
925 if(options.common.is_last_file)
926 encoder_session.total_samples_to_encode += (588-align_remainder); /* will pad with zeroes */
928 encoder_session.total_samples_to_encode -= align_remainder; /* will stop short and carry over to next file */
931 /* +44 for the size of the WAV headers; this is just an estimate for the progress indicator and doesn't need to be exact */
932 encoder_session.unencoded_size = encoder_session.total_samples_to_encode * bytes_per_wide_sample + 44;
934 if(!EncoderSession_init_encoder(&encoder_session, options.common, channel_mask, channels, bps-shift, sample_rate, /*flac_decoder_data=*/0))
935 return EncoderSession_finish_error(&encoder_session);
938 * first do any samples in the reservoir
940 if(options.common.sector_align && *options.common.align_reservoir_samples > 0) {
941 if(!EncoderSession_process(&encoder_session, (const FLAC__int32 * const *)options.common.align_reservoir, *options.common.align_reservoir_samples)) {
942 print_error_with_state(&encoder_session, "ERROR during encoding");
943 return EncoderSession_finish_error(&encoder_session);
948 * decrement the data_bytes counter if we need to align the file
950 if(options.common.sector_align) {
951 if(options.common.is_last_file) {
952 *options.common.align_reservoir_samples = 0;
955 *options.common.align_reservoir_samples = align_remainder;
956 data_bytes -= (*options.common.align_reservoir_samples) * bytes_per_wide_sample;
961 * now do from the file
963 while(data_bytes > 0) {
964 bytes_read = fread(ucbuffer_, sizeof(unsigned char), min(data_bytes, CHUNK_OF_SAMPLES * bytes_per_wide_sample), infile);
965 if(bytes_read == 0) {
967 flac__utils_printf(stderr, 1, "%s: ERROR during read\n", encoder_session.inbasefilename);
968 return EncoderSession_finish_error(&encoder_session);
970 else if(feof(infile)) {
971 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);
976 if(bytes_read % bytes_per_wide_sample != 0) {
977 flac__utils_printf(stderr, 1, "%s: ERROR: got partial sample\n", encoder_session.inbasefilename);
978 return EncoderSession_finish_error(&encoder_session);
981 unsigned wide_samples = bytes_read / bytes_per_wide_sample;
982 if(!format_input(input_, wide_samples, /*is_big_endian=*/false, is_unsigned_samples, channels, bps, shift, channel_map))
983 return EncoderSession_finish_error(&encoder_session);
985 if(!EncoderSession_process(&encoder_session, (const FLAC__int32 * const *)input_, wide_samples)) {
986 print_error_with_state(&encoder_session, "ERROR during encoding");
987 return EncoderSession_finish_error(&encoder_session);
989 data_bytes -= bytes_read;
995 FLAC__ASSERT(!options.common.sector_align);
996 if(!fskip_ahead(infile, trim * bytes_per_wide_sample)) {
997 flac__utils_printf(stderr, 1, "%s: ERROR during read while skipping samples\n", encoder_session.inbasefilename);
998 return EncoderSession_finish_error(&encoder_session);
1003 * now read unaligned samples into reservoir or pad with zeroes if necessary
1005 if(options.common.sector_align) {
1006 if(options.common.is_last_file) {
1007 unsigned wide_samples = 588 - align_remainder;
1008 if(wide_samples < 588) {
1011 info_align_zero = wide_samples;
1012 for(channel = 0; channel < channels; channel++)
1013 memset(input_[channel], 0, sizeof(input_[0][0]) * wide_samples);
1015 if(!EncoderSession_process(&encoder_session, (const FLAC__int32 * const *)input_, wide_samples)) {
1016 print_error_with_state(&encoder_session, "ERROR during encoding");
1017 return EncoderSession_finish_error(&encoder_session);
1022 if(*options.common.align_reservoir_samples > 0) {
1023 FLAC__ASSERT(CHUNK_OF_SAMPLES >= 588);
1024 bytes_read = fread(ucbuffer_, sizeof(unsigned char), (*options.common.align_reservoir_samples) * bytes_per_wide_sample, infile);
1025 if(bytes_read == 0 && ferror(infile)) {
1026 flac__utils_printf(stderr, 1, "%s: ERROR during read\n", encoder_session.inbasefilename);
1027 return EncoderSession_finish_error(&encoder_session);
1029 else if(bytes_read != (*options.common.align_reservoir_samples) * bytes_per_wide_sample) {
1030 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);
1033 info_align_carry = *options.common.align_reservoir_samples;
1034 if(!format_input(options.common.align_reservoir, *options.common.align_reservoir_samples, /*is_big_endian=*/false, is_unsigned_samples, channels, bps, shift, channel_map))
1035 return EncoderSession_finish_error(&encoder_session);
1044 if(fread(&tmp, 1U, 1U, infile) < 1U) {
1045 flac__utils_printf(stderr, 1, "%s: ERROR during read of data pad byte\n", encoder_session.inbasefilename);
1046 return EncoderSession_finish_error(&encoder_session);
1050 got_data_chunk = true;
1053 if(xx == 0x20746d66 && got_fmt_chunk) { /* "fmt " */
1054 flac__utils_printf(stderr, 1, "%s: WARNING: skipping extra 'fmt ' sub-chunk\n", encoder_session.inbasefilename);
1056 else if(xx == 0x61746164) { /* "data" */
1057 if(got_data_chunk) {
1058 flac__utils_printf(stderr, 1, "%s: WARNING: skipping extra 'data' sub-chunk\n", encoder_session.inbasefilename);
1060 else if(!got_fmt_chunk) {
1061 flac__utils_printf(stderr, 1, "%s: ERROR: got 'data' sub-chunk before 'fmt' sub-chunk\n", encoder_session.inbasefilename);
1062 return EncoderSession_finish_error(&encoder_session);
1069 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));
1071 /* sub-chunk size */
1072 if(!read_little_endian_uint32(infile, &xx, false, encoder_session.inbasefilename))
1073 return EncoderSession_finish_error(&encoder_session);
1075 unsigned long skip = xx+(xx & 1U);
1077 FLAC__ASSERT(skip<=LONG_MAX);
1078 if(!fskip_ahead(infile, skip)) {
1079 flac__utils_printf(stderr, 1, "%s: ERROR during read while skipping unsupported sub-chunk\n", encoder_session.inbasefilename);
1080 return EncoderSession_finish_error(&encoder_session);
1086 return EncoderSession_finish_ok(&encoder_session, info_align_carry, info_align_zero);
1089 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)
1091 EncoderSession encoder_session;
1093 const size_t bytes_per_wide_sample = options.channels * (options.bps >> 3);
1094 unsigned align_remainder = 0;
1095 int info_align_carry = -1, info_align_zero = -1;
1096 FLAC__uint64 total_samples_in_input = 0;
1098 FLAC__ASSERT(!options.common.sector_align || options.channels == 2);
1099 FLAC__ASSERT(!options.common.sector_align || options.bps == 16);
1100 FLAC__ASSERT(!options.common.sector_align || options.sample_rate == 44100);
1101 FLAC__ASSERT(!options.common.sector_align || infilesize >= 0);
1102 FLAC__ASSERT(!options.common.replay_gain || options.channels <= 2);
1103 FLAC__ASSERT(!options.common.replay_gain || grabbag__replaygain_is_valid_sample_frequency(options.sample_rate));
1106 EncoderSession_construct(
1108 #ifdef FLAC__HAS_OGG
1109 options.common.use_ogg,
1113 options.common.verify,
1122 * now that we know the sample rate, canonicalize the
1123 * --skip string to a number of samples:
1125 flac__utils_canonicalize_skip_until_specification(&options.common.skip_specification, options.sample_rate);
1126 FLAC__ASSERT(options.common.skip_specification.value.samples >= 0);
1127 encoder_session.skip = (FLAC__uint64)options.common.skip_specification.value.samples;
1128 FLAC__ASSERT(!options.common.sector_align || encoder_session.skip == 0);
1131 total_samples_in_input = 0;
1133 /* *options.common.align_reservoir_samples will be 0 unless --sector-align is used */
1134 FLAC__ASSERT(options.common.sector_align || *options.common.align_reservoir_samples == 0);
1135 total_samples_in_input = (FLAC__uint64)infilesize / bytes_per_wide_sample + *options.common.align_reservoir_samples;
1139 * now that we know the input size, canonicalize the
1140 * --until strings to a number of samples:
1142 if(!canonicalize_until_specification(&options.common.until_specification, encoder_session.inbasefilename, options.sample_rate, encoder_session.skip, total_samples_in_input))
1143 return EncoderSession_finish_error(&encoder_session);
1144 encoder_session.until = (FLAC__uint64)options.common.until_specification.value.samples;
1145 FLAC__ASSERT(!options.common.sector_align || encoder_session.until == 0);
1147 infilesize -= (off_t)encoder_session.skip * bytes_per_wide_sample;
1148 encoder_session.total_samples_to_encode = total_samples_in_input - encoder_session.skip;
1149 if(encoder_session.until > 0) {
1150 const FLAC__uint64 trim = total_samples_in_input - encoder_session.until;
1151 FLAC__ASSERT(total_samples_in_input > 0);
1152 FLAC__ASSERT(!options.common.sector_align);
1153 infilesize -= (off_t)trim * bytes_per_wide_sample;
1154 encoder_session.total_samples_to_encode -= trim;
1156 if(infilesize >= 0 && options.common.sector_align) {
1157 FLAC__ASSERT(encoder_session.skip == 0);
1158 align_remainder = (unsigned)(encoder_session.total_samples_to_encode % 588);
1159 if(options.common.is_last_file)
1160 encoder_session.total_samples_to_encode += (588-align_remainder); /* will pad with zeroes */
1162 encoder_session.total_samples_to_encode -= align_remainder; /* will stop short and carry over to next file */
1164 encoder_session.unencoded_size = encoder_session.total_samples_to_encode * bytes_per_wide_sample;
1166 if(encoder_session.total_samples_to_encode <= 0)
1167 flac__utils_printf(stderr, 2, "(No runtime statistics possible; please wait for encoding to finish...)\n");
1169 if(encoder_session.skip > 0) {
1170 unsigned skip_bytes = bytes_per_wide_sample * (unsigned)encoder_session.skip;
1171 if(skip_bytes > lookahead_length) {
1172 skip_bytes -= lookahead_length;
1173 lookahead_length = 0;
1174 if(!fskip_ahead(infile, skip_bytes)) {
1175 flac__utils_printf(stderr, 1, "%s: ERROR during read while skipping samples\n", encoder_session.inbasefilename);
1176 return EncoderSession_finish_error(&encoder_session);
1180 lookahead += skip_bytes;
1181 lookahead_length -= skip_bytes;
1185 if(!EncoderSession_init_encoder(&encoder_session, options.common, /*channel_mask=*/0, options.channels, options.bps, options.sample_rate, /*flac_decoder_data=*/0))
1186 return EncoderSession_finish_error(&encoder_session);
1189 * first do any samples in the reservoir
1191 if(options.common.sector_align && *options.common.align_reservoir_samples > 0) {
1192 if(!EncoderSession_process(&encoder_session, (const FLAC__int32 * const *)options.common.align_reservoir, *options.common.align_reservoir_samples)) {
1193 print_error_with_state(&encoder_session, "ERROR during encoding");
1194 return EncoderSession_finish_error(&encoder_session);
1199 * decrement infilesize if we need to align the file
1201 if(options.common.sector_align) {
1202 FLAC__ASSERT(infilesize >= 0);
1203 if(options.common.is_last_file) {
1204 *options.common.align_reservoir_samples = 0;
1207 *options.common.align_reservoir_samples = align_remainder;
1208 infilesize -= (off_t)((*options.common.align_reservoir_samples) * bytes_per_wide_sample);
1209 FLAC__ASSERT(infilesize >= 0);
1214 * now do from the file
1216 if(infilesize < 0) {
1217 while(!feof(infile)) {
1218 if(lookahead_length > 0) {
1219 FLAC__ASSERT(lookahead_length < CHUNK_OF_SAMPLES * bytes_per_wide_sample);
1220 memcpy(ucbuffer_, lookahead, lookahead_length);
1221 bytes_read = fread(ucbuffer_+lookahead_length, sizeof(unsigned char), CHUNK_OF_SAMPLES * bytes_per_wide_sample - lookahead_length, infile) + lookahead_length;
1222 if(ferror(infile)) {
1223 flac__utils_printf(stderr, 1, "%s: ERROR during read\n", encoder_session.inbasefilename);
1224 return EncoderSession_finish_error(&encoder_session);
1226 lookahead_length = 0;
1229 bytes_read = fread(ucbuffer_, sizeof(unsigned char), CHUNK_OF_SAMPLES * bytes_per_wide_sample, infile);
1231 if(bytes_read == 0) {
1232 if(ferror(infile)) {
1233 flac__utils_printf(stderr, 1, "%s: ERROR during read\n", encoder_session.inbasefilename);
1234 return EncoderSession_finish_error(&encoder_session);
1237 else if(bytes_read % bytes_per_wide_sample != 0) {
1238 flac__utils_printf(stderr, 1, "%s: ERROR: got partial sample\n", encoder_session.inbasefilename);
1239 return EncoderSession_finish_error(&encoder_session);
1242 unsigned wide_samples = bytes_read / bytes_per_wide_sample;
1243 if(!format_input(input_, wide_samples, options.is_big_endian, options.is_unsigned_samples, options.channels, options.bps, /*shift=*/0, /*channel_map=*/0))
1244 return EncoderSession_finish_error(&encoder_session);
1246 if(!EncoderSession_process(&encoder_session, (const FLAC__int32 * const *)input_, wide_samples)) {
1247 print_error_with_state(&encoder_session, "ERROR during encoding");
1248 return EncoderSession_finish_error(&encoder_session);
1254 const FLAC__uint64 max_input_bytes = infilesize;
1255 FLAC__uint64 total_input_bytes_read = 0;
1256 while(total_input_bytes_read < max_input_bytes) {
1258 size_t wanted = (CHUNK_OF_SAMPLES * bytes_per_wide_sample);
1259 wanted = (size_t) min((FLAC__uint64)wanted, max_input_bytes - total_input_bytes_read);
1261 if(lookahead_length > 0) {
1262 FLAC__ASSERT(lookahead_length <= wanted);
1263 memcpy(ucbuffer_, lookahead, lookahead_length);
1264 wanted -= lookahead_length;
1265 bytes_read = lookahead_length;
1267 bytes_read += fread(ucbuffer_+lookahead_length, sizeof(unsigned char), wanted, infile);
1268 if(ferror(infile)) {
1269 flac__utils_printf(stderr, 1, "%s: ERROR during read\n", encoder_session.inbasefilename);
1270 return EncoderSession_finish_error(&encoder_session);
1273 lookahead_length = 0;
1276 bytes_read = fread(ucbuffer_, sizeof(unsigned char), wanted, infile);
1279 if(bytes_read == 0) {
1280 if(ferror(infile)) {
1281 flac__utils_printf(stderr, 1, "%s: ERROR during read\n", encoder_session.inbasefilename);
1282 return EncoderSession_finish_error(&encoder_session);
1284 else if(feof(infile)) {
1285 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);
1286 total_input_bytes_read = max_input_bytes;
1290 if(bytes_read % bytes_per_wide_sample != 0) {
1291 flac__utils_printf(stderr, 1, "%s: ERROR: got partial sample\n", encoder_session.inbasefilename);
1292 return EncoderSession_finish_error(&encoder_session);
1295 unsigned wide_samples = bytes_read / bytes_per_wide_sample;
1296 if(!format_input(input_, wide_samples, options.is_big_endian, options.is_unsigned_samples, options.channels, options.bps, /*shift=*/0, /*channel_map=*/0))
1297 return EncoderSession_finish_error(&encoder_session);
1299 if(!EncoderSession_process(&encoder_session, (const FLAC__int32 * const *)input_, wide_samples)) {
1300 print_error_with_state(&encoder_session, "ERROR during encoding");
1301 return EncoderSession_finish_error(&encoder_session);
1303 total_input_bytes_read += bytes_read;
1310 * now read unaligned samples into reservoir or pad with zeroes if necessary
1312 if(options.common.sector_align) {
1313 if(options.common.is_last_file) {
1314 unsigned wide_samples = 588 - align_remainder;
1315 if(wide_samples < 588) {
1318 info_align_zero = wide_samples;
1319 for(channel = 0; channel < options.channels; channel++)
1320 memset(input_[channel], 0, sizeof(input_[0][0]) * wide_samples);
1322 if(!EncoderSession_process(&encoder_session, (const FLAC__int32 * const *)input_, wide_samples)) {
1323 print_error_with_state(&encoder_session, "ERROR during encoding");
1324 return EncoderSession_finish_error(&encoder_session);
1329 if(*options.common.align_reservoir_samples > 0) {
1330 FLAC__ASSERT(CHUNK_OF_SAMPLES >= 588);
1331 bytes_read = fread(ucbuffer_, sizeof(unsigned char), (*options.common.align_reservoir_samples) * bytes_per_wide_sample, infile);
1332 if(bytes_read == 0 && ferror(infile)) {
1333 flac__utils_printf(stderr, 1, "%s: ERROR during read\n", encoder_session.inbasefilename);
1334 return EncoderSession_finish_error(&encoder_session);
1336 else if(bytes_read != (*options.common.align_reservoir_samples) * bytes_per_wide_sample) {
1337 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);
1340 info_align_carry = *options.common.align_reservoir_samples;
1341 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))
1342 return EncoderSession_finish_error(&encoder_session);
1348 return EncoderSession_finish_ok(&encoder_session, info_align_carry, info_align_zero);
1351 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)
1353 EncoderSession encoder_session;
1354 FLAC__StreamDecoder *decoder = 0;
1355 FLACDecoderData decoder_data;
1360 EncoderSession_construct(
1362 #ifdef FLAC__HAS_OGG
1363 options.common.use_ogg,
1367 options.common.verify,
1375 decoder_data.encoder_session = &encoder_session;
1376 decoder_data.filesize = (infilesize == (off_t)(-1)? 0 : infilesize);
1377 decoder_data.lookahead = lookahead;
1378 decoder_data.lookahead_length = lookahead_length;
1379 decoder_data.num_metadata_blocks = 0;
1380 decoder_data.samples_left_to_process = 0;
1381 decoder_data.fatal_error = false;
1384 * set up FLAC decoder for the input
1386 if (0 == (decoder = FLAC__stream_decoder_new())) {
1387 flac__utils_printf(stderr, 1, "%s: ERROR: creating decoder for FLAC input\n", encoder_session.inbasefilename);
1388 return EncoderSession_finish_error(&encoder_session);
1391 FLAC__stream_decoder_set_md5_checking(decoder, false) &&
1392 FLAC__stream_decoder_set_metadata_respond_all(decoder)
1394 flac__utils_printf(stderr, 1, "%s: ERROR: setting up decoder for FLAC input\n", encoder_session.inbasefilename);
1395 goto fubar1; /*@@@ yuck */
1399 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) {
1400 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));
1401 goto fubar1; /*@@@ yuck */
1404 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) {
1405 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));
1406 goto fubar1; /*@@@ yuck */
1409 if (!FLAC__stream_decoder_process_until_end_of_metadata(decoder) || decoder_data.fatal_error) {
1410 if (decoder_data.fatal_error)
1411 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);
1413 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));
1414 goto fubar1; /*@@@ yuck */
1417 if (decoder_data.num_metadata_blocks == 0) {
1418 flac__utils_printf(stderr, 1, "%s: ERROR: reading metadata in FLAC input, got no metadata blocks\n", encoder_session.inbasefilename);
1419 goto fubar2; /*@@@ yuck */
1421 else if (decoder_data.metadata_blocks[0]->type != FLAC__METADATA_TYPE_STREAMINFO) {
1422 flac__utils_printf(stderr, 1, "%s: ERROR: reading metadata in FLAC input, first metadata block is not STREAMINFO\n", encoder_session.inbasefilename);
1423 goto fubar2; /*@@@ yuck */
1425 else if (decoder_data.metadata_blocks[0]->data.stream_info.total_samples == 0) {
1426 flac__utils_printf(stderr, 1, "%s: ERROR: FLAC input has STREAMINFO with unknown total samples which is not supported\n", encoder_session.inbasefilename);
1427 goto fubar2; /*@@@ yuck */
1431 * now that we have the STREAMINFO and know the sample rate,
1432 * canonicalize the --skip string to a number of samples:
1434 flac__utils_canonicalize_skip_until_specification(&options.common.skip_specification, decoder_data.metadata_blocks[0]->data.stream_info.sample_rate);
1435 FLAC__ASSERT(options.common.skip_specification.value.samples >= 0);
1436 encoder_session.skip = (FLAC__uint64)options.common.skip_specification.value.samples;
1437 FLAC__ASSERT(!options.common.sector_align); /* --sector-align with FLAC input is not supported */
1440 FLAC__uint64 total_samples_in_input, trim = 0;
1442 total_samples_in_input = decoder_data.metadata_blocks[0]->data.stream_info.total_samples;
1445 * now that we know the input size, canonicalize the
1446 * --until string to an absolute sample number:
1448 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))
1449 goto fubar2; /*@@@ yuck */
1450 encoder_session.until = (FLAC__uint64)options.common.until_specification.value.samples;
1452 encoder_session.total_samples_to_encode = total_samples_in_input - encoder_session.skip;
1453 if(encoder_session.until > 0) {
1454 trim = total_samples_in_input - encoder_session.until;
1455 FLAC__ASSERT(total_samples_in_input > 0);
1456 encoder_session.total_samples_to_encode -= trim;
1459 encoder_session.unencoded_size = decoder_data.filesize;
1461 /* (channel mask will get copied over from the source VORBIS_COMMENT if it exists) */
1462 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))
1463 return EncoderSession_finish_error(&encoder_session);
1466 * have to wait until the FLAC encoder is set up for writing
1467 * before any seeking in the input FLAC file, because the seek
1468 * itself will usually call the decoder's write callback, and
1469 * our decoder's write callback passes samples to our FLAC
1472 decoder_data.samples_left_to_process = encoder_session.total_samples_to_encode;
1473 if(encoder_session.skip > 0) {
1474 if(!FLAC__stream_decoder_seek_absolute(decoder, encoder_session.skip)) {
1475 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));
1476 goto fubar2; /*@@@ yuck */
1481 * now do samples from the file
1483 while(!decoder_data.fatal_error && decoder_data.samples_left_to_process > 0) {
1484 if(!FLAC__stream_decoder_process_single(decoder)) {
1485 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));
1486 goto fubar2; /*@@@ yuck */
1491 FLAC__stream_decoder_delete(decoder);
1492 retval = EncoderSession_finish_ok(&encoder_session, -1, -1);
1493 /* have to wail until encoder is completely finished before deleting because of the final step of writing the seekpoint offsets */
1494 for(i = 0; i < decoder_data.num_metadata_blocks; i++)
1495 free(decoder_data.metadata_blocks[i]);
1499 for(i = 0; i < decoder_data.num_metadata_blocks; i++)
1500 free(decoder_data.metadata_blocks[i]);
1502 FLAC__stream_decoder_delete(decoder);
1503 return EncoderSession_finish_error(&encoder_session);
1506 FLAC__bool EncoderSession_construct(EncoderSession *e, FLAC__bool use_ogg, FLAC__bool verify, FILE *infile, const char *infilename, const char *outfilename)
1509 FLAC__uint32 test = 1;
1512 * initialize globals
1515 is_big_endian_host_ = (*((FLAC__byte*)(&test)))? false : true;
1517 for(i = 0; i < FLAC__MAX_CHANNELS; i++)
1518 input_[i] = &(in_[i][0]);
1522 * initialize instance
1525 #ifdef FLAC__HAS_OGG
1526 e->use_ogg = use_ogg;
1532 e->is_stdout = (0 == strcmp(outfilename, "-"));
1533 e->outputfile_opened = false;
1535 e->inbasefilename = grabbag__file_get_basename(infilename);
1536 e->outfilename = outfilename;
1538 e->skip = 0; /* filled in later after the sample_rate is known */
1539 e->unencoded_size = 0;
1540 e->total_samples_to_encode = 0;
1541 e->bytes_written = 0;
1542 e->samples_written = 0;
1548 e->seek_table_template = 0;
1550 if(0 == (e->seek_table_template = FLAC__metadata_object_new(FLAC__METADATA_TYPE_SEEKTABLE))) {
1551 flac__utils_printf(stderr, 1, "%s: ERROR allocating memory for seek table\n", e->inbasefilename);
1555 e->encoder = FLAC__stream_encoder_new();
1556 if(0 == e->encoder) {
1557 flac__utils_printf(stderr, 1, "%s: ERROR creating the encoder instance\n", e->inbasefilename);
1558 EncoderSession_destroy(e);
1565 void EncoderSession_destroy(EncoderSession *e)
1570 if(0 != e->encoder) {
1571 FLAC__stream_encoder_delete(e->encoder);
1575 if(0 != e->seek_table_template) {
1576 FLAC__metadata_object_delete(e->seek_table_template);
1577 e->seek_table_template = 0;
1581 int EncoderSession_finish_ok(EncoderSession *e, int info_align_carry, int info_align_zero)
1583 FLAC__StreamEncoderState fse_state = FLAC__STREAM_ENCODER_OK;
1585 FLAC__bool verify_error = false;
1588 fse_state = FLAC__stream_encoder_get_state(e->encoder);
1589 ret = FLAC__stream_encoder_finish(e->encoder)? 0 : 1;
1591 fse_state == FLAC__STREAM_ENCODER_VERIFY_MISMATCH_IN_AUDIO_DATA ||
1592 FLAC__stream_encoder_get_state(e->encoder) == FLAC__STREAM_ENCODER_VERIFY_MISMATCH_IN_AUDIO_DATA
1595 /* all errors except verify errors should interrupt the stats */
1596 if(ret && !verify_error)
1597 print_error_with_state(e, "ERROR during encoding");
1598 else if(e->total_samples_to_encode > 0) {
1600 flac__utils_printf(stderr, 2, "\n");
1604 print_verify_error(e);
1608 if(info_align_carry >= 0) {
1609 flac__utils_printf(stderr, 1, "%s: INFO: sector alignment causing %d samples to be carried over\n", e->inbasefilename, info_align_carry);
1611 if(info_align_zero >= 0) {
1612 flac__utils_printf(stderr, 1, "%s: INFO: sector alignment causing %d zero samples to be appended\n", e->inbasefilename, info_align_zero);
1616 EncoderSession_destroy(e);
1621 int EncoderSession_finish_error(EncoderSession *e)
1623 FLAC__ASSERT(e->encoder);
1625 if(e->total_samples_to_encode > 0)
1626 flac__utils_printf(stderr, 2, "\n");
1628 if(FLAC__stream_encoder_get_state(e->encoder) == FLAC__STREAM_ENCODER_VERIFY_MISMATCH_IN_AUDIO_DATA)
1629 print_verify_error(e);
1630 else if(e->outputfile_opened)
1631 /* only want to delete the file if we opened it; otherwise it could be an existing file and our overwrite failed */
1632 unlink(e->outfilename);
1634 EncoderSession_destroy(e);
1639 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)
1641 unsigned num_metadata, i;
1642 FLAC__StreamMetadata padding, *cuesheet = 0;
1643 FLAC__StreamMetadata *static_metadata[4+64]; /* MAGIC +64 is for pictures metadata in options.pictures */
1644 FLAC__StreamMetadata **metadata = static_metadata;
1645 FLAC__StreamEncoderInitStatus init_status;
1646 const FLAC__bool is_cdda = (channels == 1 || channels == 2) && (bps == 16) && (sample_rate == 44100);
1647 char apodizations[2000];
1649 FLAC__ASSERT(sizeof(options.pictures)/sizeof(options.pictures[0]) <= 64);
1651 e->replay_gain = options.replay_gain;
1652 e->channels = channels;
1653 e->bits_per_sample = bps;
1654 e->sample_rate = sample_rate;
1656 apodizations[0] = '\0';
1658 if(e->replay_gain) {
1659 if(channels != 1 && channels != 2) {
1660 flac__utils_printf(stderr, 1, "%s: ERROR, number of channels (%u) must be 1 or 2 for --replay-gain\n", e->inbasefilename, channels);
1663 if(!grabbag__replaygain_is_valid_sample_frequency(sample_rate)) {
1664 flac__utils_printf(stderr, 1, "%s: ERROR, invalid sample rate (%u) for --replay-gain\n", e->inbasefilename, sample_rate);
1667 if(options.is_first_file) {
1668 if(!grabbag__replaygain_init(sample_rate)) {
1669 flac__utils_printf(stderr, 1, "%s: ERROR initializing ReplayGain stage\n", e->inbasefilename);
1675 if(!parse_cuesheet(&cuesheet, options.cuesheet_filename, e->inbasefilename, is_cdda, e->total_samples_to_encode))
1678 if(!convert_to_seek_table_template(options.requested_seek_points, options.num_requested_seek_points, options.cued_seekpoints? cuesheet : 0, e)) {
1679 flac__utils_printf(stderr, 1, "%s: ERROR allocating memory for seek table\n", e->inbasefilename);
1681 FLAC__metadata_object_delete(cuesheet);
1685 if(flac_decoder_data) {
1687 * we're encoding from FLAC so we will use the FLAC file's
1688 * metadata as the basic for the encoded file
1692 * first handle padding: if --no-padding was specified,
1693 * then delete all padding; else if -P was specified,
1694 * use that instead of existing padding (if any); else
1695 * if existing file has padding, move all existing
1696 * padding blocks to one padding block at the end; else
1697 * use default padding.
1701 for(i = 0, j = 0; i < flac_decoder_data->num_metadata_blocks; i++) {
1702 if(flac_decoder_data->metadata_blocks[i]->type == FLAC__METADATA_TYPE_PADDING) {
1705 p += flac_decoder_data->metadata_blocks[i]->length;
1706 FLAC__metadata_object_delete(flac_decoder_data->metadata_blocks[i]);
1707 flac_decoder_data->metadata_blocks[i] = 0;
1710 flac_decoder_data->metadata_blocks[j++] = flac_decoder_data->metadata_blocks[i];
1712 flac_decoder_data->num_metadata_blocks = j;
1713 if(options.padding > 0)
1714 p = options.padding;
1716 p = e->total_samples_to_encode / e->sample_rate < 20*60? FLAC_ENCODE__DEFAULT_PADDING : FLAC_ENCODE__DEFAULT_PADDING*8;
1717 if(options.padding != 0) {
1718 if(p > 0 && flac_decoder_data->num_metadata_blocks < sizeof(flac_decoder_data->metadata_blocks)/sizeof(flac_decoder_data->metadata_blocks[0])) {
1719 flac_decoder_data->metadata_blocks[flac_decoder_data->num_metadata_blocks] = FLAC__metadata_object_new(FLAC__METADATA_TYPE_PADDING);
1720 if(0 == flac_decoder_data->metadata_blocks[flac_decoder_data->num_metadata_blocks]) {
1721 flac__utils_printf(stderr, 1, "%s: ERROR allocating memory for PADDING block\n", e->inbasefilename);
1723 FLAC__metadata_object_delete(cuesheet);
1726 flac_decoder_data->metadata_blocks[flac_decoder_data->num_metadata_blocks]->is_last = false; /* the encoder will set this for us */
1727 flac_decoder_data->metadata_blocks[flac_decoder_data->num_metadata_blocks]->length = p;
1728 flac_decoder_data->num_metadata_blocks++;
1734 * next handle vorbis comment: if any tags were specified
1735 * or there is no existing vorbis comment, we create a
1736 * new vorbis comment (discarding any existing one); else
1737 * we keep the existing one. also need to make sure to
1738 * propagate any channel mask tag.
1741 FLAC__bool vc_found = false;
1742 for(i = 0, j = 0; i < flac_decoder_data->num_metadata_blocks; i++) {
1743 if(flac_decoder_data->metadata_blocks[i]->type == FLAC__METADATA_TYPE_VORBIS_COMMENT)
1745 if(flac_decoder_data->metadata_blocks[i]->type == FLAC__METADATA_TYPE_VORBIS_COMMENT && options.vorbis_comment->data.vorbis_comment.num_comments > 0) {
1746 (void) flac__utils_get_channel_mask_tag(flac_decoder_data->metadata_blocks[i], &channel_mask);
1747 flac__utils_printf(stderr, 1, "%s: WARNING, replacing tags from input FLAC file with those given on the command-line\n", e->inbasefilename);
1748 FLAC__metadata_object_delete(flac_decoder_data->metadata_blocks[i]);
1749 flac_decoder_data->metadata_blocks[i] = 0;
1752 flac_decoder_data->metadata_blocks[j++] = flac_decoder_data->metadata_blocks[i];
1754 flac_decoder_data->num_metadata_blocks = j;
1755 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])) {
1757 FLAC__StreamMetadata *vc = FLAC__metadata_object_clone(options.vorbis_comment);
1758 if(0 == vc || (channel_mask && !flac__utils_set_channel_mask_tag(vc, channel_mask))) {
1759 flac__utils_printf(stderr, 1, "%s: ERROR allocating memory for VORBIS_COMMENT block\n", e->inbasefilename);
1761 FLAC__metadata_object_delete(cuesheet);
1764 for(i = flac_decoder_data->num_metadata_blocks; i > 1; i--)
1765 flac_decoder_data->metadata_blocks[i] = flac_decoder_data->metadata_blocks[i-1];
1766 flac_decoder_data->metadata_blocks[1] = vc;
1767 flac_decoder_data->num_metadata_blocks++;
1772 * next handle cuesheet: if --cuesheet was specified, use
1773 * it; else if file has existing CUESHEET and cuesheet's
1774 * lead-out offset is correct, keep it; else no CUESHEET
1777 for(i = 0, j = 0; i < flac_decoder_data->num_metadata_blocks; i++) {
1778 FLAC__bool existing_cuesheet_is_bad = false;
1779 /* check if existing cuesheet matches the input audio */
1780 if(flac_decoder_data->metadata_blocks[i]->type == FLAC__METADATA_TYPE_CUESHEET && 0 == cuesheet) {
1781 const FLAC__StreamMetadata_CueSheet *cs = &flac_decoder_data->metadata_blocks[i]->data.cue_sheet;
1782 if(e->total_samples_to_encode == 0) {
1783 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);
1784 existing_cuesheet_is_bad = true;
1786 else if(e->total_samples_to_encode != cs->tracks[cs->num_tracks-1].offset) {
1787 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);
1788 existing_cuesheet_is_bad = true;
1791 if(flac_decoder_data->metadata_blocks[i]->type == FLAC__METADATA_TYPE_CUESHEET && (existing_cuesheet_is_bad || 0 != cuesheet)) {
1793 flac__utils_printf(stderr, 1, "%s: WARNING, replacing cuesheet in input FLAC file with the one given on the command-line\n", e->inbasefilename);
1794 FLAC__metadata_object_delete(flac_decoder_data->metadata_blocks[i]);
1795 flac_decoder_data->metadata_blocks[i] = 0;
1798 flac_decoder_data->metadata_blocks[j++] = flac_decoder_data->metadata_blocks[i];
1800 flac_decoder_data->num_metadata_blocks = j;
1801 if(0 != cuesheet && flac_decoder_data->num_metadata_blocks < sizeof(flac_decoder_data->metadata_blocks)/sizeof(flac_decoder_data->metadata_blocks[0])) {
1803 FLAC__StreamMetadata *cs = FLAC__metadata_object_clone(cuesheet);
1805 flac__utils_printf(stderr, 1, "%s: ERROR allocating memory for CUESHEET block\n", e->inbasefilename);
1807 FLAC__metadata_object_delete(cuesheet);
1810 for(i = flac_decoder_data->num_metadata_blocks; i > 1; i--)
1811 flac_decoder_data->metadata_blocks[i] = flac_decoder_data->metadata_blocks[i-1];
1812 flac_decoder_data->metadata_blocks[1] = cs;
1813 flac_decoder_data->num_metadata_blocks++;
1818 * finally handle seektable: if -S- was specified, no
1819 * SEEKTABLE; else if -S was specified, use it/them;
1820 * else if file has existing SEEKTABLE and input size is
1821 * preserved (no --skip/--until/etc specified), keep it;
1822 * else use default seektable options
1824 * note: meanings of num_requested_seek_points:
1825 * -1 : no -S option given, default to some value
1826 * 0 : -S- given (no seektable)
1827 * >0 : one or more -S options given
1830 FLAC__bool existing_seektable = false;
1831 for(i = 0, j = 0; i < flac_decoder_data->num_metadata_blocks; i++) {
1832 if(flac_decoder_data->metadata_blocks[i]->type == FLAC__METADATA_TYPE_SEEKTABLE)
1833 existing_seektable = true;
1834 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)) {
1835 if(options.num_requested_seek_points > 0)
1836 flac__utils_printf(stderr, 1, "%s: WARNING, replacing seektable in input FLAC file with the one given on the command-line\n", e->inbasefilename);
1837 else if(options.num_requested_seek_points == 0)
1838 ; /* no warning, silently delete existing SEEKTABLE since user specified --no-seektable (-S-) */
1840 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);
1841 FLAC__metadata_object_delete(flac_decoder_data->metadata_blocks[i]);
1842 flac_decoder_data->metadata_blocks[i] = 0;
1843 existing_seektable = false;
1846 flac_decoder_data->metadata_blocks[j++] = flac_decoder_data->metadata_blocks[i];
1848 flac_decoder_data->num_metadata_blocks = j;
1849 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])) {
1851 FLAC__StreamMetadata *st = FLAC__metadata_object_clone(e->seek_table_template);
1853 flac__utils_printf(stderr, 1, "%s: ERROR allocating memory for SEEKTABLE block\n", e->inbasefilename);
1855 FLAC__metadata_object_delete(cuesheet);
1858 for(i = flac_decoder_data->num_metadata_blocks; i > 1; i--)
1859 flac_decoder_data->metadata_blocks[i] = flac_decoder_data->metadata_blocks[i-1];
1860 flac_decoder_data->metadata_blocks[1] = st;
1861 flac_decoder_data->num_metadata_blocks++;
1864 metadata = &flac_decoder_data->metadata_blocks[1]; /* don't include STREAMINFO */
1865 num_metadata = flac_decoder_data->num_metadata_blocks - 1;
1869 * we're not encoding from FLAC so we will build the metadata
1873 if(e->seek_table_template->data.seek_table.num_points > 0) {
1874 e->seek_table_template->is_last = false; /* the encoder will set this for us */
1875 metadata[num_metadata++] = e->seek_table_template;
1878 metadata[num_metadata++] = cuesheet;
1880 if(!flac__utils_set_channel_mask_tag(options.vorbis_comment, channel_mask)) {
1881 flac__utils_printf(stderr, 1, "%s: ERROR adding channel mask tag\n", e->inbasefilename);
1883 FLAC__metadata_object_delete(cuesheet);
1887 metadata[num_metadata++] = options.vorbis_comment;
1888 for(i = 0; i < options.num_pictures; i++)
1889 metadata[num_metadata++] = options.pictures[i];
1890 if(options.padding != 0) {
1891 padding.is_last = false; /* the encoder will set this for us */
1892 padding.type = FLAC__METADATA_TYPE_PADDING;
1893 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));
1894 metadata[num_metadata++] = &padding;
1898 /* check for a few things that have not already been checked. the
1899 * FLAC__stream_encoder_init*() will check it but only return
1900 * FLAC__STREAM_ENCODER_INIT_STATUS_INVALID_METADATA so we check some
1901 * up front to give a better error message.
1903 if(!verify_metadata(e, metadata, num_metadata)) {
1905 FLAC__metadata_object_delete(cuesheet);
1909 FLAC__stream_encoder_set_verify(e->encoder, options.verify);
1910 FLAC__stream_encoder_set_streamable_subset(e->encoder, !options.lax);
1911 FLAC__stream_encoder_set_channels(e->encoder, channels);
1912 FLAC__stream_encoder_set_bits_per_sample(e->encoder, bps);
1913 FLAC__stream_encoder_set_sample_rate(e->encoder, sample_rate);
1914 for(i = 0; i < options.num_compression_settings; i++) {
1915 switch(options.compression_settings[i].type) {
1917 FLAC__stream_encoder_set_blocksize(e->encoder, options.compression_settings[i].value.t_unsigned);
1919 case CST_COMPRESSION_LEVEL:
1920 FLAC__stream_encoder_set_compression_level(e->encoder, options.compression_settings[i].value.t_unsigned);
1921 apodizations[0] = '\0';
1923 case CST_DO_MID_SIDE:
1924 FLAC__stream_encoder_set_do_mid_side_stereo(e->encoder, options.compression_settings[i].value.t_bool);
1926 case CST_LOOSE_MID_SIDE:
1927 FLAC__stream_encoder_set_loose_mid_side_stereo(e->encoder, options.compression_settings[i].value.t_bool);
1929 case CST_APODIZATION:
1930 if(strlen(apodizations)+strlen(options.compression_settings[i].value.t_string)+2 >= sizeof(apodizations)) {
1931 flac__utils_printf(stderr, 1, "%s: ERROR: too many apodization functions requested\n", e->inbasefilename);
1933 FLAC__metadata_object_delete(cuesheet);
1937 strcat(apodizations, options.compression_settings[i].value.t_string);
1938 strcat(apodizations, ";");
1941 case CST_MAX_LPC_ORDER:
1942 FLAC__stream_encoder_set_max_lpc_order(e->encoder, options.compression_settings[i].value.t_unsigned);
1944 case CST_QLP_COEFF_PRECISION:
1945 FLAC__stream_encoder_set_qlp_coeff_precision(e->encoder, options.compression_settings[i].value.t_unsigned);
1947 case CST_DO_QLP_COEFF_PREC_SEARCH:
1948 FLAC__stream_encoder_set_do_qlp_coeff_prec_search(e->encoder, options.compression_settings[i].value.t_bool);
1950 case CST_DO_ESCAPE_CODING:
1951 FLAC__stream_encoder_set_do_escape_coding(e->encoder, options.compression_settings[i].value.t_bool);
1953 case CST_DO_EXHAUSTIVE_MODEL_SEARCH:
1954 FLAC__stream_encoder_set_do_exhaustive_model_search(e->encoder, options.compression_settings[i].value.t_bool);
1956 case CST_MIN_RESIDUAL_PARTITION_ORDER:
1957 FLAC__stream_encoder_set_min_residual_partition_order(e->encoder, options.compression_settings[i].value.t_unsigned);
1959 case CST_MAX_RESIDUAL_PARTITION_ORDER:
1960 FLAC__stream_encoder_set_max_residual_partition_order(e->encoder, options.compression_settings[i].value.t_unsigned);
1962 case CST_RICE_PARAMETER_SEARCH_DIST:
1963 FLAC__stream_encoder_set_rice_parameter_search_dist(e->encoder, options.compression_settings[i].value.t_unsigned);
1968 FLAC__stream_encoder_set_apodization(e->encoder, apodizations);
1969 FLAC__stream_encoder_set_total_samples_estimate(e->encoder, e->total_samples_to_encode);
1970 FLAC__stream_encoder_set_metadata(e->encoder, (num_metadata > 0)? metadata : 0, num_metadata);
1972 FLAC__stream_encoder_disable_constant_subframes(e->encoder, options.debug.disable_constant_subframes);
1973 FLAC__stream_encoder_disable_fixed_subframes(e->encoder, options.debug.disable_fixed_subframes);
1974 FLAC__stream_encoder_disable_verbatim_subframes(e->encoder, options.debug.disable_verbatim_subframes);
1976 #ifdef FLAC__HAS_OGG
1978 FLAC__stream_encoder_set_ogg_serial_number(e->encoder, options.serial_number);
1980 init_status = FLAC__stream_encoder_init_ogg_file(e->encoder, e->is_stdout? 0 : e->outfilename, encoder_progress_callback, /*client_data=*/e);
1985 init_status = FLAC__stream_encoder_init_file(e->encoder, e->is_stdout? 0 : e->outfilename, encoder_progress_callback, /*client_data=*/e);
1988 if(init_status != FLAC__STREAM_ENCODER_INIT_STATUS_OK) {
1989 print_error_with_init_status(e, "ERROR initializing encoder", init_status);
1990 if(FLAC__stream_encoder_get_state(e->encoder) != FLAC__STREAM_ENCODER_IO_ERROR)
1991 e->outputfile_opened = true;
1993 FLAC__metadata_object_delete(cuesheet);
1997 e->outputfile_opened = true;
2000 (FLAC__stream_encoder_get_do_exhaustive_model_search(e->encoder) && FLAC__stream_encoder_get_do_qlp_coeff_prec_search(e->encoder))? 0x07 :
2001 (FLAC__stream_encoder_get_do_exhaustive_model_search(e->encoder) || FLAC__stream_encoder_get_do_qlp_coeff_prec_search(e->encoder))? 0x0f :
2005 FLAC__metadata_object_delete(cuesheet);
2010 FLAC__bool EncoderSession_process(EncoderSession *e, const FLAC__int32 * const buffer[], unsigned samples)
2012 if(e->replay_gain) {
2013 if(!grabbag__replaygain_analyze(buffer, e->channels==2, e->bits_per_sample, samples)) {
2014 flac__utils_printf(stderr, 1, "%s: WARNING, error while calculating ReplayGain\n", e->inbasefilename);
2018 return FLAC__stream_encoder_process(e->encoder, buffer, samples);
2021 FLAC__bool convert_to_seek_table_template(const char *requested_seek_points, int num_requested_seek_points, FLAC__StreamMetadata *cuesheet, EncoderSession *e)
2023 const FLAC__bool only_placeholders = e->is_stdout;
2024 FLAC__bool has_real_points;
2026 if(num_requested_seek_points == 0 && 0 == cuesheet)
2029 if(num_requested_seek_points < 0) {
2030 requested_seek_points = "10s;";
2031 num_requested_seek_points = 1;
2034 if(num_requested_seek_points > 0) {
2035 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))
2041 const FLAC__StreamMetadata_CueSheet *cs = &cuesheet->data.cue_sheet;
2042 for(i = 0; i < cs->num_tracks; i++) {
2043 const FLAC__StreamMetadata_CueSheet_Track *tr = cs->tracks+i;
2044 for(j = 0; j < tr->num_indices; j++) {
2045 if(!FLAC__metadata_object_seektable_template_append_point(e->seek_table_template, tr->offset + tr->indices[j].offset))
2047 has_real_points = true;
2051 if(!FLAC__metadata_object_seektable_template_sort(e->seek_table_template, /*compact=*/true))
2055 if(has_real_points) {
2057 flac__utils_printf(stderr, 1, "%s: WARNING, cannot write back seekpoints when encoding to stdout\n", e->inbasefilename);
2064 FLAC__bool canonicalize_until_specification(utils__SkipUntilSpecification *spec, const char *inbasefilename, unsigned sample_rate, FLAC__uint64 skip, FLAC__uint64 total_samples_in_input)
2066 /* convert from mm:ss.sss to sample number if necessary */
2067 flac__utils_canonicalize_skip_until_specification(spec, sample_rate);
2069 /* special case: if "--until=-0", use the special value '0' to mean "end-of-stream" */
2070 if(spec->is_relative && spec->value.samples == 0) {
2071 spec->is_relative = false;
2075 /* in any other case the total samples in the input must be known */
2076 if(total_samples_in_input == 0) {
2077 flac__utils_printf(stderr, 1, "%s: ERROR, cannot use --until when input length is unknown\n", inbasefilename);
2081 FLAC__ASSERT(spec->value_is_samples);
2083 /* convert relative specifications to absolute */
2084 if(spec->is_relative) {
2085 if(spec->value.samples <= 0)
2086 spec->value.samples += (FLAC__int64)total_samples_in_input;
2088 spec->value.samples += skip;
2089 spec->is_relative = false;
2093 if(spec->value.samples < 0) {
2094 flac__utils_printf(stderr, 1, "%s: ERROR, --until value is before beginning of input\n", inbasefilename);
2097 if((FLAC__uint64)spec->value.samples <= skip) {
2098 flac__utils_printf(stderr, 1, "%s: ERROR, --until value is before --skip point\n", inbasefilename);
2101 if((FLAC__uint64)spec->value.samples > total_samples_in_input) {
2102 flac__utils_printf(stderr, 1, "%s: ERROR, --until value is after end of input\n", inbasefilename);
2109 FLAC__bool verify_metadata(const EncoderSession *e, FLAC__StreamMetadata **metadata, unsigned num_metadata)
2111 FLAC__bool metadata_picture_has_type1 = false;
2112 FLAC__bool metadata_picture_has_type2 = false;
2115 FLAC__ASSERT(0 != metadata);
2116 for(i = 0; i < num_metadata; i++) {
2117 const FLAC__StreamMetadata *m = metadata[i];
2118 if(m->type == FLAC__METADATA_TYPE_SEEKTABLE) {
2119 if(!FLAC__format_seektable_is_legal(&m->data.seek_table)) {
2120 flac__utils_printf(stderr, 1, "%s: ERROR: SEEKTABLE metadata block is invalid\n", e->inbasefilename);
2124 else if(m->type == FLAC__METADATA_TYPE_CUESHEET) {
2125 if(!FLAC__format_cuesheet_is_legal(&m->data.cue_sheet, m->data.cue_sheet.is_cd, /*violation=*/0)) {
2126 flac__utils_printf(stderr, 1, "%s: ERROR: CUESHEET metadata block is invalid\n", e->inbasefilename);
2130 else if(m->type == FLAC__METADATA_TYPE_PICTURE) {
2131 const char *error = 0;
2132 if(!FLAC__format_picture_is_legal(&m->data.picture, &error)) {
2133 flac__utils_printf(stderr, 1, "%s: ERROR: PICTURE metadata block is invalid: %s\n", e->inbasefilename, error);
2136 if(m->data.picture.type == FLAC__STREAM_METADATA_PICTURE_TYPE_FILE_ICON_STANDARD) {
2137 if(metadata_picture_has_type1) {
2138 flac__utils_printf(stderr, 1, "%s: ERROR: there may only be one picture of type 1 (32x32 icon) in the file\n", e->inbasefilename);
2141 metadata_picture_has_type1 = true;
2143 else if(m->data.picture.type == FLAC__STREAM_METADATA_PICTURE_TYPE_FILE_ICON) {
2144 if(metadata_picture_has_type2) {
2145 flac__utils_printf(stderr, 1, "%s: ERROR: there may only be one picture of type 2 (icon) in the file\n", e->inbasefilename);
2148 metadata_picture_has_type2 = true;
2156 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)
2158 unsigned wide_sample, sample, channel, byte;
2159 FLAC__int32 *out[FLAC__MAX_CHANNELS];
2161 if(0 == channel_map) {
2162 for(channel = 0; channel < channels; channel++)
2163 out[channel] = dest[channel];
2166 for(channel = 0; channel < channels; channel++)
2167 out[channel] = dest[channel_map[channel]];
2171 if(is_unsigned_samples) {
2172 for(sample = wide_sample = 0; wide_sample < wide_samples; wide_sample++)
2173 for(channel = 0; channel < channels; channel++, sample++)
2174 out[channel][wide_sample] = (FLAC__int32)ucbuffer_[sample] - 0x80;
2177 for(sample = wide_sample = 0; wide_sample < wide_samples; wide_sample++)
2178 for(channel = 0; channel < channels; channel++, sample++)
2179 out[channel][wide_sample] = (FLAC__int32)scbuffer_[sample];
2182 else if(bps == 16) {
2183 if(is_big_endian != is_big_endian_host_) {
2185 const unsigned bytes = wide_samples * channels * (bps >> 3);
2186 for(byte = 0; byte < bytes; byte += 2) {
2187 tmp = ucbuffer_[byte];
2188 ucbuffer_[byte] = ucbuffer_[byte+1];
2189 ucbuffer_[byte+1] = tmp;
2192 if(is_unsigned_samples) {
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)usbuffer_[sample] - 0x8000;
2198 for(sample = wide_sample = 0; wide_sample < wide_samples; wide_sample++)
2199 for(channel = 0; channel < channels; channel++, sample++)
2200 out[channel][wide_sample] = (FLAC__int32)ssbuffer_[sample];
2203 else if(bps == 24) {
2204 if(!is_big_endian) {
2206 const unsigned bytes = wide_samples * channels * (bps >> 3);
2207 for(byte = 0; byte < bytes; byte += 3) {
2208 tmp = ucbuffer_[byte];
2209 ucbuffer_[byte] = ucbuffer_[byte+2];
2210 ucbuffer_[byte+2] = tmp;
2213 if(is_unsigned_samples) {
2214 for(byte = sample = wide_sample = 0; wide_sample < wide_samples; wide_sample++)
2215 for(channel = 0; channel < channels; channel++, sample++) {
2216 out[channel][wide_sample] = ucbuffer_[byte++]; out[channel][wide_sample] <<= 8;
2217 out[channel][wide_sample] |= ucbuffer_[byte++]; out[channel][wide_sample] <<= 8;
2218 out[channel][wide_sample] |= ucbuffer_[byte++];
2219 out[channel][wide_sample] -= 0x800000;
2223 for(byte = sample = wide_sample = 0; wide_sample < wide_samples; wide_sample++)
2224 for(channel = 0; channel < channels; channel++, sample++) {
2225 out[channel][wide_sample] = scbuffer_[byte++]; out[channel][wide_sample] <<= 8;
2226 out[channel][wide_sample] |= ucbuffer_[byte++]; out[channel][wide_sample] <<= 8;
2227 out[channel][wide_sample] |= ucbuffer_[byte++];
2235 FLAC__int32 mask = (1<<shift)-1;
2236 for(wide_sample = 0; wide_sample < wide_samples; wide_sample++)
2237 for(channel = 0; channel < channels; channel++) {
2238 if(out[channel][wide_sample] & mask) {
2239 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);
2242 out[channel][wide_sample] >>= shift;
2248 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)
2250 EncoderSession *encoder_session = (EncoderSession*)client_data;
2252 (void)encoder, (void)total_frames_estimate;
2254 encoder_session->bytes_written = bytes_written;
2255 encoder_session->samples_written = samples_written;
2257 if(encoder_session->total_samples_to_encode > 0 && !((frames_written-1) & encoder_session->stats_mask))
2258 print_stats(encoder_session);
2261 FLAC__StreamDecoderReadStatus flac_decoder_read_callback(const FLAC__StreamDecoder *decoder, FLAC__byte buffer[], size_t *bytes, void *client_data)
2264 FLACDecoderData *data = (FLACDecoderData*)client_data;
2267 if (data->fatal_error)
2268 return FLAC__STREAM_DECODER_READ_STATUS_ABORT;
2270 /* use up lookahead first */
2271 if (data->lookahead_length) {
2272 n = min(data->lookahead_length, *bytes);
2273 memcpy(buffer, data->lookahead, n);
2275 data->lookahead += n;
2276 data->lookahead_length -= n;
2279 /* get the rest from file */
2281 *bytes = n + fread(buffer, 1, *bytes-n, data->encoder_session->fin);
2282 if(ferror(data->encoder_session->fin))
2283 return FLAC__STREAM_DECODER_READ_STATUS_ABORT;
2284 else if(0 == *bytes)
2285 return FLAC__STREAM_DECODER_READ_STATUS_END_OF_STREAM;
2287 return FLAC__STREAM_DECODER_READ_STATUS_CONTINUE;
2290 return FLAC__STREAM_DECODER_READ_STATUS_CONTINUE;
2293 FLAC__StreamDecoderSeekStatus flac_decoder_seek_callback(const FLAC__StreamDecoder *decoder, FLAC__uint64 absolute_byte_offset, void *client_data)
2295 FLACDecoderData *data = (FLACDecoderData*)client_data;
2298 if(fseeko(data->encoder_session->fin, (off_t)absolute_byte_offset, SEEK_SET) < 0)
2299 return FLAC__STREAM_DECODER_SEEK_STATUS_ERROR;
2301 return FLAC__STREAM_DECODER_SEEK_STATUS_OK;
2304 FLAC__StreamDecoderTellStatus flac_decoder_tell_callback(const FLAC__StreamDecoder *decoder, FLAC__uint64 *absolute_byte_offset, void *client_data)
2306 FLACDecoderData *data = (FLACDecoderData*)client_data;
2310 if((pos = ftello(data->encoder_session->fin)) < 0)
2311 return FLAC__STREAM_DECODER_TELL_STATUS_ERROR;
2313 *absolute_byte_offset = (FLAC__uint64)pos;
2314 return FLAC__STREAM_DECODER_TELL_STATUS_OK;
2318 FLAC__StreamDecoderLengthStatus flac_decoder_length_callback(const FLAC__StreamDecoder *decoder, FLAC__uint64 *stream_length, void *client_data)
2320 FLACDecoderData *data = (FLACDecoderData*)client_data;
2323 if(0 == data->filesize)
2324 return FLAC__STREAM_DECODER_LENGTH_STATUS_ERROR;
2326 *stream_length = (FLAC__uint64)data->filesize;
2327 return FLAC__STREAM_DECODER_LENGTH_STATUS_OK;
2331 FLAC__bool flac_decoder_eof_callback(const FLAC__StreamDecoder *decoder, void *client_data)
2333 FLACDecoderData *data = (FLACDecoderData*)client_data;
2336 return feof(data->encoder_session->fin)? true : false;
2339 FLAC__StreamDecoderWriteStatus flac_decoder_write_callback(const FLAC__StreamDecoder *decoder, const FLAC__Frame *frame, const FLAC__int32 * const buffer[], void *client_data)
2341 FLACDecoderData *data = (FLACDecoderData*)client_data;
2342 FLAC__uint64 n = min(data->samples_left_to_process, frame->header.blocksize);
2345 if(!EncoderSession_process(data->encoder_session, buffer, (unsigned)n)) {
2346 print_error_with_state(data->encoder_session, "ERROR during encoding");
2347 data->fatal_error = true;
2348 return FLAC__STREAM_DECODER_WRITE_STATUS_ABORT;
2351 data->samples_left_to_process -= n;
2352 return FLAC__STREAM_DECODER_WRITE_STATUS_CONTINUE;
2355 void flac_decoder_metadata_callback(const FLAC__StreamDecoder *decoder, const FLAC__StreamMetadata *metadata, void *client_data)
2357 FLACDecoderData *data = (FLACDecoderData*)client_data;
2360 if (data->fatal_error)
2364 data->num_metadata_blocks == sizeof(data->metadata_blocks)/sizeof(data->metadata_blocks[0]) ||
2365 0 == (data->metadata_blocks[data->num_metadata_blocks] = FLAC__metadata_object_clone(metadata))
2367 data->fatal_error = true;
2369 data->num_metadata_blocks++;
2372 void flac_decoder_error_callback(const FLAC__StreamDecoder *decoder, FLAC__StreamDecoderErrorStatus status, void *client_data)
2374 FLACDecoderData *data = (FLACDecoderData*)client_data;
2377 flac__utils_printf(stderr, 1, "%s: ERROR got %s while decoding FLAC input\n", data->encoder_session->inbasefilename, FLAC__StreamDecoderErrorStatusString[status]);
2378 data->fatal_error = true;
2381 FLAC__bool parse_cuesheet(FLAC__StreamMetadata **cuesheet, const char *cuesheet_filename, const char *inbasefilename, FLAC__bool is_cdda, FLAC__uint64 lead_out_offset)
2384 unsigned last_line_read;
2385 const char *error_message;
2387 if(0 == cuesheet_filename)
2390 if(lead_out_offset == 0) {
2391 flac__utils_printf(stderr, 1, "%s: ERROR cannot import cuesheet when the number of input samples to encode is unknown\n", inbasefilename);
2395 if(0 == (f = fopen(cuesheet_filename, "r"))) {
2396 flac__utils_printf(stderr, 1, "%s: ERROR opening cuesheet \"%s\" for reading: %s\n", inbasefilename, cuesheet_filename, strerror(errno));
2400 *cuesheet = grabbag__cuesheet_parse(f, &error_message, &last_line_read, is_cdda, lead_out_offset);
2404 if(0 == *cuesheet) {
2405 flac__utils_printf(stderr, 1, "%s: ERROR parsing cuesheet \"%s\" on line %u: %s\n", inbasefilename, cuesheet_filename, last_line_read, error_message);
2409 if(!FLAC__format_cuesheet_is_legal(&(*cuesheet)->data.cue_sheet, /*check_cd_da_subset=*/false, &error_message)) {
2410 flac__utils_printf(stderr, 1, "%s: ERROR parsing cuesheet \"%s\": %s\n", inbasefilename, cuesheet_filename, error_message);
2414 /* if we're expecting CDDA, warn about non-compliance */
2415 if(is_cdda && !FLAC__format_cuesheet_is_legal(&(*cuesheet)->data.cue_sheet, /*check_cd_da_subset=*/true, &error_message)) {
2416 flac__utils_printf(stderr, 1, "%s: WARNING cuesheet \"%s\" is not audio CD compliant: %s\n", inbasefilename, cuesheet_filename, error_message);
2417 (*cuesheet)->data.cue_sheet.is_cd = false;
2423 void print_stats(const EncoderSession *encoder_session)
2425 const FLAC__uint64 samples_written = min(encoder_session->total_samples_to_encode, encoder_session->samples_written);
2426 #if defined _MSC_VER || defined __MINGW32__
2427 /* with MSVC you have to spoon feed it the casting */
2428 const double progress = (double)(FLAC__int64)samples_written / (double)(FLAC__int64)encoder_session->total_samples_to_encode;
2429 const double ratio = (double)(FLAC__int64)encoder_session->bytes_written / ((double)(FLAC__int64)encoder_session->unencoded_size * min(1.0, progress));
2431 const double progress = (double)samples_written / (double)encoder_session->total_samples_to_encode;
2432 const double ratio = (double)encoder_session->bytes_written / ((double)encoder_session->unencoded_size * min(1.0, progress));
2435 if(samples_written == encoder_session->total_samples_to_encode) {
2436 flac__utils_printf(stderr, 2, "\r%s:%s wrote %u bytes, ratio=%0.3f",
2437 encoder_session->inbasefilename,
2438 encoder_session->verify? " Verify OK," : "",
2439 (unsigned)encoder_session->bytes_written,
2444 flac__utils_printf(stderr, 2, "\r%s: %u%% complete, ratio=%0.3f", encoder_session->inbasefilename, (unsigned)floor(progress * 100.0 + 0.5), ratio);
2448 void print_error_with_init_status(const EncoderSession *e, const char *message, FLAC__StreamEncoderInitStatus init_status)
2450 const int ilen = strlen(e->inbasefilename) + 1;
2451 const char *state_string = "";
2453 flac__utils_printf(stderr, 1, "\n%s: %s\n", e->inbasefilename, message);
2455 flac__utils_printf(stderr, 1, "%*s init_status = %s\n", ilen, "", FLAC__StreamEncoderInitStatusString[init_status]);
2457 if(init_status == FLAC__STREAM_ENCODER_INIT_STATUS_ENCODER_ERROR) {
2458 state_string = FLAC__stream_encoder_get_resolved_state_string(e->encoder);
2460 flac__utils_printf(stderr, 1, "%*s state = %s\n", ilen, "", state_string);
2462 /* print out some more info for some errors: */
2463 if(0 == strcmp(state_string, FLAC__StreamEncoderStateString[FLAC__STREAM_ENCODER_CLIENT_ERROR])) {
2464 flac__utils_printf(stderr, 1,
2466 "An error occurred while writing; the most common cause is that the disk is full.\n"
2469 else if(0 == strcmp(state_string, FLAC__StreamEncoderStateString[FLAC__STREAM_ENCODER_IO_ERROR])) {
2470 flac__utils_printf(stderr, 1,
2472 "An error occurred opening the output file; it is likely that the output\n"
2473 "directory does not exist or is not writable, the output file already exists and\n"
2474 "is not writable, or the disk is full.\n"
2478 else if(init_status == FLAC__STREAM_ENCODER_INIT_STATUS_NOT_STREAMABLE) {
2479 flac__utils_printf(stderr, 1,
2481 "The encoding parameters specified do not conform to the FLAC Subset and may not\n"
2482 "be streamable or playable in hardware devices. If you really understand the\n"
2483 "consequences, you can add --lax to the command-line options to encode with\n"
2484 "these parameters anyway. See http://flac.sourceforge.net/format.html#subset\n"
2489 void print_error_with_state(const EncoderSession *e, const char *message)
2491 const int ilen = strlen(e->inbasefilename) + 1;
2492 const char *state_string;
2494 flac__utils_printf(stderr, 1, "\n%s: %s\n", e->inbasefilename, message);
2496 state_string = FLAC__stream_encoder_get_resolved_state_string(e->encoder);
2498 flac__utils_printf(stderr, 1, "%*s state = %s\n", ilen, "", state_string);
2500 /* print out some more info for some errors: */
2501 if(0 == strcmp(state_string, FLAC__StreamEncoderStateString[FLAC__STREAM_ENCODER_CLIENT_ERROR])) {
2502 flac__utils_printf(stderr, 1,
2504 "An error occurred while writing; the most common cause is that the disk is full.\n"
2509 void print_verify_error(EncoderSession *e)
2511 FLAC__uint64 absolute_sample;
2512 unsigned frame_number;
2515 FLAC__int32 expected;
2518 FLAC__stream_encoder_get_verify_decoder_error_stats(e->encoder, &absolute_sample, &frame_number, &channel, &sample, &expected, &got);
2520 flac__utils_printf(stderr, 1, "%s: ERROR: mismatch in decoded data, verify FAILED!\n", e->inbasefilename);
2521 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);
2522 flac__utils_printf(stderr, 1, " In all known cases, verify errors are caused by hardware problems,\n");
2523 flac__utils_printf(stderr, 1, " usually overclocking or bad RAM. Delete %s\n", e->outfilename);
2524 flac__utils_printf(stderr, 1, " and repeat the flac command exactly as before. If it does not give a\n");
2525 flac__utils_printf(stderr, 1, " verify error in the exact same place each time you try it, then there is\n");
2526 flac__utils_printf(stderr, 1, " a problem with your hardware; please see the FAQ:\n");
2527 flac__utils_printf(stderr, 1, " http://flac.sourceforge.net/faq.html#tools__hardware_prob\n");
2528 flac__utils_printf(stderr, 1, " If it does fail in the exact same place every time, keep\n");
2529 flac__utils_printf(stderr, 1, " %s and submit a bug report to:\n", e->outfilename);
2530 flac__utils_printf(stderr, 1, " https://sourceforge.net/bugs/?func=addbug&group_id=13478\n");
2531 flac__utils_printf(stderr, 1, " Make sure to upload the FLAC file and use the \"Monitor\" feature to\n");
2532 flac__utils_printf(stderr, 1, " monitor the bug status.\n");
2533 flac__utils_printf(stderr, 1, "Verify FAILED! Do not trust %s\n", e->outfilename);
2536 FLAC__bool read_little_endian_uint16(FILE *f, FLAC__uint16 *val, FLAC__bool eof_ok, const char *fn)
2538 size_t bytes_read = fread(val, 1, 2, f);
2540 if(bytes_read == 0) {
2542 flac__utils_printf(stderr, 1, "%s: ERROR: unexpected EOF\n", fn);
2548 else if(bytes_read < 2) {
2549 flac__utils_printf(stderr, 1, "%s: ERROR: unexpected EOF\n", fn);
2553 if(is_big_endian_host_) {
2554 FLAC__byte tmp, *b = (FLAC__byte*)val;
2555 tmp = b[1]; b[1] = b[0]; b[0] = tmp;
2561 FLAC__bool read_little_endian_uint32(FILE *f, FLAC__uint32 *val, FLAC__bool eof_ok, const char *fn)
2563 size_t bytes_read = fread(val, 1, 4, f);
2565 if(bytes_read == 0) {
2567 flac__utils_printf(stderr, 1, "%s: ERROR: unexpected EOF\n", fn);
2573 else if(bytes_read < 4) {
2574 flac__utils_printf(stderr, 1, "%s: ERROR: unexpected EOF\n", fn);
2578 if(is_big_endian_host_) {
2579 FLAC__byte tmp, *b = (FLAC__byte*)val;
2580 tmp = b[3]; b[3] = b[0]; b[0] = tmp;
2581 tmp = b[2]; b[2] = b[1]; b[1] = tmp;
2587 FLAC__bool read_big_endian_uint16(FILE *f, FLAC__uint16 *val, FLAC__bool eof_ok, const char *fn)
2589 unsigned char buf[4];
2590 size_t bytes_read= fread(buf, 1, 2, f);
2592 if(bytes_read==0U && eof_ok)
2594 else if(bytes_read<2U) {
2595 flac__utils_printf(stderr, 1, "%s: ERROR: unexpected EOF\n", fn);
2599 /* this is independent of host endianness */
2600 *val= (FLAC__uint16)(buf[0])<<8 | buf[1];
2605 FLAC__bool read_big_endian_uint32(FILE *f, FLAC__uint32 *val, FLAC__bool eof_ok, const char *fn)
2607 unsigned char buf[4];
2608 size_t bytes_read= fread(buf, 1, 4, f);
2610 if(bytes_read==0U && eof_ok)
2612 else if(bytes_read<4U) {
2613 flac__utils_printf(stderr, 1, "%s: ERROR: unexpected EOF\n", fn);
2617 /* this is independent of host endianness */
2618 *val= (FLAC__uint32)(buf[0])<<24 | (FLAC__uint32)(buf[1])<<16 |
2619 (FLAC__uint32)(buf[2])<<8 | buf[3];
2624 FLAC__bool read_sane_extended(FILE *f, FLAC__uint32 *val, FLAC__bool eof_ok, const char *fn)
2625 /* Read an IEEE 754 80-bit (aka SANE) extended floating point value from 'f',
2626 * convert it into an integral value and store in 'val'. Return false if only
2627 * between 1 and 9 bytes remain in 'f', if 0 bytes remain in 'f' and 'eof_ok' is
2628 * false, or if the value is negative, between zero and one, or too large to be
2629 * represented by 'val'; return true otherwise.
2633 unsigned char buf[10];
2634 size_t bytes_read= fread(buf, 1U, 10U, f);
2635 FLAC__int16 e= ((FLAC__uint16)(buf[0])<<8 | (FLAC__uint16)(buf[1]))-0x3FFF;
2636 FLAC__int16 shift= 63-e;
2639 if(bytes_read==0U && eof_ok)
2641 else if(bytes_read<10U) {
2642 flac__utils_printf(stderr, 1, "%s: ERROR: unexpected EOF\n", fn);
2645 else if((buf[0]>>7)==1U || e<0 || e>63) {
2646 flac__utils_printf(stderr, 1, "%s: ERROR: invalid floating-point value\n", fn);
2650 for(i= 0U; i<8U; ++i)
2651 p|= (FLAC__uint64)(buf[i+2])<<(56U-i*8);
2652 *val= (FLAC__uint32)((p>>shift)+(p>>(shift-1) & 0x1));
2657 FLAC__bool fskip_ahead(FILE *f, FLAC__uint64 offset)
2659 static unsigned char dump[8192];
2662 long need = (long)min(offset, LONG_MAX);
2663 if(fseeko(f, need, SEEK_CUR) < 0) {
2664 need = (long)min(offset, sizeof(dump));
2665 if((long)fread(dump, 1, need, f) < need)
2670 #if 0 /* pure non-fseek() version */
2672 const long need = (long)min(offset, sizeof(dump));
2673 if(fread(dump, 1, need, f) < need)
2681 unsigned count_channel_mask_bits(FLAC__uint32 mask)
2692 FLAC__uint32 limit_channel_mask(FLAC__uint32 mask, unsigned channels)
2694 FLAC__uint32 x = 0x80000000;
2695 unsigned count = count_channel_mask_bits(mask);
2696 while(x && count > channels) {
2703 FLAC__ASSERT(count_channel_mask_bits(mask) == channels);