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;
81 FLAC__StreamEncoder *encoder;
84 FLAC__StreamMetadata *seek_table_template;
87 /* this is data attached to the FLAC decoder when encoding from a FLAC file */
89 EncoderSession *encoder_session;
91 const FLAC__byte *lookahead;
92 unsigned lookahead_length;
93 size_t num_metadata_blocks;
94 FLAC__StreamMetadata *metadata_blocks[1024]; /*@@@ BAD MAGIC number */
95 FLAC__uint64 samples_left_to_process;
96 FLAC__bool fatal_error;
99 const int FLAC_ENCODE__DEFAULT_PADDING = 8192;
101 static FLAC__bool is_big_endian_host_;
103 static unsigned char ucbuffer_[CHUNK_OF_SAMPLES*FLAC__MAX_CHANNELS*((FLAC__REFERENCE_CODEC_MAX_BITS_PER_SAMPLE+7)/8)];
104 static signed char *scbuffer_ = (signed char *)ucbuffer_;
105 static FLAC__uint16 *usbuffer_ = (FLAC__uint16 *)ucbuffer_;
106 static FLAC__int16 *ssbuffer_ = (FLAC__int16 *)ucbuffer_;
108 static FLAC__int32 in_[FLAC__MAX_CHANNELS][CHUNK_OF_SAMPLES];
109 static FLAC__int32 *input_[FLAC__MAX_CHANNELS];
113 * unpublished debug routines from the FLAC libs
115 extern FLAC__bool FLAC__stream_encoder_disable_constant_subframes(FLAC__StreamEncoder *encoder, FLAC__bool value);
116 extern FLAC__bool FLAC__stream_encoder_disable_fixed_subframes(FLAC__StreamEncoder *encoder, FLAC__bool value);
117 extern FLAC__bool FLAC__stream_encoder_disable_verbatim_subframes(FLAC__StreamEncoder *encoder, FLAC__bool value);
122 static FLAC__bool EncoderSession_construct(EncoderSession *e, FLAC__bool use_ogg, FLAC__bool verify, FILE *infile, const char *infilename, const char *outfilename);
123 static void EncoderSession_destroy(EncoderSession *e);
124 static int EncoderSession_finish_ok(EncoderSession *e, int info_align_carry, int info_align_zero);
125 static int EncoderSession_finish_error(EncoderSession *e);
126 static FLAC__bool EncoderSession_init_encoder(EncoderSession *e, encode_options_t options, FLAC__uint32 channel_mask, unsigned channels, unsigned bps, unsigned sample_rate, FLACDecoderData *flac_decoder_data);
127 static FLAC__bool EncoderSession_process(EncoderSession *e, const FLAC__int32 * const buffer[], unsigned samples);
128 static FLAC__bool convert_to_seek_table_template(const char *requested_seek_points, int num_requested_seek_points, FLAC__StreamMetadata *cuesheet, EncoderSession *e);
129 static FLAC__bool canonicalize_until_specification(utils__SkipUntilSpecification *spec, const char *inbasefilename, unsigned sample_rate, FLAC__uint64 skip, FLAC__uint64 total_samples_in_input);
130 static FLAC__bool verify_metadata(const EncoderSession *e, FLAC__StreamMetadata **metadata, unsigned num_metadata);
131 static FLAC__bool format_input(FLAC__int32 *dest[], unsigned wide_samples, FLAC__bool is_big_endian, FLAC__bool is_unsigned_samples, unsigned channels, unsigned bps, unsigned shift, size_t *channel_map);
132 static void encoder_progress_callback(const FLAC__StreamEncoder *encoder, FLAC__uint64 bytes_written, FLAC__uint64 samples_written, unsigned frames_written, unsigned total_frames_estimate, void *client_data);
133 static FLAC__StreamDecoderReadStatus flac_decoder_read_callback(const FLAC__StreamDecoder *decoder, FLAC__byte buffer[], unsigned *bytes, void *client_data);
134 static FLAC__StreamDecoderSeekStatus flac_decoder_seek_callback(const FLAC__StreamDecoder *decoder, FLAC__uint64 absolute_byte_offset, void *client_data);
135 static FLAC__StreamDecoderTellStatus flac_decoder_tell_callback(const FLAC__StreamDecoder *decoder, FLAC__uint64 *absolute_byte_offset, void *client_data);
136 static FLAC__StreamDecoderLengthStatus flac_decoder_length_callback(const FLAC__StreamDecoder *decoder, FLAC__uint64 *stream_length, void *client_data);
137 static FLAC__bool flac_decoder_eof_callback(const FLAC__StreamDecoder *decoder, void *client_data);
138 static FLAC__StreamDecoderWriteStatus flac_decoder_write_callback(const FLAC__StreamDecoder *decoder, const FLAC__Frame *frame, const FLAC__int32 * const buffer[], void *client_data);
139 static void flac_decoder_metadata_callback(const FLAC__StreamDecoder *decoder, const FLAC__StreamMetadata *metadata, void *client_data);
140 static void flac_decoder_error_callback(const FLAC__StreamDecoder *decoder, FLAC__StreamDecoderErrorStatus status, void *client_data);
141 static FLAC__bool parse_cuesheet(FLAC__StreamMetadata **cuesheet, const char *cuesheet_filename, const char *inbasefilename, FLAC__bool is_cdda, FLAC__uint64 lead_out_offset);
142 static void print_stats(const EncoderSession *encoder_session);
143 static void print_error_with_init_status(const EncoderSession *e, const char *message, FLAC__StreamEncoderInitStatus init_status);
144 static void print_error_with_state(const EncoderSession *e, const char *message);
145 static void print_verify_error(EncoderSession *e);
146 static FLAC__bool read_little_endian_uint16(FILE *f, FLAC__uint16 *val, FLAC__bool eof_ok, const char *fn);
147 static FLAC__bool read_little_endian_uint32(FILE *f, FLAC__uint32 *val, FLAC__bool eof_ok, const char *fn);
148 static FLAC__bool read_big_endian_uint16(FILE *f, FLAC__uint16 *val, FLAC__bool eof_ok, const char *fn);
149 static FLAC__bool read_big_endian_uint32(FILE *f, FLAC__uint32 *val, FLAC__bool eof_ok, const char *fn);
150 static FLAC__bool read_sane_extended(FILE *f, FLAC__uint32 *val, FLAC__bool eof_ok, const char *fn);
151 static FLAC__bool fskip_ahead(FILE *f, FLAC__uint64 offset);
152 static unsigned count_channel_mask_bits(FLAC__uint32 mask);
153 static FLAC__uint32 limit_channel_mask(FLAC__uint32 mask, unsigned channels);
158 int flac__encode_aif(FILE *infile, off_t infilesize, const char *infilename, const char *outfilename, const FLAC__byte *lookahead, unsigned lookahead_length, wav_encode_options_t options, FLAC__bool is_aifc)
160 EncoderSession encoder_session;
163 unsigned int channels= 0U, bps= 0U, shift= 0U, sample_rate= 0U, sample_frames= 0U;
164 size_t channel_map[FLAC__MAX_CHANNELS];
165 FLAC__bool got_comm_chunk= false, got_ssnd_chunk= false;
166 int info_align_carry= -1, info_align_zero= -1;
167 FLAC__bool is_big_endian_pcm = true;
169 (void)infilesize; /* silence compiler warning about unused parameter */
170 (void)lookahead; /* silence compiler warning about unused parameter */
171 (void)lookahead_length; /* silence compiler warning about unused parameter */
174 EncoderSession_construct(
177 options.common.use_ogg,
181 options.common.verify,
189 /* initialize default channel map that preserves channel order */
192 for(i = 0; i < sizeof(channel_map)/sizeof(channel_map[0]); i++)
196 /* lookahead[] already has "FORMxxxxAIFF", do sub-chunks */
200 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 */
202 /* chunk identifier; really conservative about behavior of fread() and feof() */
203 if(feof(infile) || ((c= fread(chunk_id, 1U, 4U, infile)), c==0U && feof(infile)))
205 else if(c<4U || feof(infile)) {
206 flac__utils_printf(stderr, 1, "%s: ERROR: incomplete chunk identifier\n", encoder_session.inbasefilename);
207 return EncoderSession_finish_error(&encoder_session);
210 if(got_comm_chunk==false && !memcmp(chunk_id, "COMM", 4)) { /* common chunk */
212 const FLAC__uint32 minimum_comm_size = (is_aifc? 22 : 18);
214 /* COMM chunk size */
215 if(!read_big_endian_uint32(infile, &xx, false, encoder_session.inbasefilename))
216 return EncoderSession_finish_error(&encoder_session);
217 else if(xx<minimum_comm_size) {
218 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);
219 return EncoderSession_finish_error(&encoder_session);
221 else if(!is_aifc && xx!=minimum_comm_size) {
222 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);
224 skip= (xx-minimum_comm_size)+(xx & 1U);
226 /* number of channels */
227 if(!read_big_endian_uint16(infile, &x, false, encoder_session.inbasefilename))
228 return EncoderSession_finish_error(&encoder_session);
229 else if(x==0U || x>FLAC__MAX_CHANNELS) {
230 flac__utils_printf(stderr, 1, "%s: ERROR: unsupported number channels %u\n", encoder_session.inbasefilename, (unsigned int)x);
231 return EncoderSession_finish_error(&encoder_session);
233 else if(x>2U && !options.common.channel_map_none) {
234 flac__utils_printf(stderr, 1, "%s: ERROR: unsupported number channels %u for AIFF\n", encoder_session.inbasefilename, (unsigned int)x);
235 return EncoderSession_finish_error(&encoder_session);
237 else if(options.common.sector_align && x!=2U) {
238 flac__utils_printf(stderr, 1, "%s: ERROR: file has %u channels, must be 2 for --sector-align\n", encoder_session.inbasefilename, (unsigned int)x);
239 return EncoderSession_finish_error(&encoder_session);
243 /* number of sample frames */
244 if(!read_big_endian_uint32(infile, &xx, false, encoder_session.inbasefilename))
245 return EncoderSession_finish_error(&encoder_session);
248 /* bits per sample */
249 if(!read_big_endian_uint16(infile, &x, false, encoder_session.inbasefilename))
250 return EncoderSession_finish_error(&encoder_session);
251 else if(x<4U || x>24U) {
252 flac__utils_printf(stderr, 1, "%s: ERROR: unsupported bits-per-sample %u\n", encoder_session.inbasefilename, (unsigned int)x);
253 return EncoderSession_finish_error(&encoder_session);
255 else if(options.common.sector_align && x!=16U) {
256 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);
257 return EncoderSession_finish_error(&encoder_session);
260 shift= (bps%8)? 8-(bps%8) : 0; /* SSND data is always byte-aligned, left-justified but format_input() will double-check */
264 if(!read_sane_extended(infile, &xx, false, encoder_session.inbasefilename))
265 return EncoderSession_finish_error(&encoder_session);
266 else if(!FLAC__format_sample_rate_is_valid(xx)) {
267 flac__utils_printf(stderr, 1, "%s: ERROR: unsupported sample rate %u\n", encoder_session.inbasefilename, (unsigned int)xx);
268 return EncoderSession_finish_error(&encoder_session);
270 else if(options.common.sector_align && xx!=44100U) {
271 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);
272 return EncoderSession_finish_error(&encoder_session);
276 /* check compression type for AIFF-C */
278 if(!read_big_endian_uint32(infile, &xx, false, encoder_session.inbasefilename))
279 return EncoderSession_finish_error(&encoder_session);
280 if(xx == 0x736F7774) /* "sowt" */
281 is_big_endian_pcm = false;
282 else if(xx == 0x4E4F4E45) /* "NONE" */
283 ; /* nothing to do, we already default to big-endian */
285 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));
286 return EncoderSession_finish_error(&encoder_session);
290 /* set channel mapping */
291 /* FLAC order follows SMPTE and WAVEFORMATEXTENSIBLE but with fewer channels, which are: */
292 /* front left, front right, center, LFE, back left, back right, surround left, surround right */
293 /* specs say the channel ordering is:
295 * ___________________________________________________
299 * quad (ambiguous with 4ch) Fl Fr Bl Br
302 * 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
303 * so we only have unambiguous mappings for 2, 3, and 5 channels
306 options.common.channel_map_none ||
307 channels == 1 || /* 1 channel: (mono) */
308 channels == 2 || /* 2 channels: left, right */
309 channels == 3 || /* 3 channels: left, right, center */
310 channels == 5 /* 5 channels: front left, front right, center, surround left, surround right */
312 /* keep default channel order */
315 flac__utils_printf(stderr, 1, "%s: ERROR: unsupported number channels %u for AIFF\n", encoder_session.inbasefilename, channels);
316 return EncoderSession_finish_error(&encoder_session);
319 /* skip any extra data in the COMM chunk */
320 if(!fskip_ahead(infile, skip)) {
321 flac__utils_printf(stderr, 1, "%s: ERROR during read while skipping extra COMM data\n", encoder_session.inbasefilename);
322 return EncoderSession_finish_error(&encoder_session);
326 * now that we know the sample rate, canonicalize the
327 * --skip string to a number of samples:
329 flac__utils_canonicalize_skip_until_specification(&options.common.skip_specification, sample_rate);
330 FLAC__ASSERT(options.common.skip_specification.value.samples >= 0);
331 encoder_session.skip = (FLAC__uint64)options.common.skip_specification.value.samples;
332 FLAC__ASSERT(!options.common.sector_align || encoder_session.skip == 0);
334 got_comm_chunk= true;
336 else if(got_ssnd_chunk==false && !memcmp(chunk_id, "SSND", 4)) { /* sound data chunk */
337 unsigned int offset= 0U, block_size= 0U, align_remainder= 0U, data_bytes;
338 size_t bytes_per_frame= channels*(bps>>3);
339 FLAC__uint64 total_samples_in_input, trim = 0;
340 FLAC__bool pad= false;
342 if(got_comm_chunk==false) {
343 flac__utils_printf(stderr, 1, "%s: ERROR: got 'SSND' chunk before 'COMM' chunk\n", encoder_session.inbasefilename);
344 return EncoderSession_finish_error(&encoder_session);
347 /* SSND chunk size */
348 if(!read_big_endian_uint32(infile, &xx, false, encoder_session.inbasefilename))
349 return EncoderSession_finish_error(&encoder_session);
351 pad= (data_bytes & 1U) ? true : false;
352 data_bytes-= 8U; /* discount the offset and block size fields */
355 if(!read_big_endian_uint32(infile, &xx, false, encoder_session.inbasefilename))
356 return EncoderSession_finish_error(&encoder_session);
361 if(!read_big_endian_uint32(infile, &xx, false, encoder_session.inbasefilename))
362 return EncoderSession_finish_error(&encoder_session);
364 flac__utils_printf(stderr, 1, "%s: ERROR: block size is %u; must be 0\n", encoder_session.inbasefilename, (unsigned int)xx);
365 return EncoderSession_finish_error(&encoder_session);
369 /* skip any SSND offset bytes */
370 FLAC__ASSERT(offset<=LONG_MAX);
371 if(!fskip_ahead(infile, offset)) {
372 flac__utils_printf(stderr, 1, "%s: ERROR: skipping offset in SSND chunk\n", encoder_session.inbasefilename);
373 return EncoderSession_finish_error(&encoder_session);
375 if(data_bytes!=(sample_frames*bytes_per_frame)) {
376 flac__utils_printf(stderr, 1, "%s: ERROR: SSND chunk size inconsistent with sample frame count\n", encoder_session.inbasefilename);
377 return EncoderSession_finish_error(&encoder_session);
380 /* *options.common.align_reservoir_samples will be 0 unless --sector-align is used */
381 FLAC__ASSERT(options.common.sector_align || *options.common.align_reservoir_samples == 0);
382 total_samples_in_input = data_bytes / bytes_per_frame + *options.common.align_reservoir_samples;
385 * now that we know the input size, canonicalize the
386 * --until string to an absolute sample number:
388 if(!canonicalize_until_specification(&options.common.until_specification, encoder_session.inbasefilename, sample_rate, encoder_session.skip, total_samples_in_input))
389 return EncoderSession_finish_error(&encoder_session);
390 encoder_session.until = (FLAC__uint64)options.common.until_specification.value.samples;
391 FLAC__ASSERT(!options.common.sector_align || encoder_session.until == 0);
393 if(encoder_session.skip>0U) {
394 if(!fskip_ahead(infile, encoder_session.skip*bytes_per_frame)) {
395 flac__utils_printf(stderr, 1, "%s: ERROR during read while skipping samples\n", encoder_session.inbasefilename);
396 return EncoderSession_finish_error(&encoder_session);
400 data_bytes-= (unsigned int)encoder_session.skip*bytes_per_frame; /*@@@ WATCHOUT: 4GB limit */
401 encoder_session.total_samples_to_encode= total_samples_in_input - encoder_session.skip;
402 if(encoder_session.until > 0) {
403 trim = total_samples_in_input - encoder_session.until;
404 FLAC__ASSERT(total_samples_in_input > 0);
405 FLAC__ASSERT(!options.common.sector_align);
406 data_bytes-= (unsigned int)trim*bytes_per_frame;
407 encoder_session.total_samples_to_encode-= trim;
409 if(options.common.sector_align) {
410 align_remainder= (unsigned int)(encoder_session.total_samples_to_encode % 588U);
411 if(options.common.is_last_file)
412 encoder_session.total_samples_to_encode+= (588U-align_remainder); /* will pad with zeroes */
414 encoder_session.total_samples_to_encode-= align_remainder; /* will stop short and carry over to next file */
417 /* +54 for the size of the AIFF headers; this is just an estimate for the progress indicator and doesn't need to be exact */
418 encoder_session.unencoded_size= encoder_session.total_samples_to_encode*bytes_per_frame+54;
420 if(!EncoderSession_init_encoder(&encoder_session, options.common, /*channel_mask=*/0, channels, bps-shift, sample_rate, /*flac_decoder_data=*/0))
421 return EncoderSession_finish_error(&encoder_session);
423 /* first do any samples in the reservoir */
424 if(options.common.sector_align && *options.common.align_reservoir_samples>0U) {
426 if(!EncoderSession_process(&encoder_session, (const FLAC__int32 *const *)options.common.align_reservoir, *options.common.align_reservoir_samples)) {
427 print_error_with_state(&encoder_session, "ERROR during encoding");
428 return EncoderSession_finish_error(&encoder_session);
432 /* decrement the data_bytes counter if we need to align the file */
433 if(options.common.sector_align) {
434 if(options.common.is_last_file)
435 *options.common.align_reservoir_samples= 0U;
437 *options.common.align_reservoir_samples= align_remainder;
438 data_bytes-= (*options.common.align_reservoir_samples)*bytes_per_frame;
442 /* now do from the file */
443 while(data_bytes>0) {
444 size_t bytes_read= fread(ucbuffer_, 1U, min(data_bytes, CHUNK_OF_SAMPLES*bytes_per_frame), infile);
448 flac__utils_printf(stderr, 1, "%s: ERROR during read\n", encoder_session.inbasefilename);
449 return EncoderSession_finish_error(&encoder_session);
451 else if(feof(infile)) {
452 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);
457 if(bytes_read % bytes_per_frame != 0U) {
458 flac__utils_printf(stderr, 1, "%s: ERROR: got partial sample\n", encoder_session.inbasefilename);
459 return EncoderSession_finish_error(&encoder_session);
462 unsigned int frames= bytes_read/bytes_per_frame;
463 if(!format_input(input_, frames, is_big_endian_pcm, /*is_unsigned_samples=*/false, channels, bps, shift, channel_map))
464 return EncoderSession_finish_error(&encoder_session);
466 if(!EncoderSession_process(&encoder_session, (const FLAC__int32 *const *)input_, frames)) {
467 print_error_with_state(&encoder_session, "ERROR during encoding");
468 return EncoderSession_finish_error(&encoder_session);
471 data_bytes-= bytes_read;
477 FLAC__ASSERT(!options.common.sector_align);
478 if(!fskip_ahead(infile, trim*bytes_per_frame)) {
479 flac__utils_printf(stderr, 1, "%s: ERROR during read while skipping samples\n", encoder_session.inbasefilename);
480 return EncoderSession_finish_error(&encoder_session);
484 /* now read unaligned samples into reservoir or pad with zeroes if necessary */
485 if(options.common.sector_align) {
486 if(options.common.is_last_file) {
487 unsigned int pad_frames= 588U-align_remainder;
489 if(pad_frames<588U) {
492 info_align_zero= pad_frames;
493 for(i= 0U; i<channels; ++i)
494 memset(input_[i], 0, sizeof(input_[0][0])*pad_frames);
496 if(!EncoderSession_process(&encoder_session, (const FLAC__int32 *const *)input_, pad_frames)) {
497 print_error_with_state(&encoder_session, "ERROR during encoding");
498 return EncoderSession_finish_error(&encoder_session);
503 if(*options.common.align_reservoir_samples > 0) {
504 size_t bytes_read= fread(ucbuffer_, 1U, (*options.common.align_reservoir_samples)*bytes_per_frame, infile);
506 FLAC__ASSERT(CHUNK_OF_SAMPLES>=588U);
507 if(bytes_read==0U && ferror(infile)) {
508 flac__utils_printf(stderr, 1, "%s: ERROR during read\n", encoder_session.inbasefilename);
509 return EncoderSession_finish_error(&encoder_session);
511 else if(bytes_read != (*options.common.align_reservoir_samples) * bytes_per_frame) {
512 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);
515 info_align_carry= *options.common.align_reservoir_samples;
516 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))
517 return EncoderSession_finish_error(&encoder_session);
526 if(fread(&tmp, 1U, 1U, infile)<1U) {
527 flac__utils_printf(stderr, 1, "%s: ERROR during read of SSND pad byte\n", encoder_session.inbasefilename);
528 return EncoderSession_finish_error(&encoder_session);
532 got_ssnd_chunk= true;
534 else { /* other chunk */
535 if(!memcmp(chunk_id, "COMM", 4)) {
536 flac__utils_printf(stderr, 1, "%s: WARNING: skipping extra 'COMM' chunk\n", encoder_session.inbasefilename);
538 else if(!memcmp(chunk_id, "SSND", 4)) {
539 flac__utils_printf(stderr, 1, "%s: WARNING: skipping extra 'SSND' chunk\n", encoder_session.inbasefilename);
542 flac__utils_printf(stderr, 1, "%s: WARNING: skipping unknown chunk '%s'\n", encoder_session.inbasefilename, chunk_id);
546 if(!read_big_endian_uint32(infile, &xx, false, encoder_session.inbasefilename))
547 return EncoderSession_finish_error(&encoder_session);
549 unsigned long skip= xx+(xx & 1U);
551 FLAC__ASSERT(skip<=LONG_MAX);
552 if(!fskip_ahead(infile, skip)) {
553 fprintf(stderr, "%s: ERROR during read while skipping unknown chunk\n", encoder_session.inbasefilename);
554 return EncoderSession_finish_error(&encoder_session);
560 if(got_ssnd_chunk==false && sample_frames!=0U) {
561 flac__utils_printf(stderr, 1, "%s: ERROR: missing SSND chunk\n", encoder_session.inbasefilename);
562 return EncoderSession_finish_error(&encoder_session);
565 return EncoderSession_finish_ok(&encoder_session, info_align_carry, info_align_zero);
568 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)
570 EncoderSession encoder_session;
571 FLAC__bool is_unsigned_samples = false;
572 unsigned channels = 0, bps = 0, sample_rate = 0, shift = 0;
573 size_t bytes_per_wide_sample, bytes_read;
574 size_t channel_map[FLAC__MAX_CHANNELS];
575 FLAC__uint16 x, format; /* format is the wFormatTag word from the 'fmt ' chunk */
576 FLAC__uint32 xx, channel_mask = 0;
577 FLAC__bool got_fmt_chunk = false, got_data_chunk = false;
578 unsigned align_remainder = 0;
579 int info_align_carry = -1, info_align_zero = -1;
583 (void)lookahead_length;
586 EncoderSession_construct(
589 options.common.use_ogg,
593 options.common.verify,
601 /* initialize default channel map that preserves channel order */
604 for(i = 0; i < sizeof(channel_map)/sizeof(channel_map[0]); i++)
609 * lookahead[] already has "RIFFxxxxWAVE", do sub-chunks
611 while(!feof(infile)) {
612 if(!read_little_endian_uint32(infile, &xx, true, encoder_session.inbasefilename))
613 return EncoderSession_finish_error(&encoder_session);
616 if(xx == 0x20746d66 && !got_fmt_chunk) { /* "fmt " */
617 unsigned block_align, data_bytes;
620 * http://www-mmsp.ece.mcgill.ca/Documents/AudioFormats/WAVE/WAVE.html
621 * http://windowssdk.msdn.microsoft.com/en-us/library/ms713497.aspx
622 * 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
625 * 4 byte: subchunk size
626 * 2 byte: format type: 1 for WAVE_FORMAT_PCM, 65534 for WAVE_FORMAT_EXTENSIBLE
628 * 4 byte: sample rate (Hz)
629 * 4 byte: avg bytes per sec
630 * 2 byte: block align
631 * 2 byte: bits per sample (not necessarily all significant)
633 * 2 byte: extension size in bytes (usually 0 for WAVEFORMATEX and 22 for WAVEFORMATEXTENSIBLE with PCM)
634 * WAVEFORMATEXTENSIBLE adds
635 * 2 byte: valid bits per sample
636 * 4 byte: channel mask
637 * 16 byte: subformat GUID, first 2 bytes have format type, 1 being PCM
639 * Current spec says WAVEFORMATEX with PCM must have bps == 8 or 16, or any multiple of 8 for WAVEFORMATEXTENSIBLE.
640 * 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.
642 * Block align for WAVE_FORMAT_PCM or WAVE_FORMAT_EXTENSIBLE is also supposed to be channels*bps/8
644 * If the channel mask has more set bits than # of channels, the extra MSBs are ignored.
645 * If the channel mask has less set bits than # of channels, the extra channels are unassigned to any speaker.
647 * Data is supposed to be unsigned for bps <= 8 else signed.
650 /* fmt sub-chunk size */
651 if(!read_little_endian_uint32(infile, &xx, false, encoder_session.inbasefilename))
652 return EncoderSession_finish_error(&encoder_session);
654 if(data_bytes < 16) {
655 flac__utils_printf(stderr, 1, "%s: ERROR: found non-standard 'fmt ' sub-chunk which has length = %u\n", encoder_session.inbasefilename, data_bytes);
656 return EncoderSession_finish_error(&encoder_session);
659 if(!read_little_endian_uint16(infile, &format, false, encoder_session.inbasefilename))
660 return EncoderSession_finish_error(&encoder_session);
661 if(format != 1 /*WAVE_FORMAT_PCM*/ && format != 65534 /*WAVE_FORMAT_EXTENSIBLE*/) {
662 flac__utils_printf(stderr, 1, "%s: ERROR: unsupported format type %u\n", encoder_session.inbasefilename, (unsigned)format);
663 return EncoderSession_finish_error(&encoder_session);
665 /* number of channels */
666 if(!read_little_endian_uint16(infile, &x, false, encoder_session.inbasefilename))
667 return EncoderSession_finish_error(&encoder_session);
668 channels = (unsigned)x;
669 if(channels == 0 || channels > FLAC__MAX_CHANNELS) {
670 flac__utils_printf(stderr, 1, "%s: ERROR: unsupported number of channels %u\n", encoder_session.inbasefilename, channels);
671 return EncoderSession_finish_error(&encoder_session);
673 else if(options.common.sector_align && channels != 2) {
674 flac__utils_printf(stderr, 1, "%s: ERROR: file has %u channels, must be 2 for --sector-align\n", encoder_session.inbasefilename, channels);
675 return EncoderSession_finish_error(&encoder_session);
678 if(!read_little_endian_uint32(infile, &xx, false, encoder_session.inbasefilename))
679 return EncoderSession_finish_error(&encoder_session);
681 if(!FLAC__format_sample_rate_is_valid(sample_rate)) {
682 flac__utils_printf(stderr, 1, "%s: ERROR: unsupported sample rate %u\n", encoder_session.inbasefilename, sample_rate);
683 return EncoderSession_finish_error(&encoder_session);
685 else if(options.common.sector_align && sample_rate != 44100) {
686 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);
687 return EncoderSession_finish_error(&encoder_session);
689 /* avg bytes per second (ignored) */
690 if(!read_little_endian_uint32(infile, &xx, false, encoder_session.inbasefilename))
691 return EncoderSession_finish_error(&encoder_session);
693 if(!read_little_endian_uint16(infile, &x, false, encoder_session.inbasefilename))
694 return EncoderSession_finish_error(&encoder_session);
695 block_align = (unsigned)x;
696 /* bits per sample */
697 if(!read_little_endian_uint16(infile, &x, false, encoder_session.inbasefilename))
698 return EncoderSession_finish_error(&encoder_session);
700 is_unsigned_samples = (bps <= 8);
702 if(bps != 8 && bps != 16) {
703 if(bps == 24 || bps == 32) {
704 /* let these slide with a warning since they're unambiguous */
705 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);
708 /* @@@ we could add an option to specify left- or right-justified blocks so we knew how to set 'shift' */
709 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);
710 return EncoderSession_finish_error(&encoder_session);
713 #if 0 /* @@@ reinstate once we can get an answer about whether the samples are left- or right-justified */
714 if((bps+7)/8 * channels == block_align) {
716 /* assume legacy file is byte aligned with some LSBs zero; this is double-checked in format_input() */
717 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);
718 shift = 8 - (bps % 8);
725 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);
726 return EncoderSession_finish_error(&encoder_session);
731 if(channels > 2 && !options.common.channel_map_none) {
732 flac__utils_printf(stderr, 1, "%s: ERROR: WAVE has >2 channels but is not WAVE_FORMAT_EXTENSIBLE; cannot assign channels\n", encoder_session.inbasefilename);
733 return EncoderSession_finish_error(&encoder_session);
735 FLAC__ASSERT(data_bytes >= 16);
739 if(data_bytes < 40) {
740 flac__utils_printf(stderr, 1, "%s: ERROR: invalid WAVEFORMATEXTENSIBLE chunk with size %u\n", encoder_session.inbasefilename, data_bytes);
741 return EncoderSession_finish_error(&encoder_session);
744 if(!read_little_endian_uint16(infile, &x, false, encoder_session.inbasefilename))
745 return EncoderSession_finish_error(&encoder_session);
747 flac__utils_printf(stderr, 1, "%s: ERROR: invalid WAVEFORMATEXTENSIBLE chunk with cbSize %u\n", encoder_session.inbasefilename, (unsigned)x);
748 return EncoderSession_finish_error(&encoder_session);
751 if(!read_little_endian_uint16(infile, &x, false, encoder_session.inbasefilename))
752 return EncoderSession_finish_error(&encoder_session);
753 if((unsigned)x > bps) {
754 flac__utils_printf(stderr, 1, "%s: ERROR: invalid WAVEFORMATEXTENSIBLE chunk with wValidBitsPerSample (%u) > wBitsPerSample (%u)\n", encoder_session.inbasefilename, (unsigned)x, bps);
755 return EncoderSession_finish_error(&encoder_session);
757 shift = bps - (unsigned)x;
759 if(!read_little_endian_uint32(infile, &channel_mask, false, encoder_session.inbasefilename))
760 return EncoderSession_finish_error(&encoder_session);
761 /* for mono/stereo and unassigned channels, we fake the mask */
762 if(channel_mask == 0) {
764 channel_mask = 0x0001;
765 else if(channels == 2)
766 channel_mask = 0x0003;
768 /* set channel mapping */
769 /* FLAC order follows SMPTE and WAVEFORMATEXTENSIBLE but with fewer channels, which are: */
770 /* front left, front right, center, LFE, back left, back right, surround left, surround right */
771 /* the default mapping is sufficient for 1-6 channels and 7-8 are currently unspecified anyway */
773 /* @@@ example for dolby/vorbis order, for reference later in case it becomes important */
775 options.common.channel_map_none ||
776 channel_mask == 0x0001 || /* 1 channel: (mono) */
777 channel_mask == 0x0003 || /* 2 channels: front left, front right */
778 channel_mask == 0x0033 || /* 4 channels: front left, front right, back left, back right */
779 channel_mask == 0x0603 /* 4 channels: front left, front right, side left, side right */
781 /* keep default channel order */
784 channel_mask == 0x0007 || /* 3 channels: front left, front right, front center */
785 channel_mask == 0x0037 || /* 5 channels: front left, front right, front center, back left, back right */
786 channel_mask == 0x0607 /* 5 channels: front left, front right, front center, side left, side right */
788 /* to dolby order: front left, center, front right [, surround left, surround right ] */
793 channel_mask == 0x003f || /* 6 channels: front left, front right, front center, LFE, back left, back right */
794 channel_mask == 0x060f /* 6 channels: front left, front right, front center, LFE, side left, side right */
796 /* to dolby order: front left, center, front right, surround left, surround right, LFE */
805 options.common.channel_map_none ||
806 channel_mask == 0x0001 || /* 1 channel: (mono) */
807 channel_mask == 0x0003 || /* 2 channels: front left, front right */
808 channel_mask == 0x0007 || /* 3 channels: front left, front right, front center */
809 channel_mask == 0x0033 || /* 4 channels: front left, front right, back left, back right */
810 channel_mask == 0x0603 || /* 4 channels: front left, front right, side left, side right */
811 channel_mask == 0x0037 || /* 5 channels: front left, front right, front center, back left, back right */
812 channel_mask == 0x0607 || /* 5 channels: front left, front right, front center, side left, side right */
813 channel_mask == 0x003f || /* 6 channels: front left, front right, front center, LFE, back left, back right */
814 channel_mask == 0x060f /* 6 channels: front left, front right, front center, LFE, side left, side right */
816 /* keep default channel order */
820 flac__utils_printf(stderr, 1, "%s: ERROR: WAVEFORMATEXTENSIBLE chunk with unsupported channel mask=0x%04X\n", encoder_session.inbasefilename, (unsigned)channel_mask);
821 return EncoderSession_finish_error(&encoder_session);
823 if(!options.common.channel_map_none) {
824 if(count_channel_mask_bits(channel_mask) < channels) {
825 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);
826 return EncoderSession_finish_error(&encoder_session);
829 /* supporting this is too difficult with channel mapping; e.g. what if mask is 0x003f but #channels=4?
830 * there would be holes in the order that would have to be filled in, or the mask would have to be
831 * limited and the logic above rerun to see if it still fits into the FLAC mapping.
833 else if(count_channel_mask_bits(channel_mask) > channels)
834 channel_mask = limit_channel_mask(channel_mask, channels);
836 else if(count_channel_mask_bits(channel_mask) > channels) {
837 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);
838 return EncoderSession_finish_error(&encoder_session);
842 /* first part of GUID */
843 if(!read_little_endian_uint16(infile, &x, false, encoder_session.inbasefilename))
844 return EncoderSession_finish_error(&encoder_session);
846 flac__utils_printf(stderr, 1, "%s: ERROR: unsupported WAVEFORMATEXTENSIBLE chunk with non-PCM format %u\n", encoder_session.inbasefilename, (unsigned)x);
847 return EncoderSession_finish_error(&encoder_session);
852 if(bps-shift < 4 || bps-shift > 24) {
853 flac__utils_printf(stderr, 1, "%s: ERROR: unsupported bits-per-sample %u\n", encoder_session.inbasefilename, bps-shift);
854 return EncoderSession_finish_error(&encoder_session);
856 else if(options.common.sector_align && bps-shift != 16) {
857 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);
858 return EncoderSession_finish_error(&encoder_session);
861 /* skip any extra data in the fmt sub-chunk */
862 if(!fskip_ahead(infile, data_bytes)) {
863 flac__utils_printf(stderr, 1, "%s: ERROR during read while skipping extra 'fmt' data\n", encoder_session.inbasefilename);
864 return EncoderSession_finish_error(&encoder_session);
868 * now that we know the sample rate, canonicalize the
869 * --skip string to a number of samples:
871 flac__utils_canonicalize_skip_until_specification(&options.common.skip_specification, sample_rate);
872 FLAC__ASSERT(options.common.skip_specification.value.samples >= 0);
873 encoder_session.skip = (FLAC__uint64)options.common.skip_specification.value.samples;
874 FLAC__ASSERT(!options.common.sector_align || encoder_session.skip == 0);
876 got_fmt_chunk = true;
878 else if(xx == 0x61746164 && !got_data_chunk && got_fmt_chunk) { /* "data" */
879 FLAC__uint64 total_samples_in_input, trim = 0;
880 FLAC__bool pad = false;
884 if(!read_little_endian_uint32(infile, &xx, false, encoder_session.inbasefilename))
885 return EncoderSession_finish_error(&encoder_session);
887 pad = (data_bytes & 1U) ? true : false;
889 bytes_per_wide_sample = channels * (bps >> 3);
891 /* *options.common.align_reservoir_samples will be 0 unless --sector-align is used */
892 FLAC__ASSERT(options.common.sector_align || *options.common.align_reservoir_samples == 0);
893 total_samples_in_input = data_bytes / bytes_per_wide_sample + *options.common.align_reservoir_samples;
896 * now that we know the input size, canonicalize the
897 * --until string to an absolute sample number:
899 if(!canonicalize_until_specification(&options.common.until_specification, encoder_session.inbasefilename, sample_rate, encoder_session.skip, total_samples_in_input))
900 return EncoderSession_finish_error(&encoder_session);
901 encoder_session.until = (FLAC__uint64)options.common.until_specification.value.samples;
902 FLAC__ASSERT(!options.common.sector_align || encoder_session.until == 0);
904 if(encoder_session.skip > 0) {
905 if(!fskip_ahead(infile, encoder_session.skip * bytes_per_wide_sample)) {
906 flac__utils_printf(stderr, 1, "%s: ERROR during read while skipping samples\n", encoder_session.inbasefilename);
907 return EncoderSession_finish_error(&encoder_session);
911 data_bytes -= (unsigned)encoder_session.skip * bytes_per_wide_sample; /*@@@ WATCHOUT: 4GB limit */
912 encoder_session.total_samples_to_encode = total_samples_in_input - encoder_session.skip;
913 if(encoder_session.until > 0) {
914 trim = total_samples_in_input - encoder_session.until;
915 FLAC__ASSERT(total_samples_in_input > 0);
916 FLAC__ASSERT(!options.common.sector_align);
917 data_bytes -= (unsigned int)trim * bytes_per_wide_sample;
918 encoder_session.total_samples_to_encode -= trim;
920 if(options.common.sector_align) {
921 align_remainder = (unsigned)(encoder_session.total_samples_to_encode % 588);
922 if(options.common.is_last_file)
923 encoder_session.total_samples_to_encode += (588-align_remainder); /* will pad with zeroes */
925 encoder_session.total_samples_to_encode -= align_remainder; /* will stop short and carry over to next file */
928 /* +44 for the size of the WAV headers; this is just an estimate for the progress indicator and doesn't need to be exact */
929 encoder_session.unencoded_size = encoder_session.total_samples_to_encode * bytes_per_wide_sample + 44;
931 if(!EncoderSession_init_encoder(&encoder_session, options.common, channel_mask, channels, bps-shift, sample_rate, /*flac_decoder_data=*/0))
932 return EncoderSession_finish_error(&encoder_session);
935 * first do any samples in the reservoir
937 if(options.common.sector_align && *options.common.align_reservoir_samples > 0) {
938 if(!EncoderSession_process(&encoder_session, (const FLAC__int32 * const *)options.common.align_reservoir, *options.common.align_reservoir_samples)) {
939 print_error_with_state(&encoder_session, "ERROR during encoding");
940 return EncoderSession_finish_error(&encoder_session);
945 * decrement the data_bytes counter if we need to align the file
947 if(options.common.sector_align) {
948 if(options.common.is_last_file) {
949 *options.common.align_reservoir_samples = 0;
952 *options.common.align_reservoir_samples = align_remainder;
953 data_bytes -= (*options.common.align_reservoir_samples) * bytes_per_wide_sample;
958 * now do from the file
960 while(data_bytes > 0) {
961 bytes_read = fread(ucbuffer_, sizeof(unsigned char), min(data_bytes, CHUNK_OF_SAMPLES * bytes_per_wide_sample), infile);
962 if(bytes_read == 0) {
964 flac__utils_printf(stderr, 1, "%s: ERROR during read\n", encoder_session.inbasefilename);
965 return EncoderSession_finish_error(&encoder_session);
967 else if(feof(infile)) {
968 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);
973 if(bytes_read % bytes_per_wide_sample != 0) {
974 flac__utils_printf(stderr, 1, "%s: ERROR: got partial sample\n", encoder_session.inbasefilename);
975 return EncoderSession_finish_error(&encoder_session);
978 unsigned wide_samples = bytes_read / bytes_per_wide_sample;
979 if(!format_input(input_, wide_samples, /*is_big_endian=*/false, is_unsigned_samples, channels, bps, shift, channel_map))
980 return EncoderSession_finish_error(&encoder_session);
982 if(!EncoderSession_process(&encoder_session, (const FLAC__int32 * const *)input_, wide_samples)) {
983 print_error_with_state(&encoder_session, "ERROR during encoding");
984 return EncoderSession_finish_error(&encoder_session);
986 data_bytes -= bytes_read;
992 FLAC__ASSERT(!options.common.sector_align);
993 if(!fskip_ahead(infile, trim * bytes_per_wide_sample)) {
994 flac__utils_printf(stderr, 1, "%s: ERROR during read while skipping samples\n", encoder_session.inbasefilename);
995 return EncoderSession_finish_error(&encoder_session);
1000 * now read unaligned samples into reservoir or pad with zeroes if necessary
1002 if(options.common.sector_align) {
1003 if(options.common.is_last_file) {
1004 unsigned wide_samples = 588 - align_remainder;
1005 if(wide_samples < 588) {
1008 info_align_zero = wide_samples;
1009 for(channel = 0; channel < channels; channel++)
1010 memset(input_[channel], 0, sizeof(input_[0][0]) * wide_samples);
1012 if(!EncoderSession_process(&encoder_session, (const FLAC__int32 * const *)input_, wide_samples)) {
1013 print_error_with_state(&encoder_session, "ERROR during encoding");
1014 return EncoderSession_finish_error(&encoder_session);
1019 if(*options.common.align_reservoir_samples > 0) {
1020 FLAC__ASSERT(CHUNK_OF_SAMPLES >= 588);
1021 bytes_read = fread(ucbuffer_, sizeof(unsigned char), (*options.common.align_reservoir_samples) * bytes_per_wide_sample, infile);
1022 if(bytes_read == 0 && ferror(infile)) {
1023 flac__utils_printf(stderr, 1, "%s: ERROR during read\n", encoder_session.inbasefilename);
1024 return EncoderSession_finish_error(&encoder_session);
1026 else if(bytes_read != (*options.common.align_reservoir_samples) * bytes_per_wide_sample) {
1027 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);
1030 info_align_carry = *options.common.align_reservoir_samples;
1031 if(!format_input(options.common.align_reservoir, *options.common.align_reservoir_samples, /*is_big_endian=*/false, is_unsigned_samples, channels, bps, shift, channel_map))
1032 return EncoderSession_finish_error(&encoder_session);
1041 if(fread(&tmp, 1U, 1U, infile) < 1U) {
1042 flac__utils_printf(stderr, 1, "%s: ERROR during read of data pad byte\n", encoder_session.inbasefilename);
1043 return EncoderSession_finish_error(&encoder_session);
1047 got_data_chunk = true;
1050 if(xx == 0x20746d66 && got_fmt_chunk) { /* "fmt " */
1051 flac__utils_printf(stderr, 1, "%s: WARNING: skipping extra 'fmt ' sub-chunk\n", encoder_session.inbasefilename);
1053 else if(xx == 0x61746164) { /* "data" */
1054 if(got_data_chunk) {
1055 flac__utils_printf(stderr, 1, "%s: WARNING: skipping extra 'data' sub-chunk\n", encoder_session.inbasefilename);
1057 else if(!got_fmt_chunk) {
1058 flac__utils_printf(stderr, 1, "%s: ERROR: got 'data' sub-chunk before 'fmt' sub-chunk\n", encoder_session.inbasefilename);
1059 return EncoderSession_finish_error(&encoder_session);
1066 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));
1068 /* sub-chunk size */
1069 if(!read_little_endian_uint32(infile, &xx, false, encoder_session.inbasefilename))
1070 return EncoderSession_finish_error(&encoder_session);
1072 unsigned long skip = xx+(xx & 1U);
1074 FLAC__ASSERT(skip<=LONG_MAX);
1075 if(!fskip_ahead(infile, skip)) {
1076 flac__utils_printf(stderr, 1, "%s: ERROR during read while skipping unsupported sub-chunk\n", encoder_session.inbasefilename);
1077 return EncoderSession_finish_error(&encoder_session);
1083 return EncoderSession_finish_ok(&encoder_session, info_align_carry, info_align_zero);
1086 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)
1088 EncoderSession encoder_session;
1090 const size_t bytes_per_wide_sample = options.channels * (options.bps >> 3);
1091 unsigned align_remainder = 0;
1092 int info_align_carry = -1, info_align_zero = -1;
1093 FLAC__uint64 total_samples_in_input = 0;
1095 FLAC__ASSERT(!options.common.sector_align || options.channels == 2);
1096 FLAC__ASSERT(!options.common.sector_align || options.bps == 16);
1097 FLAC__ASSERT(!options.common.sector_align || options.sample_rate == 44100);
1098 FLAC__ASSERT(!options.common.sector_align || infilesize >= 0);
1099 FLAC__ASSERT(!options.common.replay_gain || options.channels <= 2);
1100 FLAC__ASSERT(!options.common.replay_gain || grabbag__replaygain_is_valid_sample_frequency(options.sample_rate));
1103 EncoderSession_construct(
1105 #ifdef FLAC__HAS_OGG
1106 options.common.use_ogg,
1110 options.common.verify,
1119 * now that we know the sample rate, canonicalize the
1120 * --skip string to a number of samples:
1122 flac__utils_canonicalize_skip_until_specification(&options.common.skip_specification, options.sample_rate);
1123 FLAC__ASSERT(options.common.skip_specification.value.samples >= 0);
1124 encoder_session.skip = (FLAC__uint64)options.common.skip_specification.value.samples;
1125 FLAC__ASSERT(!options.common.sector_align || encoder_session.skip == 0);
1128 total_samples_in_input = 0;
1130 /* *options.common.align_reservoir_samples will be 0 unless --sector-align is used */
1131 FLAC__ASSERT(options.common.sector_align || *options.common.align_reservoir_samples == 0);
1132 total_samples_in_input = (FLAC__uint64)infilesize / bytes_per_wide_sample + *options.common.align_reservoir_samples;
1136 * now that we know the input size, canonicalize the
1137 * --until strings to a number of samples:
1139 if(!canonicalize_until_specification(&options.common.until_specification, encoder_session.inbasefilename, options.sample_rate, encoder_session.skip, total_samples_in_input))
1140 return EncoderSession_finish_error(&encoder_session);
1141 encoder_session.until = (FLAC__uint64)options.common.until_specification.value.samples;
1142 FLAC__ASSERT(!options.common.sector_align || encoder_session.until == 0);
1144 infilesize -= (off_t)encoder_session.skip * bytes_per_wide_sample;
1145 encoder_session.total_samples_to_encode = total_samples_in_input - encoder_session.skip;
1146 if(encoder_session.until > 0) {
1147 const FLAC__uint64 trim = total_samples_in_input - encoder_session.until;
1148 FLAC__ASSERT(total_samples_in_input > 0);
1149 FLAC__ASSERT(!options.common.sector_align);
1150 infilesize -= (off_t)trim * bytes_per_wide_sample;
1151 encoder_session.total_samples_to_encode -= trim;
1153 if(infilesize >= 0 && options.common.sector_align) {
1154 FLAC__ASSERT(encoder_session.skip == 0);
1155 align_remainder = (unsigned)(encoder_session.total_samples_to_encode % 588);
1156 if(options.common.is_last_file)
1157 encoder_session.total_samples_to_encode += (588-align_remainder); /* will pad with zeroes */
1159 encoder_session.total_samples_to_encode -= align_remainder; /* will stop short and carry over to next file */
1161 encoder_session.unencoded_size = encoder_session.total_samples_to_encode * bytes_per_wide_sample;
1163 if(encoder_session.total_samples_to_encode <= 0)
1164 flac__utils_printf(stderr, 2, "(No runtime statistics possible; please wait for encoding to finish...)\n");
1166 if(encoder_session.skip > 0) {
1167 unsigned skip_bytes = bytes_per_wide_sample * (unsigned)encoder_session.skip;
1168 if(skip_bytes > lookahead_length) {
1169 skip_bytes -= lookahead_length;
1170 lookahead_length = 0;
1171 if(!fskip_ahead(infile, skip_bytes)) {
1172 flac__utils_printf(stderr, 1, "%s: ERROR during read while skipping samples\n", encoder_session.inbasefilename);
1173 return EncoderSession_finish_error(&encoder_session);
1177 lookahead += skip_bytes;
1178 lookahead_length -= skip_bytes;
1182 if(!EncoderSession_init_encoder(&encoder_session, options.common, /*channel_mask=*/0, options.channels, options.bps, options.sample_rate, /*flac_decoder_data=*/0))
1183 return EncoderSession_finish_error(&encoder_session);
1186 * first do any samples in the reservoir
1188 if(options.common.sector_align && *options.common.align_reservoir_samples > 0) {
1189 if(!EncoderSession_process(&encoder_session, (const FLAC__int32 * const *)options.common.align_reservoir, *options.common.align_reservoir_samples)) {
1190 print_error_with_state(&encoder_session, "ERROR during encoding");
1191 return EncoderSession_finish_error(&encoder_session);
1196 * decrement infilesize if we need to align the file
1198 if(options.common.sector_align) {
1199 FLAC__ASSERT(infilesize >= 0);
1200 if(options.common.is_last_file) {
1201 *options.common.align_reservoir_samples = 0;
1204 *options.common.align_reservoir_samples = align_remainder;
1205 infilesize -= (off_t)((*options.common.align_reservoir_samples) * bytes_per_wide_sample);
1206 FLAC__ASSERT(infilesize >= 0);
1211 * now do from the file
1213 if(infilesize < 0) {
1214 while(!feof(infile)) {
1215 if(lookahead_length > 0) {
1216 FLAC__ASSERT(lookahead_length < CHUNK_OF_SAMPLES * bytes_per_wide_sample);
1217 memcpy(ucbuffer_, lookahead, lookahead_length);
1218 bytes_read = fread(ucbuffer_+lookahead_length, sizeof(unsigned char), CHUNK_OF_SAMPLES * bytes_per_wide_sample - lookahead_length, infile) + lookahead_length;
1219 if(ferror(infile)) {
1220 flac__utils_printf(stderr, 1, "%s: ERROR during read\n", encoder_session.inbasefilename);
1221 return EncoderSession_finish_error(&encoder_session);
1223 lookahead_length = 0;
1226 bytes_read = fread(ucbuffer_, sizeof(unsigned char), CHUNK_OF_SAMPLES * bytes_per_wide_sample, infile);
1228 if(bytes_read == 0) {
1229 if(ferror(infile)) {
1230 flac__utils_printf(stderr, 1, "%s: ERROR during read\n", encoder_session.inbasefilename);
1231 return EncoderSession_finish_error(&encoder_session);
1234 else if(bytes_read % bytes_per_wide_sample != 0) {
1235 flac__utils_printf(stderr, 1, "%s: ERROR: got partial sample\n", encoder_session.inbasefilename);
1236 return EncoderSession_finish_error(&encoder_session);
1239 unsigned wide_samples = bytes_read / bytes_per_wide_sample;
1240 if(!format_input(input_, wide_samples, options.is_big_endian, options.is_unsigned_samples, options.channels, options.bps, /*shift=*/0, /*channel_map=*/0))
1241 return EncoderSession_finish_error(&encoder_session);
1243 if(!EncoderSession_process(&encoder_session, (const FLAC__int32 * const *)input_, wide_samples)) {
1244 print_error_with_state(&encoder_session, "ERROR during encoding");
1245 return EncoderSession_finish_error(&encoder_session);
1251 const FLAC__uint64 max_input_bytes = infilesize;
1252 FLAC__uint64 total_input_bytes_read = 0;
1253 while(total_input_bytes_read < max_input_bytes) {
1255 size_t wanted = (CHUNK_OF_SAMPLES * bytes_per_wide_sample);
1256 wanted = (size_t) min((FLAC__uint64)wanted, max_input_bytes - total_input_bytes_read);
1258 if(lookahead_length > 0) {
1259 FLAC__ASSERT(lookahead_length <= wanted);
1260 memcpy(ucbuffer_, lookahead, lookahead_length);
1261 wanted -= lookahead_length;
1262 bytes_read = lookahead_length;
1264 bytes_read += fread(ucbuffer_+lookahead_length, sizeof(unsigned char), wanted, infile);
1265 if(ferror(infile)) {
1266 flac__utils_printf(stderr, 1, "%s: ERROR during read\n", encoder_session.inbasefilename);
1267 return EncoderSession_finish_error(&encoder_session);
1270 lookahead_length = 0;
1273 bytes_read = fread(ucbuffer_, sizeof(unsigned char), wanted, infile);
1276 if(bytes_read == 0) {
1277 if(ferror(infile)) {
1278 flac__utils_printf(stderr, 1, "%s: ERROR during read\n", encoder_session.inbasefilename);
1279 return EncoderSession_finish_error(&encoder_session);
1281 else if(feof(infile)) {
1282 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);
1283 total_input_bytes_read = max_input_bytes;
1287 if(bytes_read % bytes_per_wide_sample != 0) {
1288 flac__utils_printf(stderr, 1, "%s: ERROR: got partial sample\n", encoder_session.inbasefilename);
1289 return EncoderSession_finish_error(&encoder_session);
1292 unsigned wide_samples = bytes_read / bytes_per_wide_sample;
1293 if(!format_input(input_, wide_samples, options.is_big_endian, options.is_unsigned_samples, options.channels, options.bps, /*shift=*/0, /*channel_map=*/0))
1294 return EncoderSession_finish_error(&encoder_session);
1296 if(!EncoderSession_process(&encoder_session, (const FLAC__int32 * const *)input_, wide_samples)) {
1297 print_error_with_state(&encoder_session, "ERROR during encoding");
1298 return EncoderSession_finish_error(&encoder_session);
1300 total_input_bytes_read += bytes_read;
1307 * now read unaligned samples into reservoir or pad with zeroes if necessary
1309 if(options.common.sector_align) {
1310 if(options.common.is_last_file) {
1311 unsigned wide_samples = 588 - align_remainder;
1312 if(wide_samples < 588) {
1315 info_align_zero = wide_samples;
1316 for(channel = 0; channel < options.channels; channel++)
1317 memset(input_[channel], 0, sizeof(input_[0][0]) * wide_samples);
1319 if(!EncoderSession_process(&encoder_session, (const FLAC__int32 * const *)input_, wide_samples)) {
1320 print_error_with_state(&encoder_session, "ERROR during encoding");
1321 return EncoderSession_finish_error(&encoder_session);
1326 if(*options.common.align_reservoir_samples > 0) {
1327 FLAC__ASSERT(CHUNK_OF_SAMPLES >= 588);
1328 bytes_read = fread(ucbuffer_, sizeof(unsigned char), (*options.common.align_reservoir_samples) * bytes_per_wide_sample, infile);
1329 if(bytes_read == 0 && ferror(infile)) {
1330 flac__utils_printf(stderr, 1, "%s: ERROR during read\n", encoder_session.inbasefilename);
1331 return EncoderSession_finish_error(&encoder_session);
1333 else if(bytes_read != (*options.common.align_reservoir_samples) * bytes_per_wide_sample) {
1334 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);
1337 info_align_carry = *options.common.align_reservoir_samples;
1338 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))
1339 return EncoderSession_finish_error(&encoder_session);
1345 return EncoderSession_finish_ok(&encoder_session, info_align_carry, info_align_zero);
1348 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)
1350 EncoderSession encoder_session;
1351 FLAC__StreamDecoder *decoder = 0;
1352 FLACDecoderData decoder_data;
1357 EncoderSession_construct(
1359 #ifdef FLAC__HAS_OGG
1360 options.common.use_ogg,
1364 options.common.verify,
1372 decoder_data.encoder_session = &encoder_session;
1373 decoder_data.filesize = (infilesize == (off_t)(-1)? 0 : infilesize);
1374 decoder_data.lookahead = lookahead;
1375 decoder_data.lookahead_length = lookahead_length;
1376 decoder_data.num_metadata_blocks = 0;
1377 decoder_data.samples_left_to_process = 0;
1378 decoder_data.fatal_error = false;
1381 * set up FLAC decoder for the input
1383 if (0 == (decoder = FLAC__stream_decoder_new())) {
1384 flac__utils_printf(stderr, 1, "%s: ERROR: creating decoder for FLAC input\n", encoder_session.inbasefilename);
1385 return EncoderSession_finish_error(&encoder_session);
1388 FLAC__stream_decoder_set_md5_checking(decoder, false) &&
1389 FLAC__stream_decoder_set_metadata_respond_all(decoder)
1391 flac__utils_printf(stderr, 1, "%s: ERROR: setting up decoder for FLAC input\n", encoder_session.inbasefilename);
1392 goto fubar1; /*@@@ yuck */
1395 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) {
1396 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));
1397 goto fubar1; /*@@@ yuck */
1400 if (!FLAC__stream_decoder_process_until_end_of_metadata(decoder) || decoder_data.fatal_error) {
1401 if (decoder_data.fatal_error)
1402 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);
1404 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));
1405 goto fubar1; /*@@@ yuck */
1408 if (decoder_data.num_metadata_blocks == 0) {
1409 flac__utils_printf(stderr, 1, "%s: ERROR: reading metadata in FLAC input, got no metadata blocks\n", encoder_session.inbasefilename);
1410 goto fubar2; /*@@@ yuck */
1412 else if (decoder_data.metadata_blocks[0]->type != FLAC__METADATA_TYPE_STREAMINFO) {
1413 flac__utils_printf(stderr, 1, "%s: ERROR: reading metadata in FLAC input, first metadata block is not STREAMINFO\n", encoder_session.inbasefilename);
1414 goto fubar2; /*@@@ yuck */
1416 else if (decoder_data.metadata_blocks[0]->data.stream_info.total_samples == 0) {
1417 flac__utils_printf(stderr, 1, "%s: ERROR: FLAC input has STREAMINFO with unknown total samples which is not supported\n", encoder_session.inbasefilename);
1418 goto fubar2; /*@@@ yuck */
1422 * now that we have the STREAMINFO and know the sample rate,
1423 * canonicalize the --skip string to a number of samples:
1425 flac__utils_canonicalize_skip_until_specification(&options.common.skip_specification, decoder_data.metadata_blocks[0]->data.stream_info.sample_rate);
1426 FLAC__ASSERT(options.common.skip_specification.value.samples >= 0);
1427 encoder_session.skip = (FLAC__uint64)options.common.skip_specification.value.samples;
1428 FLAC__ASSERT(!options.common.sector_align); /* --sector-align with FLAC input is not supported */
1431 FLAC__uint64 total_samples_in_input, trim = 0;
1433 total_samples_in_input = decoder_data.metadata_blocks[0]->data.stream_info.total_samples;
1436 * now that we know the input size, canonicalize the
1437 * --until string to an absolute sample number:
1439 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))
1440 goto fubar2; /*@@@ yuck */
1441 encoder_session.until = (FLAC__uint64)options.common.until_specification.value.samples;
1443 encoder_session.total_samples_to_encode = total_samples_in_input - encoder_session.skip;
1444 if(encoder_session.until > 0) {
1445 trim = total_samples_in_input - encoder_session.until;
1446 FLAC__ASSERT(total_samples_in_input > 0);
1447 encoder_session.total_samples_to_encode -= trim;
1450 encoder_session.unencoded_size = decoder_data.filesize;
1452 /* (channel mask will get copied over from the source VORBIS_COMMENT if it exists) */
1453 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))
1454 return EncoderSession_finish_error(&encoder_session);
1457 * have to wait until the FLAC encoder is set up for writing
1458 * before any seeking in the input FLAC file, because the seek
1459 * itself will usually call the decoder's write callback, and
1460 * our decoder's write callback passes samples to our FLAC
1463 decoder_data.samples_left_to_process = encoder_session.total_samples_to_encode;
1464 if(encoder_session.skip > 0) {
1465 if(!FLAC__stream_decoder_seek_absolute(decoder, encoder_session.skip)) {
1466 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));
1467 goto fubar2; /*@@@ yuck */
1472 * now do samples from the file
1474 while(!decoder_data.fatal_error && decoder_data.samples_left_to_process > 0) {
1475 if(!FLAC__stream_decoder_process_single(decoder)) {
1476 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));
1477 goto fubar2; /*@@@ yuck */
1482 FLAC__stream_decoder_delete(decoder);
1483 retval = EncoderSession_finish_ok(&encoder_session, -1, -1);
1484 /* have to wail until encoder is completely finished before deleting because of the final step of writing the seekpoint offsets */
1485 for(i = 0; i < decoder_data.num_metadata_blocks; i++)
1486 free(decoder_data.metadata_blocks[i]);
1490 for(i = 0; i < decoder_data.num_metadata_blocks; i++)
1491 free(decoder_data.metadata_blocks[i]);
1493 FLAC__stream_decoder_delete(decoder);
1494 return EncoderSession_finish_error(&encoder_session);
1497 FLAC__bool EncoderSession_construct(EncoderSession *e, FLAC__bool use_ogg, FLAC__bool verify, FILE *infile, const char *infilename, const char *outfilename)
1500 FLAC__uint32 test = 1;
1503 * initialize globals
1506 is_big_endian_host_ = (*((FLAC__byte*)(&test)))? false : true;
1508 for(i = 0; i < FLAC__MAX_CHANNELS; i++)
1509 input_[i] = &(in_[i][0]);
1513 * initialize instance
1516 #ifdef FLAC__HAS_OGG
1517 e->use_ogg = use_ogg;
1523 e->is_stdout = (0 == strcmp(outfilename, "-"));
1524 e->outputfile_opened = false;
1526 e->inbasefilename = grabbag__file_get_basename(infilename);
1527 e->outfilename = outfilename;
1529 e->skip = 0; /* filled in later after the sample_rate is known */
1530 e->unencoded_size = 0;
1531 e->total_samples_to_encode = 0;
1532 e->bytes_written = 0;
1533 e->samples_written = 0;
1540 e->seek_table_template = 0;
1542 if(0 == (e->seek_table_template = FLAC__metadata_object_new(FLAC__METADATA_TYPE_SEEKTABLE))) {
1543 flac__utils_printf(stderr, 1, "%s: ERROR allocating memory for seek table\n", e->inbasefilename);
1547 e->encoder = FLAC__stream_encoder_new();
1548 if(0 == e->encoder) {
1549 flac__utils_printf(stderr, 1, "%s: ERROR creating the encoder instance\n", e->inbasefilename);
1550 EncoderSession_destroy(e);
1557 void EncoderSession_destroy(EncoderSession *e)
1562 if(0 != e->encoder) {
1563 FLAC__stream_encoder_delete(e->encoder);
1567 if(0 != e->seek_table_template) {
1568 FLAC__metadata_object_delete(e->seek_table_template);
1569 e->seek_table_template = 0;
1573 int EncoderSession_finish_ok(EncoderSession *e, int info_align_carry, int info_align_zero)
1575 FLAC__StreamEncoderState fse_state = FLAC__STREAM_ENCODER_OK;
1579 fse_state = FLAC__stream_encoder_get_state(e->encoder);
1580 FLAC__stream_encoder_finish(e->encoder);
1583 if(e->total_samples_to_encode > 0) {
1585 flac__utils_printf(stderr, 2, "\n");
1588 if(fse_state == FLAC__STREAM_ENCODER_VERIFY_MISMATCH_IN_AUDIO_DATA) {
1589 print_verify_error(e);
1593 if(info_align_carry >= 0) {
1594 flac__utils_printf(stderr, 1, "%s: INFO: sector alignment causing %d samples to be carried over\n", e->inbasefilename, info_align_carry);
1596 if(info_align_zero >= 0) {
1597 flac__utils_printf(stderr, 1, "%s: INFO: sector alignment causing %d zero samples to be appended\n", e->inbasefilename, info_align_zero);
1601 EncoderSession_destroy(e);
1606 int EncoderSession_finish_error(EncoderSession *e)
1608 FLAC__ASSERT(e->encoder);
1610 if(e->total_samples_to_encode > 0)
1611 flac__utils_printf(stderr, 2, "\n");
1613 if(FLAC__stream_encoder_get_state(e->encoder) == FLAC__STREAM_ENCODER_VERIFY_MISMATCH_IN_AUDIO_DATA)
1614 print_verify_error(e);
1615 else if(e->outputfile_opened)
1616 /* only want to delete the file if we opened it; otherwise it could be an existing file and our overwrite failed */
1617 unlink(e->outfilename);
1619 EncoderSession_destroy(e);
1624 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)
1626 unsigned num_metadata, i;
1627 FLAC__StreamMetadata padding, *cuesheet = 0;
1628 FLAC__StreamMetadata *static_metadata[4+64]; /* MAGIC +64 is for pictures metadata in options.pictures */
1629 FLAC__StreamMetadata **metadata = static_metadata;
1630 FLAC__StreamEncoderInitStatus init_status;
1631 const FLAC__bool is_cdda = (channels == 1 || channels == 2) && (bps == 16) && (sample_rate == 44100);
1633 FLAC__ASSERT(sizeof(options.pictures)/sizeof(options.pictures[0]) <= 64);
1635 e->replay_gain = options.replay_gain;
1636 e->channels = channels;
1637 e->bits_per_sample = bps;
1638 e->sample_rate = sample_rate;
1640 if(e->replay_gain) {
1641 if(channels != 1 && channels != 2) {
1642 flac__utils_printf(stderr, 1, "%s: ERROR, number of channels (%u) must be 1 or 2 for --replay-gain\n", e->inbasefilename, channels);
1645 if(!grabbag__replaygain_is_valid_sample_frequency(sample_rate)) {
1646 flac__utils_printf(stderr, 1, "%s: ERROR, invalid sample rate (%u) for --replay-gain\n", e->inbasefilename, sample_rate);
1649 if(options.is_first_file) {
1650 if(!grabbag__replaygain_init(sample_rate)) {
1651 flac__utils_printf(stderr, 1, "%s: ERROR initializing ReplayGain stage\n", e->inbasefilename);
1658 options.do_mid_side = options.loose_mid_side = false;
1660 if(!parse_cuesheet(&cuesheet, options.cuesheet_filename, e->inbasefilename, is_cdda, e->total_samples_to_encode))
1663 if(!convert_to_seek_table_template(options.requested_seek_points, options.num_requested_seek_points, options.cued_seekpoints? cuesheet : 0, e)) {
1664 flac__utils_printf(stderr, 1, "%s: ERROR allocating memory for seek table\n", e->inbasefilename);
1666 FLAC__metadata_object_delete(cuesheet);
1670 if(flac_decoder_data) {
1672 * we're encoding from FLAC so we will use the FLAC file's
1673 * metadata as the basic for the encoded file
1677 * first handle padding: if --no-padding was specified,
1678 * then delete all padding; else if -P was specified,
1679 * use that instead of existing padding (if any); else
1680 * if existing file has padding, move all existing
1681 * padding blocks to one padding block at the end; else
1682 * use default padding.
1686 for(i = 0, j = 0; i < flac_decoder_data->num_metadata_blocks; i++) {
1687 if(flac_decoder_data->metadata_blocks[i]->type == FLAC__METADATA_TYPE_PADDING) {
1690 p += flac_decoder_data->metadata_blocks[i]->length;
1691 FLAC__metadata_object_delete(flac_decoder_data->metadata_blocks[i]);
1692 flac_decoder_data->metadata_blocks[i] = 0;
1695 flac_decoder_data->metadata_blocks[j++] = flac_decoder_data->metadata_blocks[i];
1697 flac_decoder_data->num_metadata_blocks = j;
1698 if(options.padding > 0)
1699 p = options.padding;
1701 p = e->total_samples_to_encode / e->sample_rate < 20*60? FLAC_ENCODE__DEFAULT_PADDING : FLAC_ENCODE__DEFAULT_PADDING*8;
1702 if(options.padding != 0) {
1703 if(p > 0 && flac_decoder_data->num_metadata_blocks < sizeof(flac_decoder_data->metadata_blocks)/sizeof(flac_decoder_data->metadata_blocks[0])) {
1704 flac_decoder_data->metadata_blocks[flac_decoder_data->num_metadata_blocks] = FLAC__metadata_object_new(FLAC__METADATA_TYPE_PADDING);
1705 if(0 == flac_decoder_data->metadata_blocks[flac_decoder_data->num_metadata_blocks]) {
1706 flac__utils_printf(stderr, 1, "%s: ERROR allocating memory for PADDING block\n", e->inbasefilename);
1708 FLAC__metadata_object_delete(cuesheet);
1711 flac_decoder_data->metadata_blocks[flac_decoder_data->num_metadata_blocks]->is_last = false; /* the encoder will set this for us */
1712 flac_decoder_data->metadata_blocks[flac_decoder_data->num_metadata_blocks]->length = p;
1713 flac_decoder_data->num_metadata_blocks++;
1719 * next handle vorbis comment: if any tags were specified
1720 * or there is no existing vorbis comment, we create a
1721 * new vorbis comment (discarding any existing one); else
1722 * we keep the existing one. also need to make sure to
1723 * propagate any channel mask tag.
1726 FLAC__bool vc_found = false;
1727 for(i = 0, j = 0; i < flac_decoder_data->num_metadata_blocks; i++) {
1728 if(flac_decoder_data->metadata_blocks[i]->type == FLAC__METADATA_TYPE_VORBIS_COMMENT)
1730 if(flac_decoder_data->metadata_blocks[i]->type == FLAC__METADATA_TYPE_VORBIS_COMMENT && options.vorbis_comment->data.vorbis_comment.num_comments > 0) {
1731 (void) flac__utils_get_channel_mask_tag(flac_decoder_data->metadata_blocks[i], &channel_mask);
1732 flac__utils_printf(stderr, 1, "%s: WARNING, replacing tags from input FLAC file with those given on the command-line\n", e->inbasefilename);
1733 FLAC__metadata_object_delete(flac_decoder_data->metadata_blocks[i]);
1734 flac_decoder_data->metadata_blocks[i] = 0;
1737 flac_decoder_data->metadata_blocks[j++] = flac_decoder_data->metadata_blocks[i];
1739 flac_decoder_data->num_metadata_blocks = j;
1740 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])) {
1742 FLAC__StreamMetadata *vc = FLAC__metadata_object_clone(options.vorbis_comment);
1743 if(0 == vc || (channel_mask && !flac__utils_set_channel_mask_tag(vc, channel_mask))) {
1744 flac__utils_printf(stderr, 1, "%s: ERROR allocating memory for VORBIS_COMMENT block\n", e->inbasefilename);
1746 FLAC__metadata_object_delete(cuesheet);
1749 for(i = flac_decoder_data->num_metadata_blocks; i > 1; i--)
1750 flac_decoder_data->metadata_blocks[i] = flac_decoder_data->metadata_blocks[i-1];
1751 flac_decoder_data->metadata_blocks[1] = vc;
1752 flac_decoder_data->num_metadata_blocks++;
1757 * next handle cuesheet: if --cuesheet was specified, use
1758 * it; else if file has existing CUESHEET and cuesheet's
1759 * lead-out offset is correct, keep it; else no CUESHEET
1762 for(i = 0, j = 0; i < flac_decoder_data->num_metadata_blocks; i++) {
1763 FLAC__bool existing_cuesheet_is_bad = false;
1764 /* check if existing cuesheet matches the input audio */
1765 if(flac_decoder_data->metadata_blocks[i]->type == FLAC__METADATA_TYPE_CUESHEET && 0 == cuesheet) {
1766 const FLAC__StreamMetadata_CueSheet *cs = &flac_decoder_data->metadata_blocks[i]->data.cue_sheet;
1767 if(e->total_samples_to_encode == 0) {
1768 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);
1769 existing_cuesheet_is_bad = true;
1771 else if(e->total_samples_to_encode != cs->tracks[cs->num_tracks-1].offset) {
1772 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);
1773 existing_cuesheet_is_bad = true;
1776 if(flac_decoder_data->metadata_blocks[i]->type == FLAC__METADATA_TYPE_CUESHEET && (existing_cuesheet_is_bad || 0 != cuesheet)) {
1778 flac__utils_printf(stderr, 1, "%s: WARNING, replacing cuesheet in input FLAC file with the one given on the command-line\n", e->inbasefilename);
1779 FLAC__metadata_object_delete(flac_decoder_data->metadata_blocks[i]);
1780 flac_decoder_data->metadata_blocks[i] = 0;
1783 flac_decoder_data->metadata_blocks[j++] = flac_decoder_data->metadata_blocks[i];
1785 flac_decoder_data->num_metadata_blocks = j;
1786 if(0 != cuesheet && flac_decoder_data->num_metadata_blocks < sizeof(flac_decoder_data->metadata_blocks)/sizeof(flac_decoder_data->metadata_blocks[0])) {
1788 FLAC__StreamMetadata *cs = FLAC__metadata_object_clone(cuesheet);
1790 flac__utils_printf(stderr, 1, "%s: ERROR allocating memory for CUESHEET block\n", e->inbasefilename);
1792 FLAC__metadata_object_delete(cuesheet);
1795 for(i = flac_decoder_data->num_metadata_blocks; i > 1; i--)
1796 flac_decoder_data->metadata_blocks[i] = flac_decoder_data->metadata_blocks[i-1];
1797 flac_decoder_data->metadata_blocks[1] = cs;
1798 flac_decoder_data->num_metadata_blocks++;
1803 * finally handle seektable: if -S- was specified, no
1804 * SEEKTABLE; else if -S was specified, use it/them;
1805 * else if file has existing SEEKTABLE and input size is
1806 * preserved (no --skip/--until/etc specified), keep it;
1807 * else use default seektable options
1809 * note: meanings of num_requested_seek_points:
1810 * -1 : no -S option given, default to some value
1811 * 0 : -S- given (no seektable)
1812 * >0 : one or more -S options given
1815 FLAC__bool existing_seektable = false;
1816 for(i = 0, j = 0; i < flac_decoder_data->num_metadata_blocks; i++) {
1817 if(flac_decoder_data->metadata_blocks[i]->type == FLAC__METADATA_TYPE_SEEKTABLE)
1818 existing_seektable = true;
1819 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)) {
1820 if(options.num_requested_seek_points > 0)
1821 flac__utils_printf(stderr, 1, "%s: WARNING, replacing seektable in input FLAC file with the one given on the command-line\n", e->inbasefilename);
1822 else if(options.num_requested_seek_points == 0)
1823 ; /* no warning, silently delete existing SEEKTABLE since user specified --no-seektable (-S-) */
1825 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);
1826 FLAC__metadata_object_delete(flac_decoder_data->metadata_blocks[i]);
1827 flac_decoder_data->metadata_blocks[i] = 0;
1828 existing_seektable = false;
1831 flac_decoder_data->metadata_blocks[j++] = flac_decoder_data->metadata_blocks[i];
1833 flac_decoder_data->num_metadata_blocks = j;
1834 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])) {
1836 FLAC__StreamMetadata *st = FLAC__metadata_object_clone(e->seek_table_template);
1838 flac__utils_printf(stderr, 1, "%s: ERROR allocating memory for SEEKTABLE block\n", e->inbasefilename);
1840 FLAC__metadata_object_delete(cuesheet);
1843 for(i = flac_decoder_data->num_metadata_blocks; i > 1; i--)
1844 flac_decoder_data->metadata_blocks[i] = flac_decoder_data->metadata_blocks[i-1];
1845 flac_decoder_data->metadata_blocks[1] = st;
1846 flac_decoder_data->num_metadata_blocks++;
1849 metadata = &flac_decoder_data->metadata_blocks[1]; /* don't include STREAMINFO */
1850 num_metadata = flac_decoder_data->num_metadata_blocks - 1;
1854 * we're not encoding from FLAC so we will build the metadata
1858 if(e->seek_table_template->data.seek_table.num_points > 0) {
1859 e->seek_table_template->is_last = false; /* the encoder will set this for us */
1860 metadata[num_metadata++] = e->seek_table_template;
1863 metadata[num_metadata++] = cuesheet;
1865 if(!flac__utils_set_channel_mask_tag(options.vorbis_comment, channel_mask)) {
1866 flac__utils_printf(stderr, 1, "%s: ERROR adding channel mask tag\n", e->inbasefilename);
1868 FLAC__metadata_object_delete(cuesheet);
1872 metadata[num_metadata++] = options.vorbis_comment;
1873 for(i = 0; i < options.num_pictures; i++)
1874 metadata[num_metadata++] = options.pictures[i];
1875 if(options.padding != 0) {
1876 padding.is_last = false; /* the encoder will set this for us */
1877 padding.type = FLAC__METADATA_TYPE_PADDING;
1878 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));
1879 metadata[num_metadata++] = &padding;
1883 /* check for a few things that have not already been checked. the
1884 * FLAC__stream_encoder_init*() will check it but only return
1885 * FLAC__STREAM_ENCODER_INIT_STATUS_INVALID_METADATA so we check some
1886 * up front to give a better error message.
1888 if(!verify_metadata(e, metadata, num_metadata)) {
1890 FLAC__metadata_object_delete(cuesheet);
1894 e->blocksize = options.blocksize;
1895 e->stats_mask = (options.do_exhaustive_model_search || options.do_qlp_coeff_prec_search)? 0x0f : 0x3f;
1897 FLAC__stream_encoder_set_verify(e->encoder, options.verify);
1898 FLAC__stream_encoder_set_streamable_subset(e->encoder, !options.lax);
1899 FLAC__stream_encoder_set_do_mid_side_stereo(e->encoder, options.do_mid_side);
1900 FLAC__stream_encoder_set_loose_mid_side_stereo(e->encoder, options.loose_mid_side);
1901 FLAC__stream_encoder_set_channels(e->encoder, channels);
1902 FLAC__stream_encoder_set_bits_per_sample(e->encoder, bps);
1903 FLAC__stream_encoder_set_sample_rate(e->encoder, sample_rate);
1904 FLAC__stream_encoder_set_blocksize(e->encoder, options.blocksize);
1905 FLAC__stream_encoder_set_apodization(e->encoder, options.apodizations);
1906 FLAC__stream_encoder_set_max_lpc_order(e->encoder, options.max_lpc_order);
1907 FLAC__stream_encoder_set_qlp_coeff_precision(e->encoder, options.qlp_coeff_precision);
1908 FLAC__stream_encoder_set_do_qlp_coeff_prec_search(e->encoder, options.do_qlp_coeff_prec_search);
1909 FLAC__stream_encoder_set_do_escape_coding(e->encoder, options.do_escape_coding);
1910 FLAC__stream_encoder_set_do_exhaustive_model_search(e->encoder, options.do_exhaustive_model_search);
1911 FLAC__stream_encoder_set_min_residual_partition_order(e->encoder, options.min_residual_partition_order);
1912 FLAC__stream_encoder_set_max_residual_partition_order(e->encoder, options.max_residual_partition_order);
1913 FLAC__stream_encoder_set_rice_parameter_search_dist(e->encoder, options.rice_parameter_search_dist);
1914 FLAC__stream_encoder_set_total_samples_estimate(e->encoder, e->total_samples_to_encode);
1915 FLAC__stream_encoder_set_metadata(e->encoder, (num_metadata > 0)? metadata : 0, num_metadata);
1917 FLAC__stream_encoder_disable_constant_subframes(e->encoder, options.debug.disable_constant_subframes);
1918 FLAC__stream_encoder_disable_fixed_subframes(e->encoder, options.debug.disable_fixed_subframes);
1919 FLAC__stream_encoder_disable_verbatim_subframes(e->encoder, options.debug.disable_verbatim_subframes);
1921 #ifdef FLAC__HAS_OGG
1923 FLAC__stream_encoder_set_ogg_serial_number(e->encoder, options.serial_number);
1925 init_status = FLAC__stream_encoder_init_ogg_file(e->encoder, e->is_stdout? 0 : e->outfilename, encoder_progress_callback, /*client_data=*/e);
1930 init_status = FLAC__stream_encoder_init_file(e->encoder, e->is_stdout? 0 : e->outfilename, encoder_progress_callback, /*client_data=*/e);
1933 if(init_status != FLAC__STREAM_ENCODER_INIT_STATUS_OK) {
1934 print_error_with_init_status(e, "ERROR initializing encoder", init_status);
1935 if(FLAC__stream_encoder_get_state(e->encoder) != FLAC__STREAM_ENCODER_IO_ERROR)
1936 e->outputfile_opened = true;
1938 FLAC__metadata_object_delete(cuesheet);
1942 e->outputfile_opened = true;
1945 FLAC__metadata_object_delete(cuesheet);
1950 FLAC__bool EncoderSession_process(EncoderSession *e, const FLAC__int32 * const buffer[], unsigned samples)
1952 if(e->replay_gain) {
1953 if(!grabbag__replaygain_analyze(buffer, e->channels==2, e->bits_per_sample, samples)) {
1954 flac__utils_printf(stderr, 1, "%s: WARNING, error while calculating ReplayGain\n", e->inbasefilename);
1958 return FLAC__stream_encoder_process(e->encoder, buffer, samples);
1961 FLAC__bool convert_to_seek_table_template(const char *requested_seek_points, int num_requested_seek_points, FLAC__StreamMetadata *cuesheet, EncoderSession *e)
1963 const FLAC__bool only_placeholders = e->is_stdout;
1964 FLAC__bool has_real_points;
1966 if(num_requested_seek_points == 0 && 0 == cuesheet)
1969 if(num_requested_seek_points < 0) {
1970 requested_seek_points = "10s;";
1971 num_requested_seek_points = 1;
1974 if(num_requested_seek_points > 0) {
1975 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))
1981 const FLAC__StreamMetadata_CueSheet *cs = &cuesheet->data.cue_sheet;
1982 for(i = 0; i < cs->num_tracks; i++) {
1983 const FLAC__StreamMetadata_CueSheet_Track *tr = cs->tracks+i;
1984 for(j = 0; j < tr->num_indices; j++) {
1985 if(!FLAC__metadata_object_seektable_template_append_point(e->seek_table_template, tr->offset + tr->indices[j].offset))
1987 has_real_points = true;
1991 if(!FLAC__metadata_object_seektable_template_sort(e->seek_table_template, /*compact=*/true))
1995 if(has_real_points) {
1997 flac__utils_printf(stderr, 1, "%s: WARNING, cannot write back seekpoints when encoding to stdout\n", e->inbasefilename);
2004 FLAC__bool canonicalize_until_specification(utils__SkipUntilSpecification *spec, const char *inbasefilename, unsigned sample_rate, FLAC__uint64 skip, FLAC__uint64 total_samples_in_input)
2006 /* convert from mm:ss.sss to sample number if necessary */
2007 flac__utils_canonicalize_skip_until_specification(spec, sample_rate);
2009 /* special case: if "--until=-0", use the special value '0' to mean "end-of-stream" */
2010 if(spec->is_relative && spec->value.samples == 0) {
2011 spec->is_relative = false;
2015 /* in any other case the total samples in the input must be known */
2016 if(total_samples_in_input == 0) {
2017 flac__utils_printf(stderr, 1, "%s: ERROR, cannot use --until when input length is unknown\n", inbasefilename);
2021 FLAC__ASSERT(spec->value_is_samples);
2023 /* convert relative specifications to absolute */
2024 if(spec->is_relative) {
2025 if(spec->value.samples <= 0)
2026 spec->value.samples += (FLAC__int64)total_samples_in_input;
2028 spec->value.samples += skip;
2029 spec->is_relative = false;
2033 if(spec->value.samples < 0) {
2034 flac__utils_printf(stderr, 1, "%s: ERROR, --until value is before beginning of input\n", inbasefilename);
2037 if((FLAC__uint64)spec->value.samples <= skip) {
2038 flac__utils_printf(stderr, 1, "%s: ERROR, --until value is before --skip point\n", inbasefilename);
2041 if((FLAC__uint64)spec->value.samples > total_samples_in_input) {
2042 flac__utils_printf(stderr, 1, "%s: ERROR, --until value is after end of input\n", inbasefilename);
2049 FLAC__bool verify_metadata(const EncoderSession *e, FLAC__StreamMetadata **metadata, unsigned num_metadata)
2051 FLAC__bool metadata_picture_has_type1 = false;
2052 FLAC__bool metadata_picture_has_type2 = false;
2055 FLAC__ASSERT(0 != metadata);
2056 for(i = 0; i < num_metadata; i++) {
2057 const FLAC__StreamMetadata *m = metadata[i];
2058 if(m->type == FLAC__METADATA_TYPE_SEEKTABLE) {
2059 if(!FLAC__format_seektable_is_legal(&m->data.seek_table)) {
2060 flac__utils_printf(stderr, 1, "%s: ERROR: SEEKTABLE metadata block is invalid\n", e->inbasefilename);
2064 else if(m->type == FLAC__METADATA_TYPE_CUESHEET) {
2065 if(!FLAC__format_cuesheet_is_legal(&m->data.cue_sheet, m->data.cue_sheet.is_cd, /*violation=*/0)) {
2066 flac__utils_printf(stderr, 1, "%s: ERROR: CUESHEET metadata block is invalid\n", e->inbasefilename);
2070 else if(m->type == FLAC__METADATA_TYPE_PICTURE) {
2071 const char *error = 0;
2072 if(!FLAC__format_picture_is_legal(&m->data.picture, &error)) {
2073 flac__utils_printf(stderr, 1, "%s: ERROR: PICTURE metadata block is invalid: %s\n", e->inbasefilename, error);
2076 if(m->data.picture.type == FLAC__STREAM_METADATA_PICTURE_TYPE_FILE_ICON_STANDARD) {
2077 if(metadata_picture_has_type1) {
2078 flac__utils_printf(stderr, 1, "%s: ERROR: there may only be one picture of type 1 (32x32 icon) in the file\n", e->inbasefilename);
2081 metadata_picture_has_type1 = true;
2083 else if(m->data.picture.type == FLAC__STREAM_METADATA_PICTURE_TYPE_FILE_ICON) {
2084 if(metadata_picture_has_type2) {
2085 flac__utils_printf(stderr, 1, "%s: ERROR: there may only be one picture of type 2 (icon) in the file\n", e->inbasefilename);
2088 metadata_picture_has_type2 = true;
2096 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)
2098 unsigned wide_sample, sample, channel, byte;
2099 FLAC__int32 *out[FLAC__MAX_CHANNELS];
2101 if(0 == channel_map) {
2102 for(channel = 0; channel < channels; channel++)
2103 out[channel] = dest[channel];
2106 for(channel = 0; channel < channels; channel++)
2107 out[channel] = dest[channel_map[channel]];
2111 if(is_unsigned_samples) {
2112 for(sample = wide_sample = 0; wide_sample < wide_samples; wide_sample++)
2113 for(channel = 0; channel < channels; channel++, sample++)
2114 out[channel][wide_sample] = (FLAC__int32)ucbuffer_[sample] - 0x80;
2117 for(sample = wide_sample = 0; wide_sample < wide_samples; wide_sample++)
2118 for(channel = 0; channel < channels; channel++, sample++)
2119 out[channel][wide_sample] = (FLAC__int32)scbuffer_[sample];
2122 else if(bps == 16) {
2123 if(is_big_endian != is_big_endian_host_) {
2125 const unsigned bytes = wide_samples * channels * (bps >> 3);
2126 for(byte = 0; byte < bytes; byte += 2) {
2127 tmp = ucbuffer_[byte];
2128 ucbuffer_[byte] = ucbuffer_[byte+1];
2129 ucbuffer_[byte+1] = tmp;
2132 if(is_unsigned_samples) {
2133 for(sample = wide_sample = 0; wide_sample < wide_samples; wide_sample++)
2134 for(channel = 0; channel < channels; channel++, sample++)
2135 out[channel][wide_sample] = (FLAC__int32)usbuffer_[sample] - 0x8000;
2138 for(sample = wide_sample = 0; wide_sample < wide_samples; wide_sample++)
2139 for(channel = 0; channel < channels; channel++, sample++)
2140 out[channel][wide_sample] = (FLAC__int32)ssbuffer_[sample];
2143 else if(bps == 24) {
2144 if(!is_big_endian) {
2146 const unsigned bytes = wide_samples * channels * (bps >> 3);
2147 for(byte = 0; byte < bytes; byte += 3) {
2148 tmp = ucbuffer_[byte];
2149 ucbuffer_[byte] = ucbuffer_[byte+2];
2150 ucbuffer_[byte+2] = tmp;
2153 if(is_unsigned_samples) {
2154 for(byte = sample = wide_sample = 0; wide_sample < wide_samples; wide_sample++)
2155 for(channel = 0; channel < channels; channel++, sample++) {
2156 out[channel][wide_sample] = ucbuffer_[byte++]; out[channel][wide_sample] <<= 8;
2157 out[channel][wide_sample] |= ucbuffer_[byte++]; out[channel][wide_sample] <<= 8;
2158 out[channel][wide_sample] |= ucbuffer_[byte++];
2159 out[channel][wide_sample] -= 0x800000;
2163 for(byte = sample = wide_sample = 0; wide_sample < wide_samples; wide_sample++)
2164 for(channel = 0; channel < channels; channel++, sample++) {
2165 out[channel][wide_sample] = scbuffer_[byte++]; out[channel][wide_sample] <<= 8;
2166 out[channel][wide_sample] |= ucbuffer_[byte++]; out[channel][wide_sample] <<= 8;
2167 out[channel][wide_sample] |= ucbuffer_[byte++];
2175 FLAC__int32 mask = (1<<shift)-1;
2176 for(wide_sample = 0; wide_sample < wide_samples; wide_sample++)
2177 for(channel = 0; channel < channels; channel++) {
2178 if(out[channel][wide_sample] & mask) {
2179 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);
2182 out[channel][wide_sample] >>= shift;
2188 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)
2190 EncoderSession *encoder_session = (EncoderSession*)client_data;
2192 (void)encoder, (void)total_frames_estimate;
2194 encoder_session->bytes_written = bytes_written;
2195 encoder_session->samples_written = samples_written;
2197 if(encoder_session->total_samples_to_encode > 0 && !((frames_written-1) & encoder_session->stats_mask))
2198 print_stats(encoder_session);
2201 FLAC__StreamDecoderReadStatus flac_decoder_read_callback(const FLAC__StreamDecoder *decoder, FLAC__byte buffer[], unsigned *bytes, void *client_data)
2204 FLACDecoderData *data = (FLACDecoderData*)client_data;
2207 if (data->fatal_error)
2208 return FLAC__STREAM_DECODER_READ_STATUS_ABORT;
2210 /* use up lookahead first */
2211 if (data->lookahead_length) {
2212 n = min(data->lookahead_length, *bytes);
2213 memcpy(buffer, data->lookahead, n);
2215 data->lookahead += n;
2216 data->lookahead_length -= n;
2219 /* get the rest from file */
2221 *bytes = n + fread(buffer, 1, *bytes-n, data->encoder_session->fin);
2222 return ferror(data->encoder_session->fin)? FLAC__STREAM_DECODER_READ_STATUS_ABORT : FLAC__STREAM_DECODER_READ_STATUS_CONTINUE;
2225 return FLAC__STREAM_DECODER_READ_STATUS_CONTINUE;
2228 FLAC__StreamDecoderSeekStatus flac_decoder_seek_callback(const FLAC__StreamDecoder *decoder, FLAC__uint64 absolute_byte_offset, void *client_data)
2230 FLACDecoderData *data = (FLACDecoderData*)client_data;
2233 if(fseeko(data->encoder_session->fin, (off_t)absolute_byte_offset, SEEK_SET) < 0)
2234 return FLAC__STREAM_DECODER_SEEK_STATUS_ERROR;
2236 return FLAC__STREAM_DECODER_SEEK_STATUS_OK;
2239 FLAC__StreamDecoderTellStatus flac_decoder_tell_callback(const FLAC__StreamDecoder *decoder, FLAC__uint64 *absolute_byte_offset, void *client_data)
2241 FLACDecoderData *data = (FLACDecoderData*)client_data;
2245 if((pos = ftello(data->encoder_session->fin)) < 0)
2246 return FLAC__STREAM_DECODER_TELL_STATUS_ERROR;
2248 *absolute_byte_offset = (FLAC__uint64)pos;
2249 return FLAC__STREAM_DECODER_TELL_STATUS_OK;
2253 FLAC__StreamDecoderLengthStatus flac_decoder_length_callback(const FLAC__StreamDecoder *decoder, FLAC__uint64 *stream_length, void *client_data)
2255 FLACDecoderData *data = (FLACDecoderData*)client_data;
2258 if(0 == data->filesize)
2259 return FLAC__STREAM_DECODER_LENGTH_STATUS_ERROR;
2261 *stream_length = (FLAC__uint64)data->filesize;
2262 return FLAC__STREAM_DECODER_LENGTH_STATUS_OK;
2266 FLAC__bool flac_decoder_eof_callback(const FLAC__StreamDecoder *decoder, void *client_data)
2268 FLACDecoderData *data = (FLACDecoderData*)client_data;
2271 return feof(data->encoder_session->fin)? true : false;
2274 FLAC__StreamDecoderWriteStatus flac_decoder_write_callback(const FLAC__StreamDecoder *decoder, const FLAC__Frame *frame, const FLAC__int32 * const buffer[], void *client_data)
2276 FLACDecoderData *data = (FLACDecoderData*)client_data;
2277 FLAC__uint64 n = min(data->samples_left_to_process, frame->header.blocksize);
2280 if(!EncoderSession_process(data->encoder_session, buffer, (unsigned)n)) {
2281 print_error_with_state(data->encoder_session, "ERROR during encoding");
2282 data->fatal_error = true;
2283 return FLAC__STREAM_DECODER_WRITE_STATUS_ABORT;
2286 data->samples_left_to_process -= n;
2287 return FLAC__STREAM_DECODER_WRITE_STATUS_CONTINUE;
2290 void flac_decoder_metadata_callback(const FLAC__StreamDecoder *decoder, const FLAC__StreamMetadata *metadata, void *client_data)
2292 FLACDecoderData *data = (FLACDecoderData*)client_data;
2295 if (data->fatal_error)
2299 data->num_metadata_blocks == sizeof(data->metadata_blocks)/sizeof(data->metadata_blocks[0]) ||
2300 0 == (data->metadata_blocks[data->num_metadata_blocks] = FLAC__metadata_object_clone(metadata))
2302 data->fatal_error = true;
2304 data->num_metadata_blocks++;
2307 void flac_decoder_error_callback(const FLAC__StreamDecoder *decoder, FLAC__StreamDecoderErrorStatus status, void *client_data)
2309 FLACDecoderData *data = (FLACDecoderData*)client_data;
2312 flac__utils_printf(stderr, 1, "%s: ERROR got %s while decoding FLAC input\n", data->encoder_session->inbasefilename, FLAC__StreamDecoderErrorStatusString[status]);
2313 data->fatal_error = true;
2316 FLAC__bool parse_cuesheet(FLAC__StreamMetadata **cuesheet, const char *cuesheet_filename, const char *inbasefilename, FLAC__bool is_cdda, FLAC__uint64 lead_out_offset)
2319 unsigned last_line_read;
2320 const char *error_message;
2322 if(0 == cuesheet_filename)
2325 if(lead_out_offset == 0) {
2326 flac__utils_printf(stderr, 1, "%s: ERROR cannot import cuesheet when the number of input samples to encode is unknown\n", inbasefilename);
2330 if(0 == (f = fopen(cuesheet_filename, "r"))) {
2331 flac__utils_printf(stderr, 1, "%s: ERROR opening cuesheet \"%s\" for reading: %s\n", inbasefilename, cuesheet_filename, strerror(errno));
2335 *cuesheet = grabbag__cuesheet_parse(f, &error_message, &last_line_read, is_cdda, lead_out_offset);
2339 if(0 == *cuesheet) {
2340 flac__utils_printf(stderr, 1, "%s: ERROR parsing cuesheet \"%s\" on line %u: %s\n", inbasefilename, cuesheet_filename, last_line_read, error_message);
2344 if(!FLAC__format_cuesheet_is_legal(&(*cuesheet)->data.cue_sheet, /*check_cd_da_subset=*/false, &error_message)) {
2345 flac__utils_printf(stderr, 1, "%s: ERROR parsing cuesheet \"%s\": %s\n", inbasefilename, cuesheet_filename, error_message);
2349 /* if we're expecting CDDA, warn about non-compliance */
2350 if(is_cdda && !FLAC__format_cuesheet_is_legal(&(*cuesheet)->data.cue_sheet, /*check_cd_da_subset=*/true, &error_message)) {
2351 flac__utils_printf(stderr, 1, "%s: WARNING cuesheet \"%s\" is not audio CD compliant: %s\n", inbasefilename, cuesheet_filename, error_message);
2352 (*cuesheet)->data.cue_sheet.is_cd = false;
2358 void print_stats(const EncoderSession *encoder_session)
2360 const FLAC__uint64 samples_written = min(encoder_session->total_samples_to_encode, encoder_session->samples_written);
2361 #if defined _MSC_VER || defined __MINGW32__
2362 /* with MSVC you have to spoon feed it the casting */
2363 const double progress = (double)(FLAC__int64)samples_written / (double)(FLAC__int64)encoder_session->total_samples_to_encode;
2364 const double ratio = (double)(FLAC__int64)encoder_session->bytes_written / ((double)(FLAC__int64)encoder_session->unencoded_size * min(1.0, progress));
2366 const double progress = (double)samples_written / (double)encoder_session->total_samples_to_encode;
2367 const double ratio = (double)encoder_session->bytes_written / ((double)encoder_session->unencoded_size * min(1.0, progress));
2370 if(samples_written == encoder_session->total_samples_to_encode) {
2371 flac__utils_printf(stderr, 2, "\r%s:%s wrote %u bytes, ratio=%0.3f",
2372 encoder_session->inbasefilename,
2373 encoder_session->verify? " Verify OK," : "",
2374 (unsigned)encoder_session->bytes_written,
2379 flac__utils_printf(stderr, 2, "\r%s: %u%% complete, ratio=%0.3f", encoder_session->inbasefilename, (unsigned)floor(progress * 100.0 + 0.5), ratio);
2383 void print_error_with_init_status(const EncoderSession *e, const char *message, FLAC__StreamEncoderInitStatus init_status)
2385 const int ilen = strlen(e->inbasefilename) + 1;
2386 const char *state_string = "";
2388 flac__utils_printf(stderr, 1, "\n%s: %s\n", e->inbasefilename, message);
2390 flac__utils_printf(stderr, 1, "%*s init_status = %s\n", ilen, "", FLAC__StreamEncoderInitStatusString[init_status]);
2392 if(init_status == FLAC__STREAM_ENCODER_INIT_STATUS_ENCODER_ERROR) {
2393 state_string = FLAC__stream_encoder_get_resolved_state_string(e->encoder);
2395 flac__utils_printf(stderr, 1, "%*s state = %s\n", ilen, "", state_string);
2397 /* print out some more info for some errors: */
2398 if(0 == strcmp(state_string, FLAC__StreamEncoderStateString[FLAC__STREAM_ENCODER_CLIENT_ERROR])) {
2399 flac__utils_printf(stderr, 1,
2401 "An error occurred while writing; the most common cause is that the disk is full.\n"
2404 else if(0 == strcmp(state_string, FLAC__StreamEncoderStateString[FLAC__STREAM_ENCODER_IO_ERROR])) {
2405 flac__utils_printf(stderr, 1,
2407 "An error occurred opening the output file; it is likely that the output\n"
2408 "directory does not exist or is not writable, the output file already exists and\n"
2409 "is not writable, or the disk is full.\n"
2413 else if(init_status == FLAC__STREAM_ENCODER_INIT_STATUS_NOT_STREAMABLE) {
2414 flac__utils_printf(stderr, 1,
2416 "The encoding parameters specified do not conform to the FLAC Subset and may not\n"
2417 "be streamable or playable in hardware devices. If you really understand the\n"
2418 "consequences, you can add --lax to the command-line options to encode with\n"
2419 "these parameters anyway. See http://flac.sourceforge.net/format.html#subset\n"
2424 void print_error_with_state(const EncoderSession *e, const char *message)
2426 const int ilen = strlen(e->inbasefilename) + 1;
2427 const char *state_string;
2429 flac__utils_printf(stderr, 1, "\n%s: %s\n", e->inbasefilename, message);
2431 state_string = FLAC__stream_encoder_get_resolved_state_string(e->encoder);
2433 flac__utils_printf(stderr, 1, "%*s state = %s\n", ilen, "", state_string);
2435 /* print out some more info for some errors: */
2436 if(0 == strcmp(state_string, FLAC__StreamEncoderStateString[FLAC__STREAM_ENCODER_CLIENT_ERROR])) {
2437 flac__utils_printf(stderr, 1,
2439 "An error occurred while writing; the most common cause is that the disk is full.\n"
2444 void print_verify_error(EncoderSession *e)
2446 FLAC__uint64 absolute_sample;
2447 unsigned frame_number;
2450 FLAC__int32 expected;
2453 FLAC__stream_encoder_get_verify_decoder_error_stats(e->encoder, &absolute_sample, &frame_number, &channel, &sample, &expected, &got);
2455 flac__utils_printf(stderr, 1, "%s: ERROR: mismatch in decoded data, verify FAILED!\n", e->inbasefilename);
2456 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);
2457 flac__utils_printf(stderr, 1, " In all known cases, verify errors are caused by hardware problems,\n");
2458 flac__utils_printf(stderr, 1, " usually overclocking or bad RAM. Delete %s\n", e->outfilename);
2459 flac__utils_printf(stderr, 1, " and repeat the flac command exactly as before. If it does not give a\n");
2460 flac__utils_printf(stderr, 1, " verify error in the exact same place each time you try it, then there is\n");
2461 flac__utils_printf(stderr, 1, " a problem with your hardware; please see the FAQ:\n");
2462 flac__utils_printf(stderr, 1, " http://flac.sourceforge.net/faq.html#tools__hardware_prob\n");
2463 flac__utils_printf(stderr, 1, " If it does fail in the exact same place every time, keep\n");
2464 flac__utils_printf(stderr, 1, " %s and submit a bug report to:\n", e->outfilename);
2465 flac__utils_printf(stderr, 1, " https://sourceforge.net/bugs/?func=addbug&group_id=13478\n");
2466 flac__utils_printf(stderr, 1, " Make sure to upload the FLAC file and use the \"Monitor\" feature to\n");
2467 flac__utils_printf(stderr, 1, " monitor the bug status.\n");
2468 flac__utils_printf(stderr, 1, "Verify FAILED! Do not trust %s\n", e->outfilename);
2471 FLAC__bool read_little_endian_uint16(FILE *f, FLAC__uint16 *val, FLAC__bool eof_ok, const char *fn)
2473 size_t bytes_read = fread(val, 1, 2, f);
2475 if(bytes_read == 0) {
2477 flac__utils_printf(stderr, 1, "%s: ERROR: unexpected EOF\n", fn);
2483 else if(bytes_read < 2) {
2484 flac__utils_printf(stderr, 1, "%s: ERROR: unexpected EOF\n", fn);
2488 if(is_big_endian_host_) {
2489 FLAC__byte tmp, *b = (FLAC__byte*)val;
2490 tmp = b[1]; b[1] = b[0]; b[0] = tmp;
2496 FLAC__bool read_little_endian_uint32(FILE *f, FLAC__uint32 *val, FLAC__bool eof_ok, const char *fn)
2498 size_t bytes_read = fread(val, 1, 4, f);
2500 if(bytes_read == 0) {
2502 flac__utils_printf(stderr, 1, "%s: ERROR: unexpected EOF\n", fn);
2508 else if(bytes_read < 4) {
2509 flac__utils_printf(stderr, 1, "%s: ERROR: unexpected EOF\n", fn);
2513 if(is_big_endian_host_) {
2514 FLAC__byte tmp, *b = (FLAC__byte*)val;
2515 tmp = b[3]; b[3] = b[0]; b[0] = tmp;
2516 tmp = b[2]; b[2] = b[1]; b[1] = tmp;
2522 FLAC__bool read_big_endian_uint16(FILE *f, FLAC__uint16 *val, FLAC__bool eof_ok, const char *fn)
2524 unsigned char buf[4];
2525 size_t bytes_read= fread(buf, 1, 2, f);
2527 if(bytes_read==0U && eof_ok)
2529 else if(bytes_read<2U) {
2530 flac__utils_printf(stderr, 1, "%s: ERROR: unexpected EOF\n", fn);
2534 /* this is independent of host endianness */
2535 *val= (FLAC__uint16)(buf[0])<<8 | buf[1];
2540 FLAC__bool read_big_endian_uint32(FILE *f, FLAC__uint32 *val, FLAC__bool eof_ok, const char *fn)
2542 unsigned char buf[4];
2543 size_t bytes_read= fread(buf, 1, 4, f);
2545 if(bytes_read==0U && eof_ok)
2547 else if(bytes_read<4U) {
2548 flac__utils_printf(stderr, 1, "%s: ERROR: unexpected EOF\n", fn);
2552 /* this is independent of host endianness */
2553 *val= (FLAC__uint32)(buf[0])<<24 | (FLAC__uint32)(buf[1])<<16 |
2554 (FLAC__uint32)(buf[2])<<8 | buf[3];
2559 FLAC__bool read_sane_extended(FILE *f, FLAC__uint32 *val, FLAC__bool eof_ok, const char *fn)
2560 /* Read an IEEE 754 80-bit (aka SANE) extended floating point value from 'f',
2561 * convert it into an integral value and store in 'val'. Return false if only
2562 * between 1 and 9 bytes remain in 'f', if 0 bytes remain in 'f' and 'eof_ok' is
2563 * false, or if the value is negative, between zero and one, or too large to be
2564 * represented by 'val'; return true otherwise.
2568 unsigned char buf[10];
2569 size_t bytes_read= fread(buf, 1U, 10U, f);
2570 FLAC__int16 e= ((FLAC__uint16)(buf[0])<<8 | (FLAC__uint16)(buf[1]))-0x3FFF;
2571 FLAC__int16 shift= 63-e;
2574 if(bytes_read==0U && eof_ok)
2576 else if(bytes_read<10U) {
2577 flac__utils_printf(stderr, 1, "%s: ERROR: unexpected EOF\n", fn);
2580 else if((buf[0]>>7)==1U || e<0 || e>63) {
2581 flac__utils_printf(stderr, 1, "%s: ERROR: invalid floating-point value\n", fn);
2585 for(i= 0U; i<8U; ++i)
2586 p|= (FLAC__uint64)(buf[i+2])<<(56U-i*8);
2587 *val= (FLAC__uint32)((p>>shift)+(p>>(shift-1) & 0x1));
2592 FLAC__bool fskip_ahead(FILE *f, FLAC__uint64 offset)
2594 static unsigned char dump[8192];
2597 long need = (long)min(offset, LONG_MAX);
2598 if(fseeko(f, need, SEEK_CUR) < 0) {
2599 need = (long)min(offset, sizeof(dump));
2600 if((long)fread(dump, 1, need, f) < need)
2605 #if 0 /* pure non-fseek() version */
2607 const long need = (long)min(offset, sizeof(dump));
2608 if(fread(dump, 1, need, f) < need)
2616 unsigned count_channel_mask_bits(FLAC__uint32 mask)
2627 FLAC__uint32 limit_channel_mask(FLAC__uint32 mask, unsigned channels)
2629 FLAC__uint32 x = 0x80000000;
2630 unsigned count = count_channel_mask_bits(mask);
2631 while(x && count > channels) {
2638 FLAC__ASSERT(count_channel_mask_bits(mask) == channels);