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;
804 unsigned offset = 0, block_size = 0;
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))
842 flac__utils_printf(stderr, 1, "%s: ERROR: block size is %u; must be 0\n", e->inbasefilename, (unsigned)xx);
847 /* skip any SSND offset bytes */
848 if(!fskip_ahead(e->fin, offset)) {
849 flac__utils_printf(stderr, 1, "%s: ERROR: skipping offset in SSND chunk\n", e->inbasefilename);
852 if(data_bytes != (sample_frames * e->info.bytes_per_wide_sample)) {
853 flac__utils_printf(stderr, 1, "%s: ERROR: SSND chunk size inconsistent with sample frame count\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 total_samples_in_input = encoder_session.fmt.iff.data_bytes / encoder_session.info.bytes_per_wide_sample + *options.align_reservoir_samples;
1074 case FORMAT_OGGFLAC:
1075 total_samples_in_input = encoder_session.fmt.flac.client_data.metadata_blocks[0]->data.stream_info.total_samples + *options.align_reservoir_samples;
1079 /* double protection */
1080 return EncoderSession_finish_error(&encoder_session);
1084 * now that we know the sample rate, canonicalize the
1085 * --skip string to an absolute sample number:
1087 flac__utils_canonicalize_skip_until_specification(&options.skip_specification, encoder_session.info.sample_rate);
1088 FLAC__ASSERT(options.skip_specification.value.samples >= 0);
1089 skip = (FLAC__uint64)options.skip_specification.value.samples;
1090 FLAC__ASSERT(!options.sector_align || (options.format != FORMAT_FLAC && options.format != FORMAT_OGGFLAC && skip == 0));
1091 /* *options.align_reservoir_samples will be 0 unless --sector-align is used */
1092 FLAC__ASSERT(options.sector_align || *options.align_reservoir_samples == 0);
1095 * now that we possibly know the input size, canonicalize the
1096 * --until string to an absolute sample number:
1098 if(!canonicalize_until_specification(&options.until_specification, encoder_session.inbasefilename, encoder_session.info.sample_rate, skip, total_samples_in_input))
1099 return EncoderSession_finish_error(&encoder_session);
1100 until = (FLAC__uint64)options.until_specification.value.samples;
1101 FLAC__ASSERT(!options.sector_align || until == 0);
1103 /* adjust encoding parameters based on skip and until values */
1104 switch(options.format) {
1106 infilesize -= (off_t)skip * encoder_session.info.bytes_per_wide_sample;
1107 encoder_session.total_samples_to_encode = total_samples_in_input - skip;
1114 encoder_session.fmt.iff.data_bytes -= skip * encoder_session.info.bytes_per_wide_sample;
1115 if(options.ignore_chunk_sizes) {
1116 encoder_session.total_samples_to_encode = 0;
1117 flac__utils_printf(stderr, 2, "(No runtime statistics possible; please wait for encoding to finish...)\n");
1118 FLAC__ASSERT(0 == until);
1121 encoder_session.total_samples_to_encode = total_samples_in_input - skip;
1125 case FORMAT_OGGFLAC:
1126 encoder_session.total_samples_to_encode = total_samples_in_input - skip;
1130 /* double protection */
1131 return EncoderSession_finish_error(&encoder_session);
1134 const FLAC__uint64 trim = total_samples_in_input - until;
1135 FLAC__ASSERT(total_samples_in_input > 0);
1136 FLAC__ASSERT(!options.sector_align);
1137 if(options.format == FORMAT_RAW)
1138 infilesize -= (off_t)trim * encoder_session.info.bytes_per_wide_sample;
1139 else if(EncoderSession_format_is_iff(&encoder_session))
1140 encoder_session.fmt.iff.data_bytes -= trim * encoder_session.info.bytes_per_wide_sample;
1141 encoder_session.total_samples_to_encode -= trim;
1143 if(options.sector_align && (options.format != FORMAT_RAW || infilesize >=0)) { /* for RAW, need to know the filesize */
1144 FLAC__ASSERT(skip == 0); /* asserted above too, but lest we forget */
1145 align_remainder = (unsigned)(encoder_session.total_samples_to_encode % 588);
1146 if(options.is_last_file)
1147 encoder_session.total_samples_to_encode += (588-align_remainder); /* will pad with zeroes */
1149 encoder_session.total_samples_to_encode -= align_remainder; /* will stop short and carry over to next file */
1151 switch(options.format) {
1153 encoder_session.unencoded_size = encoder_session.total_samples_to_encode * encoder_session.info.bytes_per_wide_sample;
1156 /* +44 for the size of the WAVE headers; this is just an estimate for the progress indicator and doesn't need to be exact */
1157 encoder_session.unencoded_size = encoder_session.total_samples_to_encode * encoder_session.info.bytes_per_wide_sample + 44;
1160 /* +44 for the size of the WAVE headers; this is just an estimate for the progress indicator and doesn't need to be exact */
1161 encoder_session.unencoded_size = encoder_session.total_samples_to_encode * encoder_session.info.bytes_per_wide_sample + 104;
1164 /* +72 for the size of the RF64 headers; this is just an estimate for the progress indicator and doesn't need to be exact */
1165 encoder_session.unencoded_size = encoder_session.total_samples_to_encode * encoder_session.info.bytes_per_wide_sample + 80;
1169 /* +54 for the size of the AIFF headers; this is just an estimate for the progress indicator and doesn't need to be exact */
1170 encoder_session.unencoded_size = encoder_session.total_samples_to_encode * encoder_session.info.bytes_per_wide_sample + 54;
1173 case FORMAT_OGGFLAC:
1175 /* if we don't know, use 0 as hint to progress indicator (which is the only place this is used): */
1176 encoder_session.unencoded_size = 0;
1177 else if(skip == 0 && until == 0)
1178 encoder_session.unencoded_size = (FLAC__uint64)infilesize;
1179 else if(total_samples_in_input)
1180 encoder_session.unencoded_size = (FLAC__uint64)infilesize * encoder_session.total_samples_to_encode / total_samples_in_input;
1182 encoder_session.unencoded_size = (FLAC__uint64)infilesize;
1186 /* double protection */
1187 return EncoderSession_finish_error(&encoder_session);
1190 if(encoder_session.total_samples_to_encode == 0)
1191 flac__utils_printf(stderr, 2, "(No runtime statistics possible; please wait for encoding to finish...)\n");
1193 if(options.format == FORMAT_FLAC || options.format == FORMAT_OGGFLAC)
1194 encoder_session.fmt.flac.client_data.samples_left_to_process = encoder_session.total_samples_to_encode;
1196 /* init the encoder */
1197 if(!EncoderSession_init_encoder(&encoder_session, options))
1198 return EncoderSession_finish_error(&encoder_session);
1200 /* skip over any samples as requested */
1202 switch(options.format) {
1205 unsigned skip_bytes = encoder_session.info.bytes_per_wide_sample * (unsigned)skip;
1206 if(skip_bytes > lookahead_length) {
1207 skip_bytes -= lookahead_length;
1208 lookahead_length = 0;
1209 if(!fskip_ahead(encoder_session.fin, skip_bytes)) {
1210 flac__utils_printf(stderr, 1, "%s: ERROR during read while skipping samples\n", encoder_session.inbasefilename);
1211 return EncoderSession_finish_error(&encoder_session);
1215 lookahead += skip_bytes;
1216 lookahead_length -= skip_bytes;
1225 if(!fskip_ahead(encoder_session.fin, skip * encoder_session.info.bytes_per_wide_sample)) {
1226 flac__utils_printf(stderr, 1, "%s: ERROR during read while skipping samples\n", encoder_session.inbasefilename);
1227 return EncoderSession_finish_error(&encoder_session);
1231 case FORMAT_OGGFLAC:
1233 * have to wait until the FLAC encoder is set up for writing
1234 * before any seeking in the input FLAC file, because the seek
1235 * itself will usually call the decoder's write callback, and
1236 * our decoder's write callback passes samples to our FLAC
1239 if(!FLAC__stream_decoder_seek_absolute(encoder_session.fmt.flac.decoder, skip)) {
1240 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));
1241 return EncoderSession_finish_error(&encoder_session);
1246 /* double protection */
1247 return EncoderSession_finish_error(&encoder_session);
1252 * first do any samples in the reservoir
1254 if(options.sector_align && *options.align_reservoir_samples > 0) {
1255 FLAC__ASSERT(options.format != FORMAT_FLAC && options.format != FORMAT_OGGFLAC); /* check again */
1256 if(!EncoderSession_process(&encoder_session, (const FLAC__int32 * const *)options.align_reservoir, *options.align_reservoir_samples)) {
1257 print_error_with_state(&encoder_session, "ERROR during encoding");
1258 return EncoderSession_finish_error(&encoder_session);
1263 * decrement infilesize or the data_bytes counter if we need to align the file
1265 if(options.sector_align) {
1266 if(options.is_last_file) {
1267 *options.align_reservoir_samples = 0;
1270 *options.align_reservoir_samples = align_remainder;
1271 if(options.format == FORMAT_RAW) {
1272 FLAC__ASSERT(infilesize >= 0);
1273 infilesize -= (off_t)((*options.align_reservoir_samples) * encoder_session.info.bytes_per_wide_sample);
1274 FLAC__ASSERT(infilesize >= 0);
1276 else if(EncoderSession_format_is_iff(&encoder_session))
1277 encoder_session.fmt.iff.data_bytes -= (*options.align_reservoir_samples) * encoder_session.info.bytes_per_wide_sample;
1282 * now do samples from the file
1284 switch(options.format) {
1286 if(infilesize < 0) {
1288 while(!feof(infile)) {
1289 if(lookahead_length > 0) {
1290 FLAC__ASSERT(lookahead_length < CHUNK_OF_SAMPLES * encoder_session.info.bytes_per_wide_sample);
1291 memcpy(ucbuffer_, lookahead, lookahead_length);
1292 bytes_read = fread(ucbuffer_+lookahead_length, sizeof(unsigned char), CHUNK_OF_SAMPLES * encoder_session.info.bytes_per_wide_sample - lookahead_length, infile) + lookahead_length;
1293 if(ferror(infile)) {
1294 flac__utils_printf(stderr, 1, "%s: ERROR during read\n", encoder_session.inbasefilename);
1295 return EncoderSession_finish_error(&encoder_session);
1297 lookahead_length = 0;
1300 bytes_read = fread(ucbuffer_, sizeof(unsigned char), CHUNK_OF_SAMPLES * encoder_session.info.bytes_per_wide_sample, infile);
1302 if(bytes_read == 0) {
1303 if(ferror(infile)) {
1304 flac__utils_printf(stderr, 1, "%s: ERROR during read\n", encoder_session.inbasefilename);
1305 return EncoderSession_finish_error(&encoder_session);
1308 else if(bytes_read % encoder_session.info.bytes_per_wide_sample != 0) {
1309 flac__utils_printf(stderr, 1, "%s: ERROR: got partial sample\n", encoder_session.inbasefilename);
1310 return EncoderSession_finish_error(&encoder_session);
1313 unsigned wide_samples = bytes_read / encoder_session.info.bytes_per_wide_sample;
1314 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))
1315 return EncoderSession_finish_error(&encoder_session);
1317 if(!EncoderSession_process(&encoder_session, (const FLAC__int32 * const *)input_, wide_samples)) {
1318 print_error_with_state(&encoder_session, "ERROR during encoding");
1319 return EncoderSession_finish_error(&encoder_session);
1326 const FLAC__uint64 max_input_bytes = infilesize;
1327 FLAC__uint64 total_input_bytes_read = 0;
1328 while(total_input_bytes_read < max_input_bytes) {
1330 size_t wanted = (CHUNK_OF_SAMPLES * encoder_session.info.bytes_per_wide_sample);
1331 wanted = (size_t) min((FLAC__uint64)wanted, max_input_bytes - total_input_bytes_read);
1333 if(lookahead_length > 0) {
1334 FLAC__ASSERT(lookahead_length <= wanted);
1335 memcpy(ucbuffer_, lookahead, lookahead_length);
1336 wanted -= lookahead_length;
1337 bytes_read = lookahead_length;
1339 bytes_read += fread(ucbuffer_+lookahead_length, sizeof(unsigned char), wanted, infile);
1340 if(ferror(infile)) {
1341 flac__utils_printf(stderr, 1, "%s: ERROR during read\n", encoder_session.inbasefilename);
1342 return EncoderSession_finish_error(&encoder_session);
1345 lookahead_length = 0;
1348 bytes_read = fread(ucbuffer_, sizeof(unsigned char), wanted, infile);
1351 if(bytes_read == 0) {
1352 if(ferror(infile)) {
1353 flac__utils_printf(stderr, 1, "%s: ERROR during read\n", encoder_session.inbasefilename);
1354 return EncoderSession_finish_error(&encoder_session);
1356 else if(feof(infile)) {
1357 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);
1358 if(encoder_session.treat_warnings_as_errors)
1359 return EncoderSession_finish_error(&encoder_session);
1360 total_input_bytes_read = max_input_bytes;
1364 if(bytes_read % encoder_session.info.bytes_per_wide_sample != 0) {
1365 flac__utils_printf(stderr, 1, "%s: ERROR: got partial sample\n", encoder_session.inbasefilename);
1366 return EncoderSession_finish_error(&encoder_session);
1369 unsigned wide_samples = bytes_read / encoder_session.info.bytes_per_wide_sample;
1370 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))
1371 return EncoderSession_finish_error(&encoder_session);
1373 if(!EncoderSession_process(&encoder_session, (const FLAC__int32 * const *)input_, wide_samples)) {
1374 print_error_with_state(&encoder_session, "ERROR during encoding");
1375 return EncoderSession_finish_error(&encoder_session);
1377 total_input_bytes_read += bytes_read;
1388 while(encoder_session.fmt.iff.data_bytes > 0) {
1389 const size_t bytes_to_read = (size_t)min(
1390 encoder_session.fmt.iff.data_bytes,
1391 (FLAC__uint64)CHUNK_OF_SAMPLES * (FLAC__uint64)encoder_session.info.bytes_per_wide_sample
1393 size_t bytes_read = fread(ucbuffer_, sizeof(unsigned char), bytes_to_read, infile);
1394 if(bytes_read == 0) {
1395 if(ferror(infile)) {
1396 flac__utils_printf(stderr, 1, "%s: ERROR during read\n", encoder_session.inbasefilename);
1397 return EncoderSession_finish_error(&encoder_session);
1399 else if(feof(infile)) {
1400 if(options.ignore_chunk_sizes) {
1401 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);
1404 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);
1405 if(encoder_session.treat_warnings_as_errors)
1406 return EncoderSession_finish_error(&encoder_session);
1408 encoder_session.fmt.iff.data_bytes = 0;
1412 if(bytes_read % encoder_session.info.bytes_per_wide_sample != 0) {
1413 flac__utils_printf(stderr, 1, "%s: ERROR: got partial sample\n", encoder_session.inbasefilename);
1414 return EncoderSession_finish_error(&encoder_session);
1417 unsigned wide_samples = bytes_read / encoder_session.info.bytes_per_wide_sample;
1418 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))
1419 return EncoderSession_finish_error(&encoder_session);
1421 if(!EncoderSession_process(&encoder_session, (const FLAC__int32 * const *)input_, wide_samples)) {
1422 print_error_with_state(&encoder_session, "ERROR during encoding");
1423 return EncoderSession_finish_error(&encoder_session);
1425 encoder_session.fmt.iff.data_bytes -= bytes_read;
1431 case FORMAT_OGGFLAC:
1432 while(!encoder_session.fmt.flac.client_data.fatal_error && encoder_session.fmt.flac.client_data.samples_left_to_process > 0) {
1433 /* We can also hit the end of stream without samples_left_to_process
1434 * going to 0 if there are errors and continue_through_decode_errors
1435 * is on, so we want to break in that case too:
1437 if(encoder_session.continue_through_decode_errors && FLAC__stream_decoder_get_state(encoder_session.fmt.flac.decoder) == FLAC__STREAM_DECODER_END_OF_STREAM)
1439 if(!FLAC__stream_decoder_process_single(encoder_session.fmt.flac.decoder)) {
1440 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));
1441 return EncoderSession_finish_error(&encoder_session);
1444 if(encoder_session.fmt.flac.client_data.fatal_error) {
1445 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));
1446 return EncoderSession_finish_error(&encoder_session);
1451 /* double protection */
1452 return EncoderSession_finish_error(&encoder_session);
1456 * now read unaligned samples into reservoir or pad with zeroes if necessary
1458 if(options.sector_align) {
1459 if(options.is_last_file) {
1460 unsigned wide_samples = 588 - align_remainder;
1461 if(wide_samples < 588) {
1464 info_align_zero = wide_samples;
1465 for(channel = 0; channel < encoder_session.info.channels; channel++)
1466 memset(input_[channel], 0, sizeof(input_[0][0]) * wide_samples);
1468 if(!EncoderSession_process(&encoder_session, (const FLAC__int32 * const *)input_, wide_samples)) {
1469 print_error_with_state(&encoder_session, "ERROR during encoding");
1470 return EncoderSession_finish_error(&encoder_session);
1475 if(*options.align_reservoir_samples > 0) {
1477 FLAC__ASSERT(CHUNK_OF_SAMPLES >= 588);
1478 bytes_read = fread(ucbuffer_, sizeof(unsigned char), (*options.align_reservoir_samples) * encoder_session.info.bytes_per_wide_sample, infile);
1479 if(bytes_read == 0 && ferror(infile)) {
1480 flac__utils_printf(stderr, 1, "%s: ERROR during read\n", encoder_session.inbasefilename);
1481 return EncoderSession_finish_error(&encoder_session);
1483 else if(bytes_read != (*options.align_reservoir_samples) * encoder_session.info.bytes_per_wide_sample) {
1484 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);
1485 if(encoder_session.treat_warnings_as_errors)
1486 return EncoderSession_finish_error(&encoder_session);
1489 info_align_carry = *options.align_reservoir_samples;
1490 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))
1491 return EncoderSession_finish_error(&encoder_session);
1498 return EncoderSession_finish_ok(
1502 EncoderSession_format_is_iff(&encoder_session)? options.format_options.iff.foreign_metadata : 0
1506 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)
1509 FLAC__uint32 test = 1;
1512 * initialize globals
1515 is_big_endian_host_ = (*((FLAC__byte*)(&test)))? false : true;
1517 for(i = 0; i < FLAC__MAX_CHANNELS; i++)
1518 input_[i] = &(in_[i][0]);
1522 * initialize instance
1526 e->use_ogg = options.use_ogg;
1528 e->verify = options.verify;
1529 e->treat_warnings_as_errors = options.treat_warnings_as_errors;
1530 e->continue_through_decode_errors = options.continue_through_decode_errors;
1532 e->is_stdout = (0 == strcmp(outfilename, "-"));
1533 e->outputfile_opened = false;
1535 e->inbasefilename = grabbag__file_get_basename(infilename);
1536 e->infilename = infilename;
1537 e->outfilename = outfilename;
1539 e->total_samples_to_encode = 0;
1540 e->unencoded_size = 0;
1541 e->bytes_written = 0;
1542 e->samples_written = 0;
1545 memset(&e->info, 0, sizeof(e->info));
1547 e->format = options.format;
1549 switch(options.format) {
1557 e->fmt.iff.data_bytes = 0;
1560 case FORMAT_OGGFLAC:
1561 e->fmt.flac.decoder = 0;
1562 e->fmt.flac.client_data.filesize = infilesize;
1563 e->fmt.flac.client_data.lookahead = lookahead;
1564 e->fmt.flac.client_data.lookahead_length = lookahead_length;
1565 e->fmt.flac.client_data.num_metadata_blocks = 0;
1566 e->fmt.flac.client_data.samples_left_to_process = 0;
1567 e->fmt.flac.client_data.fatal_error = false;
1571 /* double protection */
1578 e->seek_table_template = 0;
1580 if(0 == (e->seek_table_template = FLAC__metadata_object_new(FLAC__METADATA_TYPE_SEEKTABLE))) {
1581 flac__utils_printf(stderr, 1, "%s: ERROR allocating memory for seek table\n", e->inbasefilename);
1585 e->encoder = FLAC__stream_encoder_new();
1586 if(0 == e->encoder) {
1587 flac__utils_printf(stderr, 1, "%s: ERROR creating the encoder instance\n", e->inbasefilename);
1588 EncoderSession_destroy(e);
1595 void EncoderSession_destroy(EncoderSession *e)
1597 if(e->format == FORMAT_FLAC || e->format == FORMAT_OGGFLAC) {
1599 if(e->fmt.flac.decoder)
1600 FLAC__stream_decoder_delete(e->fmt.flac.decoder);
1601 e->fmt.flac.decoder = 0;
1602 for(i = 0; i < e->fmt.flac.client_data.num_metadata_blocks; i++)
1603 FLAC__metadata_object_delete(e->fmt.flac.client_data.metadata_blocks[i]);
1604 e->fmt.flac.client_data.num_metadata_blocks = 0;
1610 if(0 != e->encoder) {
1611 FLAC__stream_encoder_delete(e->encoder);
1615 if(0 != e->seek_table_template) {
1616 FLAC__metadata_object_delete(e->seek_table_template);
1617 e->seek_table_template = 0;
1621 int EncoderSession_finish_ok(EncoderSession *e, int info_align_carry, int info_align_zero, foreign_metadata_t *foreign_metadata)
1623 FLAC__StreamEncoderState fse_state = FLAC__STREAM_ENCODER_OK;
1625 FLAC__bool verify_error = false;
1628 fse_state = FLAC__stream_encoder_get_state(e->encoder);
1629 ret = FLAC__stream_encoder_finish(e->encoder)? 0 : 1;
1631 fse_state == FLAC__STREAM_ENCODER_VERIFY_MISMATCH_IN_AUDIO_DATA ||
1632 FLAC__stream_encoder_get_state(e->encoder) == FLAC__STREAM_ENCODER_VERIFY_MISMATCH_IN_AUDIO_DATA
1635 /* all errors except verify errors should interrupt the stats */
1636 if(ret && !verify_error)
1637 print_error_with_state(e, "ERROR during encoding");
1638 else if(e->total_samples_to_encode > 0) {
1640 flac__utils_printf(stderr, 2, "\n");
1644 print_verify_error(e);
1648 if(info_align_carry >= 0) {
1649 flac__utils_printf(stderr, 1, "%s: INFO: sector alignment causing %d samples to be carried over\n", e->inbasefilename, info_align_carry);
1651 if(info_align_zero >= 0) {
1652 flac__utils_printf(stderr, 1, "%s: INFO: sector alignment causing %d zero samples to be appended\n", e->inbasefilename, info_align_zero);
1656 /*@@@@@@ should this go here or somewhere else? */
1657 if(ret == 0 && foreign_metadata) {
1659 if(!flac__foreign_metadata_write_to_flac(foreign_metadata, e->infilename, e->outfilename, &error)) {
1660 flac__utils_printf(stderr, 1, "%s: ERROR: updating foreign metadata in FLAC file: %s\n", e->inbasefilename, error);
1665 EncoderSession_destroy(e);
1670 int EncoderSession_finish_error(EncoderSession *e)
1672 FLAC__ASSERT(e->encoder);
1674 if(e->total_samples_to_encode > 0)
1675 flac__utils_printf(stderr, 2, "\n");
1677 if(FLAC__stream_encoder_get_state(e->encoder) == FLAC__STREAM_ENCODER_VERIFY_MISMATCH_IN_AUDIO_DATA)
1678 print_verify_error(e);
1679 else if(e->outputfile_opened)
1680 /* only want to delete the file if we opened it; otherwise it could be an existing file and our overwrite failed */
1681 unlink(e->outfilename);
1683 EncoderSession_destroy(e);
1689 unsigned num_metadata;
1690 FLAC__bool *needs_delete;
1691 FLAC__StreamMetadata **metadata;
1692 FLAC__StreamMetadata *cuesheet; /* always needs to be deleted */
1693 } static_metadata_t;
1695 static void static_metadata_init(static_metadata_t *m)
1697 m->num_metadata = 0;
1698 m->needs_delete = 0;
1703 static void static_metadata_clear(static_metadata_t *m)
1706 for(i = 0; i < m->num_metadata; i++)
1707 if(m->needs_delete[i])
1708 FLAC__metadata_object_delete(m->metadata[i]);
1712 free(m->needs_delete);
1714 FLAC__metadata_object_delete(m->cuesheet);
1715 static_metadata_init(m);
1718 static FLAC__bool static_metadata_append(static_metadata_t *m, FLAC__StreamMetadata *d, FLAC__bool needs_delete)
1721 if(0 == (x = safe_realloc_muladd2_(m->metadata, sizeof(*m->metadata), /*times (*/m->num_metadata, /*+*/1/*)*/)))
1723 m->metadata = (FLAC__StreamMetadata**)x;
1724 if(0 == (x = safe_realloc_muladd2_(m->needs_delete, sizeof(*m->needs_delete), /*times (*/m->num_metadata, /*+*/1/*)*/)))
1726 m->needs_delete = (FLAC__bool*)x;
1727 m->metadata[m->num_metadata] = d;
1728 m->needs_delete[m->num_metadata] = needs_delete;
1733 FLAC__bool EncoderSession_init_encoder(EncoderSession *e, encode_options_t options)
1735 const unsigned channels = e->info.channels;
1736 const unsigned bps = e->info.bits_per_sample - e->info.shift;
1737 const unsigned sample_rate = e->info.sample_rate;
1738 FLACDecoderData *flac_decoder_data = (e->format == FORMAT_FLAC || e->format == FORMAT_OGGFLAC)? &e->fmt.flac.client_data : 0;
1739 FLAC__StreamMetadata padding;
1740 FLAC__StreamMetadata **metadata = 0;
1741 static_metadata_t static_metadata;
1742 unsigned num_metadata = 0, i;
1743 FLAC__StreamEncoderInitStatus init_status;
1744 const FLAC__bool is_cdda = (channels == 1 || channels == 2) && (bps == 16) && (sample_rate == 44100);
1745 char apodizations[2000];
1747 FLAC__ASSERT(sizeof(options.pictures)/sizeof(options.pictures[0]) <= 64);
1749 static_metadata_init(&static_metadata);
1751 e->replay_gain = options.replay_gain;
1753 apodizations[0] = '\0';
1755 if(e->replay_gain) {
1756 if(channels != 1 && channels != 2) {
1757 flac__utils_printf(stderr, 1, "%s: ERROR, number of channels (%u) must be 1 or 2 for --replay-gain\n", e->inbasefilename, channels);
1760 if(!grabbag__replaygain_is_valid_sample_frequency(sample_rate)) {
1761 flac__utils_printf(stderr, 1, "%s: ERROR, invalid sample rate (%u) for --replay-gain\n", e->inbasefilename, sample_rate);
1764 if(options.is_first_file) {
1765 if(!grabbag__replaygain_init(sample_rate)) {
1766 flac__utils_printf(stderr, 1, "%s: ERROR initializing ReplayGain stage\n", e->inbasefilename);
1772 if(!parse_cuesheet(&static_metadata.cuesheet, options.cuesheet_filename, e->inbasefilename, is_cdda, e->total_samples_to_encode, e->treat_warnings_as_errors))
1775 if(!convert_to_seek_table_template(options.requested_seek_points, options.num_requested_seek_points, options.cued_seekpoints? static_metadata.cuesheet : 0, e)) {
1776 flac__utils_printf(stderr, 1, "%s: ERROR allocating memory for seek table\n", e->inbasefilename);
1777 static_metadata_clear(&static_metadata);
1781 /* build metadata */
1782 if(flac_decoder_data) {
1784 * we're encoding from FLAC so we will use the FLAC file's
1785 * metadata as the basis for the encoded file
1789 * first handle pictures: simple append any --pictures
1792 for(i = 0; i < options.num_pictures; i++) {
1793 FLAC__StreamMetadata *pic = FLAC__metadata_object_clone(options.pictures[i]);
1795 flac__utils_printf(stderr, 1, "%s: ERROR allocating memory for PICTURE block\n", e->inbasefilename);
1796 static_metadata_clear(&static_metadata);
1799 flac_decoder_data->metadata_blocks[flac_decoder_data->num_metadata_blocks++] = pic;
1804 * next handle vorbis comment: if any tags were specified
1805 * or there is no existing vorbis comment, we create a
1806 * new vorbis comment (discarding any existing one); else
1807 * we keep the existing one. also need to make sure to
1808 * propagate any channel mask tag.
1810 /* @@@ change to append -T values from options.vorbis_comment if input has VC already? */
1812 FLAC__bool vc_found = false;
1813 for(i = 0, j = 0; i < flac_decoder_data->num_metadata_blocks; i++) {
1814 if(flac_decoder_data->metadata_blocks[i]->type == FLAC__METADATA_TYPE_VORBIS_COMMENT)
1816 if(flac_decoder_data->metadata_blocks[i]->type == FLAC__METADATA_TYPE_VORBIS_COMMENT && options.vorbis_comment->data.vorbis_comment.num_comments > 0) {
1817 (void) flac__utils_get_channel_mask_tag(flac_decoder_data->metadata_blocks[i], &e->info.channel_mask);
1818 flac__utils_printf(stderr, 1, "%s: WARNING, replacing tags from input FLAC file with those given on the command-line\n", e->inbasefilename);
1819 if(e->treat_warnings_as_errors) {
1820 static_metadata_clear(&static_metadata);
1823 FLAC__metadata_object_delete(flac_decoder_data->metadata_blocks[i]);
1824 flac_decoder_data->metadata_blocks[i] = 0;
1827 flac_decoder_data->metadata_blocks[j++] = flac_decoder_data->metadata_blocks[i];
1829 flac_decoder_data->num_metadata_blocks = j;
1830 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])) {
1832 FLAC__StreamMetadata *vc = FLAC__metadata_object_clone(options.vorbis_comment);
1833 if(0 == vc || (e->info.channel_mask && !flac__utils_set_channel_mask_tag(vc, e->info.channel_mask))) {
1834 flac__utils_printf(stderr, 1, "%s: ERROR allocating memory for VORBIS_COMMENT block\n", e->inbasefilename);
1835 static_metadata_clear(&static_metadata);
1838 for(i = flac_decoder_data->num_metadata_blocks; i > 1; i--)
1839 flac_decoder_data->metadata_blocks[i] = flac_decoder_data->metadata_blocks[i-1];
1840 flac_decoder_data->metadata_blocks[1] = vc;
1841 flac_decoder_data->num_metadata_blocks++;
1846 * next handle cuesheet: if --cuesheet was specified, use
1847 * it; else if file has existing CUESHEET and cuesheet's
1848 * lead-out offset is correct, keep it; else no CUESHEET
1851 for(i = 0, j = 0; i < flac_decoder_data->num_metadata_blocks; i++) {
1852 FLAC__bool existing_cuesheet_is_bad = false;
1853 /* check if existing cuesheet matches the input audio */
1854 if(flac_decoder_data->metadata_blocks[i]->type == FLAC__METADATA_TYPE_CUESHEET && 0 == static_metadata.cuesheet) {
1855 const FLAC__StreamMetadata_CueSheet *cs = &flac_decoder_data->metadata_blocks[i]->data.cue_sheet;
1856 if(e->total_samples_to_encode == 0) {
1857 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);
1858 if(e->treat_warnings_as_errors) {
1859 static_metadata_clear(&static_metadata);
1862 existing_cuesheet_is_bad = true;
1864 else if(e->total_samples_to_encode != cs->tracks[cs->num_tracks-1].offset) {
1865 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);
1866 if(e->treat_warnings_as_errors) {
1867 static_metadata_clear(&static_metadata);
1870 existing_cuesheet_is_bad = true;
1873 if(flac_decoder_data->metadata_blocks[i]->type == FLAC__METADATA_TYPE_CUESHEET && (existing_cuesheet_is_bad || 0 != static_metadata.cuesheet)) {
1874 if(0 != static_metadata.cuesheet) {
1875 flac__utils_printf(stderr, 1, "%s: WARNING, replacing cuesheet in input FLAC file with the one given on the command-line\n", e->inbasefilename);
1876 if(e->treat_warnings_as_errors) {
1877 static_metadata_clear(&static_metadata);
1881 FLAC__metadata_object_delete(flac_decoder_data->metadata_blocks[i]);
1882 flac_decoder_data->metadata_blocks[i] = 0;
1885 flac_decoder_data->metadata_blocks[j++] = flac_decoder_data->metadata_blocks[i];
1887 flac_decoder_data->num_metadata_blocks = j;
1888 if(0 != static_metadata.cuesheet && flac_decoder_data->num_metadata_blocks < sizeof(flac_decoder_data->metadata_blocks)/sizeof(flac_decoder_data->metadata_blocks[0])) {
1890 FLAC__StreamMetadata *cs = FLAC__metadata_object_clone(static_metadata.cuesheet);
1892 flac__utils_printf(stderr, 1, "%s: ERROR allocating memory for CUESHEET block\n", e->inbasefilename);
1893 static_metadata_clear(&static_metadata);
1896 for(i = flac_decoder_data->num_metadata_blocks; i > 1; i--)
1897 flac_decoder_data->metadata_blocks[i] = flac_decoder_data->metadata_blocks[i-1];
1898 flac_decoder_data->metadata_blocks[1] = cs;
1899 flac_decoder_data->num_metadata_blocks++;
1904 * next handle seektable: if -S- was specified, no
1905 * SEEKTABLE; else if -S was specified, use it/them;
1906 * else if file has existing SEEKTABLE and input size is
1907 * preserved (no --skip/--until/etc specified), keep it;
1908 * else use default seektable options
1910 * note: meanings of num_requested_seek_points:
1911 * -1 : no -S option given, default to some value
1912 * 0 : -S- given (no seektable)
1913 * >0 : one or more -S options given
1916 FLAC__bool existing_seektable = false;
1917 for(i = 0, j = 0; i < flac_decoder_data->num_metadata_blocks; i++) {
1918 if(flac_decoder_data->metadata_blocks[i]->type == FLAC__METADATA_TYPE_SEEKTABLE)
1919 existing_seektable = true;
1920 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)) {
1921 if(options.num_requested_seek_points > 0) {
1922 flac__utils_printf(stderr, 1, "%s: WARNING, replacing seektable in input FLAC file with the one given on the command-line\n", e->inbasefilename);
1923 if(e->treat_warnings_as_errors) {
1924 static_metadata_clear(&static_metadata);
1928 else if(options.num_requested_seek_points == 0)
1929 ; /* no warning, silently delete existing SEEKTABLE since user specified --no-seektable (-S-) */
1931 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);
1932 if(e->treat_warnings_as_errors) {
1933 static_metadata_clear(&static_metadata);
1937 FLAC__metadata_object_delete(flac_decoder_data->metadata_blocks[i]);
1938 flac_decoder_data->metadata_blocks[i] = 0;
1939 existing_seektable = false;
1942 flac_decoder_data->metadata_blocks[j++] = flac_decoder_data->metadata_blocks[i];
1944 flac_decoder_data->num_metadata_blocks = j;
1945 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])) {
1947 FLAC__StreamMetadata *st = FLAC__metadata_object_clone(e->seek_table_template);
1949 flac__utils_printf(stderr, 1, "%s: ERROR allocating memory for SEEKTABLE block\n", e->inbasefilename);
1950 static_metadata_clear(&static_metadata);
1953 for(i = flac_decoder_data->num_metadata_blocks; i > 1; i--)
1954 flac_decoder_data->metadata_blocks[i] = flac_decoder_data->metadata_blocks[i-1];
1955 flac_decoder_data->metadata_blocks[1] = st;
1956 flac_decoder_data->num_metadata_blocks++;
1961 * finally handle padding: if --no-padding was specified,
1962 * then delete all padding; else if -P was specified,
1963 * use that instead of existing padding (if any); else
1964 * if existing file has padding, move all existing
1965 * padding blocks to one padding block at the end; else
1966 * use default padding.
1970 for(i = 0, j = 0; i < flac_decoder_data->num_metadata_blocks; i++) {
1971 if(flac_decoder_data->metadata_blocks[i]->type == FLAC__METADATA_TYPE_PADDING) {
1974 p += flac_decoder_data->metadata_blocks[i]->length;
1975 FLAC__metadata_object_delete(flac_decoder_data->metadata_blocks[i]);
1976 flac_decoder_data->metadata_blocks[i] = 0;
1979 flac_decoder_data->metadata_blocks[j++] = flac_decoder_data->metadata_blocks[i];
1981 flac_decoder_data->num_metadata_blocks = j;
1982 if(options.padding > 0)
1983 p = options.padding;
1985 p = e->total_samples_to_encode / sample_rate < 20*60? FLAC_ENCODE__DEFAULT_PADDING : FLAC_ENCODE__DEFAULT_PADDING*8;
1986 if(options.padding != 0) {
1987 if(p > 0 && flac_decoder_data->num_metadata_blocks < sizeof(flac_decoder_data->metadata_blocks)/sizeof(flac_decoder_data->metadata_blocks[0])) {
1988 flac_decoder_data->metadata_blocks[flac_decoder_data->num_metadata_blocks] = FLAC__metadata_object_new(FLAC__METADATA_TYPE_PADDING);
1989 if(0 == flac_decoder_data->metadata_blocks[flac_decoder_data->num_metadata_blocks]) {
1990 flac__utils_printf(stderr, 1, "%s: ERROR allocating memory for PADDING block\n", e->inbasefilename);
1991 static_metadata_clear(&static_metadata);
1994 flac_decoder_data->metadata_blocks[flac_decoder_data->num_metadata_blocks]->is_last = false; /* the encoder will set this for us */
1995 flac_decoder_data->metadata_blocks[flac_decoder_data->num_metadata_blocks]->length = p;
1996 flac_decoder_data->num_metadata_blocks++;
2000 metadata = &flac_decoder_data->metadata_blocks[1]; /* don't include STREAMINFO */
2001 num_metadata = flac_decoder_data->num_metadata_blocks - 1;
2005 * we're not encoding from FLAC so we will build the metadata
2008 const foreign_metadata_t *foreign_metadata = EncoderSession_format_is_iff(e)? options.format_options.iff.foreign_metadata : 0;
2010 if(e->seek_table_template->data.seek_table.num_points > 0) {
2011 e->seek_table_template->is_last = false; /* the encoder will set this for us */
2012 static_metadata_append(&static_metadata, e->seek_table_template, /*needs_delete=*/false);
2014 if(0 != static_metadata.cuesheet)
2015 static_metadata_append(&static_metadata, static_metadata.cuesheet, /*needs_delete=*/false);
2016 if(e->info.channel_mask) {
2017 if(!flac__utils_set_channel_mask_tag(options.vorbis_comment, e->info.channel_mask)) {
2018 flac__utils_printf(stderr, 1, "%s: ERROR adding channel mask tag\n", e->inbasefilename);
2019 static_metadata_clear(&static_metadata);
2023 static_metadata_append(&static_metadata, options.vorbis_comment, /*needs_delete=*/false);
2024 for(i = 0; i < options.num_pictures; i++)
2025 static_metadata_append(&static_metadata, options.pictures[i], /*needs_delete=*/false);
2026 if(foreign_metadata) {
2027 for(i = 0; i < foreign_metadata->num_blocks; i++) {
2028 FLAC__StreamMetadata *p = FLAC__metadata_object_new(FLAC__METADATA_TYPE_PADDING);
2030 flac__utils_printf(stderr, 1, "%s: ERROR: out of memory\n", e->inbasefilename);
2031 static_metadata_clear(&static_metadata);
2034 static_metadata_append(&static_metadata, p, /*needs_delete=*/true);
2035 static_metadata.metadata[static_metadata.num_metadata-1]->length = FLAC__STREAM_METADATA_APPLICATION_ID_LEN/8 + foreign_metadata->blocks[i].size;
2038 if(options.padding != 0) {
2039 padding.is_last = false; /* the encoder will set this for us */
2040 padding.type = FLAC__METADATA_TYPE_PADDING;
2041 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));
2042 static_metadata_append(&static_metadata, &padding, /*needs_delete=*/false);
2044 metadata = static_metadata.metadata;
2045 num_metadata = static_metadata.num_metadata;
2048 /* check for a few things that have not already been checked. the
2049 * FLAC__stream_encoder_init*() will check it but only return
2050 * FLAC__STREAM_ENCODER_INIT_STATUS_INVALID_METADATA so we check some
2051 * up front to give a better error message.
2053 if(!verify_metadata(e, metadata, num_metadata)) {
2054 static_metadata_clear(&static_metadata);
2058 FLAC__stream_encoder_set_verify(e->encoder, options.verify);
2059 FLAC__stream_encoder_set_streamable_subset(e->encoder, !options.lax);
2060 FLAC__stream_encoder_set_channels(e->encoder, channels);
2061 FLAC__stream_encoder_set_bits_per_sample(e->encoder, bps);
2062 FLAC__stream_encoder_set_sample_rate(e->encoder, sample_rate);
2063 for(i = 0; i < options.num_compression_settings; i++) {
2064 switch(options.compression_settings[i].type) {
2066 FLAC__stream_encoder_set_blocksize(e->encoder, options.compression_settings[i].value.t_unsigned);
2068 case CST_COMPRESSION_LEVEL:
2069 FLAC__stream_encoder_set_compression_level(e->encoder, options.compression_settings[i].value.t_unsigned);
2070 apodizations[0] = '\0';
2072 case CST_DO_MID_SIDE:
2073 FLAC__stream_encoder_set_do_mid_side_stereo(e->encoder, options.compression_settings[i].value.t_bool);
2075 case CST_LOOSE_MID_SIDE:
2076 FLAC__stream_encoder_set_loose_mid_side_stereo(e->encoder, options.compression_settings[i].value.t_bool);
2078 case CST_APODIZATION:
2079 if(strlen(apodizations)+strlen(options.compression_settings[i].value.t_string)+2 >= sizeof(apodizations)) {
2080 flac__utils_printf(stderr, 1, "%s: ERROR: too many apodization functions requested\n", e->inbasefilename);
2081 static_metadata_clear(&static_metadata);
2085 strcat(apodizations, options.compression_settings[i].value.t_string);
2086 strcat(apodizations, ";");
2089 case CST_MAX_LPC_ORDER:
2090 FLAC__stream_encoder_set_max_lpc_order(e->encoder, options.compression_settings[i].value.t_unsigned);
2092 case CST_QLP_COEFF_PRECISION:
2093 FLAC__stream_encoder_set_qlp_coeff_precision(e->encoder, options.compression_settings[i].value.t_unsigned);
2095 case CST_DO_QLP_COEFF_PREC_SEARCH:
2096 FLAC__stream_encoder_set_do_qlp_coeff_prec_search(e->encoder, options.compression_settings[i].value.t_bool);
2098 case CST_DO_ESCAPE_CODING:
2099 FLAC__stream_encoder_set_do_escape_coding(e->encoder, options.compression_settings[i].value.t_bool);
2101 case CST_DO_EXHAUSTIVE_MODEL_SEARCH:
2102 FLAC__stream_encoder_set_do_exhaustive_model_search(e->encoder, options.compression_settings[i].value.t_bool);
2104 case CST_MIN_RESIDUAL_PARTITION_ORDER:
2105 FLAC__stream_encoder_set_min_residual_partition_order(e->encoder, options.compression_settings[i].value.t_unsigned);
2107 case CST_MAX_RESIDUAL_PARTITION_ORDER:
2108 FLAC__stream_encoder_set_max_residual_partition_order(e->encoder, options.compression_settings[i].value.t_unsigned);
2110 case CST_RICE_PARAMETER_SEARCH_DIST:
2111 FLAC__stream_encoder_set_rice_parameter_search_dist(e->encoder, options.compression_settings[i].value.t_unsigned);
2116 FLAC__stream_encoder_set_apodization(e->encoder, apodizations);
2117 FLAC__stream_encoder_set_total_samples_estimate(e->encoder, e->total_samples_to_encode);
2118 FLAC__stream_encoder_set_metadata(e->encoder, (num_metadata > 0)? metadata : 0, num_metadata);
2120 FLAC__stream_encoder_disable_constant_subframes(e->encoder, options.debug.disable_constant_subframes);
2121 FLAC__stream_encoder_disable_fixed_subframes(e->encoder, options.debug.disable_fixed_subframes);
2122 FLAC__stream_encoder_disable_verbatim_subframes(e->encoder, options.debug.disable_verbatim_subframes);
2123 if(!options.debug.do_md5) {
2124 flac__utils_printf(stderr, 1, "%s: WARNING, MD5 computation disabled, resulting file will not have MD5 sum\n", e->inbasefilename);
2125 if(e->treat_warnings_as_errors) {
2126 static_metadata_clear(&static_metadata);
2129 FLAC__stream_encoder_set_do_md5(e->encoder, false);
2134 FLAC__stream_encoder_set_ogg_serial_number(e->encoder, options.serial_number);
2136 init_status = FLAC__stream_encoder_init_ogg_file(e->encoder, e->is_stdout? 0 : e->outfilename, encoder_progress_callback, /*client_data=*/e);
2141 init_status = FLAC__stream_encoder_init_file(e->encoder, e->is_stdout? 0 : e->outfilename, encoder_progress_callback, /*client_data=*/e);
2144 if(init_status != FLAC__STREAM_ENCODER_INIT_STATUS_OK) {
2145 print_error_with_init_status(e, "ERROR initializing encoder", init_status);
2146 if(FLAC__stream_encoder_get_state(e->encoder) != FLAC__STREAM_ENCODER_IO_ERROR)
2147 e->outputfile_opened = true;
2148 static_metadata_clear(&static_metadata);
2152 e->outputfile_opened = true;
2155 (FLAC__stream_encoder_get_do_exhaustive_model_search(e->encoder) && FLAC__stream_encoder_get_do_qlp_coeff_prec_search(e->encoder))? 0x07 :
2156 (FLAC__stream_encoder_get_do_exhaustive_model_search(e->encoder) || FLAC__stream_encoder_get_do_qlp_coeff_prec_search(e->encoder))? 0x0f :
2159 static_metadata_clear(&static_metadata);
2164 FLAC__bool EncoderSession_process(EncoderSession *e, const FLAC__int32 * const buffer[], unsigned samples)
2166 if(e->replay_gain) {
2167 if(!grabbag__replaygain_analyze(buffer, e->info.channels==2, e->info.bits_per_sample, samples)) {
2168 flac__utils_printf(stderr, 1, "%s: WARNING, error while calculating ReplayGain\n", e->inbasefilename);
2169 if(e->treat_warnings_as_errors)
2174 return FLAC__stream_encoder_process(e->encoder, buffer, samples);
2177 FLAC__bool EncoderSession_format_is_iff(const EncoderSession *e)
2180 e->format == FORMAT_WAVE ||
2181 e->format == FORMAT_WAVE64 ||
2182 e->format == FORMAT_RF64 ||
2183 e->format == FORMAT_AIFF ||
2184 e->format == FORMAT_AIFF_C;
2187 FLAC__bool convert_to_seek_table_template(const char *requested_seek_points, int num_requested_seek_points, FLAC__StreamMetadata *cuesheet, EncoderSession *e)
2189 const FLAC__bool only_placeholders = e->is_stdout;
2190 FLAC__bool has_real_points;
2192 if(num_requested_seek_points == 0 && 0 == cuesheet)
2195 if(num_requested_seek_points < 0) {
2197 /*@@@@@@ workaround ogg bug: too many seekpoints makes table not fit in one page */
2198 if(e->use_ogg && e->total_samples_to_encode > 0 && e->total_samples_to_encode / e->info.sample_rate / 10 > 230)
2199 requested_seek_points = "230x;";
2202 requested_seek_points = "10s;";
2203 num_requested_seek_points = 1;
2206 if(num_requested_seek_points > 0) {
2207 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))
2213 const FLAC__StreamMetadata_CueSheet *cs = &cuesheet->data.cue_sheet;
2214 for(i = 0; i < cs->num_tracks; i++) {
2215 const FLAC__StreamMetadata_CueSheet_Track *tr = cs->tracks+i;
2216 for(j = 0; j < tr->num_indices; j++) {
2217 if(!FLAC__metadata_object_seektable_template_append_point(e->seek_table_template, tr->offset + tr->indices[j].offset))
2219 has_real_points = true;
2223 if(!FLAC__metadata_object_seektable_template_sort(e->seek_table_template, /*compact=*/true))
2227 if(has_real_points) {
2229 flac__utils_printf(stderr, 1, "%s: WARNING, cannot write back seekpoints when encoding to stdout\n", e->inbasefilename);
2230 if(e->treat_warnings_as_errors)
2238 FLAC__bool canonicalize_until_specification(utils__SkipUntilSpecification *spec, const char *inbasefilename, unsigned sample_rate, FLAC__uint64 skip, FLAC__uint64 total_samples_in_input)
2240 /* convert from mm:ss.sss to sample number if necessary */
2241 flac__utils_canonicalize_skip_until_specification(spec, sample_rate);
2243 /* special case: if "--until=-0", use the special value '0' to mean "end-of-stream" */
2244 if(spec->is_relative && spec->value.samples == 0) {
2245 spec->is_relative = false;
2249 /* in any other case the total samples in the input must be known */
2250 if(total_samples_in_input == 0) {
2251 flac__utils_printf(stderr, 1, "%s: ERROR, cannot use --until when input length is unknown\n", inbasefilename);
2255 FLAC__ASSERT(spec->value_is_samples);
2257 /* convert relative specifications to absolute */
2258 if(spec->is_relative) {
2259 if(spec->value.samples <= 0)
2260 spec->value.samples += (FLAC__int64)total_samples_in_input;
2262 spec->value.samples += skip;
2263 spec->is_relative = false;
2267 if(spec->value.samples < 0) {
2268 flac__utils_printf(stderr, 1, "%s: ERROR, --until value is before beginning of input\n", inbasefilename);
2271 if((FLAC__uint64)spec->value.samples <= skip) {
2272 flac__utils_printf(stderr, 1, "%s: ERROR, --until value is before --skip point\n", inbasefilename);
2275 if((FLAC__uint64)spec->value.samples > total_samples_in_input) {
2276 flac__utils_printf(stderr, 1, "%s: ERROR, --until value is after end of input\n", inbasefilename);
2283 FLAC__bool verify_metadata(const EncoderSession *e, FLAC__StreamMetadata **metadata, unsigned num_metadata)
2285 FLAC__bool metadata_picture_has_type1 = false;
2286 FLAC__bool metadata_picture_has_type2 = false;
2289 FLAC__ASSERT(0 != metadata);
2290 for(i = 0; i < num_metadata; i++) {
2291 const FLAC__StreamMetadata *m = metadata[i];
2292 if(m->type == FLAC__METADATA_TYPE_SEEKTABLE) {
2293 if(!FLAC__format_seektable_is_legal(&m->data.seek_table)) {
2294 flac__utils_printf(stderr, 1, "%s: ERROR: SEEKTABLE metadata block is invalid\n", e->inbasefilename);
2298 else if(m->type == FLAC__METADATA_TYPE_CUESHEET) {
2299 if(!FLAC__format_cuesheet_is_legal(&m->data.cue_sheet, m->data.cue_sheet.is_cd, /*violation=*/0)) {
2300 flac__utils_printf(stderr, 1, "%s: ERROR: CUESHEET metadata block is invalid\n", e->inbasefilename);
2304 else if(m->type == FLAC__METADATA_TYPE_PICTURE) {
2305 const char *error = 0;
2306 if(!FLAC__format_picture_is_legal(&m->data.picture, &error)) {
2307 flac__utils_printf(stderr, 1, "%s: ERROR: PICTURE metadata block is invalid: %s\n", e->inbasefilename, error);
2310 if(m->data.picture.type == FLAC__STREAM_METADATA_PICTURE_TYPE_FILE_ICON_STANDARD) {
2311 if(metadata_picture_has_type1) {
2312 flac__utils_printf(stderr, 1, "%s: ERROR: there may only be one picture of type 1 (32x32 icon) in the file\n", e->inbasefilename);
2315 metadata_picture_has_type1 = true;
2317 else if(m->data.picture.type == FLAC__STREAM_METADATA_PICTURE_TYPE_FILE_ICON) {
2318 if(metadata_picture_has_type2) {
2319 flac__utils_printf(stderr, 1, "%s: ERROR: there may only be one picture of type 2 (icon) in the file\n", e->inbasefilename);
2322 metadata_picture_has_type2 = true;
2330 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)
2332 unsigned wide_sample, sample, channel, byte;
2333 FLAC__int32 *out[FLAC__MAX_CHANNELS];
2335 if(0 == channel_map) {
2336 for(channel = 0; channel < channels; channel++)
2337 out[channel] = dest[channel];
2340 for(channel = 0; channel < channels; channel++)
2341 out[channel] = dest[channel_map[channel]];
2345 if(is_unsigned_samples) {
2346 for(sample = wide_sample = 0; wide_sample < wide_samples; wide_sample++)
2347 for(channel = 0; channel < channels; channel++, sample++)
2348 out[channel][wide_sample] = (FLAC__int32)ucbuffer_[sample] - 0x80;
2351 for(sample = wide_sample = 0; wide_sample < wide_samples; wide_sample++)
2352 for(channel = 0; channel < channels; channel++, sample++)
2353 out[channel][wide_sample] = (FLAC__int32)scbuffer_[sample];
2356 else if(bps == 16) {
2357 if(is_big_endian != is_big_endian_host_) {
2359 const unsigned bytes = wide_samples * channels * (bps >> 3);
2360 for(byte = 0; byte < bytes; byte += 2) {
2361 tmp = ucbuffer_[byte];
2362 ucbuffer_[byte] = ucbuffer_[byte+1];
2363 ucbuffer_[byte+1] = tmp;
2366 if(is_unsigned_samples) {
2367 for(sample = wide_sample = 0; wide_sample < wide_samples; wide_sample++)
2368 for(channel = 0; channel < channels; channel++, sample++)
2369 out[channel][wide_sample] = (FLAC__int32)usbuffer_[sample] - 0x8000;
2372 for(sample = wide_sample = 0; wide_sample < wide_samples; wide_sample++)
2373 for(channel = 0; channel < channels; channel++, sample++)
2374 out[channel][wide_sample] = (FLAC__int32)ssbuffer_[sample];
2377 else if(bps == 24) {
2378 if(!is_big_endian) {
2380 const unsigned bytes = wide_samples * channels * (bps >> 3);
2381 for(byte = 0; byte < bytes; byte += 3) {
2382 tmp = ucbuffer_[byte];
2383 ucbuffer_[byte] = ucbuffer_[byte+2];
2384 ucbuffer_[byte+2] = tmp;
2387 if(is_unsigned_samples) {
2388 for(byte = sample = wide_sample = 0; wide_sample < wide_samples; wide_sample++)
2389 for(channel = 0; channel < channels; channel++, sample++) {
2390 out[channel][wide_sample] = ucbuffer_[byte++]; out[channel][wide_sample] <<= 8;
2391 out[channel][wide_sample] |= ucbuffer_[byte++]; out[channel][wide_sample] <<= 8;
2392 out[channel][wide_sample] |= ucbuffer_[byte++];
2393 out[channel][wide_sample] -= 0x800000;
2397 for(byte = sample = wide_sample = 0; wide_sample < wide_samples; wide_sample++)
2398 for(channel = 0; channel < channels; channel++, sample++) {
2399 out[channel][wide_sample] = scbuffer_[byte++]; out[channel][wide_sample] <<= 8;
2400 out[channel][wide_sample] |= ucbuffer_[byte++]; out[channel][wide_sample] <<= 8;
2401 out[channel][wide_sample] |= ucbuffer_[byte++];
2409 FLAC__int32 mask = (1<<shift)-1;
2410 for(wide_sample = 0; wide_sample < wide_samples; wide_sample++)
2411 for(channel = 0; channel < channels; channel++) {
2412 if(out[channel][wide_sample] & mask) {
2413 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);
2416 out[channel][wide_sample] >>= shift;
2422 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)
2424 EncoderSession *e = (EncoderSession*)client_data;
2426 (void)encoder, (void)total_frames_estimate;
2428 e->bytes_written = bytes_written;
2429 e->samples_written = samples_written;
2431 if(e->total_samples_to_encode > 0 && !((frames_written-1) & e->stats_mask))
2435 FLAC__StreamDecoderReadStatus flac_decoder_read_callback(const FLAC__StreamDecoder *decoder, FLAC__byte buffer[], size_t *bytes, void *client_data)
2438 EncoderSession *e = (EncoderSession*)client_data;
2439 FLACDecoderData *data = &e->fmt.flac.client_data;
2443 if (data->fatal_error)
2444 return FLAC__STREAM_DECODER_READ_STATUS_ABORT;
2446 /* use up lookahead first */
2447 if (data->lookahead_length) {
2448 n = min(data->lookahead_length, *bytes);
2449 memcpy(buffer, data->lookahead, n);
2451 data->lookahead += n;
2452 data->lookahead_length -= n;
2455 /* get the rest from file */
2457 *bytes = n + fread(buffer, 1, *bytes-n, e->fin);
2459 return FLAC__STREAM_DECODER_READ_STATUS_ABORT;
2460 else if(0 == *bytes)
2461 return FLAC__STREAM_DECODER_READ_STATUS_END_OF_STREAM;
2463 return FLAC__STREAM_DECODER_READ_STATUS_CONTINUE;
2466 return FLAC__STREAM_DECODER_READ_STATUS_CONTINUE;
2469 FLAC__StreamDecoderSeekStatus flac_decoder_seek_callback(const FLAC__StreamDecoder *decoder, FLAC__uint64 absolute_byte_offset, void *client_data)
2471 EncoderSession *e = (EncoderSession*)client_data;
2474 if(fseeko(e->fin, (off_t)absolute_byte_offset, SEEK_SET) < 0)
2475 return FLAC__STREAM_DECODER_SEEK_STATUS_ERROR;
2477 return FLAC__STREAM_DECODER_SEEK_STATUS_OK;
2480 FLAC__StreamDecoderTellStatus flac_decoder_tell_callback(const FLAC__StreamDecoder *decoder, FLAC__uint64 *absolute_byte_offset, void *client_data)
2482 EncoderSession *e = (EncoderSession*)client_data;
2486 if((pos = ftello(e->fin)) < 0)
2487 return FLAC__STREAM_DECODER_TELL_STATUS_ERROR;
2489 *absolute_byte_offset = (FLAC__uint64)pos;
2490 return FLAC__STREAM_DECODER_TELL_STATUS_OK;
2494 FLAC__StreamDecoderLengthStatus flac_decoder_length_callback(const FLAC__StreamDecoder *decoder, FLAC__uint64 *stream_length, void *client_data)
2496 const EncoderSession *e = (EncoderSession*)client_data;
2497 const FLACDecoderData *data = &e->fmt.flac.client_data;
2500 if(data->filesize < 0)
2501 return FLAC__STREAM_DECODER_LENGTH_STATUS_ERROR;
2503 *stream_length = (FLAC__uint64)data->filesize;
2504 return FLAC__STREAM_DECODER_LENGTH_STATUS_OK;
2508 FLAC__bool flac_decoder_eof_callback(const FLAC__StreamDecoder *decoder, void *client_data)
2510 EncoderSession *e = (EncoderSession*)client_data;
2513 return feof(e->fin)? true : false;
2516 FLAC__StreamDecoderWriteStatus flac_decoder_write_callback(const FLAC__StreamDecoder *decoder, const FLAC__Frame *frame, const FLAC__int32 * const buffer[], void *client_data)
2518 EncoderSession *e = (EncoderSession*)client_data;
2519 FLACDecoderData *data = &e->fmt.flac.client_data;
2520 FLAC__uint64 n = min(data->samples_left_to_process, frame->header.blocksize);
2523 if(!EncoderSession_process(e, buffer, (unsigned)n)) {
2524 print_error_with_state(e, "ERROR during encoding");
2525 data->fatal_error = true;
2526 return FLAC__STREAM_DECODER_WRITE_STATUS_ABORT;
2529 data->samples_left_to_process -= n;
2530 return FLAC__STREAM_DECODER_WRITE_STATUS_CONTINUE;
2533 void flac_decoder_metadata_callback(const FLAC__StreamDecoder *decoder, const FLAC__StreamMetadata *metadata, void *client_data)
2535 EncoderSession *e = (EncoderSession*)client_data;
2536 FLACDecoderData *data = &e->fmt.flac.client_data;
2539 if (data->fatal_error)
2543 data->num_metadata_blocks == sizeof(data->metadata_blocks)/sizeof(data->metadata_blocks[0]) ||
2544 0 == (data->metadata_blocks[data->num_metadata_blocks] = FLAC__metadata_object_clone(metadata))
2546 data->fatal_error = true;
2548 data->num_metadata_blocks++;
2551 void flac_decoder_error_callback(const FLAC__StreamDecoder *decoder, FLAC__StreamDecoderErrorStatus status, void *client_data)
2553 EncoderSession *e = (EncoderSession*)client_data;
2554 FLACDecoderData *data = &e->fmt.flac.client_data;
2557 flac__utils_printf(stderr, 1, "%s: ERROR got %s while decoding FLAC input\n", e->inbasefilename, FLAC__StreamDecoderErrorStatusString[status]);
2558 if(!e->continue_through_decode_errors)
2559 data->fatal_error = true;
2562 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)
2565 unsigned last_line_read;
2566 const char *error_message;
2568 if(0 == cuesheet_filename)
2571 if(lead_out_offset == 0) {
2572 flac__utils_printf(stderr, 1, "%s: ERROR cannot import cuesheet when the number of input samples to encode is unknown\n", inbasefilename);
2576 if(0 == (f = fopen(cuesheet_filename, "r"))) {
2577 flac__utils_printf(stderr, 1, "%s: ERROR opening cuesheet \"%s\" for reading: %s\n", inbasefilename, cuesheet_filename, strerror(errno));
2581 *cuesheet = grabbag__cuesheet_parse(f, &error_message, &last_line_read, is_cdda, lead_out_offset);
2585 if(0 == *cuesheet) {
2586 flac__utils_printf(stderr, 1, "%s: ERROR parsing cuesheet \"%s\" on line %u: %s\n", inbasefilename, cuesheet_filename, last_line_read, error_message);
2590 if(!FLAC__format_cuesheet_is_legal(&(*cuesheet)->data.cue_sheet, /*check_cd_da_subset=*/false, &error_message)) {
2591 flac__utils_printf(stderr, 1, "%s: ERROR parsing cuesheet \"%s\": %s\n", inbasefilename, cuesheet_filename, error_message);
2595 /* if we're expecting CDDA, warn about non-compliance */
2596 if(is_cdda && !FLAC__format_cuesheet_is_legal(&(*cuesheet)->data.cue_sheet, /*check_cd_da_subset=*/true, &error_message)) {
2597 flac__utils_printf(stderr, 1, "%s: WARNING cuesheet \"%s\" is not audio CD compliant: %s\n", inbasefilename, cuesheet_filename, error_message);
2598 if(treat_warnings_as_errors)
2600 (*cuesheet)->data.cue_sheet.is_cd = false;
2606 void print_stats(const EncoderSession *encoder_session)
2608 const FLAC__uint64 samples_written = min(encoder_session->total_samples_to_encode, encoder_session->samples_written);
2609 const FLAC__uint64 uesize = encoder_session->unencoded_size;
2610 #if defined _MSC_VER || defined __MINGW32__
2611 /* with MSVC you have to spoon feed it the casting */
2612 const double progress = (double)(FLAC__int64)samples_written / (double)(FLAC__int64)encoder_session->total_samples_to_encode;
2613 const double ratio = (double)(FLAC__int64)encoder_session->bytes_written / ((double)(FLAC__int64)(uesize? uesize:1) * min(1.0, progress));
2615 const double progress = (double)samples_written / (double)encoder_session->total_samples_to_encode;
2616 const double ratio = (double)encoder_session->bytes_written / ((double)(uesize? uesize:1) * min(1.0, progress));
2619 FLAC__ASSERT(encoder_session->total_samples_to_encode > 0);
2621 if(samples_written == encoder_session->total_samples_to_encode) {
2622 flac__utils_printf(stderr, 2, "\r%s:%s wrote %u bytes, ratio=",
2623 encoder_session->inbasefilename,
2624 encoder_session->verify? " Verify OK," : "",
2625 (unsigned)encoder_session->bytes_written
2629 flac__utils_printf(stderr, 2, "\r%s: %u%% complete, ratio=", encoder_session->inbasefilename, (unsigned)floor(progress * 100.0 + 0.5));
2632 flac__utils_printf(stderr, 2, "%0.3f", ratio);
2634 flac__utils_printf(stderr, 2, "N/A");
2637 void print_error_with_init_status(const EncoderSession *e, const char *message, FLAC__StreamEncoderInitStatus init_status)
2639 const int ilen = strlen(e->inbasefilename) + 1;
2640 const char *state_string = "";
2642 flac__utils_printf(stderr, 1, "\n%s: %s\n", e->inbasefilename, message);
2644 flac__utils_printf(stderr, 1, "%*s init_status = %s\n", ilen, "", FLAC__StreamEncoderInitStatusString[init_status]);
2646 if(init_status == FLAC__STREAM_ENCODER_INIT_STATUS_ENCODER_ERROR) {
2647 state_string = FLAC__stream_encoder_get_resolved_state_string(e->encoder);
2649 flac__utils_printf(stderr, 1, "%*s state = %s\n", ilen, "", state_string);
2651 /* print out some more info for some errors: */
2652 if(0 == strcmp(state_string, FLAC__StreamEncoderStateString[FLAC__STREAM_ENCODER_CLIENT_ERROR])) {
2653 flac__utils_printf(stderr, 1,
2655 "An error occurred while writing; the most common cause is that the disk is full.\n"
2658 else if(0 == strcmp(state_string, FLAC__StreamEncoderStateString[FLAC__STREAM_ENCODER_IO_ERROR])) {
2659 flac__utils_printf(stderr, 1,
2661 "An error occurred opening the output file; it is likely that the output\n"
2662 "directory does not exist or is not writable, the output file already exists and\n"
2663 "is not writable, or the disk is full.\n"
2667 else if(init_status == FLAC__STREAM_ENCODER_INIT_STATUS_NOT_STREAMABLE) {
2668 flac__utils_printf(stderr, 1,
2670 "The encoding parameters specified do not conform to the FLAC Subset and may not\n"
2671 "be streamable or playable in hardware devices. If you really understand the\n"
2672 "consequences, you can add --lax to the command-line options to encode with\n"
2673 "these parameters anyway. See http://flac.sourceforge.net/format.html#subset\n"
2678 void print_error_with_state(const EncoderSession *e, const char *message)
2680 const int ilen = strlen(e->inbasefilename) + 1;
2681 const char *state_string;
2683 flac__utils_printf(stderr, 1, "\n%s: %s\n", e->inbasefilename, message);
2685 state_string = FLAC__stream_encoder_get_resolved_state_string(e->encoder);
2687 flac__utils_printf(stderr, 1, "%*s state = %s\n", ilen, "", state_string);
2689 /* print out some more info for some errors: */
2690 if(0 == strcmp(state_string, FLAC__StreamEncoderStateString[FLAC__STREAM_ENCODER_CLIENT_ERROR])) {
2691 flac__utils_printf(stderr, 1,
2693 "An error occurred while writing; the most common cause is that the disk is full.\n"
2698 void print_verify_error(EncoderSession *e)
2700 FLAC__uint64 absolute_sample;
2701 unsigned frame_number;
2704 FLAC__int32 expected;
2707 FLAC__stream_encoder_get_verify_decoder_error_stats(e->encoder, &absolute_sample, &frame_number, &channel, &sample, &expected, &got);
2709 flac__utils_printf(stderr, 1, "%s: ERROR: mismatch in decoded data, verify FAILED!\n", e->inbasefilename);
2710 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);
2711 flac__utils_printf(stderr, 1, " In all known cases, verify errors are caused by hardware problems,\n");
2712 flac__utils_printf(stderr, 1, " usually overclocking or bad RAM. Delete %s\n", e->outfilename);
2713 flac__utils_printf(stderr, 1, " and repeat the flac command exactly as before. If it does not give a\n");
2714 flac__utils_printf(stderr, 1, " verify error in the exact same place each time you try it, then there is\n");
2715 flac__utils_printf(stderr, 1, " a problem with your hardware; please see the FAQ:\n");
2716 flac__utils_printf(stderr, 1, " http://flac.sourceforge.net/faq.html#tools__hardware_prob\n");
2717 flac__utils_printf(stderr, 1, " If it does fail in the exact same place every time, keep\n");
2718 flac__utils_printf(stderr, 1, " %s and submit a bug report to:\n", e->outfilename);
2719 flac__utils_printf(stderr, 1, " https://sourceforge.net/bugs/?func=addbug&group_id=13478\n");
2720 flac__utils_printf(stderr, 1, " Make sure to upload the FLAC file and use the \"Monitor\" feature to\n");
2721 flac__utils_printf(stderr, 1, " monitor the bug status.\n");
2722 flac__utils_printf(stderr, 1, "Verify FAILED! Do not trust %s\n", e->outfilename);
2725 FLAC__bool read_bytes(FILE *f, FLAC__byte *buf, size_t n, FLAC__bool eof_ok, const char *fn)
2727 size_t bytes_read = fread(buf, 1, n, f);
2729 if(bytes_read == 0) {
2731 flac__utils_printf(stderr, 1, "%s: ERROR: unexpected EOF\n", fn);
2737 if(bytes_read < n) {
2738 flac__utils_printf(stderr, 1, "%s: ERROR: unexpected EOF\n", fn);
2744 FLAC__bool read_uint16(FILE *f, FLAC__bool big_endian, FLAC__uint16 *val, const char *fn)
2746 if(!read_bytes(f, (FLAC__byte*)val, 2, /*eof_ok=*/false, fn))
2748 if(is_big_endian_host_ != big_endian) {
2749 FLAC__byte tmp, *b = (FLAC__byte*)val;
2750 tmp = b[1]; b[1] = b[0]; b[0] = tmp;
2755 FLAC__bool read_uint32(FILE *f, FLAC__bool big_endian, FLAC__uint32 *val, const char *fn)
2757 if(!read_bytes(f, (FLAC__byte*)val, 4, /*eof_ok=*/false, fn))
2759 if(is_big_endian_host_ != big_endian) {
2760 FLAC__byte tmp, *b = (FLAC__byte*)val;
2761 tmp = b[3]; b[3] = b[0]; b[0] = tmp;
2762 tmp = b[2]; b[2] = b[1]; b[1] = tmp;
2767 FLAC__bool read_uint64(FILE *f, FLAC__bool big_endian, FLAC__uint64 *val, const char *fn)
2769 if(!read_bytes(f, (FLAC__byte*)val, 8, /*eof_ok=*/false, fn))
2771 if(is_big_endian_host_ != big_endian) {
2772 FLAC__byte tmp, *b = (FLAC__byte*)val;
2773 tmp = b[7]; b[7] = b[0]; b[0] = tmp;
2774 tmp = b[6]; b[6] = b[1]; b[1] = tmp;
2775 tmp = b[5]; b[5] = b[2]; b[2] = tmp;
2776 tmp = b[4]; b[4] = b[3]; b[3] = tmp;
2781 FLAC__bool read_sane_extended(FILE *f, FLAC__uint32 *val, const char *fn)
2782 /* Read an IEEE 754 80-bit (aka SANE) extended floating point value from 'f',
2783 * convert it into an integral value and store in 'val'. Return false if only
2784 * between 1 and 9 bytes remain in 'f', if 0 bytes remain in 'f', or if the
2785 * value is negative, between zero and one, or too large to be represented by
2786 * 'val'; return true otherwise.
2795 if(!read_bytes(f, buf, sizeof(buf), /*eof_ok=*/false, fn))
2797 e = ((FLAC__uint16)(buf[0])<<8 | (FLAC__uint16)(buf[1]))-0x3FFF;
2799 if((buf[0]>>7)==1U || e<0 || e>63) {
2800 flac__utils_printf(stderr, 1, "%s: ERROR: invalid floating-point value\n", fn);
2804 for(i = 0; i < 8; ++i)
2805 p |= (FLAC__uint64)(buf[i+2])<<(56U-i*8);
2806 *val = (FLAC__uint32)((p>>shift)+(p>>(shift-1) & 0x1));
2811 FLAC__bool fskip_ahead(FILE *f, FLAC__uint64 offset)
2813 static unsigned char dump[8192];
2817 /* MS' stdio impl can't even seek forward on stdin, have to use pure non-fseek() version: */
2819 const long need = (long)min(offset, sizeof(dump));
2820 if((long)fread(dump, 1, need, f) < need)
2829 long need = (long)min(offset, LONG_MAX);
2830 if(fseeko(f, need, SEEK_CUR) < 0) {
2831 need = (long)min(offset, sizeof(dump));
2832 if((long)fread(dump, 1, need, f) < need)
2841 unsigned count_channel_mask_bits(FLAC__uint32 mask)
2853 FLAC__uint32 limit_channel_mask(FLAC__uint32 mask, unsigned channels)
2855 FLAC__uint32 x = 0x80000000;
2856 unsigned count = count_channel_mask_bits(mask);
2857 while(x && count > channels) {
2864 FLAC__ASSERT(count_channel_mask_bits(mask) == channels);