1 /* flac - Command-line FLAC encoder/decoder
2 * Copyright (C) 2000,2001,2002,2003,2004,2005,2006,2007,2008,2009 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 along
15 * with this program; if not, write to the Free Software Foundation, Inc.,
16 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
24 #include <limits.h> /* for LONG_MAX */
25 #include <math.h> /* for floor() */
26 #include <stdio.h> /* for FILE etc. */
27 #include <stdlib.h> /* for malloc */
28 #include <string.h> /* for strcmp(), strerror() */
31 #include "share/alloc.h"
32 #include "share/grabbag.h"
33 #include "share/compat.h"
34 #include "share/private.h"
35 #include "share/safe_str.h"
41 #define min(x,y) ((x)<(y)?(x):(y))
45 #define max(x,y) ((x)>(y)?(x):(y))
47 /* this MUST be >= 588 so that sector aligning can take place with one read */
48 /* this MUST be < 2^sizeof(size_t) / ( FLAC__MAX_CHANNELS * (FLAC__MAX_BITS_PER_SAMPLE/8) ) */
49 #define CHUNK_OF_SAMPLES 2048
54 unsigned bits_per_sample; /* width of sample point, including 'shift' bits, valid bps is bits_per_sample-shift */
55 unsigned shift; /* # of LSBs samples have been shifted left by */
56 unsigned bytes_per_wide_sample; /* for convenience, always == channels*((bps+7)/8), or 0 if N/A to input format (like FLAC) */
57 FLAC__bool is_unsigned_samples;
58 FLAC__bool is_big_endian;
59 FLAC__uint32 channel_mask;
62 /* this is the client_data attached to the FLAC decoder when encoding from a FLAC file */
65 const FLAC__byte *lookahead;
66 unsigned lookahead_length;
67 size_t num_metadata_blocks;
68 FLAC__StreamMetadata *metadata_blocks[1024]; /*@@@ BAD MAGIC number */
69 FLAC__uint64 samples_left_to_process;
70 FLAC__bool fatal_error;
79 FLAC__bool outputfile_opened; /* true if we successfully opened the output file and we want it to be deleted if there is an error */
80 const char *inbasefilename;
81 const char *infilename;
82 const char *outfilename;
84 FLAC__bool treat_warnings_as_errors;
85 FLAC__bool continue_through_decode_errors;
86 FLAC__bool replay_gain;
87 FLAC__uint64 total_samples_to_encode; /* (i.e. "wide samples" aka "sample frames") WATCHOUT: may be 0 to mean 'unknown' */
88 FLAC__uint64 unencoded_size; /* an estimate of the input size, only used in the progress indicator */
89 FLAC__uint64 bytes_written;
90 FLAC__uint64 samples_written;
98 FLAC__uint64 data_bytes;
101 FLAC__StreamDecoder *decoder;
102 FLACDecoderData client_data;
106 FLAC__StreamEncoder *encoder;
109 FLAC__StreamMetadata *seek_table_template;
112 const int FLAC_ENCODE__DEFAULT_PADDING = 8192;
114 static FLAC__bool is_big_endian_host_;
116 static unsigned char ucbuffer_[CHUNK_OF_SAMPLES*FLAC__MAX_CHANNELS*((FLAC__REFERENCE_CODEC_MAX_BITS_PER_SAMPLE+7)/8)];
117 static signed char *scbuffer_ = (signed char *)ucbuffer_;
118 static FLAC__uint16 *usbuffer_ = (FLAC__uint16 *)ucbuffer_;
119 static FLAC__int16 *ssbuffer_ = (FLAC__int16 *)ucbuffer_;
121 static FLAC__int32 in_[FLAC__MAX_CHANNELS][CHUNK_OF_SAMPLES];
122 static FLAC__int32 *input_[FLAC__MAX_CHANNELS];
128 static FLAC__bool EncoderSession_construct(EncoderSession *e, encode_options_t options, FLAC__off_t infilesize, FILE *infile, const char *infilename, const char *outfilename, const FLAC__byte *lookahead, unsigned lookahead_length);
129 static void EncoderSession_destroy(EncoderSession *e);
130 static int EncoderSession_finish_ok(EncoderSession *e, int info_align_carry, int info_align_zero, foreign_metadata_t *foreign_metadata);
131 static int EncoderSession_finish_error(EncoderSession *e);
132 static FLAC__bool EncoderSession_init_encoder(EncoderSession *e, encode_options_t options);
133 static FLAC__bool EncoderSession_process(EncoderSession *e, const FLAC__int32 * const buffer[], unsigned samples);
134 static FLAC__bool EncoderSession_format_is_iff(const EncoderSession *e);
135 static FLAC__bool convert_to_seek_table_template(const char *requested_seek_points, int num_requested_seek_points, FLAC__StreamMetadata *cuesheet, EncoderSession *e);
136 static FLAC__bool canonicalize_until_specification(utils__SkipUntilSpecification *spec, const char *inbasefilename, unsigned sample_rate, FLAC__uint64 skip, FLAC__uint64 total_samples_in_input);
137 static FLAC__bool verify_metadata(const EncoderSession *e, FLAC__StreamMetadata **metadata, unsigned num_metadata);
138 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);
139 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);
140 static FLAC__StreamDecoderReadStatus flac_decoder_read_callback(const FLAC__StreamDecoder *decoder, FLAC__byte buffer[], size_t *bytes, void *client_data);
141 static FLAC__StreamDecoderSeekStatus flac_decoder_seek_callback(const FLAC__StreamDecoder *decoder, FLAC__uint64 absolute_byte_offset, void *client_data);
142 static FLAC__StreamDecoderTellStatus flac_decoder_tell_callback(const FLAC__StreamDecoder *decoder, FLAC__uint64 *absolute_byte_offset, void *client_data);
143 static FLAC__StreamDecoderLengthStatus flac_decoder_length_callback(const FLAC__StreamDecoder *decoder, FLAC__uint64 *stream_length, void *client_data);
144 static FLAC__bool flac_decoder_eof_callback(const FLAC__StreamDecoder *decoder, void *client_data);
145 static FLAC__StreamDecoderWriteStatus flac_decoder_write_callback(const FLAC__StreamDecoder *decoder, const FLAC__Frame *frame, const FLAC__int32 * const buffer[], void *client_data);
146 static void flac_decoder_metadata_callback(const FLAC__StreamDecoder *decoder, const FLAC__StreamMetadata *metadata, void *client_data);
147 static void flac_decoder_error_callback(const FLAC__StreamDecoder *decoder, FLAC__StreamDecoderErrorStatus status, void *client_data);
148 static FLAC__bool parse_cuesheet(FLAC__StreamMetadata **cuesheet, const char *cuesheet_filename, const char *inbasefilename, unsigned sample_rate, FLAC__bool is_cdda, FLAC__uint64 lead_out_offset, FLAC__bool treat_warnings_as_errors);
149 static void print_stats(const EncoderSession *encoder_session);
150 static void print_error_with_init_status(const EncoderSession *e, const char *message, FLAC__StreamEncoderInitStatus init_status);
151 static void print_error_with_state(const EncoderSession *e, const char *message);
152 static void print_verify_error(EncoderSession *e);
153 static FLAC__bool read_bytes(FILE *f, FLAC__byte *buf, size_t n, FLAC__bool eof_ok, const char *fn);
154 static FLAC__bool read_uint16(FILE *f, FLAC__bool big_endian, FLAC__uint16 *val, const char *fn);
155 static FLAC__bool read_uint32(FILE *f, FLAC__bool big_endian, FLAC__uint32 *val, const char *fn);
156 static FLAC__bool read_uint64(FILE *f, FLAC__bool big_endian, FLAC__uint64 *val, const char *fn);
157 static FLAC__bool read_sane_extended(FILE *f, FLAC__uint32 *val, const char *fn);
158 static FLAC__bool fskip_ahead(FILE *f, FLAC__uint64 offset);
159 static unsigned count_channel_mask_bits(FLAC__uint32 mask);
161 static FLAC__uint32 limit_channel_mask(FLAC__uint32 mask, unsigned channels);
164 static FLAC__bool get_sample_info_raw(EncoderSession *e, encode_options_t options)
166 e->info.sample_rate = options.format_options.raw.sample_rate;
167 e->info.channels = options.format_options.raw.channels;
168 e->info.bits_per_sample = options.format_options.raw.bps;
170 e->info.bytes_per_wide_sample = options.format_options.raw.channels * ((options.format_options.raw.bps+7)/8);
171 e->info.is_unsigned_samples = options.format_options.raw.is_unsigned_samples;
172 e->info.is_big_endian = options.format_options.raw.is_big_endian;
173 e->info.channel_mask = 0;
178 static FLAC__bool get_sample_info_wave(EncoderSession *e, encode_options_t options)
180 FLAC__bool got_fmt_chunk = false, got_data_chunk = false, got_ds64_chunk = false;
181 unsigned sample_rate = 0, channels = 0, bps = 0, shift = 0;
182 FLAC__uint32 channel_mask = 0;
183 FLAC__uint64 ds64_data_size = 0;
185 e->info.is_unsigned_samples = false;
186 e->info.is_big_endian = false;
188 if(e->format == FORMAT_WAVE64) {
190 * lookahead[] already has "riff\x2E\x91\xCF\x11\xA5\xD6\x28\xDB", skip over remaining header
192 if(!fskip_ahead(e->fin, 16+8+16-12)) { /* riff GUID + riff size + WAVE GUID - lookahead */
193 flac__utils_printf(stderr, 1, "%s: ERROR during read while skipping over remaining \"riff\" header\n", e->inbasefilename);
197 /* else lookahead[] already has "RIFFxxxxWAVE" or "RF64xxxxWAVE" */
199 while(!feof(e->fin) && !got_data_chunk) {
200 /* chunk IDs are 4 bytes for WAVE/RF64, 16 for Wave64 */
201 /* for WAVE/RF64 we want the 5th char zeroed so we can treat it like a C string */
202 char chunk_id[16] = { '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0' };
204 if(!read_bytes(e->fin, (FLAC__byte*)chunk_id, e->format==FORMAT_WAVE64?16:4, /*eof_ok=*/true, e->inbasefilename)) {
205 flac__utils_printf(stderr, 1, "%s: ERROR: incomplete chunk identifier\n", e->inbasefilename);
211 if(e->format == FORMAT_RF64 && !memcmp(chunk_id, "ds64", 4)) { /* RF64 64-bit sizes chunk */
212 FLAC__uint32 xx, data_bytes;
215 flac__utils_printf(stderr, 1, "%s: ERROR: file has multiple 'ds64' chunks\n", e->inbasefilename);
218 if(got_fmt_chunk || got_data_chunk) {
219 flac__utils_printf(stderr, 1, "%s: ERROR: 'ds64' chunk appears after 'fmt ' or 'data' chunk\n", e->inbasefilename);
223 /* ds64 chunk size */
224 if(!read_uint32(e->fin, /*big_endian=*/false, &xx, e->inbasefilename))
227 if(data_bytes < 28) {
228 flac__utils_printf(stderr, 1, "%s: ERROR: non-standard 'ds64' chunk has length = %u\n", e->inbasefilename, (unsigned)data_bytes);
231 if(data_bytes & 1) /* should never happen, but enforce WAVE alignment rules */
234 /* RIFF 64-bit size, lo/hi */
235 if(!read_uint32(e->fin, /*big_endian=*/false, &xx, e->inbasefilename))
237 if(!read_uint32(e->fin, /*big_endian=*/false, &xx, e->inbasefilename))
240 /* 'data' 64-bit size */
241 if(!read_uint64(e->fin, /*big_endian=*/false, &ds64_data_size, e->inbasefilename))
246 /* skip any extra data in the ds64 chunk */
247 if(!fskip_ahead(e->fin, data_bytes)) {
248 flac__utils_printf(stderr, 1, "%s: ERROR during read while skipping over extra 'ds64' data\n", e->inbasefilename);
252 got_ds64_chunk = true;
255 !memcmp(chunk_id, "fmt ", 4) &&
256 (e->format!=FORMAT_WAVE64 || !memcmp(chunk_id, "fmt \xF3\xAC\xD3\x11\x8C\xD1\x00\xC0\x4F\x8E\xDB\x8A", 16))
257 ) { /* format chunk */
259 FLAC__uint32 xx, data_bytes;
260 FLAC__uint16 wFormatTag; /* wFormatTag word from the 'fmt ' chunk */
263 flac__utils_printf(stderr, 1, "%s: ERROR: file has multiple 'fmt ' chunks\n", e->inbasefilename);
268 * http://www-mmsp.ece.mcgill.ca/Documents/AudioFormats/WAVE/WAVE.html
269 * http://windowssdk.msdn.microsoft.com/en-us/library/ms713497.aspx
270 * 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
274 * 2 byte: format type: 1 for WAVE_FORMAT_PCM, 65534 for WAVE_FORMAT_EXTENSIBLE
276 * 4 byte: sample rate (Hz)
277 * 4 byte: avg bytes per sec
278 * 2 byte: block align
279 * 2 byte: bits per sample (not necessarily all significant)
281 * 2 byte: extension size in bytes (usually 0 for WAVEFORMATEX and 22 for WAVEFORMATEXTENSIBLE with PCM)
282 * WAVEFORMATEXTENSIBLE adds
283 * 2 byte: valid bits per sample
284 * 4 byte: channel mask
285 * 16 byte: subformat GUID, first 2 bytes have format type, 1 being PCM
287 * Current spec says WAVEFORMATEX with PCM must have bps == 8 or 16, or any multiple of 8 for WAVEFORMATEXTENSIBLE.
288 * 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.
290 * Block align for WAVE_FORMAT_PCM or WAVE_FORMAT_EXTENSIBLE is also supposed to be channels*bps/8
292 * If the channel mask has more set bits than # of channels, the extra MSBs are ignored.
293 * If the channel mask has less set bits than # of channels, the extra channels are unassigned to any speaker.
295 * Data is supposed to be unsigned for bps <= 8 else signed.
299 if(!read_uint32(e->fin, /*big_endian=*/false, &xx, e->inbasefilename))
302 if(e->format == FORMAT_WAVE64) {
303 /* other half of the size field should be 0 */
304 if(!read_uint32(e->fin, /*big_endian=*/false, &xx, e->inbasefilename))
307 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);
310 /* subtract size of header */
311 if (data_bytes < 16+8) {
312 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);
315 data_bytes -= (16+8);
317 if(data_bytes < 16) {
318 flac__utils_printf(stderr, 1, "%s: ERROR: non-standard 'fmt ' chunk has length = %u\n", e->inbasefilename, (unsigned)data_bytes);
321 if(e->format != FORMAT_WAVE64) {
322 if(data_bytes & 1) /* should never happen, but enforce WAVE alignment rules */
326 data_bytes = (data_bytes+7) & (~7u); /* should never happen, but enforce Wave64 alignment rules */
330 if(!read_uint16(e->fin, /*big_endian=*/false, &wFormatTag, e->inbasefilename))
332 if(wFormatTag != 1 /*WAVE_FORMAT_PCM*/ && wFormatTag != 65534 /*WAVE_FORMAT_EXTENSIBLE*/) {
333 flac__utils_printf(stderr, 1, "%s: ERROR: unsupported format type %u\n", e->inbasefilename, (unsigned)wFormatTag);
337 /* number of channels */
338 if(!read_uint16(e->fin, /*big_endian=*/false, &x, e->inbasefilename))
340 channels = (unsigned)x;
343 if(!read_uint32(e->fin, /*big_endian=*/false, &xx, e->inbasefilename))
347 /* avg bytes per second (ignored) */
348 if(!read_uint32(e->fin, /*big_endian=*/false, &xx, e->inbasefilename))
351 if(!read_uint16(e->fin, /*big_endian=*/false, &x, e->inbasefilename))
354 /* bits per sample */
355 if(!read_uint16(e->fin, /*big_endian=*/false, &x, e->inbasefilename))
359 e->info.is_unsigned_samples = (bps <= 8);
361 if(wFormatTag == 1) {
362 if(bps != 8 && bps != 16) {
363 if(bps == 24 || bps == 32) {
364 /* let these slide with a warning since they're unambiguous */
365 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);
366 if(e->treat_warnings_as_errors)
370 /* @@@ we could add an option to specify left- or right-justified blocks so we knew how to set 'shift' */
371 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);
375 #if 0 /* @@@ reinstate once we can get an answer about whether the samples are left- or right-justified */
376 if((bps+7)/8 * channels == block_align) {
378 /* assume legacy file is byte aligned with some LSBs zero; this is double-checked in format_input() */
379 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);
380 if(e->treat_warnings_as_errors)
382 shift = 8 - (bps % 8);
389 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);
395 if(channels > 2 && !options.channel_map_none) {
396 flac__utils_printf(stderr, 1, "%s: ERROR: WAVE has >2 channels but is not WAVE_FORMAT_EXTENSIBLE; cannot assign channels\n", e->inbasefilename);
399 FLAC__ASSERT(data_bytes >= 16);
403 if(data_bytes < 40) {
404 flac__utils_printf(stderr, 1, "%s: ERROR: invalid WAVEFORMATEXTENSIBLE chunk with size %u\n", e->inbasefilename, (unsigned)data_bytes);
408 if(!read_uint16(e->fin, /*big_endian=*/false, &x, e->inbasefilename))
411 flac__utils_printf(stderr, 1, "%s: ERROR: invalid WAVEFORMATEXTENSIBLE chunk with cbSize %u\n", e->inbasefilename, (unsigned)x);
415 if(!read_uint16(e->fin, /*big_endian=*/false, &x, e->inbasefilename))
417 if((unsigned)x > bps) {
418 flac__utils_printf(stderr, 1, "%s: ERROR: invalid WAVEFORMATEXTENSIBLE chunk with wValidBitsPerSample (%u) > wBitsPerSample (%u)\n", e->inbasefilename, (unsigned)x, bps);
421 shift = bps - (unsigned)x;
423 if(!read_uint32(e->fin, /*big_endian=*/false, &channel_mask, e->inbasefilename))
425 /* for mono/stereo and unassigned channels, we fake the mask */
426 if(channel_mask == 0) {
428 channel_mask = 0x0001;
429 else if(channels == 2)
430 channel_mask = 0x0003;
432 /* set channel mapping */
433 /* FLAC order follows SMPTE and WAVEFORMATEXTENSIBLE but with fewer channels, which are: */
434 /* front left, front right, center, LFE, back left, back right, surround left, surround right */
435 /* the default mapping is sufficient for 1-6 channels and 7-8 are currently unspecified anyway */
437 /* @@@ example for dolby/vorbis order, for reference later in case it becomes important */
439 options.channel_map_none ||
440 channel_mask == 0x0001 || /* 1 channel: (mono) */
441 channel_mask == 0x0003 || /* 2 channels: front left, front right */
442 channel_mask == 0x0033 || /* 4 channels: front left, front right, back left, back right */
443 channel_mask == 0x0603 /* 4 channels: front left, front right, side left, side right */
445 /* keep default channel order */
448 channel_mask == 0x0007 || /* 3 channels: front left, front right, front center */
449 channel_mask == 0x0037 || /* 5 channels: front left, front right, front center, back left, back right */
450 channel_mask == 0x0607 /* 5 channels: front left, front right, front center, side left, side right */
452 /* to dolby order: front left, center, front right [, surround left, surround right ] */
457 channel_mask == 0x003f || /* 6 channels: front left, front right, front center, LFE, back left, back right */
458 channel_mask == 0x060f || /* 6 channels: front left, front right, front center, LFE, side left, side right */
459 channel_mask == 0x070f || /* 7 channels: front left, front right, front center, LFE, back center, side left, side right */
460 channel_mask == 0x063f /* 8 channels: front left, front right, front center, LFE, back left, back right, side left, side right */
462 /* to dolby order: front left, center, front right, surround left, surround right, LFE */
471 options.channel_map_none ||
472 channel_mask == 0x0001 || /* 1 channel: (mono) */
473 channel_mask == 0x0003 || /* 2 channels: front left, front right */
474 channel_mask == 0x0007 || /* 3 channels: front left, front right, front center */
475 channel_mask == 0x0033 || /* 4 channels: front left, front right, back left, back right */
476 channel_mask == 0x0603 || /* 4 channels: front left, front right, side left, side right */
477 channel_mask == 0x0037 || /* 5 channels: front left, front right, front center, back left, back right */
478 channel_mask == 0x0607 || /* 5 channels: front left, front right, front center, side left, side right */
479 channel_mask == 0x003f || /* 6 channels: front left, front right, front center, LFE, back left, back right */
480 channel_mask == 0x060f || /* 6 channels: front left, front right, front center, LFE, side left, side right */
481 channel_mask == 0x070f || /* 7 channels: front left, front right, front center, LFE, back center, side left, side right */
482 channel_mask == 0x063f /* 8 channels: front left, front right, front center, LFE, back left, back right, side left, side right */
484 /* keep default channel order */
488 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);
491 if(!options.channel_map_none) {
492 if(count_channel_mask_bits(channel_mask) < channels) {
493 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);
497 /* supporting this is too difficult with channel mapping; e.g. what if mask is 0x003f but #channels=4?
498 * there would be holes in the order that would have to be filled in, or the mask would have to be
499 * limited and the logic above rerun to see if it still fits into the FLAC mapping.
501 else if(count_channel_mask_bits(channel_mask) > channels)
502 channel_mask = limit_channel_mask(channel_mask, channels);
504 else if(count_channel_mask_bits(channel_mask) > channels) {
505 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);
510 /* first part of GUID */
511 if(!read_uint16(e->fin, /*big_endian=*/false, &x, e->inbasefilename))
514 flac__utils_printf(stderr, 1, "%s: ERROR: unsupported WAVEFORMATEXTENSIBLE chunk with non-PCM format %u\n", e->inbasefilename, (unsigned)x);
520 e->info.bytes_per_wide_sample = channels * (bps / 8);
522 /* skip any extra data in the fmt chunk */
523 if(!fskip_ahead(e->fin, data_bytes)) {
524 flac__utils_printf(stderr, 1, "%s: ERROR during read while skipping over extra 'fmt' data\n", e->inbasefilename);
528 got_fmt_chunk = true;
531 !memcmp(chunk_id, "data", 4) &&
532 (e->format!=FORMAT_WAVE64 || !memcmp(chunk_id, "data\xF3\xAC\xD3\x11\x8C\xD1\x00\xC0\x4F\x8E\xDB\x8A", 16))
535 FLAC__uint64 data_bytes;
538 flac__utils_printf(stderr, 1, "%s: ERROR: got 'data' chunk before 'fmt' chunk\n", e->inbasefilename);
543 if(e->format != FORMAT_WAVE64) {
544 if(!read_uint32(e->fin, /*big_endian=*/false, &xx, e->inbasefilename))
549 if(!read_uint64(e->fin, /*big_endian=*/false, &data_bytes, e->inbasefilename))
551 /* subtract size of header */
552 if (data_bytes < 16+8) {
553 flac__utils_printf(stderr, 1, "%s: ERROR: freakishly small Wave64 'data' chunk has length = 0x00000000%08X\n", e->inbasefilename, (unsigned)data_bytes);
556 data_bytes -= (16+8);
558 if(e->format == FORMAT_RF64) {
559 if(!got_ds64_chunk) {
560 flac__utils_printf(stderr, 1, "%s: ERROR: RF64 file has no 'ds64' chunk before 'data' chunk\n", e->inbasefilename);
563 if(data_bytes == 0xffffffff)
564 data_bytes = ds64_data_size;
566 if(options.ignore_chunk_sizes) {
567 FLAC__ASSERT(!options.sector_align);
569 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);
570 if(e->treat_warnings_as_errors)
573 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 */
575 else if(0 == data_bytes) {
576 flac__utils_printf(stderr, 1, "%s: ERROR: 'data' chunk has size of 0\n", e->inbasefilename);
580 e->fmt.iff.data_bytes = data_bytes;
582 got_data_chunk = true;
588 if(!options.format_options.iff.foreign_metadata) {
589 if(e->format != FORMAT_WAVE64)
590 flac__utils_printf(stderr, 1, "%s: WARNING: skipping unknown chunk '%s' (use --keep-foreign-metadata to keep)\n", e->inbasefilename, chunk_id);
592 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",
594 (unsigned)((const unsigned char *)chunk_id)[3],
595 (unsigned)((const unsigned char *)chunk_id)[2],
596 (unsigned)((const unsigned char *)chunk_id)[1],
597 (unsigned)((const unsigned char *)chunk_id)[0],
598 (unsigned)((const unsigned char *)chunk_id)[5],
599 (unsigned)((const unsigned char *)chunk_id)[4],
600 (unsigned)((const unsigned char *)chunk_id)[7],
601 (unsigned)((const unsigned char *)chunk_id)[6],
602 (unsigned)((const unsigned char *)chunk_id)[9],
603 (unsigned)((const unsigned char *)chunk_id)[8],
604 (unsigned)((const unsigned char *)chunk_id)[10],
605 (unsigned)((const unsigned char *)chunk_id)[11],
606 (unsigned)((const unsigned char *)chunk_id)[12],
607 (unsigned)((const unsigned char *)chunk_id)[13],
608 (unsigned)((const unsigned char *)chunk_id)[14],
609 (unsigned)((const unsigned char *)chunk_id)[15]
611 if(e->treat_warnings_as_errors)
616 if(e->format != FORMAT_WAVE64) {
617 if(!read_uint32(e->fin, /*big_endian=*/false, &xx, e->inbasefilename))
623 if(!read_uint64(e->fin, /*big_endian=*/false, &skip, e->inbasefilename))
625 skip = (skip+7) & (~(FLAC__uint64)7);
626 /* subtract size of header */
628 flac__utils_printf(stderr, 1, "%s: ERROR: freakishly small Wave64 chunk has length = 0x00000000%08X\n", e->inbasefilename, (unsigned)skip);
634 if(!fskip_ahead(e->fin, skip)) {
635 flac__utils_printf(stderr, 1, "%s: ERROR during read while skipping over chunk\n", e->inbasefilename);
643 flac__utils_printf(stderr, 1, "%s: ERROR: didn't find fmt chunk\n", e->inbasefilename);
646 if(!got_data_chunk) {
647 flac__utils_printf(stderr, 1, "%s: ERROR: didn't find data chunk\n", e->inbasefilename);
651 e->info.sample_rate = sample_rate;
652 e->info.channels = channels;
653 e->info.bits_per_sample = bps;
654 e->info.shift = shift;
655 e->info.channel_mask = channel_mask;
660 static FLAC__bool get_sample_info_aiff(EncoderSession *e, encode_options_t options)
662 FLAC__bool got_comm_chunk = false, got_ssnd_chunk = false;
663 unsigned sample_rate = 0, channels = 0, bps = 0, shift = 0;
664 FLAC__uint64 sample_frames = 0;
665 FLAC__uint32 channel_mask = 0;
667 e->info.is_unsigned_samples = false;
668 e->info.is_big_endian = true;
671 * lookahead[] already has "FORMxxxxAIFF", do chunks
673 while(!feof(e->fin) && !got_ssnd_chunk) {
674 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 */
675 if(!read_bytes(e->fin, (FLAC__byte*)chunk_id, 4, /*eof_ok=*/true, e->inbasefilename)) {
676 flac__utils_printf(stderr, 1, "%s: ERROR: incomplete chunk identifier\n", e->inbasefilename);
682 if(!memcmp(chunk_id, "COMM", 4)) { /* common chunk */
686 const FLAC__bool is_aifc = e->format == FORMAT_AIFF_C;
687 const FLAC__uint32 minimum_comm_size = (is_aifc? 22 : 18);
690 flac__utils_printf(stderr, 1, "%s: ERROR: file has multiple 'COMM' chunks\n", e->inbasefilename);
694 /* COMM chunk size */
695 if(!read_uint32(e->fin, /*big_endian=*/true, &xx, e->inbasefilename))
697 else if(xx < minimum_comm_size) {
698 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);
701 else if(!is_aifc && xx != minimum_comm_size) {
702 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);
703 if(e->treat_warnings_as_errors)
706 skip = (xx-minimum_comm_size)+(xx & 1);
708 /* number of channels */
709 if(!read_uint16(e->fin, /*big_endian=*/true, &x, e->inbasefilename))
711 channels = (unsigned)x;
712 if(channels > 2 && !options.channel_map_none) {
713 flac__utils_printf(stderr, 1, "%s: ERROR: unsupported number of channels %u for AIFF\n", e->inbasefilename, channels);
717 /* number of sample frames */
718 if(!read_uint32(e->fin, /*big_endian=*/true, &xx, e->inbasefilename))
722 /* bits per sample */
723 if(!read_uint16(e->fin, /*big_endian=*/true, &x, e->inbasefilename))
726 shift = (bps%8)? 8-(bps%8) : 0; /* SSND data is always byte-aligned, left-justified but format_input() will double-check */
730 if(!read_sane_extended(e->fin, &xx, e->inbasefilename))
734 /* check compression type for AIFF-C */
736 if(!read_uint32(e->fin, /*big_endian=*/true, &xx, e->inbasefilename))
738 if(xx == 0x736F7774) /* "sowt" */
739 e->info.is_big_endian = false;
740 else if(xx == 0x4E4F4E45) /* "NONE" */
741 ; /* nothing to do, we already default to big-endian */
743 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));
748 /* set channel mapping */
749 /* FLAC order follows SMPTE and WAVEFORMATEXTENSIBLE but with fewer channels, which are: */
750 /* front left, front right, center, LFE, back left, back right, surround left, surround right */
751 /* specs say the channel ordering is:
753 * ___________________________________________________
757 * quad (ambiguous with 4ch) Fl Fr Bl Br
760 * 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
761 * so we only have unambiguous mappings for 2, 3, and 5 channels
764 options.channel_map_none ||
765 channels == 1 || /* 1 channel: (mono) */
766 channels == 2 || /* 2 channels: left, right */
767 channels == 3 || /* 3 channels: left, right, center */
768 channels == 5 /* 5 channels: front left, front right, center, surround left, surround right */
770 /* keep default channel order */
773 flac__utils_printf(stderr, 1, "%s: ERROR: unsupported number of channels %u for AIFF\n", e->inbasefilename, channels);
777 e->info.bytes_per_wide_sample = channels * (bps / 8);
779 /* skip any extra data in the COMM chunk */
780 if(!fskip_ahead(e->fin, skip)) {
781 flac__utils_printf(stderr, 1, "%s: ERROR during read while skipping over extra COMM data\n", e->inbasefilename);
785 got_comm_chunk = true;
787 else if(!memcmp(chunk_id, "SSND", 4) && !got_ssnd_chunk) { /* sound data chunk */
789 FLAC__uint64 data_bytes;
792 if(!got_comm_chunk) {
793 flac__utils_printf(stderr, 1, "%s: ERROR: got 'SSND' chunk before 'COMM' chunk\n", e->inbasefilename);
797 /* SSND chunk size */
798 if(!read_uint32(e->fin, /*big_endian=*/true, &xx, e->inbasefilename))
801 if(options.ignore_chunk_sizes) {
802 FLAC__ASSERT(!options.sector_align);
804 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);
805 if(e->treat_warnings_as_errors)
808 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 */
810 else if(data_bytes <= 8) {
811 flac__utils_printf(stderr, 1, "%s: ERROR: 'SSND' chunk has size <= 8\n", e->inbasefilename);
815 data_bytes -= 8; /* discount the offset and block size fields */
819 if(!read_uint32(e->fin, /*big_endian=*/true, &xx, e->inbasefilename))
822 data_bytes -= offset;
825 if(!read_uint32(e->fin, /*big_endian=*/true, &xx, e->inbasefilename))
827 if(xx && !options.ignore_chunk_sizes)
828 data_bytes -= (xx - (data_bytes % xx));
829 if(options.ignore_chunk_sizes) {
831 flac__utils_printf(stderr, 1, "%s: WARNING: 'SSND' chunk has non-zero blocksize, using --ignore-chunk-sizes is probably a bad idea\n", e->inbasefilename, chunk_id);
832 if(e->treat_warnings_as_errors)
837 /* skip any SSND offset bytes */
838 if(!fskip_ahead(e->fin, offset)) {
839 flac__utils_printf(stderr, 1, "%s: ERROR: skipping offset in SSND chunk\n", e->inbasefilename);
843 e->fmt.iff.data_bytes = data_bytes;
845 got_ssnd_chunk = true;
849 if(!options.format_options.iff.foreign_metadata) {
850 flac__utils_printf(stderr, 1, "%s: WARNING: skipping unknown chunk '%s' (use --keep-foreign-metadata to keep)\n", e->inbasefilename, chunk_id);
851 if(e->treat_warnings_as_errors)
856 if(!read_uint32(e->fin, /*big_endian=*/true, &xx, e->inbasefilename))
859 unsigned long skip = xx + (xx & 1);
861 FLAC__ASSERT(skip <= LONG_MAX);
862 if(!fskip_ahead(e->fin, skip)) {
863 flac__utils_printf(stderr, 1, "%s: ERROR during read while skipping over chunk\n", e->inbasefilename);
870 if(!got_comm_chunk) {
871 flac__utils_printf(stderr, 1, "%s: ERROR: didn't find COMM chunk\n", e->inbasefilename);
874 if(!got_ssnd_chunk && sample_frames) {
875 flac__utils_printf(stderr, 1, "%s: ERROR: didn't find SSND chunk\n", e->inbasefilename);
879 e->info.sample_rate = sample_rate;
880 e->info.channels = channels;
881 e->info.bits_per_sample = bps;
882 e->info.shift = shift;
883 e->info.channel_mask = channel_mask;
888 static FLAC__bool get_sample_info_flac(EncoderSession *e)
891 FLAC__stream_decoder_set_md5_checking(e->fmt.flac.decoder, false) &&
892 FLAC__stream_decoder_set_metadata_respond_all(e->fmt.flac.decoder)
894 flac__utils_printf(stderr, 1, "%s: ERROR: setting up decoder for FLAC input\n", e->inbasefilename);
898 if (e->format == FORMAT_OGGFLAC) {
899 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) {
900 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));
904 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) {
905 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));
909 if (!FLAC__stream_decoder_process_until_end_of_metadata(e->fmt.flac.decoder) || e->fmt.flac.client_data.fatal_error) {
910 if (e->fmt.flac.client_data.fatal_error)
911 flac__utils_printf(stderr, 1, "%s: ERROR: out of memory or too many metadata blocks while reading metadata in FLAC input\n", e->inbasefilename);
913 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));
917 if (e->fmt.flac.client_data.num_metadata_blocks == 0) {
918 flac__utils_printf(stderr, 1, "%s: ERROR: reading metadata in FLAC input, got no metadata blocks\n", e->inbasefilename);
921 else if (e->fmt.flac.client_data.metadata_blocks[0]->type != FLAC__METADATA_TYPE_STREAMINFO) {
922 flac__utils_printf(stderr, 1, "%s: ERROR: reading metadata in FLAC input, first metadata block is not STREAMINFO\n", e->inbasefilename);
925 else if (e->fmt.flac.client_data.metadata_blocks[0]->data.stream_info.total_samples == 0) {
926 flac__utils_printf(stderr, 1, "%s: ERROR: FLAC input has STREAMINFO with unknown total samples which is not supported\n", e->inbasefilename);
930 e->info.sample_rate = e->fmt.flac.client_data.metadata_blocks[0]->data.stream_info.sample_rate;
931 e->info.channels = e->fmt.flac.client_data.metadata_blocks[0]->data.stream_info.channels;
932 e->info.bits_per_sample = e->fmt.flac.client_data.metadata_blocks[0]->data.stream_info.bits_per_sample;
934 e->info.bytes_per_wide_sample = 0;
935 e->info.is_unsigned_samples = false; /* not applicable for FLAC input */
936 e->info.is_big_endian = false; /* not applicable for FLAC input */
937 e->info.channel_mask = 0;
945 int flac__encode_file(FILE *infile, FLAC__off_t infilesize, const char *infilename, const char *outfilename, const FLAC__byte *lookahead, unsigned lookahead_length, encode_options_t options)
947 EncoderSession encoder_session;
948 size_t channel_map[FLAC__MAX_CHANNELS];
949 int info_align_carry = -1, info_align_zero = -1;
951 if(!EncoderSession_construct(&encoder_session, options, infilesize, infile, infilename, outfilename, lookahead, lookahead_length))
954 /* initialize default channel map that preserves channel order */
957 for(i = 0; i < sizeof(channel_map)/sizeof(channel_map[0]); i++)
961 /* read foreign metadata if requested */
962 if(EncoderSession_format_is_iff(&encoder_session) && options.format_options.iff.foreign_metadata) {
965 options.format == FORMAT_WAVE || options.format == FORMAT_RF64?
966 flac__foreign_metadata_read_from_wave(options.format_options.iff.foreign_metadata, infilename, &error) :
967 options.format == FORMAT_WAVE64?
968 flac__foreign_metadata_read_from_wave64(options.format_options.iff.foreign_metadata, infilename, &error) :
969 flac__foreign_metadata_read_from_aiff(options.format_options.iff.foreign_metadata, infilename, &error)
971 flac__utils_printf(stderr, 1, "%s: ERROR reading foreign metadata: %s\n", encoder_session.inbasefilename, error);
972 return EncoderSession_finish_error(&encoder_session);
976 /* initialize encoder session with info about the audio (channels/bps/resolution/endianness/etc) */
977 switch(options.format) {
979 if(!get_sample_info_raw(&encoder_session, options))
980 return EncoderSession_finish_error(&encoder_session);
985 if(!get_sample_info_wave(&encoder_session, options))
986 return EncoderSession_finish_error(&encoder_session);
990 if(!get_sample_info_aiff(&encoder_session, options))
991 return EncoderSession_finish_error(&encoder_session);
996 * set up FLAC decoder for the input
998 if (0 == (encoder_session.fmt.flac.decoder = FLAC__stream_decoder_new())) {
999 flac__utils_printf(stderr, 1, "%s: ERROR: creating decoder for FLAC input\n", encoder_session.inbasefilename);
1000 return EncoderSession_finish_error(&encoder_session);
1002 if(!get_sample_info_flac(&encoder_session))
1003 return EncoderSession_finish_error(&encoder_session);
1007 /* double protection */
1008 return EncoderSession_finish_error(&encoder_session);
1011 /* some more checks */
1012 if(encoder_session.info.channels == 0 || encoder_session.info.channels > FLAC__MAX_CHANNELS) {
1013 flac__utils_printf(stderr, 1, "%s: ERROR: unsupported number of channels %u\n", encoder_session.inbasefilename, encoder_session.info.channels);
1014 return EncoderSession_finish_error(&encoder_session);
1016 if(!FLAC__format_sample_rate_is_valid(encoder_session.info.sample_rate)) {
1017 flac__utils_printf(stderr, 1, "%s: ERROR: unsupported sample rate %u\n", encoder_session.inbasefilename, encoder_session.info.sample_rate);
1018 return EncoderSession_finish_error(&encoder_session);
1020 if(encoder_session.info.bits_per_sample-encoder_session.info.shift < 4 || encoder_session.info.bits_per_sample-encoder_session.info.shift > 24) {
1021 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);
1022 return EncoderSession_finish_error(&encoder_session);
1024 if(options.sector_align) {
1025 if(encoder_session.info.channels != 2) {
1026 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);
1027 return EncoderSession_finish_error(&encoder_session);
1029 if(encoder_session.info.sample_rate != 44100) {
1030 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);
1031 return EncoderSession_finish_error(&encoder_session);
1033 if(encoder_session.info.bits_per_sample-encoder_session.info.shift != 16) {
1034 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);
1035 return EncoderSession_finish_error(&encoder_session);
1040 FLAC__uint64 total_samples_in_input; /* WATCHOUT: may be 0 to mean "unknown" */
1042 FLAC__uint64 until; /* a value of 0 mean end-of-stream (i.e. --until=-0) */
1043 unsigned align_remainder = 0;
1045 switch(options.format) {
1048 total_samples_in_input = 0;
1050 total_samples_in_input = (FLAC__uint64)infilesize / encoder_session.info.bytes_per_wide_sample + *options.align_reservoir_samples;
1057 /* truncation in the division removes any padding byte that was counted in encoder_session.fmt.iff.data_bytes */
1058 total_samples_in_input = encoder_session.fmt.iff.data_bytes / encoder_session.info.bytes_per_wide_sample + *options.align_reservoir_samples;
1061 case FORMAT_OGGFLAC:
1062 total_samples_in_input = encoder_session.fmt.flac.client_data.metadata_blocks[0]->data.stream_info.total_samples + *options.align_reservoir_samples;
1066 /* double protection */
1067 return EncoderSession_finish_error(&encoder_session);
1071 * now that we know the sample rate, canonicalize the
1072 * --skip string to an absolute sample number:
1074 flac__utils_canonicalize_skip_until_specification(&options.skip_specification, encoder_session.info.sample_rate);
1075 FLAC__ASSERT(options.skip_specification.value.samples >= 0);
1076 skip = (FLAC__uint64)options.skip_specification.value.samples;
1077 FLAC__ASSERT(!options.sector_align || (options.format != FORMAT_FLAC && options.format != FORMAT_OGGFLAC && skip == 0));
1078 /* *options.align_reservoir_samples will be 0 unless --sector-align is used */
1079 FLAC__ASSERT(options.sector_align || *options.align_reservoir_samples == 0);
1082 * now that we possibly know the input size, canonicalize the
1083 * --until string to an absolute sample number:
1085 if(!canonicalize_until_specification(&options.until_specification, encoder_session.inbasefilename, encoder_session.info.sample_rate, skip, total_samples_in_input))
1086 return EncoderSession_finish_error(&encoder_session);
1087 until = (FLAC__uint64)options.until_specification.value.samples;
1088 FLAC__ASSERT(!options.sector_align || until == 0);
1090 /* adjust encoding parameters based on skip and until values */
1091 switch(options.format) {
1093 infilesize -= (FLAC__off_t)skip * encoder_session.info.bytes_per_wide_sample;
1094 encoder_session.total_samples_to_encode = total_samples_in_input - skip;
1101 encoder_session.fmt.iff.data_bytes -= skip * encoder_session.info.bytes_per_wide_sample;
1102 if(options.ignore_chunk_sizes) {
1103 encoder_session.total_samples_to_encode = 0;
1104 flac__utils_printf(stderr, 2, "(No runtime statistics possible; please wait for encoding to finish...)\n");
1105 FLAC__ASSERT(0 == until);
1108 encoder_session.total_samples_to_encode = total_samples_in_input - skip;
1112 case FORMAT_OGGFLAC:
1113 encoder_session.total_samples_to_encode = total_samples_in_input - skip;
1117 /* double protection */
1118 return EncoderSession_finish_error(&encoder_session);
1121 const FLAC__uint64 trim = total_samples_in_input - until;
1122 FLAC__ASSERT(total_samples_in_input > 0);
1123 FLAC__ASSERT(!options.sector_align);
1124 if(options.format == FORMAT_RAW)
1125 infilesize -= (FLAC__off_t)trim * encoder_session.info.bytes_per_wide_sample;
1126 else if(EncoderSession_format_is_iff(&encoder_session))
1127 encoder_session.fmt.iff.data_bytes -= trim * encoder_session.info.bytes_per_wide_sample;
1128 encoder_session.total_samples_to_encode -= trim;
1130 if(options.sector_align && (options.format != FORMAT_RAW || infilesize >=0)) { /* for RAW, need to know the filesize */
1131 FLAC__ASSERT(skip == 0); /* asserted above too, but lest we forget */
1132 align_remainder = (unsigned)(encoder_session.total_samples_to_encode % 588);
1133 if(options.is_last_file)
1134 encoder_session.total_samples_to_encode += (588-align_remainder); /* will pad with zeroes */
1136 encoder_session.total_samples_to_encode -= align_remainder; /* will stop short and carry over to next file */
1138 switch(options.format) {
1140 encoder_session.unencoded_size = encoder_session.total_samples_to_encode * encoder_session.info.bytes_per_wide_sample;
1143 /* +44 for the size of the WAVE headers; this is just an estimate for the progress indicator and doesn't need to be exact */
1144 encoder_session.unencoded_size = encoder_session.total_samples_to_encode * encoder_session.info.bytes_per_wide_sample + 44;
1147 /* +44 for the size of the WAVE headers; this is just an estimate for the progress indicator and doesn't need to be exact */
1148 encoder_session.unencoded_size = encoder_session.total_samples_to_encode * encoder_session.info.bytes_per_wide_sample + 104;
1151 /* +72 for the size of the RF64 headers; this is just an estimate for the progress indicator and doesn't need to be exact */
1152 encoder_session.unencoded_size = encoder_session.total_samples_to_encode * encoder_session.info.bytes_per_wide_sample + 80;
1156 /* +54 for the size of the AIFF 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 + 54;
1160 case FORMAT_OGGFLAC:
1162 /* if we don't know, use 0 as hint to progress indicator (which is the only place this is used): */
1163 encoder_session.unencoded_size = 0;
1164 else if(skip == 0 && until == 0)
1165 encoder_session.unencoded_size = (FLAC__uint64)infilesize;
1166 else if(total_samples_in_input)
1167 encoder_session.unencoded_size = (FLAC__uint64)infilesize * encoder_session.total_samples_to_encode / total_samples_in_input;
1169 encoder_session.unencoded_size = (FLAC__uint64)infilesize;
1173 /* double protection */
1174 return EncoderSession_finish_error(&encoder_session);
1177 if(encoder_session.total_samples_to_encode == 0)
1178 flac__utils_printf(stderr, 2, "(No runtime statistics possible; please wait for encoding to finish...)\n");
1180 if(options.format == FORMAT_FLAC || options.format == FORMAT_OGGFLAC)
1181 encoder_session.fmt.flac.client_data.samples_left_to_process = encoder_session.total_samples_to_encode;
1183 /* init the encoder */
1184 if(!EncoderSession_init_encoder(&encoder_session, options))
1185 return EncoderSession_finish_error(&encoder_session);
1187 /* skip over any samples as requested */
1189 switch(options.format) {
1192 unsigned skip_bytes = encoder_session.info.bytes_per_wide_sample * (unsigned)skip;
1193 if(skip_bytes > lookahead_length) {
1194 skip_bytes -= lookahead_length;
1195 lookahead_length = 0;
1196 if(!fskip_ahead(encoder_session.fin, skip_bytes)) {
1197 flac__utils_printf(stderr, 1, "%s: ERROR during read while skipping samples\n", encoder_session.inbasefilename);
1198 return EncoderSession_finish_error(&encoder_session);
1202 lookahead += skip_bytes;
1203 lookahead_length -= skip_bytes;
1212 if(!fskip_ahead(encoder_session.fin, skip * encoder_session.info.bytes_per_wide_sample)) {
1213 flac__utils_printf(stderr, 1, "%s: ERROR during read while skipping samples\n", encoder_session.inbasefilename);
1214 return EncoderSession_finish_error(&encoder_session);
1218 case FORMAT_OGGFLAC:
1220 * have to wait until the FLAC encoder is set up for writing
1221 * before any seeking in the input FLAC file, because the seek
1222 * itself will usually call the decoder's write callback, and
1223 * our decoder's write callback passes samples to our FLAC
1226 if(!FLAC__stream_decoder_seek_absolute(encoder_session.fmt.flac.decoder, skip)) {
1227 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));
1228 return EncoderSession_finish_error(&encoder_session);
1233 /* double protection */
1234 return EncoderSession_finish_error(&encoder_session);
1239 * first do any samples in the reservoir
1241 if(options.sector_align && *options.align_reservoir_samples > 0) {
1242 FLAC__ASSERT(options.format != FORMAT_FLAC && options.format != FORMAT_OGGFLAC); /* check again */
1243 if(!EncoderSession_process(&encoder_session, (const FLAC__int32 * const *)options.align_reservoir, *options.align_reservoir_samples)) {
1244 print_error_with_state(&encoder_session, "ERROR during encoding");
1245 return EncoderSession_finish_error(&encoder_session);
1250 * decrement infilesize or the data_bytes counter if we need to align the file
1252 if(options.sector_align) {
1253 if(options.is_last_file) {
1254 *options.align_reservoir_samples = 0;
1257 *options.align_reservoir_samples = align_remainder;
1258 if(options.format == FORMAT_RAW) {
1259 FLAC__ASSERT(infilesize >= 0);
1260 infilesize -= (FLAC__off_t)((*options.align_reservoir_samples) * encoder_session.info.bytes_per_wide_sample);
1261 FLAC__ASSERT(infilesize >= 0);
1263 else if(EncoderSession_format_is_iff(&encoder_session))
1264 encoder_session.fmt.iff.data_bytes -= (*options.align_reservoir_samples) * encoder_session.info.bytes_per_wide_sample;
1269 * now do samples from the file
1271 switch(options.format) {
1273 if(infilesize < 0) {
1275 while(!feof(infile)) {
1276 if(lookahead_length > 0) {
1277 FLAC__ASSERT(lookahead_length < CHUNK_OF_SAMPLES * encoder_session.info.bytes_per_wide_sample);
1278 memcpy(ucbuffer_, lookahead, lookahead_length);
1279 bytes_read = fread(ucbuffer_+lookahead_length, sizeof(unsigned char), CHUNK_OF_SAMPLES * encoder_session.info.bytes_per_wide_sample - lookahead_length, infile) + lookahead_length;
1280 if(ferror(infile)) {
1281 flac__utils_printf(stderr, 1, "%s: ERROR during read\n", encoder_session.inbasefilename);
1282 return EncoderSession_finish_error(&encoder_session);
1284 lookahead_length = 0;
1287 bytes_read = fread(ucbuffer_, sizeof(unsigned char), CHUNK_OF_SAMPLES * encoder_session.info.bytes_per_wide_sample, infile);
1289 if(bytes_read == 0) {
1290 if(ferror(infile)) {
1291 flac__utils_printf(stderr, 1, "%s: ERROR during read\n", encoder_session.inbasefilename);
1292 return EncoderSession_finish_error(&encoder_session);
1295 else if(bytes_read % encoder_session.info.bytes_per_wide_sample != 0) {
1296 flac__utils_printf(stderr, 1, "%s: ERROR: got partial sample\n", encoder_session.inbasefilename);
1297 return EncoderSession_finish_error(&encoder_session);
1300 unsigned wide_samples = bytes_read / encoder_session.info.bytes_per_wide_sample;
1301 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))
1302 return EncoderSession_finish_error(&encoder_session);
1304 if(!EncoderSession_process(&encoder_session, (const FLAC__int32 * const *)input_, wide_samples)) {
1305 print_error_with_state(&encoder_session, "ERROR during encoding");
1306 return EncoderSession_finish_error(&encoder_session);
1313 const FLAC__uint64 max_input_bytes = infilesize;
1314 FLAC__uint64 total_input_bytes_read = 0;
1315 while(total_input_bytes_read < max_input_bytes) {
1317 size_t wanted = (CHUNK_OF_SAMPLES * encoder_session.info.bytes_per_wide_sample);
1318 wanted = (size_t) min((FLAC__uint64)wanted, max_input_bytes - total_input_bytes_read);
1320 if(lookahead_length > 0) {
1321 FLAC__ASSERT(lookahead_length <= wanted);
1322 memcpy(ucbuffer_, lookahead, lookahead_length);
1323 wanted -= lookahead_length;
1324 bytes_read = lookahead_length;
1326 bytes_read += fread(ucbuffer_+lookahead_length, sizeof(unsigned char), wanted, infile);
1327 if(ferror(infile)) {
1328 flac__utils_printf(stderr, 1, "%s: ERROR during read\n", encoder_session.inbasefilename);
1329 return EncoderSession_finish_error(&encoder_session);
1332 lookahead_length = 0;
1335 bytes_read = fread(ucbuffer_, sizeof(unsigned char), wanted, infile);
1338 if(bytes_read == 0) {
1339 if(ferror(infile)) {
1340 flac__utils_printf(stderr, 1, "%s: ERROR during read\n", encoder_session.inbasefilename);
1341 return EncoderSession_finish_error(&encoder_session);
1343 else if(feof(infile)) {
1344 flac__utils_printf(stderr, 1, "%s: WARNING: unexpected EOF; expected %" PRIu64 " samples, got %" PRIu64 " samples\n", encoder_session.inbasefilename, encoder_session.total_samples_to_encode, encoder_session.samples_written);
1345 if(encoder_session.treat_warnings_as_errors)
1346 return EncoderSession_finish_error(&encoder_session);
1347 total_input_bytes_read = max_input_bytes;
1351 if(bytes_read % encoder_session.info.bytes_per_wide_sample != 0) {
1352 flac__utils_printf(stderr, 1, "%s: ERROR: got partial sample\n", encoder_session.inbasefilename);
1353 return EncoderSession_finish_error(&encoder_session);
1356 unsigned wide_samples = bytes_read / encoder_session.info.bytes_per_wide_sample;
1357 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))
1358 return EncoderSession_finish_error(&encoder_session);
1360 if(!EncoderSession_process(&encoder_session, (const FLAC__int32 * const *)input_, wide_samples)) {
1361 print_error_with_state(&encoder_session, "ERROR during encoding");
1362 return EncoderSession_finish_error(&encoder_session);
1364 total_input_bytes_read += bytes_read;
1375 while(encoder_session.fmt.iff.data_bytes > 0) {
1376 const size_t bytes_to_read = (size_t)min(
1377 encoder_session.fmt.iff.data_bytes,
1378 (FLAC__uint64)CHUNK_OF_SAMPLES * (FLAC__uint64)encoder_session.info.bytes_per_wide_sample
1380 size_t bytes_read = fread(ucbuffer_, sizeof(unsigned char), bytes_to_read, infile);
1381 if(bytes_read == 0) {
1382 if(ferror(infile)) {
1383 flac__utils_printf(stderr, 1, "%s: ERROR during read\n", encoder_session.inbasefilename);
1384 return EncoderSession_finish_error(&encoder_session);
1386 else if(feof(infile)) {
1387 if(options.ignore_chunk_sizes) {
1388 flac__utils_printf(stderr, 1, "%s: INFO: hit EOF with --ignore-chunk-sizes, got %" PRIu64 " samples\n", encoder_session.inbasefilename, encoder_session.samples_written);
1391 flac__utils_printf(stderr, 1, "%s: WARNING: unexpected EOF; expected %" PRIu64 " samples, got %" PRIu64 " samples\n", encoder_session.inbasefilename, encoder_session.total_samples_to_encode, encoder_session.samples_written);
1392 if(encoder_session.treat_warnings_as_errors)
1393 return EncoderSession_finish_error(&encoder_session);
1395 encoder_session.fmt.iff.data_bytes = 0;
1399 if(bytes_read % encoder_session.info.bytes_per_wide_sample != 0) {
1400 flac__utils_printf(stderr, 1, "%s: ERROR: got partial sample\n", encoder_session.inbasefilename);
1401 return EncoderSession_finish_error(&encoder_session);
1404 unsigned wide_samples = bytes_read / encoder_session.info.bytes_per_wide_sample;
1405 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))
1406 return EncoderSession_finish_error(&encoder_session);
1408 if(!EncoderSession_process(&encoder_session, (const FLAC__int32 * const *)input_, wide_samples)) {
1409 print_error_with_state(&encoder_session, "ERROR during encoding");
1410 return EncoderSession_finish_error(&encoder_session);
1412 encoder_session.fmt.iff.data_bytes -= bytes_read;
1418 case FORMAT_OGGFLAC:
1419 while(!encoder_session.fmt.flac.client_data.fatal_error && encoder_session.fmt.flac.client_data.samples_left_to_process > 0) {
1420 /* We can also hit the end of stream without samples_left_to_process
1421 * going to 0 if there are errors and continue_through_decode_errors
1422 * is on, so we want to break in that case too:
1424 if(encoder_session.continue_through_decode_errors && FLAC__stream_decoder_get_state(encoder_session.fmt.flac.decoder) == FLAC__STREAM_DECODER_END_OF_STREAM)
1426 if(!FLAC__stream_decoder_process_single(encoder_session.fmt.flac.decoder)) {
1427 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));
1428 return EncoderSession_finish_error(&encoder_session);
1431 if(encoder_session.fmt.flac.client_data.fatal_error) {
1432 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));
1433 return EncoderSession_finish_error(&encoder_session);
1438 /* double protection */
1439 return EncoderSession_finish_error(&encoder_session);
1443 * now read unaligned samples into reservoir or pad with zeroes if necessary
1445 if(options.sector_align) {
1446 if(options.is_last_file) {
1447 unsigned wide_samples = 588 - align_remainder;
1448 if(wide_samples < 588) {
1451 info_align_zero = wide_samples;
1452 for(channel = 0; channel < encoder_session.info.channels; channel++)
1453 memset(input_[channel], 0, sizeof(input_[0][0]) * wide_samples);
1455 if(!EncoderSession_process(&encoder_session, (const FLAC__int32 * const *)input_, wide_samples)) {
1456 print_error_with_state(&encoder_session, "ERROR during encoding");
1457 return EncoderSession_finish_error(&encoder_session);
1462 if(*options.align_reservoir_samples > 0) {
1464 FLAC__ASSERT(CHUNK_OF_SAMPLES >= 588);
1465 bytes_read = fread(ucbuffer_, sizeof(unsigned char), (*options.align_reservoir_samples) * encoder_session.info.bytes_per_wide_sample, infile);
1466 if(bytes_read == 0 && ferror(infile)) {
1467 flac__utils_printf(stderr, 1, "%s: ERROR during read\n", encoder_session.inbasefilename);
1468 return EncoderSession_finish_error(&encoder_session);
1470 else if(bytes_read != (*options.align_reservoir_samples) * encoder_session.info.bytes_per_wide_sample) {
1471 flac__utils_printf(stderr, 1, "%s: WARNING: unexpected EOF; read %" PRIu64 " bytes; expected %" PRIu64 " samples, got %" PRIu64 " samples\n", encoder_session.inbasefilename, bytes_read, encoder_session.total_samples_to_encode, encoder_session.samples_written);
1472 if(encoder_session.treat_warnings_as_errors)
1473 return EncoderSession_finish_error(&encoder_session);
1476 info_align_carry = *options.align_reservoir_samples;
1477 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))
1478 return EncoderSession_finish_error(&encoder_session);
1485 return EncoderSession_finish_ok(
1489 EncoderSession_format_is_iff(&encoder_session)? options.format_options.iff.foreign_metadata : 0
1493 FLAC__bool EncoderSession_construct(EncoderSession *e, encode_options_t options, FLAC__off_t infilesize, FILE *infile, const char *infilename, const char *outfilename, const FLAC__byte *lookahead, unsigned lookahead_length)
1496 FLAC__uint32 test = 1;
1499 * initialize globals
1502 is_big_endian_host_ = (*((FLAC__byte*)(&test)))? false : true;
1504 for(i = 0; i < FLAC__MAX_CHANNELS; i++)
1505 input_[i] = &(in_[i][0]);
1509 * initialize instance
1513 e->use_ogg = options.use_ogg;
1515 e->verify = options.verify;
1516 e->treat_warnings_as_errors = options.treat_warnings_as_errors;
1517 e->continue_through_decode_errors = options.continue_through_decode_errors;
1519 e->is_stdout = (0 == strcmp(outfilename, "-"));
1520 e->outputfile_opened = false;
1522 e->inbasefilename = grabbag__file_get_basename(infilename);
1523 e->infilename = infilename;
1524 e->outfilename = outfilename;
1526 e->total_samples_to_encode = 0;
1527 e->unencoded_size = 0;
1528 e->bytes_written = 0;
1529 e->samples_written = 0;
1532 memset(&e->info, 0, sizeof(e->info));
1534 e->format = options.format;
1536 switch(options.format) {
1544 e->fmt.iff.data_bytes = 0;
1547 case FORMAT_OGGFLAC:
1548 e->fmt.flac.decoder = 0;
1549 e->fmt.flac.client_data.filesize = infilesize;
1550 e->fmt.flac.client_data.lookahead = lookahead;
1551 e->fmt.flac.client_data.lookahead_length = lookahead_length;
1552 e->fmt.flac.client_data.num_metadata_blocks = 0;
1553 e->fmt.flac.client_data.samples_left_to_process = 0;
1554 e->fmt.flac.client_data.fatal_error = false;
1558 /* double protection */
1565 e->seek_table_template = 0;
1567 if(0 == (e->seek_table_template = FLAC__metadata_object_new(FLAC__METADATA_TYPE_SEEKTABLE))) {
1568 flac__utils_printf(stderr, 1, "%s: ERROR allocating memory for seek table\n", e->inbasefilename);
1572 e->encoder = FLAC__stream_encoder_new();
1573 if(0 == e->encoder) {
1574 flac__utils_printf(stderr, 1, "%s: ERROR creating the encoder instance\n", e->inbasefilename);
1575 EncoderSession_destroy(e);
1582 void EncoderSession_destroy(EncoderSession *e)
1584 if(e->format == FORMAT_FLAC || e->format == FORMAT_OGGFLAC) {
1586 if(e->fmt.flac.decoder)
1587 FLAC__stream_decoder_delete(e->fmt.flac.decoder);
1588 e->fmt.flac.decoder = 0;
1589 for(i = 0; i < e->fmt.flac.client_data.num_metadata_blocks; i++)
1590 FLAC__metadata_object_delete(e->fmt.flac.client_data.metadata_blocks[i]);
1591 e->fmt.flac.client_data.num_metadata_blocks = 0;
1597 if(0 != e->encoder) {
1598 FLAC__stream_encoder_delete(e->encoder);
1602 if(0 != e->seek_table_template) {
1603 FLAC__metadata_object_delete(e->seek_table_template);
1604 e->seek_table_template = 0;
1608 int EncoderSession_finish_ok(EncoderSession *e, int info_align_carry, int info_align_zero, foreign_metadata_t *foreign_metadata)
1610 FLAC__StreamEncoderState fse_state = FLAC__STREAM_ENCODER_OK;
1612 FLAC__bool verify_error = false;
1615 fse_state = FLAC__stream_encoder_get_state(e->encoder);
1616 ret = FLAC__stream_encoder_finish(e->encoder)? 0 : 1;
1618 fse_state == FLAC__STREAM_ENCODER_VERIFY_MISMATCH_IN_AUDIO_DATA ||
1619 FLAC__stream_encoder_get_state(e->encoder) == FLAC__STREAM_ENCODER_VERIFY_MISMATCH_IN_AUDIO_DATA
1622 /* all errors except verify errors should interrupt the stats */
1623 if(ret && !verify_error)
1624 print_error_with_state(e, "ERROR during encoding");
1625 else if(e->total_samples_to_encode > 0) {
1627 flac__utils_printf(stderr, 2, "\n");
1631 print_verify_error(e);
1635 if(info_align_carry >= 0) {
1636 flac__utils_printf(stderr, 1, "%s: INFO: sector alignment causing %d samples to be carried over\n", e->inbasefilename, info_align_carry);
1638 if(info_align_zero >= 0) {
1639 flac__utils_printf(stderr, 1, "%s: INFO: sector alignment causing %d zero samples to be appended\n", e->inbasefilename, info_align_zero);
1643 /*@@@@@@ should this go here or somewhere else? */
1644 if(ret == 0 && foreign_metadata) {
1646 if(!flac__foreign_metadata_write_to_flac(foreign_metadata, e->infilename, e->outfilename, &error)) {
1647 flac__utils_printf(stderr, 1, "%s: ERROR: updating foreign metadata in FLAC file: %s\n", e->inbasefilename, error);
1652 EncoderSession_destroy(e);
1657 int EncoderSession_finish_error(EncoderSession *e)
1659 FLAC__ASSERT(e->encoder);
1661 if(e->total_samples_to_encode > 0)
1662 flac__utils_printf(stderr, 2, "\n");
1664 if(FLAC__stream_encoder_get_state(e->encoder) == FLAC__STREAM_ENCODER_VERIFY_MISMATCH_IN_AUDIO_DATA)
1665 print_verify_error(e);
1666 else if(e->outputfile_opened)
1667 /* only want to delete the file if we opened it; otherwise it could be an existing file and our overwrite failed */
1668 flac_unlink(e->outfilename);
1670 EncoderSession_destroy(e);
1676 unsigned num_metadata;
1677 FLAC__bool *needs_delete;
1678 FLAC__StreamMetadata **metadata;
1679 FLAC__StreamMetadata *cuesheet; /* always needs to be deleted */
1680 } static_metadata_t;
1682 static void static_metadata_init(static_metadata_t *m)
1684 m->num_metadata = 0;
1685 m->needs_delete = 0;
1690 static void static_metadata_clear(static_metadata_t *m)
1693 for(i = 0; i < m->num_metadata; i++)
1694 if(m->needs_delete[i])
1695 FLAC__metadata_object_delete(m->metadata[i]);
1699 free(m->needs_delete);
1701 FLAC__metadata_object_delete(m->cuesheet);
1702 static_metadata_init(m);
1705 static FLAC__bool static_metadata_append(static_metadata_t *m, FLAC__StreamMetadata *d, FLAC__bool needs_delete)
1708 if(0 == (x = safe_realloc_muladd2_(m->metadata, sizeof(*m->metadata), /*times (*/m->num_metadata, /*+*/1/*)*/)))
1710 m->metadata = (FLAC__StreamMetadata**)x;
1711 if(0 == (x = safe_realloc_muladd2_(m->needs_delete, sizeof(*m->needs_delete), /*times (*/m->num_metadata, /*+*/1/*)*/)))
1713 m->needs_delete = (FLAC__bool*)x;
1714 m->metadata[m->num_metadata] = d;
1715 m->needs_delete[m->num_metadata] = needs_delete;
1720 FLAC__bool EncoderSession_init_encoder(EncoderSession *e, encode_options_t options)
1722 const unsigned channels = e->info.channels;
1723 const unsigned bps = e->info.bits_per_sample - e->info.shift;
1724 const unsigned sample_rate = e->info.sample_rate;
1725 FLACDecoderData *flac_decoder_data = (e->format == FORMAT_FLAC || e->format == FORMAT_OGGFLAC)? &e->fmt.flac.client_data : 0;
1726 FLAC__StreamMetadata padding;
1727 FLAC__StreamMetadata **metadata = 0;
1728 static_metadata_t static_metadata;
1729 unsigned num_metadata = 0, ic;
1730 FLAC__StreamEncoderInitStatus init_status;
1731 const FLAC__bool is_cdda = (channels == 1 || channels == 2) && (bps == 16) && (sample_rate == 44100);
1732 char apodizations[2000];
1734 FLAC__ASSERT(sizeof(options.pictures)/sizeof(options.pictures[0]) <= 64);
1736 static_metadata_init(&static_metadata);
1738 e->replay_gain = options.replay_gain;
1740 apodizations[0] = '\0';
1742 if(e->replay_gain) {
1743 if(channels != 1 && channels != 2) {
1744 flac__utils_printf(stderr, 1, "%s: ERROR, number of channels (%u) must be 1 or 2 for --replay-gain\n", e->inbasefilename, channels);
1747 if(!grabbag__replaygain_is_valid_sample_frequency(sample_rate)) {
1748 flac__utils_printf(stderr, 1, "%s: ERROR, invalid sample rate (%u) for --replay-gain\n", e->inbasefilename, sample_rate);
1751 if(options.is_first_file) {
1752 if(!grabbag__replaygain_init(sample_rate)) {
1753 flac__utils_printf(stderr, 1, "%s: ERROR initializing ReplayGain stage\n", e->inbasefilename);
1759 if(!parse_cuesheet(&static_metadata.cuesheet, options.cuesheet_filename, e->inbasefilename, sample_rate, is_cdda, e->total_samples_to_encode, e->treat_warnings_as_errors))
1762 if(!convert_to_seek_table_template(options.requested_seek_points, options.num_requested_seek_points, options.cued_seekpoints? static_metadata.cuesheet : 0, e)) {
1763 flac__utils_printf(stderr, 1, "%s: ERROR allocating memory for seek table\n", e->inbasefilename);
1764 static_metadata_clear(&static_metadata);
1768 /* build metadata */
1769 if(flac_decoder_data) {
1771 * we're encoding from FLAC so we will use the FLAC file's
1772 * metadata as the basis for the encoded file
1777 * first handle pictures: simple append any --pictures
1780 for(i = 0; i < options.num_pictures; i++) {
1781 FLAC__StreamMetadata *pic = FLAC__metadata_object_clone(options.pictures[i]);
1783 flac__utils_printf(stderr, 1, "%s: ERROR allocating memory for PICTURE block\n", e->inbasefilename);
1784 static_metadata_clear(&static_metadata);
1787 flac_decoder_data->metadata_blocks[flac_decoder_data->num_metadata_blocks++] = pic;
1792 * next handle vorbis comment: if any tags were specified
1793 * or there is no existing vorbis comment, we create a
1794 * new vorbis comment (discarding any existing one); else
1795 * we keep the existing one. also need to make sure to
1796 * propagate any channel mask tag.
1798 /* @@@ change to append -T values from options.vorbis_comment if input has VC already? */
1800 FLAC__bool vc_found = false;
1801 for(i = 0, j = 0; i < flac_decoder_data->num_metadata_blocks; i++) {
1802 if(flac_decoder_data->metadata_blocks[i]->type == FLAC__METADATA_TYPE_VORBIS_COMMENT)
1804 if(flac_decoder_data->metadata_blocks[i]->type == FLAC__METADATA_TYPE_VORBIS_COMMENT && options.vorbis_comment->data.vorbis_comment.num_comments > 0) {
1805 (void) flac__utils_get_channel_mask_tag(flac_decoder_data->metadata_blocks[i], &e->info.channel_mask);
1806 flac__utils_printf(stderr, 1, "%s: WARNING, replacing tags from input FLAC file with those given on the command-line\n", e->inbasefilename);
1807 if(e->treat_warnings_as_errors) {
1808 static_metadata_clear(&static_metadata);
1811 FLAC__metadata_object_delete(flac_decoder_data->metadata_blocks[i]);
1812 flac_decoder_data->metadata_blocks[i] = 0;
1815 flac_decoder_data->metadata_blocks[j++] = flac_decoder_data->metadata_blocks[i];
1817 flac_decoder_data->num_metadata_blocks = j;
1818 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])) {
1820 FLAC__StreamMetadata *vc = FLAC__metadata_object_clone(options.vorbis_comment);
1821 if(0 == vc || (e->info.channel_mask && !flac__utils_set_channel_mask_tag(vc, e->info.channel_mask))) {
1822 flac__utils_printf(stderr, 1, "%s: ERROR allocating memory for VORBIS_COMMENT block\n", e->inbasefilename);
1823 static_metadata_clear(&static_metadata);
1826 for(i = flac_decoder_data->num_metadata_blocks; i > 1; i--)
1827 flac_decoder_data->metadata_blocks[i] = flac_decoder_data->metadata_blocks[i-1];
1828 flac_decoder_data->metadata_blocks[1] = vc;
1829 flac_decoder_data->num_metadata_blocks++;
1834 * next handle cuesheet: if --cuesheet was specified, use
1835 * it; else if file has existing CUESHEET and cuesheet's
1836 * lead-out offset is correct, keep it; else no CUESHEET
1839 for(i = 0, j = 0; i < flac_decoder_data->num_metadata_blocks; i++) {
1840 FLAC__bool existing_cuesheet_is_bad = false;
1841 /* check if existing cuesheet matches the input audio */
1842 if(flac_decoder_data->metadata_blocks[i]->type == FLAC__METADATA_TYPE_CUESHEET && 0 == static_metadata.cuesheet) {
1843 const FLAC__StreamMetadata_CueSheet *cs = &flac_decoder_data->metadata_blocks[i]->data.cue_sheet;
1844 if(e->total_samples_to_encode == 0) {
1845 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);
1846 if(e->treat_warnings_as_errors) {
1847 static_metadata_clear(&static_metadata);
1850 existing_cuesheet_is_bad = true;
1852 else if(e->total_samples_to_encode != cs->tracks[cs->num_tracks-1].offset) {
1853 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);
1854 if(e->treat_warnings_as_errors) {
1855 static_metadata_clear(&static_metadata);
1858 existing_cuesheet_is_bad = true;
1861 if(flac_decoder_data->metadata_blocks[i]->type == FLAC__METADATA_TYPE_CUESHEET && (existing_cuesheet_is_bad || 0 != static_metadata.cuesheet)) {
1862 if(0 != static_metadata.cuesheet) {
1863 flac__utils_printf(stderr, 1, "%s: WARNING, replacing cuesheet in input FLAC file with the one given on the command-line\n", e->inbasefilename);
1864 if(e->treat_warnings_as_errors) {
1865 static_metadata_clear(&static_metadata);
1869 FLAC__metadata_object_delete(flac_decoder_data->metadata_blocks[i]);
1870 flac_decoder_data->metadata_blocks[i] = 0;
1873 flac_decoder_data->metadata_blocks[j++] = flac_decoder_data->metadata_blocks[i];
1875 flac_decoder_data->num_metadata_blocks = j;
1876 if(0 != static_metadata.cuesheet && flac_decoder_data->num_metadata_blocks < sizeof(flac_decoder_data->metadata_blocks)/sizeof(flac_decoder_data->metadata_blocks[0])) {
1878 FLAC__StreamMetadata *cs = FLAC__metadata_object_clone(static_metadata.cuesheet);
1880 flac__utils_printf(stderr, 1, "%s: ERROR allocating memory for CUESHEET block\n", e->inbasefilename);
1881 static_metadata_clear(&static_metadata);
1884 for(i = flac_decoder_data->num_metadata_blocks; i > 1; i--)
1885 flac_decoder_data->metadata_blocks[i] = flac_decoder_data->metadata_blocks[i-1];
1886 flac_decoder_data->metadata_blocks[1] = cs;
1887 flac_decoder_data->num_metadata_blocks++;
1892 * next handle seektable: if -S- was specified, no
1893 * SEEKTABLE; else if -S was specified, use it/them;
1894 * else if file has existing SEEKTABLE and input size is
1895 * preserved (no --skip/--until/etc specified), keep it;
1896 * else use default seektable options
1898 * note: meanings of num_requested_seek_points:
1899 * -1 : no -S option given, default to some value
1900 * 0 : -S- given (no seektable)
1901 * >0 : one or more -S options given
1904 FLAC__bool existing_seektable = false;
1905 for(i = 0, j = 0; i < flac_decoder_data->num_metadata_blocks; i++) {
1906 if(flac_decoder_data->metadata_blocks[i]->type == FLAC__METADATA_TYPE_SEEKTABLE)
1907 existing_seektable = true;
1908 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)) {
1909 if(options.num_requested_seek_points > 0) {
1910 flac__utils_printf(stderr, 1, "%s: WARNING, replacing seektable in input FLAC file with the one given on the command-line\n", e->inbasefilename);
1911 if(e->treat_warnings_as_errors) {
1912 static_metadata_clear(&static_metadata);
1916 else if(options.num_requested_seek_points == 0)
1917 ; /* no warning, silently delete existing SEEKTABLE since user specified --no-seektable (-S-) */
1919 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);
1920 if(e->treat_warnings_as_errors) {
1921 static_metadata_clear(&static_metadata);
1925 FLAC__metadata_object_delete(flac_decoder_data->metadata_blocks[i]);
1926 flac_decoder_data->metadata_blocks[i] = 0;
1927 existing_seektable = false;
1930 flac_decoder_data->metadata_blocks[j++] = flac_decoder_data->metadata_blocks[i];
1932 flac_decoder_data->num_metadata_blocks = j;
1933 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])) {
1935 FLAC__StreamMetadata *st = FLAC__metadata_object_clone(e->seek_table_template);
1937 flac__utils_printf(stderr, 1, "%s: ERROR allocating memory for SEEKTABLE block\n", e->inbasefilename);
1938 static_metadata_clear(&static_metadata);
1941 for(i = flac_decoder_data->num_metadata_blocks; i > 1; i--)
1942 flac_decoder_data->metadata_blocks[i] = flac_decoder_data->metadata_blocks[i-1];
1943 flac_decoder_data->metadata_blocks[1] = st;
1944 flac_decoder_data->num_metadata_blocks++;
1949 * finally handle padding: if --no-padding was specified,
1950 * then delete all padding; else if -P was specified,
1951 * use that instead of existing padding (if any); else
1952 * if existing file has padding, move all existing
1953 * padding blocks to one padding block at the end; else
1954 * use default padding.
1958 for(i = 0, j = 0; i < flac_decoder_data->num_metadata_blocks; i++) {
1959 if(flac_decoder_data->metadata_blocks[i]->type == FLAC__METADATA_TYPE_PADDING) {
1962 p += flac_decoder_data->metadata_blocks[i]->length;
1963 FLAC__metadata_object_delete(flac_decoder_data->metadata_blocks[i]);
1964 flac_decoder_data->metadata_blocks[i] = 0;
1967 flac_decoder_data->metadata_blocks[j++] = flac_decoder_data->metadata_blocks[i];
1969 flac_decoder_data->num_metadata_blocks = j;
1970 if(options.padding > 0)
1971 p = options.padding;
1973 p = e->total_samples_to_encode / sample_rate < 20*60? FLAC_ENCODE__DEFAULT_PADDING : FLAC_ENCODE__DEFAULT_PADDING*8;
1974 if(options.padding != 0) {
1975 if(p > 0 && flac_decoder_data->num_metadata_blocks < sizeof(flac_decoder_data->metadata_blocks)/sizeof(flac_decoder_data->metadata_blocks[0])) {
1976 flac_decoder_data->metadata_blocks[flac_decoder_data->num_metadata_blocks] = FLAC__metadata_object_new(FLAC__METADATA_TYPE_PADDING);
1977 if(0 == flac_decoder_data->metadata_blocks[flac_decoder_data->num_metadata_blocks]) {
1978 flac__utils_printf(stderr, 1, "%s: ERROR allocating memory for PADDING block\n", e->inbasefilename);
1979 static_metadata_clear(&static_metadata);
1982 flac_decoder_data->metadata_blocks[flac_decoder_data->num_metadata_blocks]->is_last = false; /* the encoder will set this for us */
1983 flac_decoder_data->metadata_blocks[flac_decoder_data->num_metadata_blocks]->length = p;
1984 flac_decoder_data->num_metadata_blocks++;
1988 metadata = &flac_decoder_data->metadata_blocks[1]; /* don't include STREAMINFO */
1989 num_metadata = flac_decoder_data->num_metadata_blocks - 1;
1993 * we're not encoding from FLAC so we will build the metadata
1996 const foreign_metadata_t *foreign_metadata = EncoderSession_format_is_iff(e)? options.format_options.iff.foreign_metadata : 0;
1999 if(e->seek_table_template->data.seek_table.num_points > 0) {
2000 e->seek_table_template->is_last = false; /* the encoder will set this for us */
2001 static_metadata_append(&static_metadata, e->seek_table_template, /*needs_delete=*/false);
2003 if(0 != static_metadata.cuesheet)
2004 static_metadata_append(&static_metadata, static_metadata.cuesheet, /*needs_delete=*/false);
2005 if(e->info.channel_mask) {
2006 if(!flac__utils_set_channel_mask_tag(options.vorbis_comment, e->info.channel_mask)) {
2007 flac__utils_printf(stderr, 1, "%s: ERROR adding channel mask tag\n", e->inbasefilename);
2008 static_metadata_clear(&static_metadata);
2012 static_metadata_append(&static_metadata, options.vorbis_comment, /*needs_delete=*/false);
2013 for(i = 0; i < options.num_pictures; i++)
2014 static_metadata_append(&static_metadata, options.pictures[i], /*needs_delete=*/false);
2015 if(foreign_metadata) {
2016 for(i = 0; i < foreign_metadata->num_blocks; i++) {
2017 FLAC__StreamMetadata *p = FLAC__metadata_object_new(FLAC__METADATA_TYPE_PADDING);
2019 flac__utils_printf(stderr, 1, "%s: ERROR: out of memory\n", e->inbasefilename);
2020 static_metadata_clear(&static_metadata);
2023 static_metadata_append(&static_metadata, p, /*needs_delete=*/true);
2024 static_metadata.metadata[static_metadata.num_metadata-1]->length = FLAC__STREAM_METADATA_APPLICATION_ID_LEN/8 + foreign_metadata->blocks[i].size;
2027 if(options.padding != 0) {
2028 padding.is_last = false; /* the encoder will set this for us */
2029 padding.type = FLAC__METADATA_TYPE_PADDING;
2030 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));
2031 static_metadata_append(&static_metadata, &padding, /*needs_delete=*/false);
2033 metadata = static_metadata.metadata;
2034 num_metadata = static_metadata.num_metadata;
2037 /* check for a few things that have not already been checked. the
2038 * FLAC__stream_encoder_init*() will check it but only return
2039 * FLAC__STREAM_ENCODER_INIT_STATUS_INVALID_METADATA so we check some
2040 * up front to give a better error message.
2042 if(!verify_metadata(e, metadata, num_metadata)) {
2043 static_metadata_clear(&static_metadata);
2047 FLAC__stream_encoder_set_verify(e->encoder, options.verify);
2048 FLAC__stream_encoder_set_streamable_subset(e->encoder, !options.lax);
2049 FLAC__stream_encoder_set_channels(e->encoder, channels);
2050 FLAC__stream_encoder_set_bits_per_sample(e->encoder, bps);
2051 FLAC__stream_encoder_set_sample_rate(e->encoder, sample_rate);
2052 for(ic = 0; ic < options.num_compression_settings; ic++) {
2053 switch(options.compression_settings[ic].type) {
2055 FLAC__stream_encoder_set_blocksize(e->encoder, options.compression_settings[ic].value.t_unsigned);
2057 case CST_COMPRESSION_LEVEL:
2058 FLAC__stream_encoder_set_compression_level(e->encoder, options.compression_settings[ic].value.t_unsigned);
2059 apodizations[0] = '\0';
2061 case CST_DO_MID_SIDE:
2062 FLAC__stream_encoder_set_do_mid_side_stereo(e->encoder, options.compression_settings[ic].value.t_bool);
2064 case CST_LOOSE_MID_SIDE:
2065 FLAC__stream_encoder_set_loose_mid_side_stereo(e->encoder, options.compression_settings[ic].value.t_bool);
2067 case CST_APODIZATION:
2068 if(strlen(apodizations)+strlen(options.compression_settings[ic].value.t_string)+2 >= sizeof(apodizations)) {
2069 flac__utils_printf(stderr, 1, "%s: ERROR: too many apodization functions requested\n", e->inbasefilename);
2070 static_metadata_clear(&static_metadata);
2074 safe_strncat(apodizations, options.compression_settings[ic].value.t_string, sizeof(apodizations));
2075 safe_strncat(apodizations, ";", sizeof(apodizations));
2078 case CST_MAX_LPC_ORDER:
2079 FLAC__stream_encoder_set_max_lpc_order(e->encoder, options.compression_settings[ic].value.t_unsigned);
2081 case CST_QLP_COEFF_PRECISION:
2082 FLAC__stream_encoder_set_qlp_coeff_precision(e->encoder, options.compression_settings[ic].value.t_unsigned);
2084 case CST_DO_QLP_COEFF_PREC_SEARCH:
2085 FLAC__stream_encoder_set_do_qlp_coeff_prec_search(e->encoder, options.compression_settings[ic].value.t_bool);
2087 case CST_DO_ESCAPE_CODING:
2088 FLAC__stream_encoder_set_do_escape_coding(e->encoder, options.compression_settings[ic].value.t_bool);
2090 case CST_DO_EXHAUSTIVE_MODEL_SEARCH:
2091 FLAC__stream_encoder_set_do_exhaustive_model_search(e->encoder, options.compression_settings[ic].value.t_bool);
2093 case CST_MIN_RESIDUAL_PARTITION_ORDER:
2094 FLAC__stream_encoder_set_min_residual_partition_order(e->encoder, options.compression_settings[ic].value.t_unsigned);
2096 case CST_MAX_RESIDUAL_PARTITION_ORDER:
2097 FLAC__stream_encoder_set_max_residual_partition_order(e->encoder, options.compression_settings[ic].value.t_unsigned);
2099 case CST_RICE_PARAMETER_SEARCH_DIST:
2100 FLAC__stream_encoder_set_rice_parameter_search_dist(e->encoder, options.compression_settings[ic].value.t_unsigned);
2105 FLAC__stream_encoder_set_apodization(e->encoder, apodizations);
2106 FLAC__stream_encoder_set_total_samples_estimate(e->encoder, e->total_samples_to_encode);
2107 FLAC__stream_encoder_set_metadata(e->encoder, (num_metadata > 0)? metadata : 0, num_metadata);
2109 FLAC__stream_encoder_disable_constant_subframes(e->encoder, options.debug.disable_constant_subframes);
2110 FLAC__stream_encoder_disable_fixed_subframes(e->encoder, options.debug.disable_fixed_subframes);
2111 FLAC__stream_encoder_disable_verbatim_subframes(e->encoder, options.debug.disable_verbatim_subframes);
2112 if(!options.debug.do_md5) {
2113 flac__utils_printf(stderr, 1, "%s: WARNING, MD5 computation disabled, resulting file will not have MD5 sum\n", e->inbasefilename);
2114 if(e->treat_warnings_as_errors) {
2115 static_metadata_clear(&static_metadata);
2118 FLAC__stream_encoder_set_do_md5(e->encoder, false);
2123 FLAC__stream_encoder_set_ogg_serial_number(e->encoder, options.serial_number);
2125 init_status = FLAC__stream_encoder_init_ogg_file(e->encoder, e->is_stdout? 0 : e->outfilename, encoder_progress_callback, /*client_data=*/e);
2130 init_status = FLAC__stream_encoder_init_file(e->encoder, e->is_stdout? 0 : e->outfilename, encoder_progress_callback, /*client_data=*/e);
2133 if(init_status != FLAC__STREAM_ENCODER_INIT_STATUS_OK) {
2134 print_error_with_init_status(e, "ERROR initializing encoder", init_status);
2135 if(FLAC__stream_encoder_get_state(e->encoder) != FLAC__STREAM_ENCODER_IO_ERROR)
2136 e->outputfile_opened = true;
2137 static_metadata_clear(&static_metadata);
2141 e->outputfile_opened = true;
2144 (FLAC__stream_encoder_get_do_exhaustive_model_search(e->encoder) && FLAC__stream_encoder_get_do_qlp_coeff_prec_search(e->encoder))? 0x07 :
2145 (FLAC__stream_encoder_get_do_exhaustive_model_search(e->encoder) || FLAC__stream_encoder_get_do_qlp_coeff_prec_search(e->encoder))? 0x0f :
2148 static_metadata_clear(&static_metadata);
2153 FLAC__bool EncoderSession_process(EncoderSession *e, const FLAC__int32 * const buffer[], unsigned samples)
2155 if(e->replay_gain) {
2156 if(!grabbag__replaygain_analyze(buffer, e->info.channels==2, e->info.bits_per_sample, samples)) {
2157 flac__utils_printf(stderr, 1, "%s: WARNING, error while calculating ReplayGain\n", e->inbasefilename);
2158 if(e->treat_warnings_as_errors)
2163 return FLAC__stream_encoder_process(e->encoder, buffer, samples);
2166 FLAC__bool EncoderSession_format_is_iff(const EncoderSession *e)
2169 e->format == FORMAT_WAVE ||
2170 e->format == FORMAT_WAVE64 ||
2171 e->format == FORMAT_RF64 ||
2172 e->format == FORMAT_AIFF ||
2173 e->format == FORMAT_AIFF_C;
2176 FLAC__bool convert_to_seek_table_template(const char *requested_seek_points, int num_requested_seek_points, FLAC__StreamMetadata *cuesheet, EncoderSession *e)
2178 const FLAC__bool only_placeholders = e->is_stdout;
2179 FLAC__bool has_real_points;
2181 if(num_requested_seek_points == 0 && 0 == cuesheet)
2184 if(num_requested_seek_points < 0) {
2186 /*@@@@@@ workaround ogg bug: too many seekpoints makes table not fit in one page */
2187 if(e->use_ogg && e->total_samples_to_encode > 0 && e->total_samples_to_encode / e->info.sample_rate / 10 > 230)
2188 requested_seek_points = "230x;";
2191 requested_seek_points = "10s;";
2192 num_requested_seek_points = 1;
2195 if(num_requested_seek_points > 0) {
2196 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))
2202 const FLAC__StreamMetadata_CueSheet *cs = &cuesheet->data.cue_sheet;
2203 for(i = 0; i < cs->num_tracks; i++) {
2204 const FLAC__StreamMetadata_CueSheet_Track *tr = cs->tracks+i;
2205 for(j = 0; j < tr->num_indices; j++) {
2206 if(!FLAC__metadata_object_seektable_template_append_point(e->seek_table_template, tr->offset + tr->indices[j].offset))
2208 has_real_points = true;
2212 if(!FLAC__metadata_object_seektable_template_sort(e->seek_table_template, /*compact=*/true))
2216 if(has_real_points) {
2218 flac__utils_printf(stderr, 1, "%s: WARNING, cannot write back seekpoints when encoding to stdout\n", e->inbasefilename);
2219 if(e->treat_warnings_as_errors)
2227 FLAC__bool canonicalize_until_specification(utils__SkipUntilSpecification *spec, const char *inbasefilename, unsigned sample_rate, FLAC__uint64 skip, FLAC__uint64 total_samples_in_input)
2229 /* convert from mm:ss.sss to sample number if necessary */
2230 flac__utils_canonicalize_skip_until_specification(spec, sample_rate);
2232 /* special case: if "--until=-0", use the special value '0' to mean "end-of-stream" */
2233 if(spec->is_relative && spec->value.samples == 0) {
2234 spec->is_relative = false;
2238 /* in any other case the total samples in the input must be known */
2239 if(total_samples_in_input == 0) {
2240 flac__utils_printf(stderr, 1, "%s: ERROR, cannot use --until when input length is unknown\n", inbasefilename);
2244 FLAC__ASSERT(spec->value_is_samples);
2246 /* convert relative specifications to absolute */
2247 if(spec->is_relative) {
2248 if(spec->value.samples <= 0)
2249 spec->value.samples += (FLAC__int64)total_samples_in_input;
2251 spec->value.samples += skip;
2252 spec->is_relative = false;
2256 if(spec->value.samples < 0) {
2257 flac__utils_printf(stderr, 1, "%s: ERROR, --until value is before beginning of input\n", inbasefilename);
2260 if((FLAC__uint64)spec->value.samples <= skip) {
2261 flac__utils_printf(stderr, 1, "%s: ERROR, --until value is before --skip point\n", inbasefilename);
2264 if((FLAC__uint64)spec->value.samples > total_samples_in_input) {
2265 flac__utils_printf(stderr, 1, "%s: ERROR, --until value is after end of input\n", inbasefilename);
2272 FLAC__bool verify_metadata(const EncoderSession *e, FLAC__StreamMetadata **metadata, unsigned num_metadata)
2274 FLAC__bool metadata_picture_has_type1 = false;
2275 FLAC__bool metadata_picture_has_type2 = false;
2278 FLAC__ASSERT(0 != metadata);
2279 for(i = 0; i < num_metadata; i++) {
2280 const FLAC__StreamMetadata *m = metadata[i];
2281 if(m->type == FLAC__METADATA_TYPE_SEEKTABLE) {
2282 if(!FLAC__format_seektable_is_legal(&m->data.seek_table)) {
2283 flac__utils_printf(stderr, 1, "%s: ERROR: SEEKTABLE metadata block is invalid\n", e->inbasefilename);
2287 else if(m->type == FLAC__METADATA_TYPE_CUESHEET) {
2288 if(!FLAC__format_cuesheet_is_legal(&m->data.cue_sheet, m->data.cue_sheet.is_cd, /*violation=*/0)) {
2289 flac__utils_printf(stderr, 1, "%s: ERROR: CUESHEET metadata block is invalid\n", e->inbasefilename);
2293 else if(m->type == FLAC__METADATA_TYPE_PICTURE) {
2294 const char *error = 0;
2295 if(!FLAC__format_picture_is_legal(&m->data.picture, &error)) {
2296 flac__utils_printf(stderr, 1, "%s: ERROR: PICTURE metadata block is invalid: %s\n", e->inbasefilename, error);
2299 if(m->data.picture.type == FLAC__STREAM_METADATA_PICTURE_TYPE_FILE_ICON_STANDARD) {
2300 if(metadata_picture_has_type1) {
2301 flac__utils_printf(stderr, 1, "%s: ERROR: there may only be one picture of type 1 (32x32 icon) in the file\n", e->inbasefilename);
2304 metadata_picture_has_type1 = true;
2306 else if(m->data.picture.type == FLAC__STREAM_METADATA_PICTURE_TYPE_FILE_ICON) {
2307 if(metadata_picture_has_type2) {
2308 flac__utils_printf(stderr, 1, "%s: ERROR: there may only be one picture of type 2 (icon) in the file\n", e->inbasefilename);
2311 metadata_picture_has_type2 = true;
2319 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)
2321 unsigned wide_sample, sample, channel, byte;
2322 FLAC__int32 *out[FLAC__MAX_CHANNELS];
2324 if(0 == channel_map) {
2325 for(channel = 0; channel < channels; channel++)
2326 out[channel] = dest[channel];
2329 for(channel = 0; channel < channels; channel++)
2330 out[channel] = dest[channel_map[channel]];
2334 if(is_unsigned_samples) {
2335 for(sample = wide_sample = 0; wide_sample < wide_samples; wide_sample++)
2336 for(channel = 0; channel < channels; channel++, sample++)
2337 out[channel][wide_sample] = (FLAC__int32)ucbuffer_[sample] - 0x80;
2340 for(sample = wide_sample = 0; wide_sample < wide_samples; wide_sample++)
2341 for(channel = 0; channel < channels; channel++, sample++)
2342 out[channel][wide_sample] = (FLAC__int32)scbuffer_[sample];
2345 else if(bps == 16) {
2346 if(is_big_endian != is_big_endian_host_) {
2348 const unsigned bytes = wide_samples * channels * (bps >> 3);
2349 for(byte = 0; byte < bytes; byte += 2) {
2350 tmp = ucbuffer_[byte];
2351 ucbuffer_[byte] = ucbuffer_[byte+1];
2352 ucbuffer_[byte+1] = tmp;
2355 if(is_unsigned_samples) {
2356 for(sample = wide_sample = 0; wide_sample < wide_samples; wide_sample++)
2357 for(channel = 0; channel < channels; channel++, sample++)
2358 out[channel][wide_sample] = (FLAC__int32)usbuffer_[sample] - 0x8000;
2361 for(sample = wide_sample = 0; wide_sample < wide_samples; wide_sample++)
2362 for(channel = 0; channel < channels; channel++, sample++)
2363 out[channel][wide_sample] = (FLAC__int32)ssbuffer_[sample];
2366 else if(bps == 24) {
2367 if(!is_big_endian) {
2369 const unsigned bytes = wide_samples * channels * (bps >> 3);
2370 for(byte = 0; byte < bytes; byte += 3) {
2371 tmp = ucbuffer_[byte];
2372 ucbuffer_[byte] = ucbuffer_[byte+2];
2373 ucbuffer_[byte+2] = tmp;
2376 if(is_unsigned_samples) {
2377 for(byte = sample = wide_sample = 0; wide_sample < wide_samples; wide_sample++)
2378 for(channel = 0; channel < channels; channel++, sample++) {
2379 out[channel][wide_sample] = ucbuffer_[byte++]; out[channel][wide_sample] <<= 8;
2380 out[channel][wide_sample] |= ucbuffer_[byte++]; out[channel][wide_sample] <<= 8;
2381 out[channel][wide_sample] |= ucbuffer_[byte++];
2382 out[channel][wide_sample] -= 0x800000;
2386 for(byte = sample = wide_sample = 0; wide_sample < wide_samples; wide_sample++)
2387 for(channel = 0; channel < channels; channel++, sample++) {
2388 out[channel][wide_sample] = scbuffer_[byte++]; out[channel][wide_sample] <<= 8;
2389 out[channel][wide_sample] |= ucbuffer_[byte++]; out[channel][wide_sample] <<= 8;
2390 out[channel][wide_sample] |= ucbuffer_[byte++];
2398 FLAC__int32 mask = (1<<shift)-1;
2399 for(wide_sample = 0; wide_sample < wide_samples; wide_sample++)
2400 for(channel = 0; channel < channels; channel++) {
2401 if(out[channel][wide_sample] & mask) {
2402 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);
2405 out[channel][wide_sample] >>= shift;
2411 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)
2413 EncoderSession *e = (EncoderSession*)client_data;
2415 (void)encoder, (void)total_frames_estimate;
2417 e->bytes_written = bytes_written;
2418 e->samples_written = samples_written;
2420 if(e->total_samples_to_encode > 0 && !((frames_written-1) & e->stats_mask))
2424 FLAC__StreamDecoderReadStatus flac_decoder_read_callback(const FLAC__StreamDecoder *decoder, FLAC__byte buffer[], size_t *bytes, void *client_data)
2427 EncoderSession *e = (EncoderSession*)client_data;
2428 FLACDecoderData *data = &e->fmt.flac.client_data;
2432 if (data->fatal_error)
2433 return FLAC__STREAM_DECODER_READ_STATUS_ABORT;
2435 /* use up lookahead first */
2436 if (data->lookahead_length) {
2437 n = min(data->lookahead_length, *bytes);
2438 memcpy(buffer, data->lookahead, n);
2440 data->lookahead += n;
2441 data->lookahead_length -= n;
2444 /* get the rest from file */
2446 *bytes = n + fread(buffer, 1, *bytes-n, e->fin);
2448 return FLAC__STREAM_DECODER_READ_STATUS_ABORT;
2449 else if(0 == *bytes)
2450 return FLAC__STREAM_DECODER_READ_STATUS_END_OF_STREAM;
2452 return FLAC__STREAM_DECODER_READ_STATUS_CONTINUE;
2455 return FLAC__STREAM_DECODER_READ_STATUS_CONTINUE;
2458 FLAC__StreamDecoderSeekStatus flac_decoder_seek_callback(const FLAC__StreamDecoder *decoder, FLAC__uint64 absolute_byte_offset, void *client_data)
2460 EncoderSession *e = (EncoderSession*)client_data;
2463 if(fseeko(e->fin, (FLAC__off_t)absolute_byte_offset, SEEK_SET) < 0)
2464 return FLAC__STREAM_DECODER_SEEK_STATUS_ERROR;
2466 return FLAC__STREAM_DECODER_SEEK_STATUS_OK;
2469 FLAC__StreamDecoderTellStatus flac_decoder_tell_callback(const FLAC__StreamDecoder *decoder, FLAC__uint64 *absolute_byte_offset, void *client_data)
2471 EncoderSession *e = (EncoderSession*)client_data;
2475 if((pos = ftello(e->fin)) < 0)
2476 return FLAC__STREAM_DECODER_TELL_STATUS_ERROR;
2478 *absolute_byte_offset = (FLAC__uint64)pos;
2479 return FLAC__STREAM_DECODER_TELL_STATUS_OK;
2483 FLAC__StreamDecoderLengthStatus flac_decoder_length_callback(const FLAC__StreamDecoder *decoder, FLAC__uint64 *stream_length, void *client_data)
2485 const EncoderSession *e = (EncoderSession*)client_data;
2486 const FLACDecoderData *data = &e->fmt.flac.client_data;
2489 if(data->filesize < 0)
2490 return FLAC__STREAM_DECODER_LENGTH_STATUS_ERROR;
2492 *stream_length = (FLAC__uint64)data->filesize;
2493 return FLAC__STREAM_DECODER_LENGTH_STATUS_OK;
2497 FLAC__bool flac_decoder_eof_callback(const FLAC__StreamDecoder *decoder, void *client_data)
2499 EncoderSession *e = (EncoderSession*)client_data;
2502 return feof(e->fin)? true : false;
2505 FLAC__StreamDecoderWriteStatus flac_decoder_write_callback(const FLAC__StreamDecoder *decoder, const FLAC__Frame *frame, const FLAC__int32 * const buffer[], void *client_data)
2507 EncoderSession *e = (EncoderSession*)client_data;
2508 FLACDecoderData *data = &e->fmt.flac.client_data;
2509 FLAC__uint64 n = min(data->samples_left_to_process, frame->header.blocksize);
2512 if(!EncoderSession_process(e, buffer, (unsigned)n)) {
2513 print_error_with_state(e, "ERROR during encoding");
2514 data->fatal_error = true;
2515 return FLAC__STREAM_DECODER_WRITE_STATUS_ABORT;
2518 data->samples_left_to_process -= n;
2519 return FLAC__STREAM_DECODER_WRITE_STATUS_CONTINUE;
2522 void flac_decoder_metadata_callback(const FLAC__StreamDecoder *decoder, const FLAC__StreamMetadata *metadata, void *client_data)
2524 EncoderSession *e = (EncoderSession*)client_data;
2525 FLACDecoderData *data = &e->fmt.flac.client_data;
2528 if (data->fatal_error)
2532 data->num_metadata_blocks == sizeof(data->metadata_blocks)/sizeof(data->metadata_blocks[0]) ||
2533 0 == (data->metadata_blocks[data->num_metadata_blocks] = FLAC__metadata_object_clone(metadata))
2535 data->fatal_error = true;
2537 data->num_metadata_blocks++;
2540 void flac_decoder_error_callback(const FLAC__StreamDecoder *decoder, FLAC__StreamDecoderErrorStatus status, void *client_data)
2542 EncoderSession *e = (EncoderSession*)client_data;
2543 FLACDecoderData *data = &e->fmt.flac.client_data;
2546 flac__utils_printf(stderr, 1, "%s: ERROR got %s while decoding FLAC input\n", e->inbasefilename, FLAC__StreamDecoderErrorStatusString[status]);
2547 if(!e->continue_through_decode_errors)
2548 data->fatal_error = true;
2551 FLAC__bool parse_cuesheet(FLAC__StreamMetadata **cuesheet, const char *cuesheet_filename, const char *inbasefilename, unsigned sample_rate, FLAC__bool is_cdda, FLAC__uint64 lead_out_offset, FLAC__bool treat_warnings_as_errors)
2554 unsigned last_line_read;
2555 const char *error_message;
2557 if(0 == cuesheet_filename)
2560 if(lead_out_offset == 0) {
2561 flac__utils_printf(stderr, 1, "%s: ERROR cannot import cuesheet when the number of input samples to encode is unknown\n", inbasefilename);
2565 if(0 == (f = flac_fopen(cuesheet_filename, "r"))) {
2566 flac__utils_printf(stderr, 1, "%s: ERROR opening cuesheet \"%s\" for reading: %s\n", inbasefilename, cuesheet_filename, strerror(errno));
2570 *cuesheet = grabbag__cuesheet_parse(f, &error_message, &last_line_read, sample_rate, is_cdda, lead_out_offset);
2574 if(0 == *cuesheet) {
2575 flac__utils_printf(stderr, 1, "%s: ERROR parsing cuesheet \"%s\" on line %u: %s\n", inbasefilename, cuesheet_filename, last_line_read, error_message);
2579 if(!FLAC__format_cuesheet_is_legal(&(*cuesheet)->data.cue_sheet, /*check_cd_da_subset=*/false, &error_message)) {
2580 flac__utils_printf(stderr, 1, "%s: ERROR parsing cuesheet \"%s\": %s\n", inbasefilename, cuesheet_filename, error_message);
2584 /* if we're expecting CDDA, warn about non-compliance */
2585 if(is_cdda && !FLAC__format_cuesheet_is_legal(&(*cuesheet)->data.cue_sheet, /*check_cd_da_subset=*/true, &error_message)) {
2586 flac__utils_printf(stderr, 1, "%s: WARNING cuesheet \"%s\" is not audio CD compliant: %s\n", inbasefilename, cuesheet_filename, error_message);
2587 if(treat_warnings_as_errors)
2589 (*cuesheet)->data.cue_sheet.is_cd = false;
2595 void print_stats(const EncoderSession *encoder_session)
2597 const FLAC__uint64 samples_written = min(encoder_session->total_samples_to_encode, encoder_session->samples_written);
2598 const FLAC__uint64 uesize = encoder_session->unencoded_size;
2599 #if defined _MSC_VER || defined __MINGW32__
2600 /* with MSVC you have to spoon feed it the casting */
2601 const double progress = (double)(FLAC__int64)samples_written / (double)(FLAC__int64)encoder_session->total_samples_to_encode;
2602 const double ratio = (double)(FLAC__int64)encoder_session->bytes_written / ((double)(FLAC__int64)(uesize? uesize:1) * min(1.0, progress));
2604 const double progress = (double)samples_written / (double)encoder_session->total_samples_to_encode;
2605 const double ratio = (double)encoder_session->bytes_written / ((double)(uesize? uesize:1) * min(1.0, progress));
2608 FLAC__ASSERT(encoder_session->total_samples_to_encode > 0);
2610 if(samples_written == encoder_session->total_samples_to_encode) {
2611 flac__utils_printf(stderr, 2, "\r%s:%s wrote %" PRIu64 " bytes, ratio=",
2612 encoder_session->inbasefilename,
2613 encoder_session->verify? " Verify OK," : "",
2614 encoder_session->bytes_written
2618 flac__utils_printf(stderr, 2, "\r%s: %u%% complete, ratio=", encoder_session->inbasefilename, (unsigned)floor(progress * 100.0 + 0.5));
2621 flac__utils_printf(stderr, 2, "%0.3f", ratio);
2623 flac__utils_printf(stderr, 2, "N/A");
2626 void print_error_with_init_status(const EncoderSession *e, const char *message, FLAC__StreamEncoderInitStatus init_status)
2628 const int ilen = strlen(e->inbasefilename) + 1;
2629 const char *state_string = "";
2631 flac__utils_printf(stderr, 1, "\n%s: %s\n", e->inbasefilename, message);
2633 flac__utils_printf(stderr, 1, "%*s init_status = %s\n", ilen, "", FLAC__StreamEncoderInitStatusString[init_status]);
2635 if(init_status == FLAC__STREAM_ENCODER_INIT_STATUS_ENCODER_ERROR) {
2636 state_string = FLAC__stream_encoder_get_resolved_state_string(e->encoder);
2638 flac__utils_printf(stderr, 1, "%*s state = %s\n", ilen, "", state_string);
2640 /* print out some more info for some errors: */
2641 if(0 == strcmp(state_string, FLAC__StreamEncoderStateString[FLAC__STREAM_ENCODER_CLIENT_ERROR])) {
2642 flac__utils_printf(stderr, 1,
2644 "An error occurred while writing; the most common cause is that the disk is full.\n"
2647 else if(0 == strcmp(state_string, FLAC__StreamEncoderStateString[FLAC__STREAM_ENCODER_IO_ERROR])) {
2648 flac__utils_printf(stderr, 1,
2650 "An error occurred opening the output file; it is likely that the output\n"
2651 "directory does not exist or is not writable, the output file already exists and\n"
2652 "is not writable, or the disk is full.\n"
2656 else if(init_status == FLAC__STREAM_ENCODER_INIT_STATUS_NOT_STREAMABLE) {
2657 flac__utils_printf(stderr, 1,
2659 "The encoding parameters specified do not conform to the FLAC Subset and may not\n"
2660 "be streamable or playable in hardware devices. If you really understand the\n"
2661 "consequences, you can add --lax to the command-line options to encode with\n"
2662 "these parameters anyway. See http://flac.sourceforge.net/format.html#subset\n"
2667 void print_error_with_state(const EncoderSession *e, const char *message)
2669 const int ilen = strlen(e->inbasefilename) + 1;
2670 const char *state_string;
2672 flac__utils_printf(stderr, 1, "\n%s: %s\n", e->inbasefilename, message);
2674 state_string = FLAC__stream_encoder_get_resolved_state_string(e->encoder);
2676 flac__utils_printf(stderr, 1, "%*s state = %s\n", ilen, "", state_string);
2678 /* print out some more info for some errors: */
2679 if(0 == strcmp(state_string, FLAC__StreamEncoderStateString[FLAC__STREAM_ENCODER_CLIENT_ERROR])) {
2680 flac__utils_printf(stderr, 1,
2682 "An error occurred while writing; the most common cause is that the disk is full.\n"
2687 void print_verify_error(EncoderSession *e)
2689 FLAC__uint64 absolute_sample;
2690 unsigned frame_number;
2693 FLAC__int32 expected;
2696 FLAC__stream_encoder_get_verify_decoder_error_stats(e->encoder, &absolute_sample, &frame_number, &channel, &sample, &expected, &got);
2698 flac__utils_printf(stderr, 1, "%s: ERROR: mismatch in decoded data, verify FAILED!\n", e->inbasefilename);
2699 flac__utils_printf(stderr, 1, " Absolute sample=%" PRIu64 ", frame=%u, channel=%u, sample=%u, expected %d, got %d\n", absolute_sample, frame_number, channel, sample, expected, got);
2700 flac__utils_printf(stderr, 1, " In all known cases, verify errors are caused by hardware problems,\n");
2701 flac__utils_printf(stderr, 1, " usually overclocking or bad RAM. Delete %s\n", e->outfilename);
2702 flac__utils_printf(stderr, 1, " and repeat the flac command exactly as before. If it does not give a\n");
2703 flac__utils_printf(stderr, 1, " verify error in the exact same place each time you try it, then there is\n");
2704 flac__utils_printf(stderr, 1, " a problem with your hardware; please see the FAQ:\n");
2705 flac__utils_printf(stderr, 1, " http://flac.sourceforge.net/faq.html#tools__hardware_prob\n");
2706 flac__utils_printf(stderr, 1, " If it does fail in the exact same place every time, keep\n");
2707 flac__utils_printf(stderr, 1, " %s and submit a bug report to:\n", e->outfilename);
2708 flac__utils_printf(stderr, 1, " https://sourceforge.net/bugs/?func=addbug&group_id=13478\n");
2709 flac__utils_printf(stderr, 1, " Make sure to upload the FLAC file and use the \"Monitor\" feature to\n");
2710 flac__utils_printf(stderr, 1, " monitor the bug status.\n");
2711 flac__utils_printf(stderr, 1, "Verify FAILED! Do not trust %s\n", e->outfilename);
2714 FLAC__bool read_bytes(FILE *f, FLAC__byte *buf, size_t n, FLAC__bool eof_ok, const char *fn)
2716 size_t bytes_read = fread(buf, 1, n, f);
2718 if(bytes_read == 0) {
2720 flac__utils_printf(stderr, 1, "%s: ERROR: unexpected EOF\n", fn);
2726 if(bytes_read < n) {
2727 flac__utils_printf(stderr, 1, "%s: ERROR: unexpected EOF\n", fn);
2733 FLAC__bool read_uint16(FILE *f, FLAC__bool big_endian, FLAC__uint16 *val, const char *fn)
2735 if(!read_bytes(f, (FLAC__byte*)val, 2, /*eof_ok=*/false, fn))
2737 if(is_big_endian_host_ != big_endian) {
2738 FLAC__byte tmp, *b = (FLAC__byte*)val;
2739 tmp = b[1]; b[1] = b[0]; b[0] = tmp;
2744 FLAC__bool read_uint32(FILE *f, FLAC__bool big_endian, FLAC__uint32 *val, const char *fn)
2746 if(!read_bytes(f, (FLAC__byte*)val, 4, /*eof_ok=*/false, fn))
2748 if(is_big_endian_host_ != big_endian) {
2749 FLAC__byte tmp, *b = (FLAC__byte*)val;
2750 tmp = b[3]; b[3] = b[0]; b[0] = tmp;
2751 tmp = b[2]; b[2] = b[1]; b[1] = tmp;
2756 FLAC__bool read_uint64(FILE *f, FLAC__bool big_endian, FLAC__uint64 *val, const char *fn)
2758 if(!read_bytes(f, (FLAC__byte*)val, 8, /*eof_ok=*/false, fn))
2760 if(is_big_endian_host_ != big_endian) {
2761 FLAC__byte tmp, *b = (FLAC__byte*)val;
2762 tmp = b[7]; b[7] = b[0]; b[0] = tmp;
2763 tmp = b[6]; b[6] = b[1]; b[1] = tmp;
2764 tmp = b[5]; b[5] = b[2]; b[2] = tmp;
2765 tmp = b[4]; b[4] = b[3]; b[3] = tmp;
2770 FLAC__bool read_sane_extended(FILE *f, FLAC__uint32 *val, const char *fn)
2771 /* Read an IEEE 754 80-bit (aka SANE) extended floating point value from 'f',
2772 * convert it into an integral value and store in 'val'. Return false if only
2773 * between 1 and 9 bytes remain in 'f', if 0 bytes remain in 'f', or if the
2774 * value is negative, between zero and one, or too large to be represented by
2775 * 'val'; return true otherwise.
2784 if(!read_bytes(f, buf, sizeof(buf), /*eof_ok=*/false, fn))
2786 e = ((FLAC__uint16)(buf[0])<<8 | (FLAC__uint16)(buf[1]))-0x3FFF;
2788 if((buf[0]>>7)==1U || e<0 || e>63) {
2789 flac__utils_printf(stderr, 1, "%s: ERROR: invalid floating-point value\n", fn);
2793 for(i = 0; i < 8; ++i)
2794 p |= (FLAC__uint64)(buf[i+2])<<(56U-i*8);
2795 *val = (FLAC__uint32)((p>>shift)+(p>>(shift-1) & 0x1));
2800 FLAC__bool fskip_ahead(FILE *f, FLAC__uint64 offset)
2802 static unsigned char dump[8192];
2803 struct flac_stat_s stb;
2805 if(flac_fstat(fileno(f), &stb) == 0 && (stb.st_mode & S_IFMT) == S_IFREG)
2807 if(fseeko(f, offset, SEEK_CUR) == 0)
2811 const long need = (long)min(offset, sizeof(dump));
2812 if((long)fread(dump, 1, need, f) < need)
2819 unsigned count_channel_mask_bits(FLAC__uint32 mask)
2831 FLAC__uint32 limit_channel_mask(FLAC__uint32 mask, unsigned channels)
2833 FLAC__uint32 x = 0x80000000;
2834 unsigned count = count_channel_mask_bits(mask);
2835 while(x && count > channels) {
2842 FLAC__ASSERT(count_channel_mask_bits(mask) == channels);