1 /* flac - Command-line FLAC encoder/decoder
2 * Copyright (C) 2000,2001,2002,2003,2004,2005,2006,2007,2008 Josh Coalson
4 * This program is free software; you can redistribute it and/or
5 * modify it under the terms of the GNU General Public License
6 * as published by the Free Software Foundation; either version 2
7 * of the License, or (at your option) any later version.
9 * This program is distributed in the hope that it will be useful,
10 * but WITHOUT ANY WARRANTY; without even the implied warranty of
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 * GNU General Public License for more details.
14 * You should have received a copy of the GNU General Public License
15 * along with this program; if not, write to the Free Software
16 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
23 #if defined _WIN32 && !defined __CYGWIN__
24 /* where MSVC puts unlink() */
29 #if defined _MSC_VER || defined __MINGW32__
30 #include <sys/types.h> /* for off_t */
31 #if _MSC_VER <= 1600 /* @@@ [2G limit] */
37 #include <limits.h> /* for LONG_MAX */
38 #include <math.h> /* for floor() */
39 #include <stdio.h> /* for FILE etc. */
40 #include <stdlib.h> /* for malloc */
41 #include <string.h> /* for strcmp(), strerror() */
43 #include "share/alloc.h"
44 #include "share/grabbag.h"
50 #define min(x,y) ((x)<(y)?(x):(y))
54 #define max(x,y) ((x)>(y)?(x):(y))
56 /* this MUST be >= 588 so that sector aligning can take place with one read */
57 /* this MUST be < 2^sizeof(size_t) / ( FLAC__MAX_CHANNELS * (FLAC__MAX_BITS_PER_SAMPLE/8) ) */
58 #define CHUNK_OF_SAMPLES 2048
63 unsigned bits_per_sample; /* width of sample point, including 'shift' bits, valid bps is bits_per_sample-shift */
64 unsigned shift; /* # of LSBs samples have been shifted left by */
65 unsigned bytes_per_wide_sample; /* for convenience, always == channels*((bps+7)/8), or 0 if N/A to input format (like FLAC) */
66 FLAC__bool is_unsigned_samples;
67 FLAC__bool is_big_endian;
68 FLAC__uint32 channel_mask;
71 /* this is the client_data attached to the FLAC decoder when encoding from a FLAC file */
74 const FLAC__byte *lookahead;
75 unsigned lookahead_length;
76 size_t num_metadata_blocks;
77 FLAC__StreamMetadata *metadata_blocks[1024]; /*@@@ BAD MAGIC number */
78 FLAC__uint64 samples_left_to_process;
79 FLAC__bool fatal_error;
88 FLAC__bool outputfile_opened; /* true if we successfully opened the output file and we want it to be deleted if there is an error */
89 const char *inbasefilename;
90 const char *infilename;
91 const char *outfilename;
93 FLAC__bool treat_warnings_as_errors;
94 FLAC__bool continue_through_decode_errors;
95 FLAC__bool replay_gain;
96 FLAC__uint64 total_samples_to_encode; /* (i.e. "wide samples" aka "sample frames") WATCHOUT: may be 0 to mean 'unknown' */
97 FLAC__uint64 unencoded_size; /* an estimate of the input size, only used in the progress indicator */
98 FLAC__uint64 bytes_written;
99 FLAC__uint64 samples_written;
107 FLAC__uint64 data_bytes;
110 FLAC__StreamDecoder *decoder;
111 FLACDecoderData client_data;
115 FLAC__StreamEncoder *encoder;
118 FLAC__StreamMetadata *seek_table_template;
121 const int FLAC_ENCODE__DEFAULT_PADDING = 8192;
123 static FLAC__bool is_big_endian_host_;
125 static unsigned char ucbuffer_[CHUNK_OF_SAMPLES*FLAC__MAX_CHANNELS*((FLAC__REFERENCE_CODEC_MAX_BITS_PER_SAMPLE+7)/8)];
126 static signed char *scbuffer_ = (signed char *)ucbuffer_;
127 static FLAC__uint16 *usbuffer_ = (FLAC__uint16 *)ucbuffer_;
128 static FLAC__int16 *ssbuffer_ = (FLAC__int16 *)ucbuffer_;
130 static FLAC__int32 in_[FLAC__MAX_CHANNELS][CHUNK_OF_SAMPLES];
131 static FLAC__int32 *input_[FLAC__MAX_CHANNELS];
135 * unpublished debug routines from the FLAC libs
137 extern FLAC__bool FLAC__stream_encoder_disable_constant_subframes(FLAC__StreamEncoder *encoder, FLAC__bool value);
138 extern FLAC__bool FLAC__stream_encoder_disable_fixed_subframes(FLAC__StreamEncoder *encoder, FLAC__bool value);
139 extern FLAC__bool FLAC__stream_encoder_disable_verbatim_subframes(FLAC__StreamEncoder *encoder, FLAC__bool value);
140 extern FLAC__bool FLAC__stream_encoder_set_do_md5(FLAC__StreamEncoder *encoder, FLAC__bool value);
145 static FLAC__bool EncoderSession_construct(EncoderSession *e, encode_options_t options, off_t infilesize, FILE *infile, const char *infilename, const char *outfilename, const FLAC__byte *lookahead, unsigned lookahead_length);
146 static void EncoderSession_destroy(EncoderSession *e);
147 static int EncoderSession_finish_ok(EncoderSession *e, int info_align_carry, int info_align_zero, foreign_metadata_t *foreign_metadata);
148 static int EncoderSession_finish_error(EncoderSession *e);
149 static FLAC__bool EncoderSession_init_encoder(EncoderSession *e, encode_options_t options);
150 static FLAC__bool EncoderSession_process(EncoderSession *e, const FLAC__int32 * const buffer[], unsigned samples);
151 static FLAC__bool EncoderSession_format_is_iff(const EncoderSession *e);
152 static FLAC__bool convert_to_seek_table_template(const char *requested_seek_points, int num_requested_seek_points, FLAC__StreamMetadata *cuesheet, EncoderSession *e);
153 static FLAC__bool canonicalize_until_specification(utils__SkipUntilSpecification *spec, const char *inbasefilename, unsigned sample_rate, FLAC__uint64 skip, FLAC__uint64 total_samples_in_input);
154 static FLAC__bool verify_metadata(const EncoderSession *e, FLAC__StreamMetadata **metadata, unsigned num_metadata);
155 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);
156 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);
157 static FLAC__StreamDecoderReadStatus flac_decoder_read_callback(const FLAC__StreamDecoder *decoder, FLAC__byte buffer[], size_t *bytes, void *client_data);
158 static FLAC__StreamDecoderSeekStatus flac_decoder_seek_callback(const FLAC__StreamDecoder *decoder, FLAC__uint64 absolute_byte_offset, void *client_data);
159 static FLAC__StreamDecoderTellStatus flac_decoder_tell_callback(const FLAC__StreamDecoder *decoder, FLAC__uint64 *absolute_byte_offset, void *client_data);
160 static FLAC__StreamDecoderLengthStatus flac_decoder_length_callback(const FLAC__StreamDecoder *decoder, FLAC__uint64 *stream_length, void *client_data);
161 static FLAC__bool flac_decoder_eof_callback(const FLAC__StreamDecoder *decoder, void *client_data);
162 static FLAC__StreamDecoderWriteStatus flac_decoder_write_callback(const FLAC__StreamDecoder *decoder, const FLAC__Frame *frame, const FLAC__int32 * const buffer[], void *client_data);
163 static void flac_decoder_metadata_callback(const FLAC__StreamDecoder *decoder, const FLAC__StreamMetadata *metadata, void *client_data);
164 static void flac_decoder_error_callback(const FLAC__StreamDecoder *decoder, FLAC__StreamDecoderErrorStatus status, void *client_data);
165 static FLAC__bool parse_cuesheet(FLAC__StreamMetadata **cuesheet, const char *cuesheet_filename, const char *inbasefilename, FLAC__bool is_cdda, FLAC__uint64 lead_out_offset, FLAC__bool treat_warnings_as_errors);
166 static void print_stats(const EncoderSession *encoder_session);
167 static void print_error_with_init_status(const EncoderSession *e, const char *message, FLAC__StreamEncoderInitStatus init_status);
168 static void print_error_with_state(const EncoderSession *e, const char *message);
169 static void print_verify_error(EncoderSession *e);
170 static FLAC__bool read_bytes(FILE *f, FLAC__byte *buf, size_t n, FLAC__bool eof_ok, const char *fn);
171 static FLAC__bool read_uint16(FILE *f, FLAC__bool big_endian, FLAC__uint16 *val, const char *fn);
172 static FLAC__bool read_uint32(FILE *f, FLAC__bool big_endian, FLAC__uint32 *val, const char *fn);
173 static FLAC__bool read_uint64(FILE *f, FLAC__bool big_endian, FLAC__uint64 *val, const char *fn);
174 static FLAC__bool read_sane_extended(FILE *f, FLAC__uint32 *val, const char *fn);
175 static FLAC__bool fskip_ahead(FILE *f, FLAC__uint64 offset);
176 static unsigned count_channel_mask_bits(FLAC__uint32 mask);
178 static FLAC__uint32 limit_channel_mask(FLAC__uint32 mask, unsigned channels);
181 static FLAC__bool get_sample_info_raw(EncoderSession *e, encode_options_t options)
183 e->info.sample_rate = options.format_options.raw.sample_rate;
184 e->info.channels = options.format_options.raw.channels;
185 e->info.bits_per_sample = options.format_options.raw.bps;
187 e->info.bytes_per_wide_sample = options.format_options.raw.channels * ((options.format_options.raw.bps+7)/8);
188 e->info.is_unsigned_samples = options.format_options.raw.is_unsigned_samples;
189 e->info.is_big_endian = options.format_options.raw.is_big_endian;
190 e->info.channel_mask = 0;
195 static FLAC__bool get_sample_info_wave(EncoderSession *e, encode_options_t options)
197 FLAC__bool got_fmt_chunk = false, got_data_chunk = false, got_ds64_chunk = false;
198 unsigned sample_rate = 0, channels = 0, bps = 0, shift = 0;
199 FLAC__uint32 channel_mask = 0;
200 FLAC__uint64 ds64_data_size = 0;
202 e->info.is_unsigned_samples = false;
203 e->info.is_big_endian = false;
205 if(e->format == FORMAT_WAVE64) {
207 * lookahead[] already has "riff\x2E\x91\xCF\x11\xD6\xA5\x28\xDB", skip over remaining header
209 if(!fskip_ahead(e->fin, 16+8+16-12)) { /* riff GUID + riff size + WAVE GUID - lookahead */
210 flac__utils_printf(stderr, 1, "%s: ERROR during read while skipping over remaining \"riff\" header\n", e->inbasefilename);
214 /* else lookahead[] already has "RIFFxxxxWAVE" or "RF64xxxxWAVE" */
216 while(!feof(e->fin) && !got_data_chunk) {
217 /* chunk IDs are 4 bytes for WAVE/RF64, 16 for Wave64 */
218 /* for WAVE/RF64 we want the 5th char zeroed so we can treat it like a C string */
219 char chunk_id[16] = { '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0' };
221 if(!read_bytes(e->fin, (FLAC__byte*)chunk_id, e->format==FORMAT_WAVE64?16:4, /*eof_ok=*/true, e->inbasefilename)) {
222 flac__utils_printf(stderr, 1, "%s: ERROR: incomplete chunk identifier\n", e->inbasefilename);
228 if(e->format == FORMAT_RF64 && !memcmp(chunk_id, "ds64", 4)) { /* RF64 64-bit sizes chunk */
229 FLAC__uint32 xx, data_bytes;
232 flac__utils_printf(stderr, 1, "%s: ERROR: file has multiple 'ds64' chunks\n", e->inbasefilename);
235 if(got_fmt_chunk || got_data_chunk) {
236 flac__utils_printf(stderr, 1, "%s: ERROR: 'ds64' chunk appears after 'fmt ' or 'data' chunk\n", e->inbasefilename);
240 /* ds64 chunk size */
241 if(!read_uint32(e->fin, /*big_endian=*/false, &xx, e->inbasefilename))
244 if(data_bytes < 28) {
245 flac__utils_printf(stderr, 1, "%s: ERROR: non-standard 'ds64' chunk has length = %u\n", e->inbasefilename, (unsigned)data_bytes);
248 if(data_bytes & 1) /* should never happen, but enforce WAVE alignment rules */
251 /* RIFF 64-bit size, lo/hi */
252 if(!read_uint32(e->fin, /*big_endian=*/false, &xx, e->inbasefilename))
254 if(!read_uint32(e->fin, /*big_endian=*/false, &xx, e->inbasefilename))
257 /* 'data' 64-bit size */
258 if(!read_uint64(e->fin, /*big_endian=*/false, &ds64_data_size, e->inbasefilename))
263 /* skip any extra data in the ds64 chunk */
264 if(!fskip_ahead(e->fin, data_bytes)) {
265 flac__utils_printf(stderr, 1, "%s: ERROR during read while skipping over extra 'ds64' data\n", e->inbasefilename);
269 got_ds64_chunk = true;
272 !memcmp(chunk_id, "fmt ", 4) &&
273 (e->format!=FORMAT_WAVE64 || !memcmp(chunk_id, "fmt \xF3\xAC\xD3\x11\xD1\x8C\x00\xC0\x4F\x8E\xDB\x8A", 16))
274 ) { /* format chunk */
276 FLAC__uint32 xx, data_bytes;
277 FLAC__uint16 wFormatTag; /* wFormatTag word from the 'fmt ' chunk */
278 unsigned block_align;
281 flac__utils_printf(stderr, 1, "%s: ERROR: file has multiple 'fmt ' chunks\n", e->inbasefilename);
286 * http://www-mmsp.ece.mcgill.ca/Documents/AudioFormats/WAVE/WAVE.html
287 * http://windowssdk.msdn.microsoft.com/en-us/library/ms713497.aspx
288 * 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
292 * 2 byte: format type: 1 for WAVE_FORMAT_PCM, 65534 for WAVE_FORMAT_EXTENSIBLE
294 * 4 byte: sample rate (Hz)
295 * 4 byte: avg bytes per sec
296 * 2 byte: block align
297 * 2 byte: bits per sample (not necessarily all significant)
299 * 2 byte: extension size in bytes (usually 0 for WAVEFORMATEX and 22 for WAVEFORMATEXTENSIBLE with PCM)
300 * WAVEFORMATEXTENSIBLE adds
301 * 2 byte: valid bits per sample
302 * 4 byte: channel mask
303 * 16 byte: subformat GUID, first 2 bytes have format type, 1 being PCM
305 * Current spec says WAVEFORMATEX with PCM must have bps == 8 or 16, or any multiple of 8 for WAVEFORMATEXTENSIBLE.
306 * 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.
308 * Block align for WAVE_FORMAT_PCM or WAVE_FORMAT_EXTENSIBLE is also supposed to be channels*bps/8
310 * If the channel mask has more set bits than # of channels, the extra MSBs are ignored.
311 * If the channel mask has less set bits than # of channels, the extra channels are unassigned to any speaker.
313 * Data is supposed to be unsigned for bps <= 8 else signed.
317 if(!read_uint32(e->fin, /*big_endian=*/false, &xx, e->inbasefilename))
320 if(e->format == FORMAT_WAVE64) {
321 /* other half of the size field should be 0 */
322 if(!read_uint32(e->fin, /*big_endian=*/false, &xx, e->inbasefilename))
325 flac__utils_printf(stderr, 1, "%s: ERROR: freakishly large Wave64 'fmt ' chunk has length = 0x%08X%08X\n", e->inbasefilename, (unsigned)xx, (unsigned)data_bytes);
328 /* subtract size of header */
329 if (data_bytes < 16+8) {
330 flac__utils_printf(stderr, 1, "%s: ERROR: freakishly small Wave64 'fmt ' chunk has length = 0x%08X%08X\n", e->inbasefilename, (unsigned)xx, (unsigned)data_bytes);
333 data_bytes -= (16+8);
335 if(data_bytes < 16) {
336 flac__utils_printf(stderr, 1, "%s: ERROR: non-standard 'fmt ' chunk has length = %u\n", e->inbasefilename, (unsigned)data_bytes);
339 if(e->format != FORMAT_WAVE64) {
340 if(data_bytes & 1) /* should never happen, but enforce WAVE alignment rules */
344 data_bytes = (data_bytes+7) & (~7u); /* should never happen, but enforce Wave64 alignment rules */
348 if(!read_uint16(e->fin, /*big_endian=*/false, &wFormatTag, e->inbasefilename))
350 if(wFormatTag != 1 /*WAVE_FORMAT_PCM*/ && wFormatTag != 65534 /*WAVE_FORMAT_EXTENSIBLE*/) {
351 flac__utils_printf(stderr, 1, "%s: ERROR: unsupported format type %u\n", e->inbasefilename, (unsigned)wFormatTag);
355 /* number of channels */
356 if(!read_uint16(e->fin, /*big_endian=*/false, &x, e->inbasefilename))
358 channels = (unsigned)x;
361 if(!read_uint32(e->fin, /*big_endian=*/false, &xx, e->inbasefilename))
365 /* avg bytes per second (ignored) */
366 if(!read_uint32(e->fin, /*big_endian=*/false, &xx, e->inbasefilename))
369 if(!read_uint16(e->fin, /*big_endian=*/false, &x, e->inbasefilename))
371 block_align = (unsigned)x;
372 /* bits per sample */
373 if(!read_uint16(e->fin, /*big_endian=*/false, &x, e->inbasefilename))
377 e->info.is_unsigned_samples = (bps <= 8);
379 if(wFormatTag == 1) {
380 if(bps != 8 && bps != 16) {
381 if(bps == 24 || bps == 32) {
382 /* let these slide with a warning since they're unambiguous */
383 flac__utils_printf(stderr, 1, "%s: WARNING: legacy WAVE file has format type %u but bits-per-sample=%u\n", e->inbasefilename, (unsigned)wFormatTag, bps);
384 if(e->treat_warnings_as_errors)
388 /* @@@ we could add an option to specify left- or right-justified blocks so we knew how to set 'shift' */
389 flac__utils_printf(stderr, 1, "%s: ERROR: legacy WAVE file has format type %u but bits-per-sample=%u\n", e->inbasefilename, (unsigned)wFormatTag, bps);
393 #if 0 /* @@@ reinstate once we can get an answer about whether the samples are left- or right-justified */
394 if((bps+7)/8 * channels == block_align) {
396 /* assume legacy file is byte aligned with some LSBs zero; this is double-checked in format_input() */
397 flac__utils_printf(stderr, 1, "%s: WARNING: legacy WAVE file (format type %d) has block alignment=%u, bits-per-sample=%u, channels=%u\n", e->inbasefilename, (unsigned)wFormatTag, block_align, bps, channels);
398 if(e->treat_warnings_as_errors)
400 shift = 8 - (bps % 8);
407 flac__utils_printf(stderr, 1, "%s: ERROR: illegal WAVE file (format type %d) has block alignment=%u, bits-per-sample=%u, channels=%u\n", e->inbasefilename, (unsigned)wFormatTag, block_align, bps, channels);
413 if(channels > 2 && !options.channel_map_none) {
414 flac__utils_printf(stderr, 1, "%s: ERROR: WAVE has >2 channels but is not WAVE_FORMAT_EXTENSIBLE; cannot assign channels\n", e->inbasefilename);
417 FLAC__ASSERT(data_bytes >= 16);
421 if(data_bytes < 40) {
422 flac__utils_printf(stderr, 1, "%s: ERROR: invalid WAVEFORMATEXTENSIBLE chunk with size %u\n", e->inbasefilename, (unsigned)data_bytes);
426 if(!read_uint16(e->fin, /*big_endian=*/false, &x, e->inbasefilename))
429 flac__utils_printf(stderr, 1, "%s: ERROR: invalid WAVEFORMATEXTENSIBLE chunk with cbSize %u\n", e->inbasefilename, (unsigned)x);
433 if(!read_uint16(e->fin, /*big_endian=*/false, &x, e->inbasefilename))
435 if((unsigned)x > bps) {
436 flac__utils_printf(stderr, 1, "%s: ERROR: invalid WAVEFORMATEXTENSIBLE chunk with wValidBitsPerSample (%u) > wBitsPerSample (%u)\n", e->inbasefilename, (unsigned)x, bps);
439 shift = bps - (unsigned)x;
441 if(!read_uint32(e->fin, /*big_endian=*/false, &channel_mask, e->inbasefilename))
443 /* for mono/stereo and unassigned channels, we fake the mask */
444 if(channel_mask == 0) {
446 channel_mask = 0x0001;
447 else if(channels == 2)
448 channel_mask = 0x0003;
450 /* set channel mapping */
451 /* FLAC order follows SMPTE and WAVEFORMATEXTENSIBLE but with fewer channels, which are: */
452 /* front left, front right, center, LFE, back left, back right, surround left, surround right */
453 /* the default mapping is sufficient for 1-6 channels and 7-8 are currently unspecified anyway */
455 /* @@@ example for dolby/vorbis order, for reference later in case it becomes important */
457 options.channel_map_none ||
458 channel_mask == 0x0001 || /* 1 channel: (mono) */
459 channel_mask == 0x0003 || /* 2 channels: front left, front right */
460 channel_mask == 0x0033 || /* 4 channels: front left, front right, back left, back right */
461 channel_mask == 0x0603 /* 4 channels: front left, front right, side left, side right */
463 /* keep default channel order */
466 channel_mask == 0x0007 || /* 3 channels: front left, front right, front center */
467 channel_mask == 0x0037 || /* 5 channels: front left, front right, front center, back left, back right */
468 channel_mask == 0x0607 /* 5 channels: front left, front right, front center, side left, side right */
470 /* to dolby order: front left, center, front right [, surround left, surround right ] */
475 channel_mask == 0x003f || /* 6 channels: front left, front right, front center, LFE, back left, back right */
476 channel_mask == 0x060f /* 6 channels: front left, front right, front center, LFE, side left, side right */
478 /* to dolby order: front left, center, front right, surround left, surround right, LFE */
487 options.channel_map_none ||
488 channel_mask == 0x0001 || /* 1 channel: (mono) */
489 channel_mask == 0x0003 || /* 2 channels: front left, front right */
490 channel_mask == 0x0007 || /* 3 channels: front left, front right, front center */
491 channel_mask == 0x0033 || /* 4 channels: front left, front right, back left, back right */
492 channel_mask == 0x0603 || /* 4 channels: front left, front right, side left, side right */
493 channel_mask == 0x0037 || /* 5 channels: front left, front right, front center, back left, back right */
494 channel_mask == 0x0607 || /* 5 channels: front left, front right, front center, side left, side right */
495 channel_mask == 0x003f || /* 6 channels: front left, front right, front center, LFE, back left, back right */
496 channel_mask == 0x060f /* 6 channels: front left, front right, front center, LFE, side left, side right */
498 /* keep default channel order */
502 flac__utils_printf(stderr, 1, "%s: ERROR: WAVEFORMATEXTENSIBLE chunk with unsupported channel mask=0x%04X\n\nUse --channel-map=none option to store channels in current order; FLAC files\nmust also be decoded with --channel-map=none to restore correct order.\n", e->inbasefilename, (unsigned)channel_mask);
505 if(!options.channel_map_none) {
506 if(count_channel_mask_bits(channel_mask) < channels) {
507 flac__utils_printf(stderr, 1, "%s: ERROR: WAVEFORMATEXTENSIBLE chunk: channel mask 0x%04X has unassigned channels (#channels=%u)\n", e->inbasefilename, (unsigned)channel_mask, channels);
511 /* supporting this is too difficult with channel mapping; e.g. what if mask is 0x003f but #channels=4?
512 * there would be holes in the order that would have to be filled in, or the mask would have to be
513 * limited and the logic above rerun to see if it still fits into the FLAC mapping.
515 else if(count_channel_mask_bits(channel_mask) > channels)
516 channel_mask = limit_channel_mask(channel_mask, channels);
518 else if(count_channel_mask_bits(channel_mask) > channels) {
519 flac__utils_printf(stderr, 1, "%s: ERROR: WAVEFORMATEXTENSIBLE chunk: channel mask 0x%04X has extra bits for non-existant channels (#channels=%u)\n", e->inbasefilename, (unsigned)channel_mask, channels);
524 /* first part of GUID */
525 if(!read_uint16(e->fin, /*big_endian=*/false, &x, e->inbasefilename))
528 flac__utils_printf(stderr, 1, "%s: ERROR: unsupported WAVEFORMATEXTENSIBLE chunk with non-PCM format %u\n", e->inbasefilename, (unsigned)x);
534 e->info.bytes_per_wide_sample = channels * (bps / 8);
536 /* skip any extra data in the fmt chunk */
537 if(!fskip_ahead(e->fin, data_bytes)) {
538 flac__utils_printf(stderr, 1, "%s: ERROR during read while skipping over extra 'fmt' data\n", e->inbasefilename);
542 got_fmt_chunk = true;
545 !memcmp(chunk_id, "data", 4) &&
546 (e->format!=FORMAT_WAVE64 || !memcmp(chunk_id, "data\xF3\xAC\xD3\x11\xD1\x8C\x00\xC0\x4F\x8E\xDB\x8A", 16))
549 FLAC__uint64 data_bytes;
552 flac__utils_printf(stderr, 1, "%s: ERROR: got 'data' chunk before 'fmt' chunk\n", e->inbasefilename);
557 if(e->format != FORMAT_WAVE64) {
558 if(!read_uint32(e->fin, /*big_endian=*/false, &xx, e->inbasefilename))
563 if(!read_uint64(e->fin, /*big_endian=*/false, &data_bytes, e->inbasefilename))
565 /* subtract size of header */
566 if (data_bytes < 16+8) {
567 flac__utils_printf(stderr, 1, "%s: ERROR: freakishly small Wave64 'data' chunk has length = 0x00000000%08X\n", e->inbasefilename, (unsigned)data_bytes);
570 data_bytes -= (16+8);
572 if(e->format == FORMAT_RF64) {
573 if(!got_ds64_chunk) {
574 flac__utils_printf(stderr, 1, "%s: ERROR: RF64 file has no 'ds64' chunk before 'data' chunk\n", e->inbasefilename);
577 if(data_bytes == 0xffffffff)
578 data_bytes = ds64_data_size;
580 if(options.ignore_chunk_sizes) {
581 FLAC__ASSERT(!options.sector_align);
583 flac__utils_printf(stderr, 1, "%s: WARNING: 'data' chunk has non-zero size, using --ignore-chunk-sizes is probably a bad idea\n", e->inbasefilename, chunk_id);
584 if(e->treat_warnings_as_errors)
587 data_bytes = (FLAC__uint64)0 - (FLAC__uint64)e->info.bytes_per_wide_sample; /* max out data_bytes; we'll use EOF as signal to stop reading */
589 else if(0 == data_bytes) {
590 flac__utils_printf(stderr, 1, "%s: ERROR: 'data' chunk has size of 0\n", e->inbasefilename);
594 e->fmt.iff.data_bytes = data_bytes;
596 got_data_chunk = true;
602 if(!options.format_options.iff.foreign_metadata) {
603 if(e->format != FORMAT_WAVE64)
604 flac__utils_printf(stderr, 1, "%s: WARNING: skipping unknown chunk '%s' (use --keep-foreign-metadata to keep)\n", e->inbasefilename, chunk_id);
606 flac__utils_printf(stderr, 1, "%s: WARNING: skipping unknown chunk %02X%02X%02X%02X-%02X%02X-%02X%02X-%02X%02X-%02X%02X%02X%02X%02X%02X (use --keep-foreign-metadata to keep)\n",
608 (unsigned)((const unsigned char *)chunk_id)[3],
609 (unsigned)((const unsigned char *)chunk_id)[2],
610 (unsigned)((const unsigned char *)chunk_id)[1],
611 (unsigned)((const unsigned char *)chunk_id)[0],
612 (unsigned)((const unsigned char *)chunk_id)[5],
613 (unsigned)((const unsigned char *)chunk_id)[4],
614 (unsigned)((const unsigned char *)chunk_id)[7],
615 (unsigned)((const unsigned char *)chunk_id)[6],
616 (unsigned)((const unsigned char *)chunk_id)[9],
617 (unsigned)((const unsigned char *)chunk_id)[8],
618 (unsigned)((const unsigned char *)chunk_id)[10],
619 (unsigned)((const unsigned char *)chunk_id)[11],
620 (unsigned)((const unsigned char *)chunk_id)[12],
621 (unsigned)((const unsigned char *)chunk_id)[13],
622 (unsigned)((const unsigned char *)chunk_id)[14],
623 (unsigned)((const unsigned char *)chunk_id)[15]
625 if(e->treat_warnings_as_errors)
630 if(e->format != FORMAT_WAVE64) {
631 if(!read_uint32(e->fin, /*big_endian=*/false, &xx, e->inbasefilename))
637 if(!read_uint64(e->fin, /*big_endian=*/false, &skip, e->inbasefilename))
639 skip = (skip+7) & (~(FLAC__uint64)7);
640 /* subtract size of header */
642 flac__utils_printf(stderr, 1, "%s: ERROR: freakishly small Wave64 chunk has length = 0x00000000%08X\n", e->inbasefilename, (unsigned)skip);
648 if(!fskip_ahead(e->fin, skip)) {
649 flac__utils_printf(stderr, 1, "%s: ERROR during read while skipping over chunk\n", e->inbasefilename);
657 flac__utils_printf(stderr, 1, "%s: ERROR: didn't find fmt chunk\n", e->inbasefilename);
660 if(!got_data_chunk) {
661 flac__utils_printf(stderr, 1, "%s: ERROR: didn't find data chunk\n", e->inbasefilename);
665 e->info.sample_rate = sample_rate;
666 e->info.channels = channels;
667 e->info.bits_per_sample = bps;
668 e->info.shift = shift;
669 e->info.channel_mask = channel_mask;
674 static FLAC__bool get_sample_info_aiff(EncoderSession *e, encode_options_t options)
676 FLAC__bool got_comm_chunk = false, got_ssnd_chunk = false;
677 unsigned sample_rate = 0, channels = 0, bps = 0, shift = 0;
678 FLAC__uint64 sample_frames = 0;
679 FLAC__uint32 channel_mask = 0;
681 e->info.is_unsigned_samples = false;
682 e->info.is_big_endian = true;
685 * lookahead[] already has "FORMxxxxAIFF", do chunks
687 while(!feof(e->fin) && !got_ssnd_chunk) {
688 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 */
689 if(!read_bytes(e->fin, (FLAC__byte*)chunk_id, 4, /*eof_ok=*/true, e->inbasefilename)) {
690 flac__utils_printf(stderr, 1, "%s: ERROR: incomplete chunk identifier\n", e->inbasefilename);
696 if(!memcmp(chunk_id, "COMM", 4)) { /* common chunk */
700 const FLAC__bool is_aifc = e->format == FORMAT_AIFF_C;
701 const FLAC__uint32 minimum_comm_size = (is_aifc? 22 : 18);
704 flac__utils_printf(stderr, 1, "%s: ERROR: file has multiple 'COMM' chunks\n", e->inbasefilename);
708 /* COMM chunk size */
709 if(!read_uint32(e->fin, /*big_endian=*/true, &xx, e->inbasefilename))
711 else if(xx < minimum_comm_size) {
712 flac__utils_printf(stderr, 1, "%s: ERROR: non-standard %s 'COMM' chunk has length = %u\n", e->inbasefilename, is_aifc? "AIFF-C" : "AIFF", (unsigned int)xx);
715 else if(!is_aifc && xx != minimum_comm_size) {
716 flac__utils_printf(stderr, 1, "%s: WARNING: non-standard %s 'COMM' chunk has length = %u, expected %u\n", e->inbasefilename, is_aifc? "AIFF-C" : "AIFF", (unsigned int)xx, minimum_comm_size);
717 if(e->treat_warnings_as_errors)
720 skip = (xx-minimum_comm_size)+(xx & 1);
722 /* number of channels */
723 if(!read_uint16(e->fin, /*big_endian=*/true, &x, e->inbasefilename))
725 channels = (unsigned)x;
726 if(channels > 2 && !options.channel_map_none) {
727 flac__utils_printf(stderr, 1, "%s: ERROR: unsupported number of channels %u for AIFF\n", e->inbasefilename, channels);
731 /* number of sample frames */
732 if(!read_uint32(e->fin, /*big_endian=*/true, &xx, e->inbasefilename))
736 /* bits per sample */
737 if(!read_uint16(e->fin, /*big_endian=*/true, &x, e->inbasefilename))
740 shift = (bps%8)? 8-(bps%8) : 0; /* SSND data is always byte-aligned, left-justified but format_input() will double-check */
744 if(!read_sane_extended(e->fin, &xx, e->inbasefilename))
748 /* check compression type for AIFF-C */
750 if(!read_uint32(e->fin, /*big_endian=*/true, &xx, e->inbasefilename))
752 if(xx == 0x736F7774) /* "sowt" */
753 e->info.is_big_endian = false;
754 else if(xx == 0x4E4F4E45) /* "NONE" */
755 ; /* nothing to do, we already default to big-endian */
757 flac__utils_printf(stderr, 1, "%s: ERROR: can't handle AIFF-C compression type \"%c%c%c%c\"\n", e->inbasefilename, (char)(xx>>24), (char)((xx>>16)&8), (char)((xx>>8)&8), (char)(xx&8));
762 /* set channel mapping */
763 /* FLAC order follows SMPTE and WAVEFORMATEXTENSIBLE but with fewer channels, which are: */
764 /* front left, front right, center, LFE, back left, back right, surround left, surround right */
765 /* specs say the channel ordering is:
767 * ___________________________________________________
771 * quad (ambiguous with 4ch) Fl Fr Bl Br
774 * 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
775 * so we only have unambiguous mappings for 2, 3, and 5 channels
778 options.channel_map_none ||
779 channels == 1 || /* 1 channel: (mono) */
780 channels == 2 || /* 2 channels: left, right */
781 channels == 3 || /* 3 channels: left, right, center */
782 channels == 5 /* 5 channels: front left, front right, center, surround left, surround right */
784 /* keep default channel order */
787 flac__utils_printf(stderr, 1, "%s: ERROR: unsupported number of channels %u for AIFF\n", e->inbasefilename, channels);
791 e->info.bytes_per_wide_sample = channels * (bps / 8);
793 /* skip any extra data in the COMM chunk */
794 if(!fskip_ahead(e->fin, skip)) {
795 flac__utils_printf(stderr, 1, "%s: ERROR during read while skipping over extra COMM data\n", e->inbasefilename);
799 got_comm_chunk = true;
801 else if(!memcmp(chunk_id, "SSND", 4) && !got_ssnd_chunk) { /* sound data chunk */
803 FLAC__uint64 data_bytes;
806 if(!got_comm_chunk) {
807 flac__utils_printf(stderr, 1, "%s: ERROR: got 'SSND' chunk before 'COMM' chunk\n", e->inbasefilename);
811 /* SSND chunk size */
812 if(!read_uint32(e->fin, /*big_endian=*/true, &xx, e->inbasefilename))
815 if(options.ignore_chunk_sizes) {
816 FLAC__ASSERT(!options.sector_align);
818 flac__utils_printf(stderr, 1, "%s: WARNING: 'SSND' chunk has non-zero size, using --ignore-chunk-sizes is probably a bad idea\n", e->inbasefilename, chunk_id);
819 if(e->treat_warnings_as_errors)
822 data_bytes = (FLAC__uint64)0 - (FLAC__uint64)e->info.bytes_per_wide_sample; /* max out data_bytes; we'll use EOF as signal to stop reading */
824 else if(data_bytes <= 8) {
825 flac__utils_printf(stderr, 1, "%s: ERROR: 'SSND' chunk has size <= 8\n", e->inbasefilename);
829 data_bytes -= 8; /* discount the offset and block size fields */
833 if(!read_uint32(e->fin, /*big_endian=*/true, &xx, e->inbasefilename))
836 data_bytes -= offset;
839 if(!read_uint32(e->fin, /*big_endian=*/true, &xx, e->inbasefilename))
841 if(xx && !options.ignore_chunk_sizes)
842 data_bytes -= (xx - (data_bytes % xx));
843 if(options.ignore_chunk_sizes) {
845 flac__utils_printf(stderr, 1, "%s: WARNING: 'SSND' chunk has non-zero blocksize, using --ignore-chunk-sizes is probably a bad idea\n", e->inbasefilename, chunk_id);
846 if(e->treat_warnings_as_errors)
851 /* skip any SSND offset bytes */
852 if(!fskip_ahead(e->fin, offset)) {
853 flac__utils_printf(stderr, 1, "%s: ERROR: skipping offset in SSND chunk\n", e->inbasefilename);
857 e->fmt.iff.data_bytes = data_bytes;
859 got_ssnd_chunk = true;
863 if(!options.format_options.iff.foreign_metadata) {
864 flac__utils_printf(stderr, 1, "%s: WARNING: skipping unknown chunk '%s' (use --keep-foreign-metadata to keep)\n", e->inbasefilename, chunk_id);
865 if(e->treat_warnings_as_errors)
870 if(!read_uint32(e->fin, /*big_endian=*/true, &xx, e->inbasefilename))
873 unsigned long skip = xx + (xx & 1);
875 FLAC__ASSERT(skip <= LONG_MAX);
876 if(!fskip_ahead(e->fin, skip)) {
877 flac__utils_printf(stderr, 1, "%s: ERROR during read while skipping over chunk\n", e->inbasefilename);
884 if(!got_comm_chunk) {
885 flac__utils_printf(stderr, 1, "%s: ERROR: didn't find COMM chunk\n", e->inbasefilename);
888 if(!got_ssnd_chunk && sample_frames) {
889 flac__utils_printf(stderr, 1, "%s: ERROR: didn't find SSND chunk\n", e->inbasefilename);
893 e->info.sample_rate = sample_rate;
894 e->info.channels = channels;
895 e->info.bits_per_sample = bps;
896 e->info.shift = shift;
897 e->info.channel_mask = channel_mask;
902 static FLAC__bool get_sample_info_flac(EncoderSession *e)
905 FLAC__stream_decoder_set_md5_checking(e->fmt.flac.decoder, false) &&
906 FLAC__stream_decoder_set_metadata_respond_all(e->fmt.flac.decoder)
908 flac__utils_printf(stderr, 1, "%s: ERROR: setting up decoder for FLAC input\n", e->inbasefilename);
912 if (e->format == FORMAT_OGGFLAC) {
913 if (FLAC__stream_decoder_init_ogg_stream(e->fmt.flac.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=*/e) != FLAC__STREAM_DECODER_INIT_STATUS_OK) {
914 flac__utils_printf(stderr, 1, "%s: ERROR: initializing decoder for Ogg FLAC input, state = %s\n", e->inbasefilename, FLAC__stream_decoder_get_resolved_state_string(e->fmt.flac.decoder));
918 else if (FLAC__stream_decoder_init_stream(e->fmt.flac.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=*/e) != FLAC__STREAM_DECODER_INIT_STATUS_OK) {
919 flac__utils_printf(stderr, 1, "%s: ERROR: initializing decoder for FLAC input, state = %s\n", e->inbasefilename, FLAC__stream_decoder_get_resolved_state_string(e->fmt.flac.decoder));
923 if (!FLAC__stream_decoder_process_until_end_of_metadata(e->fmt.flac.decoder) || e->fmt.flac.client_data.fatal_error) {
924 if (e->fmt.flac.client_data.fatal_error)
925 flac__utils_printf(stderr, 1, "%s: ERROR: out of memory or too many metadata blocks while reading metadata in FLAC input\n", e->inbasefilename);
927 flac__utils_printf(stderr, 1, "%s: ERROR: reading metadata in FLAC input, state = %s\n", e->inbasefilename, FLAC__stream_decoder_get_resolved_state_string(e->fmt.flac.decoder));
931 if (e->fmt.flac.client_data.num_metadata_blocks == 0) {
932 flac__utils_printf(stderr, 1, "%s: ERROR: reading metadata in FLAC input, got no metadata blocks\n", e->inbasefilename);
935 else if (e->fmt.flac.client_data.metadata_blocks[0]->type != FLAC__METADATA_TYPE_STREAMINFO) {
936 flac__utils_printf(stderr, 1, "%s: ERROR: reading metadata in FLAC input, first metadata block is not STREAMINFO\n", e->inbasefilename);
939 else if (e->fmt.flac.client_data.metadata_blocks[0]->data.stream_info.total_samples == 0) {
940 flac__utils_printf(stderr, 1, "%s: ERROR: FLAC input has STREAMINFO with unknown total samples which is not supported\n", e->inbasefilename);
944 e->info.sample_rate = e->fmt.flac.client_data.metadata_blocks[0]->data.stream_info.sample_rate;
945 e->info.channels = e->fmt.flac.client_data.metadata_blocks[0]->data.stream_info.channels;
946 e->info.bits_per_sample = e->fmt.flac.client_data.metadata_blocks[0]->data.stream_info.bits_per_sample;
948 e->info.bytes_per_wide_sample = 0;
949 e->info.is_unsigned_samples = false; /* not applicable for FLAC input */
950 e->info.is_big_endian = false; /* not applicable for FLAC input */
951 e->info.channel_mask = 0;
959 int flac__encode_file(FILE *infile, off_t infilesize, const char *infilename, const char *outfilename, const FLAC__byte *lookahead, unsigned lookahead_length, encode_options_t options)
961 EncoderSession encoder_session;
962 size_t channel_map[FLAC__MAX_CHANNELS];
963 int info_align_carry = -1, info_align_zero = -1;
965 if(!EncoderSession_construct(&encoder_session, options, infilesize, infile, infilename, outfilename, lookahead, lookahead_length))
968 /* initialize default channel map that preserves channel order */
971 for(i = 0; i < sizeof(channel_map)/sizeof(channel_map[0]); i++)
975 /* read foreign metadata if requested */
976 if(EncoderSession_format_is_iff(&encoder_session) && options.format_options.iff.foreign_metadata) {
979 options.format == FORMAT_WAVE || options.format == FORMAT_RF64?
980 flac__foreign_metadata_read_from_wave(options.format_options.iff.foreign_metadata, infilename, &error) :
981 options.format == FORMAT_WAVE64?
982 flac__foreign_metadata_read_from_wave64(options.format_options.iff.foreign_metadata, infilename, &error) :
983 flac__foreign_metadata_read_from_aiff(options.format_options.iff.foreign_metadata, infilename, &error)
985 flac__utils_printf(stderr, 1, "%s: ERROR reading foreign metadata: %s\n", encoder_session.inbasefilename, error);
986 return EncoderSession_finish_error(&encoder_session);
990 /* initialize encoder session with info about the audio (channels/bps/resolution/endianness/etc) */
991 switch(options.format) {
993 if(!get_sample_info_raw(&encoder_session, options))
994 return EncoderSession_finish_error(&encoder_session);
999 if(!get_sample_info_wave(&encoder_session, options))
1000 return EncoderSession_finish_error(&encoder_session);
1004 if(!get_sample_info_aiff(&encoder_session, options))
1005 return EncoderSession_finish_error(&encoder_session);
1008 case FORMAT_OGGFLAC:
1010 * set up FLAC decoder for the input
1012 if (0 == (encoder_session.fmt.flac.decoder = FLAC__stream_decoder_new())) {
1013 flac__utils_printf(stderr, 1, "%s: ERROR: creating decoder for FLAC input\n", encoder_session.inbasefilename);
1014 return EncoderSession_finish_error(&encoder_session);
1016 if(!get_sample_info_flac(&encoder_session))
1017 return EncoderSession_finish_error(&encoder_session);
1021 /* double protection */
1022 return EncoderSession_finish_error(&encoder_session);
1025 /* some more checks */
1026 if(encoder_session.info.channels == 0 || encoder_session.info.channels > FLAC__MAX_CHANNELS) {
1027 flac__utils_printf(stderr, 1, "%s: ERROR: unsupported number of channels %u\n", encoder_session.inbasefilename, encoder_session.info.channels);
1028 return EncoderSession_finish_error(&encoder_session);
1030 if(!FLAC__format_sample_rate_is_valid(encoder_session.info.sample_rate)) {
1031 flac__utils_printf(stderr, 1, "%s: ERROR: unsupported sample rate %u\n", encoder_session.inbasefilename, encoder_session.info.sample_rate);
1032 return EncoderSession_finish_error(&encoder_session);
1034 if(encoder_session.info.bits_per_sample-encoder_session.info.shift < 4 || encoder_session.info.bits_per_sample-encoder_session.info.shift > 24) {
1035 flac__utils_printf(stderr, 1, "%s: ERROR: unsupported bits-per-sample %u\n", encoder_session.inbasefilename, encoder_session.info.bits_per_sample-encoder_session.info.shift);
1036 return EncoderSession_finish_error(&encoder_session);
1038 if(options.sector_align) {
1039 if(encoder_session.info.channels != 2) {
1040 flac__utils_printf(stderr, 1, "%s: ERROR: file has %u channels, must be 2 for --sector-align\n", encoder_session.inbasefilename, encoder_session.info.channels);
1041 return EncoderSession_finish_error(&encoder_session);
1043 if(encoder_session.info.sample_rate != 44100) {
1044 flac__utils_printf(stderr, 1, "%s: ERROR: file's sample rate is %u, must be 44100 for --sector-align\n", encoder_session.inbasefilename, encoder_session.info.sample_rate);
1045 return EncoderSession_finish_error(&encoder_session);
1047 if(encoder_session.info.bits_per_sample-encoder_session.info.shift != 16) {
1048 flac__utils_printf(stderr, 1, "%s: ERROR: file has %u bits-per-sample, must be 16 for --sector-align\n", encoder_session.inbasefilename, encoder_session.info.bits_per_sample-encoder_session.info.shift);
1049 return EncoderSession_finish_error(&encoder_session);
1054 FLAC__uint64 total_samples_in_input; /* WATCHOUT: may be 0 to mean "unknown" */
1056 FLAC__uint64 until; /* a value of 0 mean end-of-stream (i.e. --until=-0) */
1057 unsigned align_remainder = 0;
1059 switch(options.format) {
1062 total_samples_in_input = 0;
1064 total_samples_in_input = (FLAC__uint64)infilesize / encoder_session.info.bytes_per_wide_sample + *options.align_reservoir_samples;
1071 /* truncation in the division removes any padding byte that was counted in encoder_session.fmt.iff.data_bytes */
1072 total_samples_in_input = encoder_session.fmt.iff.data_bytes / encoder_session.info.bytes_per_wide_sample + *options.align_reservoir_samples;
1075 case FORMAT_OGGFLAC:
1076 total_samples_in_input = encoder_session.fmt.flac.client_data.metadata_blocks[0]->data.stream_info.total_samples + *options.align_reservoir_samples;
1080 /* double protection */
1081 return EncoderSession_finish_error(&encoder_session);
1085 * now that we know the sample rate, canonicalize the
1086 * --skip string to an absolute sample number:
1088 flac__utils_canonicalize_skip_until_specification(&options.skip_specification, encoder_session.info.sample_rate);
1089 FLAC__ASSERT(options.skip_specification.value.samples >= 0);
1090 skip = (FLAC__uint64)options.skip_specification.value.samples;
1091 FLAC__ASSERT(!options.sector_align || (options.format != FORMAT_FLAC && options.format != FORMAT_OGGFLAC && skip == 0));
1092 /* *options.align_reservoir_samples will be 0 unless --sector-align is used */
1093 FLAC__ASSERT(options.sector_align || *options.align_reservoir_samples == 0);
1096 * now that we possibly know the input size, canonicalize the
1097 * --until string to an absolute sample number:
1099 if(!canonicalize_until_specification(&options.until_specification, encoder_session.inbasefilename, encoder_session.info.sample_rate, skip, total_samples_in_input))
1100 return EncoderSession_finish_error(&encoder_session);
1101 until = (FLAC__uint64)options.until_specification.value.samples;
1102 FLAC__ASSERT(!options.sector_align || until == 0);
1104 /* adjust encoding parameters based on skip and until values */
1105 switch(options.format) {
1107 infilesize -= (off_t)skip * encoder_session.info.bytes_per_wide_sample;
1108 encoder_session.total_samples_to_encode = total_samples_in_input - skip;
1115 encoder_session.fmt.iff.data_bytes -= skip * encoder_session.info.bytes_per_wide_sample;
1116 if(options.ignore_chunk_sizes) {
1117 encoder_session.total_samples_to_encode = 0;
1118 flac__utils_printf(stderr, 2, "(No runtime statistics possible; please wait for encoding to finish...)\n");
1119 FLAC__ASSERT(0 == until);
1122 encoder_session.total_samples_to_encode = total_samples_in_input - skip;
1126 case FORMAT_OGGFLAC:
1127 encoder_session.total_samples_to_encode = total_samples_in_input - skip;
1131 /* double protection */
1132 return EncoderSession_finish_error(&encoder_session);
1135 const FLAC__uint64 trim = total_samples_in_input - until;
1136 FLAC__ASSERT(total_samples_in_input > 0);
1137 FLAC__ASSERT(!options.sector_align);
1138 if(options.format == FORMAT_RAW)
1139 infilesize -= (off_t)trim * encoder_session.info.bytes_per_wide_sample;
1140 else if(EncoderSession_format_is_iff(&encoder_session))
1141 encoder_session.fmt.iff.data_bytes -= trim * encoder_session.info.bytes_per_wide_sample;
1142 encoder_session.total_samples_to_encode -= trim;
1144 if(options.sector_align && (options.format != FORMAT_RAW || infilesize >=0)) { /* for RAW, need to know the filesize */
1145 FLAC__ASSERT(skip == 0); /* asserted above too, but lest we forget */
1146 align_remainder = (unsigned)(encoder_session.total_samples_to_encode % 588);
1147 if(options.is_last_file)
1148 encoder_session.total_samples_to_encode += (588-align_remainder); /* will pad with zeroes */
1150 encoder_session.total_samples_to_encode -= align_remainder; /* will stop short and carry over to next file */
1152 switch(options.format) {
1154 encoder_session.unencoded_size = encoder_session.total_samples_to_encode * encoder_session.info.bytes_per_wide_sample;
1157 /* +44 for the size of the WAVE headers; this is just an estimate for the progress indicator and doesn't need to be exact */
1158 encoder_session.unencoded_size = encoder_session.total_samples_to_encode * encoder_session.info.bytes_per_wide_sample + 44;
1161 /* +44 for the size of the WAVE headers; this is just an estimate for the progress indicator and doesn't need to be exact */
1162 encoder_session.unencoded_size = encoder_session.total_samples_to_encode * encoder_session.info.bytes_per_wide_sample + 104;
1165 /* +72 for the size of the RF64 headers; this is just an estimate for the progress indicator and doesn't need to be exact */
1166 encoder_session.unencoded_size = encoder_session.total_samples_to_encode * encoder_session.info.bytes_per_wide_sample + 80;
1170 /* +54 for the size of the AIFF headers; this is just an estimate for the progress indicator and doesn't need to be exact */
1171 encoder_session.unencoded_size = encoder_session.total_samples_to_encode * encoder_session.info.bytes_per_wide_sample + 54;
1174 case FORMAT_OGGFLAC:
1176 /* if we don't know, use 0 as hint to progress indicator (which is the only place this is used): */
1177 encoder_session.unencoded_size = 0;
1178 else if(skip == 0 && until == 0)
1179 encoder_session.unencoded_size = (FLAC__uint64)infilesize;
1180 else if(total_samples_in_input)
1181 encoder_session.unencoded_size = (FLAC__uint64)infilesize * encoder_session.total_samples_to_encode / total_samples_in_input;
1183 encoder_session.unencoded_size = (FLAC__uint64)infilesize;
1187 /* double protection */
1188 return EncoderSession_finish_error(&encoder_session);
1191 if(encoder_session.total_samples_to_encode == 0)
1192 flac__utils_printf(stderr, 2, "(No runtime statistics possible; please wait for encoding to finish...)\n");
1194 if(options.format == FORMAT_FLAC || options.format == FORMAT_OGGFLAC)
1195 encoder_session.fmt.flac.client_data.samples_left_to_process = encoder_session.total_samples_to_encode;
1197 /* init the encoder */
1198 if(!EncoderSession_init_encoder(&encoder_session, options))
1199 return EncoderSession_finish_error(&encoder_session);
1201 /* skip over any samples as requested */
1203 switch(options.format) {
1206 unsigned skip_bytes = encoder_session.info.bytes_per_wide_sample * (unsigned)skip;
1207 if(skip_bytes > lookahead_length) {
1208 skip_bytes -= lookahead_length;
1209 lookahead_length = 0;
1210 if(!fskip_ahead(encoder_session.fin, skip_bytes)) {
1211 flac__utils_printf(stderr, 1, "%s: ERROR during read while skipping samples\n", encoder_session.inbasefilename);
1212 return EncoderSession_finish_error(&encoder_session);
1216 lookahead += skip_bytes;
1217 lookahead_length -= skip_bytes;
1226 if(!fskip_ahead(encoder_session.fin, skip * encoder_session.info.bytes_per_wide_sample)) {
1227 flac__utils_printf(stderr, 1, "%s: ERROR during read while skipping samples\n", encoder_session.inbasefilename);
1228 return EncoderSession_finish_error(&encoder_session);
1232 case FORMAT_OGGFLAC:
1234 * have to wait until the FLAC encoder is set up for writing
1235 * before any seeking in the input FLAC file, because the seek
1236 * itself will usually call the decoder's write callback, and
1237 * our decoder's write callback passes samples to our FLAC
1240 if(!FLAC__stream_decoder_seek_absolute(encoder_session.fmt.flac.decoder, skip)) {
1241 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(encoder_session.fmt.flac.decoder));
1242 return EncoderSession_finish_error(&encoder_session);
1247 /* double protection */
1248 return EncoderSession_finish_error(&encoder_session);
1253 * first do any samples in the reservoir
1255 if(options.sector_align && *options.align_reservoir_samples > 0) {
1256 FLAC__ASSERT(options.format != FORMAT_FLAC && options.format != FORMAT_OGGFLAC); /* check again */
1257 if(!EncoderSession_process(&encoder_session, (const FLAC__int32 * const *)options.align_reservoir, *options.align_reservoir_samples)) {
1258 print_error_with_state(&encoder_session, "ERROR during encoding");
1259 return EncoderSession_finish_error(&encoder_session);
1264 * decrement infilesize or the data_bytes counter if we need to align the file
1266 if(options.sector_align) {
1267 if(options.is_last_file) {
1268 *options.align_reservoir_samples = 0;
1271 *options.align_reservoir_samples = align_remainder;
1272 if(options.format == FORMAT_RAW) {
1273 FLAC__ASSERT(infilesize >= 0);
1274 infilesize -= (off_t)((*options.align_reservoir_samples) * encoder_session.info.bytes_per_wide_sample);
1275 FLAC__ASSERT(infilesize >= 0);
1277 else if(EncoderSession_format_is_iff(&encoder_session))
1278 encoder_session.fmt.iff.data_bytes -= (*options.align_reservoir_samples) * encoder_session.info.bytes_per_wide_sample;
1283 * now do samples from the file
1285 switch(options.format) {
1287 if(infilesize < 0) {
1289 while(!feof(infile)) {
1290 if(lookahead_length > 0) {
1291 FLAC__ASSERT(lookahead_length < CHUNK_OF_SAMPLES * encoder_session.info.bytes_per_wide_sample);
1292 memcpy(ucbuffer_, lookahead, lookahead_length);
1293 bytes_read = fread(ucbuffer_+lookahead_length, sizeof(unsigned char), CHUNK_OF_SAMPLES * encoder_session.info.bytes_per_wide_sample - lookahead_length, infile) + lookahead_length;
1294 if(ferror(infile)) {
1295 flac__utils_printf(stderr, 1, "%s: ERROR during read\n", encoder_session.inbasefilename);
1296 return EncoderSession_finish_error(&encoder_session);
1298 lookahead_length = 0;
1301 bytes_read = fread(ucbuffer_, sizeof(unsigned char), CHUNK_OF_SAMPLES * encoder_session.info.bytes_per_wide_sample, infile);
1303 if(bytes_read == 0) {
1304 if(ferror(infile)) {
1305 flac__utils_printf(stderr, 1, "%s: ERROR during read\n", encoder_session.inbasefilename);
1306 return EncoderSession_finish_error(&encoder_session);
1309 else if(bytes_read % encoder_session.info.bytes_per_wide_sample != 0) {
1310 flac__utils_printf(stderr, 1, "%s: ERROR: got partial sample\n", encoder_session.inbasefilename);
1311 return EncoderSession_finish_error(&encoder_session);
1314 unsigned wide_samples = bytes_read / encoder_session.info.bytes_per_wide_sample;
1315 if(!format_input(input_, wide_samples, encoder_session.info.is_big_endian, encoder_session.info.is_unsigned_samples, encoder_session.info.channels, encoder_session.info.bits_per_sample, encoder_session.info.shift, channel_map))
1316 return EncoderSession_finish_error(&encoder_session);
1318 if(!EncoderSession_process(&encoder_session, (const FLAC__int32 * const *)input_, wide_samples)) {
1319 print_error_with_state(&encoder_session, "ERROR during encoding");
1320 return EncoderSession_finish_error(&encoder_session);
1327 const FLAC__uint64 max_input_bytes = infilesize;
1328 FLAC__uint64 total_input_bytes_read = 0;
1329 while(total_input_bytes_read < max_input_bytes) {
1331 size_t wanted = (CHUNK_OF_SAMPLES * encoder_session.info.bytes_per_wide_sample);
1332 wanted = (size_t) min((FLAC__uint64)wanted, max_input_bytes - total_input_bytes_read);
1334 if(lookahead_length > 0) {
1335 FLAC__ASSERT(lookahead_length <= wanted);
1336 memcpy(ucbuffer_, lookahead, lookahead_length);
1337 wanted -= lookahead_length;
1338 bytes_read = lookahead_length;
1340 bytes_read += fread(ucbuffer_+lookahead_length, sizeof(unsigned char), wanted, infile);
1341 if(ferror(infile)) {
1342 flac__utils_printf(stderr, 1, "%s: ERROR during read\n", encoder_session.inbasefilename);
1343 return EncoderSession_finish_error(&encoder_session);
1346 lookahead_length = 0;
1349 bytes_read = fread(ucbuffer_, sizeof(unsigned char), wanted, infile);
1352 if(bytes_read == 0) {
1353 if(ferror(infile)) {
1354 flac__utils_printf(stderr, 1, "%s: ERROR during read\n", encoder_session.inbasefilename);
1355 return EncoderSession_finish_error(&encoder_session);
1357 else if(feof(infile)) {
1358 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);
1359 if(encoder_session.treat_warnings_as_errors)
1360 return EncoderSession_finish_error(&encoder_session);
1361 total_input_bytes_read = max_input_bytes;
1365 if(bytes_read % encoder_session.info.bytes_per_wide_sample != 0) {
1366 flac__utils_printf(stderr, 1, "%s: ERROR: got partial sample\n", encoder_session.inbasefilename);
1367 return EncoderSession_finish_error(&encoder_session);
1370 unsigned wide_samples = bytes_read / encoder_session.info.bytes_per_wide_sample;
1371 if(!format_input(input_, wide_samples, encoder_session.info.is_big_endian, encoder_session.info.is_unsigned_samples, encoder_session.info.channels, encoder_session.info.bits_per_sample, encoder_session.info.shift, channel_map))
1372 return EncoderSession_finish_error(&encoder_session);
1374 if(!EncoderSession_process(&encoder_session, (const FLAC__int32 * const *)input_, wide_samples)) {
1375 print_error_with_state(&encoder_session, "ERROR during encoding");
1376 return EncoderSession_finish_error(&encoder_session);
1378 total_input_bytes_read += bytes_read;
1389 while(encoder_session.fmt.iff.data_bytes > 0) {
1390 const size_t bytes_to_read = (size_t)min(
1391 encoder_session.fmt.iff.data_bytes,
1392 (FLAC__uint64)CHUNK_OF_SAMPLES * (FLAC__uint64)encoder_session.info.bytes_per_wide_sample
1394 size_t bytes_read = fread(ucbuffer_, sizeof(unsigned char), bytes_to_read, infile);
1395 if(bytes_read == 0) {
1396 if(ferror(infile)) {
1397 flac__utils_printf(stderr, 1, "%s: ERROR during read\n", encoder_session.inbasefilename);
1398 return EncoderSession_finish_error(&encoder_session);
1400 else if(feof(infile)) {
1401 if(options.ignore_chunk_sizes) {
1402 flac__utils_printf(stderr, 1, "%s: INFO: hit EOF with --ignore-chunk-sizes, got %u samples\n", encoder_session.inbasefilename, (unsigned)encoder_session.samples_written);
1405 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);
1406 if(encoder_session.treat_warnings_as_errors)
1407 return EncoderSession_finish_error(&encoder_session);
1409 encoder_session.fmt.iff.data_bytes = 0;
1413 if(bytes_read % encoder_session.info.bytes_per_wide_sample != 0) {
1414 flac__utils_printf(stderr, 1, "%s: ERROR: got partial sample\n", encoder_session.inbasefilename);
1415 return EncoderSession_finish_error(&encoder_session);
1418 unsigned wide_samples = bytes_read / encoder_session.info.bytes_per_wide_sample;
1419 if(!format_input(input_, wide_samples, encoder_session.info.is_big_endian, encoder_session.info.is_unsigned_samples, encoder_session.info.channels, encoder_session.info.bits_per_sample, encoder_session.info.shift, channel_map))
1420 return EncoderSession_finish_error(&encoder_session);
1422 if(!EncoderSession_process(&encoder_session, (const FLAC__int32 * const *)input_, wide_samples)) {
1423 print_error_with_state(&encoder_session, "ERROR during encoding");
1424 return EncoderSession_finish_error(&encoder_session);
1426 encoder_session.fmt.iff.data_bytes -= bytes_read;
1432 case FORMAT_OGGFLAC:
1433 while(!encoder_session.fmt.flac.client_data.fatal_error && encoder_session.fmt.flac.client_data.samples_left_to_process > 0) {
1434 /* We can also hit the end of stream without samples_left_to_process
1435 * going to 0 if there are errors and continue_through_decode_errors
1436 * is on, so we want to break in that case too:
1438 if(encoder_session.continue_through_decode_errors && FLAC__stream_decoder_get_state(encoder_session.fmt.flac.decoder) == FLAC__STREAM_DECODER_END_OF_STREAM)
1440 if(!FLAC__stream_decoder_process_single(encoder_session.fmt.flac.decoder)) {
1441 flac__utils_printf(stderr, 1, "%s: ERROR: while decoding FLAC input, state = %s\n", encoder_session.inbasefilename, FLAC__stream_decoder_get_resolved_state_string(encoder_session.fmt.flac.decoder));
1442 return EncoderSession_finish_error(&encoder_session);
1445 if(encoder_session.fmt.flac.client_data.fatal_error) {
1446 flac__utils_printf(stderr, 1, "%s: ERROR: while decoding FLAC input, state = %s\n", encoder_session.inbasefilename, FLAC__stream_decoder_get_resolved_state_string(encoder_session.fmt.flac.decoder));
1447 return EncoderSession_finish_error(&encoder_session);
1452 /* double protection */
1453 return EncoderSession_finish_error(&encoder_session);
1457 * now read unaligned samples into reservoir or pad with zeroes if necessary
1459 if(options.sector_align) {
1460 if(options.is_last_file) {
1461 unsigned wide_samples = 588 - align_remainder;
1462 if(wide_samples < 588) {
1465 info_align_zero = wide_samples;
1466 for(channel = 0; channel < encoder_session.info.channels; channel++)
1467 memset(input_[channel], 0, sizeof(input_[0][0]) * wide_samples);
1469 if(!EncoderSession_process(&encoder_session, (const FLAC__int32 * const *)input_, wide_samples)) {
1470 print_error_with_state(&encoder_session, "ERROR during encoding");
1471 return EncoderSession_finish_error(&encoder_session);
1476 if(*options.align_reservoir_samples > 0) {
1478 FLAC__ASSERT(CHUNK_OF_SAMPLES >= 588);
1479 bytes_read = fread(ucbuffer_, sizeof(unsigned char), (*options.align_reservoir_samples) * encoder_session.info.bytes_per_wide_sample, infile);
1480 if(bytes_read == 0 && ferror(infile)) {
1481 flac__utils_printf(stderr, 1, "%s: ERROR during read\n", encoder_session.inbasefilename);
1482 return EncoderSession_finish_error(&encoder_session);
1484 else if(bytes_read != (*options.align_reservoir_samples) * encoder_session.info.bytes_per_wide_sample) {
1485 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);
1486 if(encoder_session.treat_warnings_as_errors)
1487 return EncoderSession_finish_error(&encoder_session);
1490 info_align_carry = *options.align_reservoir_samples;
1491 if(!format_input(options.align_reservoir, *options.align_reservoir_samples, encoder_session.info.is_big_endian, encoder_session.info.is_unsigned_samples, encoder_session.info.channels, encoder_session.info.bits_per_sample, encoder_session.info.shift, channel_map))
1492 return EncoderSession_finish_error(&encoder_session);
1499 return EncoderSession_finish_ok(
1503 EncoderSession_format_is_iff(&encoder_session)? options.format_options.iff.foreign_metadata : 0
1507 FLAC__bool EncoderSession_construct(EncoderSession *e, encode_options_t options, off_t infilesize, FILE *infile, const char *infilename, const char *outfilename, const FLAC__byte *lookahead, unsigned lookahead_length)
1510 FLAC__uint32 test = 1;
1513 * initialize globals
1516 is_big_endian_host_ = (*((FLAC__byte*)(&test)))? false : true;
1518 for(i = 0; i < FLAC__MAX_CHANNELS; i++)
1519 input_[i] = &(in_[i][0]);
1523 * initialize instance
1527 e->use_ogg = options.use_ogg;
1529 e->verify = options.verify;
1530 e->treat_warnings_as_errors = options.treat_warnings_as_errors;
1531 e->continue_through_decode_errors = options.continue_through_decode_errors;
1533 e->is_stdout = (0 == strcmp(outfilename, "-"));
1534 e->outputfile_opened = false;
1536 e->inbasefilename = grabbag__file_get_basename(infilename);
1537 e->infilename = infilename;
1538 e->outfilename = outfilename;
1540 e->total_samples_to_encode = 0;
1541 e->unencoded_size = 0;
1542 e->bytes_written = 0;
1543 e->samples_written = 0;
1546 memset(&e->info, 0, sizeof(e->info));
1548 e->format = options.format;
1550 switch(options.format) {
1558 e->fmt.iff.data_bytes = 0;
1561 case FORMAT_OGGFLAC:
1562 e->fmt.flac.decoder = 0;
1563 e->fmt.flac.client_data.filesize = infilesize;
1564 e->fmt.flac.client_data.lookahead = lookahead;
1565 e->fmt.flac.client_data.lookahead_length = lookahead_length;
1566 e->fmt.flac.client_data.num_metadata_blocks = 0;
1567 e->fmt.flac.client_data.samples_left_to_process = 0;
1568 e->fmt.flac.client_data.fatal_error = false;
1572 /* double protection */
1579 e->seek_table_template = 0;
1581 if(0 == (e->seek_table_template = FLAC__metadata_object_new(FLAC__METADATA_TYPE_SEEKTABLE))) {
1582 flac__utils_printf(stderr, 1, "%s: ERROR allocating memory for seek table\n", e->inbasefilename);
1586 e->encoder = FLAC__stream_encoder_new();
1587 if(0 == e->encoder) {
1588 flac__utils_printf(stderr, 1, "%s: ERROR creating the encoder instance\n", e->inbasefilename);
1589 EncoderSession_destroy(e);
1596 void EncoderSession_destroy(EncoderSession *e)
1598 if(e->format == FORMAT_FLAC || e->format == FORMAT_OGGFLAC) {
1600 if(e->fmt.flac.decoder)
1601 FLAC__stream_decoder_delete(e->fmt.flac.decoder);
1602 e->fmt.flac.decoder = 0;
1603 for(i = 0; i < e->fmt.flac.client_data.num_metadata_blocks; i++)
1604 FLAC__metadata_object_delete(e->fmt.flac.client_data.metadata_blocks[i]);
1605 e->fmt.flac.client_data.num_metadata_blocks = 0;
1611 if(0 != e->encoder) {
1612 FLAC__stream_encoder_delete(e->encoder);
1616 if(0 != e->seek_table_template) {
1617 FLAC__metadata_object_delete(e->seek_table_template);
1618 e->seek_table_template = 0;
1622 int EncoderSession_finish_ok(EncoderSession *e, int info_align_carry, int info_align_zero, foreign_metadata_t *foreign_metadata)
1624 FLAC__StreamEncoderState fse_state = FLAC__STREAM_ENCODER_OK;
1626 FLAC__bool verify_error = false;
1629 fse_state = FLAC__stream_encoder_get_state(e->encoder);
1630 ret = FLAC__stream_encoder_finish(e->encoder)? 0 : 1;
1632 fse_state == FLAC__STREAM_ENCODER_VERIFY_MISMATCH_IN_AUDIO_DATA ||
1633 FLAC__stream_encoder_get_state(e->encoder) == FLAC__STREAM_ENCODER_VERIFY_MISMATCH_IN_AUDIO_DATA
1636 /* all errors except verify errors should interrupt the stats */
1637 if(ret && !verify_error)
1638 print_error_with_state(e, "ERROR during encoding");
1639 else if(e->total_samples_to_encode > 0) {
1641 flac__utils_printf(stderr, 2, "\n");
1645 print_verify_error(e);
1649 if(info_align_carry >= 0) {
1650 flac__utils_printf(stderr, 1, "%s: INFO: sector alignment causing %d samples to be carried over\n", e->inbasefilename, info_align_carry);
1652 if(info_align_zero >= 0) {
1653 flac__utils_printf(stderr, 1, "%s: INFO: sector alignment causing %d zero samples to be appended\n", e->inbasefilename, info_align_zero);
1657 /*@@@@@@ should this go here or somewhere else? */
1658 if(ret == 0 && foreign_metadata) {
1660 if(!flac__foreign_metadata_write_to_flac(foreign_metadata, e->infilename, e->outfilename, &error)) {
1661 flac__utils_printf(stderr, 1, "%s: ERROR: updating foreign metadata in FLAC file: %s\n", e->inbasefilename, error);
1666 EncoderSession_destroy(e);
1671 int EncoderSession_finish_error(EncoderSession *e)
1673 FLAC__ASSERT(e->encoder);
1675 if(e->total_samples_to_encode > 0)
1676 flac__utils_printf(stderr, 2, "\n");
1678 if(FLAC__stream_encoder_get_state(e->encoder) == FLAC__STREAM_ENCODER_VERIFY_MISMATCH_IN_AUDIO_DATA)
1679 print_verify_error(e);
1680 else if(e->outputfile_opened)
1681 /* only want to delete the file if we opened it; otherwise it could be an existing file and our overwrite failed */
1682 unlink(e->outfilename);
1684 EncoderSession_destroy(e);
1690 unsigned num_metadata;
1691 FLAC__bool *needs_delete;
1692 FLAC__StreamMetadata **metadata;
1693 FLAC__StreamMetadata *cuesheet; /* always needs to be deleted */
1694 } static_metadata_t;
1696 static void static_metadata_init(static_metadata_t *m)
1698 m->num_metadata = 0;
1699 m->needs_delete = 0;
1704 static void static_metadata_clear(static_metadata_t *m)
1707 for(i = 0; i < m->num_metadata; i++)
1708 if(m->needs_delete[i])
1709 FLAC__metadata_object_delete(m->metadata[i]);
1713 free(m->needs_delete);
1715 FLAC__metadata_object_delete(m->cuesheet);
1716 static_metadata_init(m);
1719 static FLAC__bool static_metadata_append(static_metadata_t *m, FLAC__StreamMetadata *d, FLAC__bool needs_delete)
1722 if(0 == (x = safe_realloc_muladd2_(m->metadata, sizeof(*m->metadata), /*times (*/m->num_metadata, /*+*/1/*)*/)))
1724 m->metadata = (FLAC__StreamMetadata**)x;
1725 if(0 == (x = safe_realloc_muladd2_(m->needs_delete, sizeof(*m->needs_delete), /*times (*/m->num_metadata, /*+*/1/*)*/)))
1727 m->needs_delete = (FLAC__bool*)x;
1728 m->metadata[m->num_metadata] = d;
1729 m->needs_delete[m->num_metadata] = needs_delete;
1734 FLAC__bool EncoderSession_init_encoder(EncoderSession *e, encode_options_t options)
1736 const unsigned channels = e->info.channels;
1737 const unsigned bps = e->info.bits_per_sample - e->info.shift;
1738 const unsigned sample_rate = e->info.sample_rate;
1739 FLACDecoderData *flac_decoder_data = (e->format == FORMAT_FLAC || e->format == FORMAT_OGGFLAC)? &e->fmt.flac.client_data : 0;
1740 FLAC__StreamMetadata padding;
1741 FLAC__StreamMetadata **metadata = 0;
1742 static_metadata_t static_metadata;
1743 unsigned num_metadata = 0, i;
1744 FLAC__StreamEncoderInitStatus init_status;
1745 const FLAC__bool is_cdda = (channels == 1 || channels == 2) && (bps == 16) && (sample_rate == 44100);
1746 char apodizations[2000];
1748 FLAC__ASSERT(sizeof(options.pictures)/sizeof(options.pictures[0]) <= 64);
1750 static_metadata_init(&static_metadata);
1752 e->replay_gain = options.replay_gain;
1754 apodizations[0] = '\0';
1756 if(e->replay_gain) {
1757 if(channels != 1 && channels != 2) {
1758 flac__utils_printf(stderr, 1, "%s: ERROR, number of channels (%u) must be 1 or 2 for --replay-gain\n", e->inbasefilename, channels);
1761 if(!grabbag__replaygain_is_valid_sample_frequency(sample_rate)) {
1762 flac__utils_printf(stderr, 1, "%s: ERROR, invalid sample rate (%u) for --replay-gain\n", e->inbasefilename, sample_rate);
1765 if(options.is_first_file) {
1766 if(!grabbag__replaygain_init(sample_rate)) {
1767 flac__utils_printf(stderr, 1, "%s: ERROR initializing ReplayGain stage\n", e->inbasefilename);
1773 if(!parse_cuesheet(&static_metadata.cuesheet, options.cuesheet_filename, e->inbasefilename, is_cdda, e->total_samples_to_encode, e->treat_warnings_as_errors))
1776 if(!convert_to_seek_table_template(options.requested_seek_points, options.num_requested_seek_points, options.cued_seekpoints? static_metadata.cuesheet : 0, e)) {
1777 flac__utils_printf(stderr, 1, "%s: ERROR allocating memory for seek table\n", e->inbasefilename);
1778 static_metadata_clear(&static_metadata);
1782 /* build metadata */
1783 if(flac_decoder_data) {
1785 * we're encoding from FLAC so we will use the FLAC file's
1786 * metadata as the basis for the encoded file
1790 * first handle pictures: simple append any --pictures
1793 for(i = 0; i < options.num_pictures; i++) {
1794 FLAC__StreamMetadata *pic = FLAC__metadata_object_clone(options.pictures[i]);
1796 flac__utils_printf(stderr, 1, "%s: ERROR allocating memory for PICTURE block\n", e->inbasefilename);
1797 static_metadata_clear(&static_metadata);
1800 flac_decoder_data->metadata_blocks[flac_decoder_data->num_metadata_blocks++] = pic;
1805 * next handle vorbis comment: if any tags were specified
1806 * or there is no existing vorbis comment, we create a
1807 * new vorbis comment (discarding any existing one); else
1808 * we keep the existing one. also need to make sure to
1809 * propagate any channel mask tag.
1811 /* @@@ change to append -T values from options.vorbis_comment if input has VC already? */
1813 FLAC__bool vc_found = false;
1814 for(i = 0, j = 0; i < flac_decoder_data->num_metadata_blocks; i++) {
1815 if(flac_decoder_data->metadata_blocks[i]->type == FLAC__METADATA_TYPE_VORBIS_COMMENT)
1817 if(flac_decoder_data->metadata_blocks[i]->type == FLAC__METADATA_TYPE_VORBIS_COMMENT && options.vorbis_comment->data.vorbis_comment.num_comments > 0) {
1818 (void) flac__utils_get_channel_mask_tag(flac_decoder_data->metadata_blocks[i], &e->info.channel_mask);
1819 flac__utils_printf(stderr, 1, "%s: WARNING, replacing tags from input FLAC file with those given on the command-line\n", e->inbasefilename);
1820 if(e->treat_warnings_as_errors) {
1821 static_metadata_clear(&static_metadata);
1824 FLAC__metadata_object_delete(flac_decoder_data->metadata_blocks[i]);
1825 flac_decoder_data->metadata_blocks[i] = 0;
1828 flac_decoder_data->metadata_blocks[j++] = flac_decoder_data->metadata_blocks[i];
1830 flac_decoder_data->num_metadata_blocks = j;
1831 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])) {
1833 FLAC__StreamMetadata *vc = FLAC__metadata_object_clone(options.vorbis_comment);
1834 if(0 == vc || (e->info.channel_mask && !flac__utils_set_channel_mask_tag(vc, e->info.channel_mask))) {
1835 flac__utils_printf(stderr, 1, "%s: ERROR allocating memory for VORBIS_COMMENT block\n", e->inbasefilename);
1836 static_metadata_clear(&static_metadata);
1839 for(i = flac_decoder_data->num_metadata_blocks; i > 1; i--)
1840 flac_decoder_data->metadata_blocks[i] = flac_decoder_data->metadata_blocks[i-1];
1841 flac_decoder_data->metadata_blocks[1] = vc;
1842 flac_decoder_data->num_metadata_blocks++;
1847 * next handle cuesheet: if --cuesheet was specified, use
1848 * it; else if file has existing CUESHEET and cuesheet's
1849 * lead-out offset is correct, keep it; else no CUESHEET
1852 for(i = 0, j = 0; i < flac_decoder_data->num_metadata_blocks; i++) {
1853 FLAC__bool existing_cuesheet_is_bad = false;
1854 /* check if existing cuesheet matches the input audio */
1855 if(flac_decoder_data->metadata_blocks[i]->type == FLAC__METADATA_TYPE_CUESHEET && 0 == static_metadata.cuesheet) {
1856 const FLAC__StreamMetadata_CueSheet *cs = &flac_decoder_data->metadata_blocks[i]->data.cue_sheet;
1857 if(e->total_samples_to_encode == 0) {
1858 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);
1859 if(e->treat_warnings_as_errors) {
1860 static_metadata_clear(&static_metadata);
1863 existing_cuesheet_is_bad = true;
1865 else if(e->total_samples_to_encode != cs->tracks[cs->num_tracks-1].offset) {
1866 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);
1867 if(e->treat_warnings_as_errors) {
1868 static_metadata_clear(&static_metadata);
1871 existing_cuesheet_is_bad = true;
1874 if(flac_decoder_data->metadata_blocks[i]->type == FLAC__METADATA_TYPE_CUESHEET && (existing_cuesheet_is_bad || 0 != static_metadata.cuesheet)) {
1875 if(0 != static_metadata.cuesheet) {
1876 flac__utils_printf(stderr, 1, "%s: WARNING, replacing cuesheet in input FLAC file with the one given on the command-line\n", e->inbasefilename);
1877 if(e->treat_warnings_as_errors) {
1878 static_metadata_clear(&static_metadata);
1882 FLAC__metadata_object_delete(flac_decoder_data->metadata_blocks[i]);
1883 flac_decoder_data->metadata_blocks[i] = 0;
1886 flac_decoder_data->metadata_blocks[j++] = flac_decoder_data->metadata_blocks[i];
1888 flac_decoder_data->num_metadata_blocks = j;
1889 if(0 != static_metadata.cuesheet && flac_decoder_data->num_metadata_blocks < sizeof(flac_decoder_data->metadata_blocks)/sizeof(flac_decoder_data->metadata_blocks[0])) {
1891 FLAC__StreamMetadata *cs = FLAC__metadata_object_clone(static_metadata.cuesheet);
1893 flac__utils_printf(stderr, 1, "%s: ERROR allocating memory for CUESHEET block\n", e->inbasefilename);
1894 static_metadata_clear(&static_metadata);
1897 for(i = flac_decoder_data->num_metadata_blocks; i > 1; i--)
1898 flac_decoder_data->metadata_blocks[i] = flac_decoder_data->metadata_blocks[i-1];
1899 flac_decoder_data->metadata_blocks[1] = cs;
1900 flac_decoder_data->num_metadata_blocks++;
1905 * next handle seektable: if -S- was specified, no
1906 * SEEKTABLE; else if -S was specified, use it/them;
1907 * else if file has existing SEEKTABLE and input size is
1908 * preserved (no --skip/--until/etc specified), keep it;
1909 * else use default seektable options
1911 * note: meanings of num_requested_seek_points:
1912 * -1 : no -S option given, default to some value
1913 * 0 : -S- given (no seektable)
1914 * >0 : one or more -S options given
1917 FLAC__bool existing_seektable = false;
1918 for(i = 0, j = 0; i < flac_decoder_data->num_metadata_blocks; i++) {
1919 if(flac_decoder_data->metadata_blocks[i]->type == FLAC__METADATA_TYPE_SEEKTABLE)
1920 existing_seektable = true;
1921 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)) {
1922 if(options.num_requested_seek_points > 0) {
1923 flac__utils_printf(stderr, 1, "%s: WARNING, replacing seektable in input FLAC file with the one given on the command-line\n", e->inbasefilename);
1924 if(e->treat_warnings_as_errors) {
1925 static_metadata_clear(&static_metadata);
1929 else if(options.num_requested_seek_points == 0)
1930 ; /* no warning, silently delete existing SEEKTABLE since user specified --no-seektable (-S-) */
1932 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);
1933 if(e->treat_warnings_as_errors) {
1934 static_metadata_clear(&static_metadata);
1938 FLAC__metadata_object_delete(flac_decoder_data->metadata_blocks[i]);
1939 flac_decoder_data->metadata_blocks[i] = 0;
1940 existing_seektable = false;
1943 flac_decoder_data->metadata_blocks[j++] = flac_decoder_data->metadata_blocks[i];
1945 flac_decoder_data->num_metadata_blocks = j;
1946 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])) {
1948 FLAC__StreamMetadata *st = FLAC__metadata_object_clone(e->seek_table_template);
1950 flac__utils_printf(stderr, 1, "%s: ERROR allocating memory for SEEKTABLE block\n", e->inbasefilename);
1951 static_metadata_clear(&static_metadata);
1954 for(i = flac_decoder_data->num_metadata_blocks; i > 1; i--)
1955 flac_decoder_data->metadata_blocks[i] = flac_decoder_data->metadata_blocks[i-1];
1956 flac_decoder_data->metadata_blocks[1] = st;
1957 flac_decoder_data->num_metadata_blocks++;
1962 * finally handle padding: if --no-padding was specified,
1963 * then delete all padding; else if -P was specified,
1964 * use that instead of existing padding (if any); else
1965 * if existing file has padding, move all existing
1966 * padding blocks to one padding block at the end; else
1967 * use default padding.
1971 for(i = 0, j = 0; i < flac_decoder_data->num_metadata_blocks; i++) {
1972 if(flac_decoder_data->metadata_blocks[i]->type == FLAC__METADATA_TYPE_PADDING) {
1975 p += flac_decoder_data->metadata_blocks[i]->length;
1976 FLAC__metadata_object_delete(flac_decoder_data->metadata_blocks[i]);
1977 flac_decoder_data->metadata_blocks[i] = 0;
1980 flac_decoder_data->metadata_blocks[j++] = flac_decoder_data->metadata_blocks[i];
1982 flac_decoder_data->num_metadata_blocks = j;
1983 if(options.padding > 0)
1984 p = options.padding;
1986 p = e->total_samples_to_encode / sample_rate < 20*60? FLAC_ENCODE__DEFAULT_PADDING : FLAC_ENCODE__DEFAULT_PADDING*8;
1987 if(options.padding != 0) {
1988 if(p > 0 && flac_decoder_data->num_metadata_blocks < sizeof(flac_decoder_data->metadata_blocks)/sizeof(flac_decoder_data->metadata_blocks[0])) {
1989 flac_decoder_data->metadata_blocks[flac_decoder_data->num_metadata_blocks] = FLAC__metadata_object_new(FLAC__METADATA_TYPE_PADDING);
1990 if(0 == flac_decoder_data->metadata_blocks[flac_decoder_data->num_metadata_blocks]) {
1991 flac__utils_printf(stderr, 1, "%s: ERROR allocating memory for PADDING block\n", e->inbasefilename);
1992 static_metadata_clear(&static_metadata);
1995 flac_decoder_data->metadata_blocks[flac_decoder_data->num_metadata_blocks]->is_last = false; /* the encoder will set this for us */
1996 flac_decoder_data->metadata_blocks[flac_decoder_data->num_metadata_blocks]->length = p;
1997 flac_decoder_data->num_metadata_blocks++;
2001 metadata = &flac_decoder_data->metadata_blocks[1]; /* don't include STREAMINFO */
2002 num_metadata = flac_decoder_data->num_metadata_blocks - 1;
2006 * we're not encoding from FLAC so we will build the metadata
2009 const foreign_metadata_t *foreign_metadata = EncoderSession_format_is_iff(e)? options.format_options.iff.foreign_metadata : 0;
2011 if(e->seek_table_template->data.seek_table.num_points > 0) {
2012 e->seek_table_template->is_last = false; /* the encoder will set this for us */
2013 static_metadata_append(&static_metadata, e->seek_table_template, /*needs_delete=*/false);
2015 if(0 != static_metadata.cuesheet)
2016 static_metadata_append(&static_metadata, static_metadata.cuesheet, /*needs_delete=*/false);
2017 if(e->info.channel_mask) {
2018 if(!flac__utils_set_channel_mask_tag(options.vorbis_comment, e->info.channel_mask)) {
2019 flac__utils_printf(stderr, 1, "%s: ERROR adding channel mask tag\n", e->inbasefilename);
2020 static_metadata_clear(&static_metadata);
2024 static_metadata_append(&static_metadata, options.vorbis_comment, /*needs_delete=*/false);
2025 for(i = 0; i < options.num_pictures; i++)
2026 static_metadata_append(&static_metadata, options.pictures[i], /*needs_delete=*/false);
2027 if(foreign_metadata) {
2028 for(i = 0; i < foreign_metadata->num_blocks; i++) {
2029 FLAC__StreamMetadata *p = FLAC__metadata_object_new(FLAC__METADATA_TYPE_PADDING);
2031 flac__utils_printf(stderr, 1, "%s: ERROR: out of memory\n", e->inbasefilename);
2032 static_metadata_clear(&static_metadata);
2035 static_metadata_append(&static_metadata, p, /*needs_delete=*/true);
2036 static_metadata.metadata[static_metadata.num_metadata-1]->length = FLAC__STREAM_METADATA_APPLICATION_ID_LEN/8 + foreign_metadata->blocks[i].size;
2039 if(options.padding != 0) {
2040 padding.is_last = false; /* the encoder will set this for us */
2041 padding.type = FLAC__METADATA_TYPE_PADDING;
2042 padding.length = (unsigned)(options.padding>0? options.padding : (e->total_samples_to_encode / sample_rate < 20*60? FLAC_ENCODE__DEFAULT_PADDING : FLAC_ENCODE__DEFAULT_PADDING*8));
2043 static_metadata_append(&static_metadata, &padding, /*needs_delete=*/false);
2045 metadata = static_metadata.metadata;
2046 num_metadata = static_metadata.num_metadata;
2049 /* check for a few things that have not already been checked. the
2050 * FLAC__stream_encoder_init*() will check it but only return
2051 * FLAC__STREAM_ENCODER_INIT_STATUS_INVALID_METADATA so we check some
2052 * up front to give a better error message.
2054 if(!verify_metadata(e, metadata, num_metadata)) {
2055 static_metadata_clear(&static_metadata);
2059 FLAC__stream_encoder_set_verify(e->encoder, options.verify);
2060 FLAC__stream_encoder_set_streamable_subset(e->encoder, !options.lax);
2061 FLAC__stream_encoder_set_channels(e->encoder, channels);
2062 FLAC__stream_encoder_set_bits_per_sample(e->encoder, bps);
2063 FLAC__stream_encoder_set_sample_rate(e->encoder, sample_rate);
2064 for(i = 0; i < options.num_compression_settings; i++) {
2065 switch(options.compression_settings[i].type) {
2067 FLAC__stream_encoder_set_blocksize(e->encoder, options.compression_settings[i].value.t_unsigned);
2069 case CST_COMPRESSION_LEVEL:
2070 FLAC__stream_encoder_set_compression_level(e->encoder, options.compression_settings[i].value.t_unsigned);
2071 apodizations[0] = '\0';
2073 case CST_DO_MID_SIDE:
2074 FLAC__stream_encoder_set_do_mid_side_stereo(e->encoder, options.compression_settings[i].value.t_bool);
2076 case CST_LOOSE_MID_SIDE:
2077 FLAC__stream_encoder_set_loose_mid_side_stereo(e->encoder, options.compression_settings[i].value.t_bool);
2079 case CST_APODIZATION:
2080 if(strlen(apodizations)+strlen(options.compression_settings[i].value.t_string)+2 >= sizeof(apodizations)) {
2081 flac__utils_printf(stderr, 1, "%s: ERROR: too many apodization functions requested\n", e->inbasefilename);
2082 static_metadata_clear(&static_metadata);
2086 strcat(apodizations, options.compression_settings[i].value.t_string);
2087 strcat(apodizations, ";");
2090 case CST_MAX_LPC_ORDER:
2091 FLAC__stream_encoder_set_max_lpc_order(e->encoder, options.compression_settings[i].value.t_unsigned);
2093 case CST_QLP_COEFF_PRECISION:
2094 FLAC__stream_encoder_set_qlp_coeff_precision(e->encoder, options.compression_settings[i].value.t_unsigned);
2096 case CST_DO_QLP_COEFF_PREC_SEARCH:
2097 FLAC__stream_encoder_set_do_qlp_coeff_prec_search(e->encoder, options.compression_settings[i].value.t_bool);
2099 case CST_DO_ESCAPE_CODING:
2100 FLAC__stream_encoder_set_do_escape_coding(e->encoder, options.compression_settings[i].value.t_bool);
2102 case CST_DO_EXHAUSTIVE_MODEL_SEARCH:
2103 FLAC__stream_encoder_set_do_exhaustive_model_search(e->encoder, options.compression_settings[i].value.t_bool);
2105 case CST_MIN_RESIDUAL_PARTITION_ORDER:
2106 FLAC__stream_encoder_set_min_residual_partition_order(e->encoder, options.compression_settings[i].value.t_unsigned);
2108 case CST_MAX_RESIDUAL_PARTITION_ORDER:
2109 FLAC__stream_encoder_set_max_residual_partition_order(e->encoder, options.compression_settings[i].value.t_unsigned);
2111 case CST_RICE_PARAMETER_SEARCH_DIST:
2112 FLAC__stream_encoder_set_rice_parameter_search_dist(e->encoder, options.compression_settings[i].value.t_unsigned);
2117 FLAC__stream_encoder_set_apodization(e->encoder, apodizations);
2118 FLAC__stream_encoder_set_total_samples_estimate(e->encoder, e->total_samples_to_encode);
2119 FLAC__stream_encoder_set_metadata(e->encoder, (num_metadata > 0)? metadata : 0, num_metadata);
2121 FLAC__stream_encoder_disable_constant_subframes(e->encoder, options.debug.disable_constant_subframes);
2122 FLAC__stream_encoder_disable_fixed_subframes(e->encoder, options.debug.disable_fixed_subframes);
2123 FLAC__stream_encoder_disable_verbatim_subframes(e->encoder, options.debug.disable_verbatim_subframes);
2124 if(!options.debug.do_md5) {
2125 flac__utils_printf(stderr, 1, "%s: WARNING, MD5 computation disabled, resulting file will not have MD5 sum\n", e->inbasefilename);
2126 if(e->treat_warnings_as_errors) {
2127 static_metadata_clear(&static_metadata);
2130 FLAC__stream_encoder_set_do_md5(e->encoder, false);
2135 FLAC__stream_encoder_set_ogg_serial_number(e->encoder, options.serial_number);
2137 init_status = FLAC__stream_encoder_init_ogg_file(e->encoder, e->is_stdout? 0 : e->outfilename, encoder_progress_callback, /*client_data=*/e);
2142 init_status = FLAC__stream_encoder_init_file(e->encoder, e->is_stdout? 0 : e->outfilename, encoder_progress_callback, /*client_data=*/e);
2145 if(init_status != FLAC__STREAM_ENCODER_INIT_STATUS_OK) {
2146 print_error_with_init_status(e, "ERROR initializing encoder", init_status);
2147 if(FLAC__stream_encoder_get_state(e->encoder) != FLAC__STREAM_ENCODER_IO_ERROR)
2148 e->outputfile_opened = true;
2149 static_metadata_clear(&static_metadata);
2153 e->outputfile_opened = true;
2156 (FLAC__stream_encoder_get_do_exhaustive_model_search(e->encoder) && FLAC__stream_encoder_get_do_qlp_coeff_prec_search(e->encoder))? 0x07 :
2157 (FLAC__stream_encoder_get_do_exhaustive_model_search(e->encoder) || FLAC__stream_encoder_get_do_qlp_coeff_prec_search(e->encoder))? 0x0f :
2160 static_metadata_clear(&static_metadata);
2165 FLAC__bool EncoderSession_process(EncoderSession *e, const FLAC__int32 * const buffer[], unsigned samples)
2167 if(e->replay_gain) {
2168 if(!grabbag__replaygain_analyze(buffer, e->info.channels==2, e->info.bits_per_sample, samples)) {
2169 flac__utils_printf(stderr, 1, "%s: WARNING, error while calculating ReplayGain\n", e->inbasefilename);
2170 if(e->treat_warnings_as_errors)
2175 return FLAC__stream_encoder_process(e->encoder, buffer, samples);
2178 FLAC__bool EncoderSession_format_is_iff(const EncoderSession *e)
2181 e->format == FORMAT_WAVE ||
2182 e->format == FORMAT_WAVE64 ||
2183 e->format == FORMAT_RF64 ||
2184 e->format == FORMAT_AIFF ||
2185 e->format == FORMAT_AIFF_C;
2188 FLAC__bool convert_to_seek_table_template(const char *requested_seek_points, int num_requested_seek_points, FLAC__StreamMetadata *cuesheet, EncoderSession *e)
2190 const FLAC__bool only_placeholders = e->is_stdout;
2191 FLAC__bool has_real_points;
2193 if(num_requested_seek_points == 0 && 0 == cuesheet)
2196 if(num_requested_seek_points < 0) {
2198 /*@@@@@@ workaround ogg bug: too many seekpoints makes table not fit in one page */
2199 if(e->use_ogg && e->total_samples_to_encode > 0 && e->total_samples_to_encode / e->info.sample_rate / 10 > 230)
2200 requested_seek_points = "230x;";
2203 requested_seek_points = "10s;";
2204 num_requested_seek_points = 1;
2207 if(num_requested_seek_points > 0) {
2208 if(!grabbag__seektable_convert_specification_to_template(requested_seek_points, only_placeholders, e->total_samples_to_encode, e->info.sample_rate, e->seek_table_template, &has_real_points))
2214 const FLAC__StreamMetadata_CueSheet *cs = &cuesheet->data.cue_sheet;
2215 for(i = 0; i < cs->num_tracks; i++) {
2216 const FLAC__StreamMetadata_CueSheet_Track *tr = cs->tracks+i;
2217 for(j = 0; j < tr->num_indices; j++) {
2218 if(!FLAC__metadata_object_seektable_template_append_point(e->seek_table_template, tr->offset + tr->indices[j].offset))
2220 has_real_points = true;
2224 if(!FLAC__metadata_object_seektable_template_sort(e->seek_table_template, /*compact=*/true))
2228 if(has_real_points) {
2230 flac__utils_printf(stderr, 1, "%s: WARNING, cannot write back seekpoints when encoding to stdout\n", e->inbasefilename);
2231 if(e->treat_warnings_as_errors)
2239 FLAC__bool canonicalize_until_specification(utils__SkipUntilSpecification *spec, const char *inbasefilename, unsigned sample_rate, FLAC__uint64 skip, FLAC__uint64 total_samples_in_input)
2241 /* convert from mm:ss.sss to sample number if necessary */
2242 flac__utils_canonicalize_skip_until_specification(spec, sample_rate);
2244 /* special case: if "--until=-0", use the special value '0' to mean "end-of-stream" */
2245 if(spec->is_relative && spec->value.samples == 0) {
2246 spec->is_relative = false;
2250 /* in any other case the total samples in the input must be known */
2251 if(total_samples_in_input == 0) {
2252 flac__utils_printf(stderr, 1, "%s: ERROR, cannot use --until when input length is unknown\n", inbasefilename);
2256 FLAC__ASSERT(spec->value_is_samples);
2258 /* convert relative specifications to absolute */
2259 if(spec->is_relative) {
2260 if(spec->value.samples <= 0)
2261 spec->value.samples += (FLAC__int64)total_samples_in_input;
2263 spec->value.samples += skip;
2264 spec->is_relative = false;
2268 if(spec->value.samples < 0) {
2269 flac__utils_printf(stderr, 1, "%s: ERROR, --until value is before beginning of input\n", inbasefilename);
2272 if((FLAC__uint64)spec->value.samples <= skip) {
2273 flac__utils_printf(stderr, 1, "%s: ERROR, --until value is before --skip point\n", inbasefilename);
2276 if((FLAC__uint64)spec->value.samples > total_samples_in_input) {
2277 flac__utils_printf(stderr, 1, "%s: ERROR, --until value is after end of input\n", inbasefilename);
2284 FLAC__bool verify_metadata(const EncoderSession *e, FLAC__StreamMetadata **metadata, unsigned num_metadata)
2286 FLAC__bool metadata_picture_has_type1 = false;
2287 FLAC__bool metadata_picture_has_type2 = false;
2290 FLAC__ASSERT(0 != metadata);
2291 for(i = 0; i < num_metadata; i++) {
2292 const FLAC__StreamMetadata *m = metadata[i];
2293 if(m->type == FLAC__METADATA_TYPE_SEEKTABLE) {
2294 if(!FLAC__format_seektable_is_legal(&m->data.seek_table)) {
2295 flac__utils_printf(stderr, 1, "%s: ERROR: SEEKTABLE metadata block is invalid\n", e->inbasefilename);
2299 else if(m->type == FLAC__METADATA_TYPE_CUESHEET) {
2300 if(!FLAC__format_cuesheet_is_legal(&m->data.cue_sheet, m->data.cue_sheet.is_cd, /*violation=*/0)) {
2301 flac__utils_printf(stderr, 1, "%s: ERROR: CUESHEET metadata block is invalid\n", e->inbasefilename);
2305 else if(m->type == FLAC__METADATA_TYPE_PICTURE) {
2306 const char *error = 0;
2307 if(!FLAC__format_picture_is_legal(&m->data.picture, &error)) {
2308 flac__utils_printf(stderr, 1, "%s: ERROR: PICTURE metadata block is invalid: %s\n", e->inbasefilename, error);
2311 if(m->data.picture.type == FLAC__STREAM_METADATA_PICTURE_TYPE_FILE_ICON_STANDARD) {
2312 if(metadata_picture_has_type1) {
2313 flac__utils_printf(stderr, 1, "%s: ERROR: there may only be one picture of type 1 (32x32 icon) in the file\n", e->inbasefilename);
2316 metadata_picture_has_type1 = true;
2318 else if(m->data.picture.type == FLAC__STREAM_METADATA_PICTURE_TYPE_FILE_ICON) {
2319 if(metadata_picture_has_type2) {
2320 flac__utils_printf(stderr, 1, "%s: ERROR: there may only be one picture of type 2 (icon) in the file\n", e->inbasefilename);
2323 metadata_picture_has_type2 = true;
2331 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)
2333 unsigned wide_sample, sample, channel, byte;
2334 FLAC__int32 *out[FLAC__MAX_CHANNELS];
2336 if(0 == channel_map) {
2337 for(channel = 0; channel < channels; channel++)
2338 out[channel] = dest[channel];
2341 for(channel = 0; channel < channels; channel++)
2342 out[channel] = dest[channel_map[channel]];
2346 if(is_unsigned_samples) {
2347 for(sample = wide_sample = 0; wide_sample < wide_samples; wide_sample++)
2348 for(channel = 0; channel < channels; channel++, sample++)
2349 out[channel][wide_sample] = (FLAC__int32)ucbuffer_[sample] - 0x80;
2352 for(sample = wide_sample = 0; wide_sample < wide_samples; wide_sample++)
2353 for(channel = 0; channel < channels; channel++, sample++)
2354 out[channel][wide_sample] = (FLAC__int32)scbuffer_[sample];
2357 else if(bps == 16) {
2358 if(is_big_endian != is_big_endian_host_) {
2360 const unsigned bytes = wide_samples * channels * (bps >> 3);
2361 for(byte = 0; byte < bytes; byte += 2) {
2362 tmp = ucbuffer_[byte];
2363 ucbuffer_[byte] = ucbuffer_[byte+1];
2364 ucbuffer_[byte+1] = tmp;
2367 if(is_unsigned_samples) {
2368 for(sample = wide_sample = 0; wide_sample < wide_samples; wide_sample++)
2369 for(channel = 0; channel < channels; channel++, sample++)
2370 out[channel][wide_sample] = (FLAC__int32)usbuffer_[sample] - 0x8000;
2373 for(sample = wide_sample = 0; wide_sample < wide_samples; wide_sample++)
2374 for(channel = 0; channel < channels; channel++, sample++)
2375 out[channel][wide_sample] = (FLAC__int32)ssbuffer_[sample];
2378 else if(bps == 24) {
2379 if(!is_big_endian) {
2381 const unsigned bytes = wide_samples * channels * (bps >> 3);
2382 for(byte = 0; byte < bytes; byte += 3) {
2383 tmp = ucbuffer_[byte];
2384 ucbuffer_[byte] = ucbuffer_[byte+2];
2385 ucbuffer_[byte+2] = tmp;
2388 if(is_unsigned_samples) {
2389 for(byte = sample = wide_sample = 0; wide_sample < wide_samples; wide_sample++)
2390 for(channel = 0; channel < channels; channel++, sample++) {
2391 out[channel][wide_sample] = ucbuffer_[byte++]; out[channel][wide_sample] <<= 8;
2392 out[channel][wide_sample] |= ucbuffer_[byte++]; out[channel][wide_sample] <<= 8;
2393 out[channel][wide_sample] |= ucbuffer_[byte++];
2394 out[channel][wide_sample] -= 0x800000;
2398 for(byte = sample = wide_sample = 0; wide_sample < wide_samples; wide_sample++)
2399 for(channel = 0; channel < channels; channel++, sample++) {
2400 out[channel][wide_sample] = scbuffer_[byte++]; out[channel][wide_sample] <<= 8;
2401 out[channel][wide_sample] |= ucbuffer_[byte++]; out[channel][wide_sample] <<= 8;
2402 out[channel][wide_sample] |= ucbuffer_[byte++];
2410 FLAC__int32 mask = (1<<shift)-1;
2411 for(wide_sample = 0; wide_sample < wide_samples; wide_sample++)
2412 for(channel = 0; channel < channels; channel++) {
2413 if(out[channel][wide_sample] & mask) {
2414 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);
2417 out[channel][wide_sample] >>= shift;
2423 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)
2425 EncoderSession *e = (EncoderSession*)client_data;
2427 (void)encoder, (void)total_frames_estimate;
2429 e->bytes_written = bytes_written;
2430 e->samples_written = samples_written;
2432 if(e->total_samples_to_encode > 0 && !((frames_written-1) & e->stats_mask))
2436 FLAC__StreamDecoderReadStatus flac_decoder_read_callback(const FLAC__StreamDecoder *decoder, FLAC__byte buffer[], size_t *bytes, void *client_data)
2439 EncoderSession *e = (EncoderSession*)client_data;
2440 FLACDecoderData *data = &e->fmt.flac.client_data;
2444 if (data->fatal_error)
2445 return FLAC__STREAM_DECODER_READ_STATUS_ABORT;
2447 /* use up lookahead first */
2448 if (data->lookahead_length) {
2449 n = min(data->lookahead_length, *bytes);
2450 memcpy(buffer, data->lookahead, n);
2452 data->lookahead += n;
2453 data->lookahead_length -= n;
2456 /* get the rest from file */
2458 *bytes = n + fread(buffer, 1, *bytes-n, e->fin);
2460 return FLAC__STREAM_DECODER_READ_STATUS_ABORT;
2461 else if(0 == *bytes)
2462 return FLAC__STREAM_DECODER_READ_STATUS_END_OF_STREAM;
2464 return FLAC__STREAM_DECODER_READ_STATUS_CONTINUE;
2467 return FLAC__STREAM_DECODER_READ_STATUS_CONTINUE;
2470 FLAC__StreamDecoderSeekStatus flac_decoder_seek_callback(const FLAC__StreamDecoder *decoder, FLAC__uint64 absolute_byte_offset, void *client_data)
2472 EncoderSession *e = (EncoderSession*)client_data;
2475 if(fseeko(e->fin, (off_t)absolute_byte_offset, SEEK_SET) < 0)
2476 return FLAC__STREAM_DECODER_SEEK_STATUS_ERROR;
2478 return FLAC__STREAM_DECODER_SEEK_STATUS_OK;
2481 FLAC__StreamDecoderTellStatus flac_decoder_tell_callback(const FLAC__StreamDecoder *decoder, FLAC__uint64 *absolute_byte_offset, void *client_data)
2483 EncoderSession *e = (EncoderSession*)client_data;
2487 if((pos = ftello(e->fin)) < 0)
2488 return FLAC__STREAM_DECODER_TELL_STATUS_ERROR;
2490 *absolute_byte_offset = (FLAC__uint64)pos;
2491 return FLAC__STREAM_DECODER_TELL_STATUS_OK;
2495 FLAC__StreamDecoderLengthStatus flac_decoder_length_callback(const FLAC__StreamDecoder *decoder, FLAC__uint64 *stream_length, void *client_data)
2497 const EncoderSession *e = (EncoderSession*)client_data;
2498 const FLACDecoderData *data = &e->fmt.flac.client_data;
2501 if(data->filesize < 0)
2502 return FLAC__STREAM_DECODER_LENGTH_STATUS_ERROR;
2504 *stream_length = (FLAC__uint64)data->filesize;
2505 return FLAC__STREAM_DECODER_LENGTH_STATUS_OK;
2509 FLAC__bool flac_decoder_eof_callback(const FLAC__StreamDecoder *decoder, void *client_data)
2511 EncoderSession *e = (EncoderSession*)client_data;
2514 return feof(e->fin)? true : false;
2517 FLAC__StreamDecoderWriteStatus flac_decoder_write_callback(const FLAC__StreamDecoder *decoder, const FLAC__Frame *frame, const FLAC__int32 * const buffer[], void *client_data)
2519 EncoderSession *e = (EncoderSession*)client_data;
2520 FLACDecoderData *data = &e->fmt.flac.client_data;
2521 FLAC__uint64 n = min(data->samples_left_to_process, frame->header.blocksize);
2524 if(!EncoderSession_process(e, buffer, (unsigned)n)) {
2525 print_error_with_state(e, "ERROR during encoding");
2526 data->fatal_error = true;
2527 return FLAC__STREAM_DECODER_WRITE_STATUS_ABORT;
2530 data->samples_left_to_process -= n;
2531 return FLAC__STREAM_DECODER_WRITE_STATUS_CONTINUE;
2534 void flac_decoder_metadata_callback(const FLAC__StreamDecoder *decoder, const FLAC__StreamMetadata *metadata, void *client_data)
2536 EncoderSession *e = (EncoderSession*)client_data;
2537 FLACDecoderData *data = &e->fmt.flac.client_data;
2540 if (data->fatal_error)
2544 data->num_metadata_blocks == sizeof(data->metadata_blocks)/sizeof(data->metadata_blocks[0]) ||
2545 0 == (data->metadata_blocks[data->num_metadata_blocks] = FLAC__metadata_object_clone(metadata))
2547 data->fatal_error = true;
2549 data->num_metadata_blocks++;
2552 void flac_decoder_error_callback(const FLAC__StreamDecoder *decoder, FLAC__StreamDecoderErrorStatus status, void *client_data)
2554 EncoderSession *e = (EncoderSession*)client_data;
2555 FLACDecoderData *data = &e->fmt.flac.client_data;
2558 flac__utils_printf(stderr, 1, "%s: ERROR got %s while decoding FLAC input\n", e->inbasefilename, FLAC__StreamDecoderErrorStatusString[status]);
2559 if(!e->continue_through_decode_errors)
2560 data->fatal_error = true;
2563 FLAC__bool parse_cuesheet(FLAC__StreamMetadata **cuesheet, const char *cuesheet_filename, const char *inbasefilename, FLAC__bool is_cdda, FLAC__uint64 lead_out_offset, FLAC__bool treat_warnings_as_errors)
2566 unsigned last_line_read;
2567 const char *error_message;
2569 if(0 == cuesheet_filename)
2572 if(lead_out_offset == 0) {
2573 flac__utils_printf(stderr, 1, "%s: ERROR cannot import cuesheet when the number of input samples to encode is unknown\n", inbasefilename);
2577 if(0 == (f = fopen(cuesheet_filename, "r"))) {
2578 flac__utils_printf(stderr, 1, "%s: ERROR opening cuesheet \"%s\" for reading: %s\n", inbasefilename, cuesheet_filename, strerror(errno));
2582 *cuesheet = grabbag__cuesheet_parse(f, &error_message, &last_line_read, is_cdda, lead_out_offset);
2586 if(0 == *cuesheet) {
2587 flac__utils_printf(stderr, 1, "%s: ERROR parsing cuesheet \"%s\" on line %u: %s\n", inbasefilename, cuesheet_filename, last_line_read, error_message);
2591 if(!FLAC__format_cuesheet_is_legal(&(*cuesheet)->data.cue_sheet, /*check_cd_da_subset=*/false, &error_message)) {
2592 flac__utils_printf(stderr, 1, "%s: ERROR parsing cuesheet \"%s\": %s\n", inbasefilename, cuesheet_filename, error_message);
2596 /* if we're expecting CDDA, warn about non-compliance */
2597 if(is_cdda && !FLAC__format_cuesheet_is_legal(&(*cuesheet)->data.cue_sheet, /*check_cd_da_subset=*/true, &error_message)) {
2598 flac__utils_printf(stderr, 1, "%s: WARNING cuesheet \"%s\" is not audio CD compliant: %s\n", inbasefilename, cuesheet_filename, error_message);
2599 if(treat_warnings_as_errors)
2601 (*cuesheet)->data.cue_sheet.is_cd = false;
2607 void print_stats(const EncoderSession *encoder_session)
2609 const FLAC__uint64 samples_written = min(encoder_session->total_samples_to_encode, encoder_session->samples_written);
2610 const FLAC__uint64 uesize = encoder_session->unencoded_size;
2611 #if defined _MSC_VER || defined __MINGW32__
2612 /* with MSVC you have to spoon feed it the casting */
2613 const double progress = (double)(FLAC__int64)samples_written / (double)(FLAC__int64)encoder_session->total_samples_to_encode;
2614 const double ratio = (double)(FLAC__int64)encoder_session->bytes_written / ((double)(FLAC__int64)(uesize? uesize:1) * min(1.0, progress));
2616 const double progress = (double)samples_written / (double)encoder_session->total_samples_to_encode;
2617 const double ratio = (double)encoder_session->bytes_written / ((double)(uesize? uesize:1) * min(1.0, progress));
2620 FLAC__ASSERT(encoder_session->total_samples_to_encode > 0);
2622 if(samples_written == encoder_session->total_samples_to_encode) {
2623 flac__utils_printf(stderr, 2, "\r%s:%s wrote %u bytes, ratio=",
2624 encoder_session->inbasefilename,
2625 encoder_session->verify? " Verify OK," : "",
2626 (unsigned)encoder_session->bytes_written
2630 flac__utils_printf(stderr, 2, "\r%s: %u%% complete, ratio=", encoder_session->inbasefilename, (unsigned)floor(progress * 100.0 + 0.5));
2633 flac__utils_printf(stderr, 2, "%0.3f", ratio);
2635 flac__utils_printf(stderr, 2, "N/A");
2638 void print_error_with_init_status(const EncoderSession *e, const char *message, FLAC__StreamEncoderInitStatus init_status)
2640 const int ilen = strlen(e->inbasefilename) + 1;
2641 const char *state_string = "";
2643 flac__utils_printf(stderr, 1, "\n%s: %s\n", e->inbasefilename, message);
2645 flac__utils_printf(stderr, 1, "%*s init_status = %s\n", ilen, "", FLAC__StreamEncoderInitStatusString[init_status]);
2647 if(init_status == FLAC__STREAM_ENCODER_INIT_STATUS_ENCODER_ERROR) {
2648 state_string = FLAC__stream_encoder_get_resolved_state_string(e->encoder);
2650 flac__utils_printf(stderr, 1, "%*s state = %s\n", ilen, "", state_string);
2652 /* print out some more info for some errors: */
2653 if(0 == strcmp(state_string, FLAC__StreamEncoderStateString[FLAC__STREAM_ENCODER_CLIENT_ERROR])) {
2654 flac__utils_printf(stderr, 1,
2656 "An error occurred while writing; the most common cause is that the disk is full.\n"
2659 else if(0 == strcmp(state_string, FLAC__StreamEncoderStateString[FLAC__STREAM_ENCODER_IO_ERROR])) {
2660 flac__utils_printf(stderr, 1,
2662 "An error occurred opening the output file; it is likely that the output\n"
2663 "directory does not exist or is not writable, the output file already exists and\n"
2664 "is not writable, or the disk is full.\n"
2668 else if(init_status == FLAC__STREAM_ENCODER_INIT_STATUS_NOT_STREAMABLE) {
2669 flac__utils_printf(stderr, 1,
2671 "The encoding parameters specified do not conform to the FLAC Subset and may not\n"
2672 "be streamable or playable in hardware devices. If you really understand the\n"
2673 "consequences, you can add --lax to the command-line options to encode with\n"
2674 "these parameters anyway. See http://flac.sourceforge.net/format.html#subset\n"
2679 void print_error_with_state(const EncoderSession *e, const char *message)
2681 const int ilen = strlen(e->inbasefilename) + 1;
2682 const char *state_string;
2684 flac__utils_printf(stderr, 1, "\n%s: %s\n", e->inbasefilename, message);
2686 state_string = FLAC__stream_encoder_get_resolved_state_string(e->encoder);
2688 flac__utils_printf(stderr, 1, "%*s state = %s\n", ilen, "", state_string);
2690 /* print out some more info for some errors: */
2691 if(0 == strcmp(state_string, FLAC__StreamEncoderStateString[FLAC__STREAM_ENCODER_CLIENT_ERROR])) {
2692 flac__utils_printf(stderr, 1,
2694 "An error occurred while writing; the most common cause is that the disk is full.\n"
2699 void print_verify_error(EncoderSession *e)
2701 FLAC__uint64 absolute_sample;
2702 unsigned frame_number;
2705 FLAC__int32 expected;
2708 FLAC__stream_encoder_get_verify_decoder_error_stats(e->encoder, &absolute_sample, &frame_number, &channel, &sample, &expected, &got);
2710 flac__utils_printf(stderr, 1, "%s: ERROR: mismatch in decoded data, verify FAILED!\n", e->inbasefilename);
2711 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);
2712 flac__utils_printf(stderr, 1, " In all known cases, verify errors are caused by hardware problems,\n");
2713 flac__utils_printf(stderr, 1, " usually overclocking or bad RAM. Delete %s\n", e->outfilename);
2714 flac__utils_printf(stderr, 1, " and repeat the flac command exactly as before. If it does not give a\n");
2715 flac__utils_printf(stderr, 1, " verify error in the exact same place each time you try it, then there is\n");
2716 flac__utils_printf(stderr, 1, " a problem with your hardware; please see the FAQ:\n");
2717 flac__utils_printf(stderr, 1, " http://flac.sourceforge.net/faq.html#tools__hardware_prob\n");
2718 flac__utils_printf(stderr, 1, " If it does fail in the exact same place every time, keep\n");
2719 flac__utils_printf(stderr, 1, " %s and submit a bug report to:\n", e->outfilename);
2720 flac__utils_printf(stderr, 1, " https://sourceforge.net/bugs/?func=addbug&group_id=13478\n");
2721 flac__utils_printf(stderr, 1, " Make sure to upload the FLAC file and use the \"Monitor\" feature to\n");
2722 flac__utils_printf(stderr, 1, " monitor the bug status.\n");
2723 flac__utils_printf(stderr, 1, "Verify FAILED! Do not trust %s\n", e->outfilename);
2726 FLAC__bool read_bytes(FILE *f, FLAC__byte *buf, size_t n, FLAC__bool eof_ok, const char *fn)
2728 size_t bytes_read = fread(buf, 1, n, f);
2730 if(bytes_read == 0) {
2732 flac__utils_printf(stderr, 1, "%s: ERROR: unexpected EOF\n", fn);
2738 if(bytes_read < n) {
2739 flac__utils_printf(stderr, 1, "%s: ERROR: unexpected EOF\n", fn);
2745 FLAC__bool read_uint16(FILE *f, FLAC__bool big_endian, FLAC__uint16 *val, const char *fn)
2747 if(!read_bytes(f, (FLAC__byte*)val, 2, /*eof_ok=*/false, fn))
2749 if(is_big_endian_host_ != big_endian) {
2750 FLAC__byte tmp, *b = (FLAC__byte*)val;
2751 tmp = b[1]; b[1] = b[0]; b[0] = tmp;
2756 FLAC__bool read_uint32(FILE *f, FLAC__bool big_endian, FLAC__uint32 *val, const char *fn)
2758 if(!read_bytes(f, (FLAC__byte*)val, 4, /*eof_ok=*/false, fn))
2760 if(is_big_endian_host_ != big_endian) {
2761 FLAC__byte tmp, *b = (FLAC__byte*)val;
2762 tmp = b[3]; b[3] = b[0]; b[0] = tmp;
2763 tmp = b[2]; b[2] = b[1]; b[1] = tmp;
2768 FLAC__bool read_uint64(FILE *f, FLAC__bool big_endian, FLAC__uint64 *val, const char *fn)
2770 if(!read_bytes(f, (FLAC__byte*)val, 8, /*eof_ok=*/false, fn))
2772 if(is_big_endian_host_ != big_endian) {
2773 FLAC__byte tmp, *b = (FLAC__byte*)val;
2774 tmp = b[7]; b[7] = b[0]; b[0] = tmp;
2775 tmp = b[6]; b[6] = b[1]; b[1] = tmp;
2776 tmp = b[5]; b[5] = b[2]; b[2] = tmp;
2777 tmp = b[4]; b[4] = b[3]; b[3] = tmp;
2782 FLAC__bool read_sane_extended(FILE *f, FLAC__uint32 *val, const char *fn)
2783 /* Read an IEEE 754 80-bit (aka SANE) extended floating point value from 'f',
2784 * convert it into an integral value and store in 'val'. Return false if only
2785 * between 1 and 9 bytes remain in 'f', if 0 bytes remain in 'f', or if the
2786 * value is negative, between zero and one, or too large to be represented by
2787 * 'val'; return true otherwise.
2796 if(!read_bytes(f, buf, sizeof(buf), /*eof_ok=*/false, fn))
2798 e = ((FLAC__uint16)(buf[0])<<8 | (FLAC__uint16)(buf[1]))-0x3FFF;
2800 if((buf[0]>>7)==1U || e<0 || e>63) {
2801 flac__utils_printf(stderr, 1, "%s: ERROR: invalid floating-point value\n", fn);
2805 for(i = 0; i < 8; ++i)
2806 p |= (FLAC__uint64)(buf[i+2])<<(56U-i*8);
2807 *val = (FLAC__uint32)((p>>shift)+(p>>(shift-1) & 0x1));
2812 FLAC__bool fskip_ahead(FILE *f, FLAC__uint64 offset)
2814 static unsigned char dump[8192];
2818 /* MS' stdio impl can't even seek forward on stdin, have to use pure non-fseek() version: */
2820 const long need = (long)min(offset, sizeof(dump));
2821 if((long)fread(dump, 1, need, f) < need)
2830 long need = (long)min(offset, LONG_MAX);
2831 if(fseeko(f, need, SEEK_CUR) < 0) {
2832 need = (long)min(offset, sizeof(dump));
2833 if((long)fread(dump, 1, need, f) < need)
2842 unsigned count_channel_mask_bits(FLAC__uint32 mask)
2854 FLAC__uint32 limit_channel_mask(FLAC__uint32 mask, unsigned channels)
2856 FLAC__uint32 x = 0x80000000;
2857 unsigned count = count_channel_mask_bits(mask);
2858 while(x && count > channels) {
2865 FLAC__ASSERT(count_channel_mask_bits(mask) == channels);