add support for Wave64 (SF#1769582: https://sourceforge.net/tracker/index.php?func...
[flac.git] / src / flac / encode.c
1 /* flac - Command-line FLAC encoder/decoder
2  * Copyright (C) 2000,2001,2002,2003,2004,2005,2006,2007,2008  Josh Coalson
3  *
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.
8  *
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.
13  *
14  * You should have received a copy of the GNU General Public License
15  * along with this program; if not, write to the Free Software
16  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
17  */
18
19 #if HAVE_CONFIG_H
20 #  include <config.h>
21 #endif
22
23 #if defined _WIN32 && !defined __CYGWIN__
24 /* where MSVC puts unlink() */
25 # include <io.h>
26 #else
27 # include <unistd.h>
28 #endif
29 #if defined _MSC_VER || defined __MINGW32__
30 #include <sys/types.h> /* for off_t */
31 #if _MSC_VER <= 1600 /* @@@ [2G limit] */
32 #define fseeko fseek
33 #define ftello ftell
34 #endif
35 #endif
36 #include <errno.h>
37 #include <limits.h> /* for LONG_MAX */
38 #include <math.h> /* for floor() */
39 #include <stdio.h> /* for FILE etc. */
40 #include <stdlib.h> /* for malloc */
41 #include <string.h> /* for strcmp(), strerror() */
42 #include "FLAC/all.h"
43 #include "share/alloc.h"
44 #include "share/grabbag.h"
45 #include "encode.h"
46
47 #ifdef min
48 #undef min
49 #endif
50 #define min(x,y) ((x)<(y)?(x):(y))
51 #ifdef max
52 #undef max
53 #endif
54 #define max(x,y) ((x)>(y)?(x):(y))
55
56 /* this MUST be >= 588 so that sector aligning can take place with one read */
57 /* this MUST be < 2^sizeof(size_t) / ( FLAC__MAX_CHANNELS * (FLAC__MAX_BITS_PER_SAMPLE/8) ) */
58 #define CHUNK_OF_SAMPLES 2048
59
60 typedef struct {
61         unsigned sample_rate;
62         unsigned channels;
63         unsigned bits_per_sample; /* width of sample point, including 'shift' bits, valid bps is bits_per_sample-shift */
64         unsigned shift; /* # of LSBs samples have been shifted left by */
65         unsigned bytes_per_wide_sample; /* for convenience, always == channels*((bps+7)/8), or 0 if N/A to input format (like FLAC) */
66         FLAC__bool is_unsigned_samples;
67         FLAC__bool is_big_endian;
68         FLAC__uint32 channel_mask;
69 } SampleInfo;
70
71 /* this is the client_data attached to the FLAC decoder when encoding from a FLAC file */
72 typedef struct {
73         off_t filesize;
74         const FLAC__byte *lookahead;
75         unsigned lookahead_length;
76         size_t num_metadata_blocks;
77         FLAC__StreamMetadata *metadata_blocks[1024]; /*@@@ BAD MAGIC number */
78         FLAC__uint64 samples_left_to_process;
79         FLAC__bool fatal_error;
80 } FLACDecoderData;
81
82 typedef struct {
83 #if FLAC__HAS_OGG
84         FLAC__bool use_ogg;
85 #endif
86         FLAC__bool verify;
87         FLAC__bool is_stdout;
88         FLAC__bool outputfile_opened; /* true if we successfully opened the output file and we want it to be deleted if there is an error */
89         const char *inbasefilename;
90         const char *infilename;
91         const char *outfilename;
92
93         FLAC__bool treat_warnings_as_errors;
94         FLAC__bool continue_through_decode_errors;
95         FLAC__bool replay_gain;
96         FLAC__uint64 total_samples_to_encode; /* (i.e. "wide samples" aka "sample frames") WATCHOUT: may be 0 to mean 'unknown' */
97         FLAC__uint64 unencoded_size; /* an estimate of the input size, only used in the progress indicator */
98         FLAC__uint64 bytes_written;
99         FLAC__uint64 samples_written;
100         unsigned stats_mask;
101
102         SampleInfo info;
103
104         FileFormat format;
105         union {
106                 struct {
107                         FLAC__uint64 data_bytes;
108                 } iff;
109                 struct {
110                         FLAC__StreamDecoder *decoder;
111                         FLACDecoderData client_data;
112                 } flac;
113         } fmt;
114
115         FLAC__StreamEncoder *encoder;
116
117         FILE *fin;
118         FLAC__StreamMetadata *seek_table_template;
119 } EncoderSession;
120
121 const int FLAC_ENCODE__DEFAULT_PADDING = 8192;
122
123 static FLAC__bool is_big_endian_host_;
124
125 static unsigned char ucbuffer_[CHUNK_OF_SAMPLES*FLAC__MAX_CHANNELS*((FLAC__REFERENCE_CODEC_MAX_BITS_PER_SAMPLE+7)/8)];
126 static signed char *scbuffer_ = (signed char *)ucbuffer_;
127 static FLAC__uint16 *usbuffer_ = (FLAC__uint16 *)ucbuffer_;
128 static FLAC__int16 *ssbuffer_ = (FLAC__int16 *)ucbuffer_;
129
130 static FLAC__int32 in_[FLAC__MAX_CHANNELS][CHUNK_OF_SAMPLES];
131 static FLAC__int32 *input_[FLAC__MAX_CHANNELS];
132
133
134 /*
135  * unpublished debug routines from the FLAC libs
136  */
137 extern FLAC__bool FLAC__stream_encoder_disable_constant_subframes(FLAC__StreamEncoder *encoder, FLAC__bool value);
138 extern FLAC__bool FLAC__stream_encoder_disable_fixed_subframes(FLAC__StreamEncoder *encoder, FLAC__bool value);
139 extern FLAC__bool FLAC__stream_encoder_disable_verbatim_subframes(FLAC__StreamEncoder *encoder, FLAC__bool value);
140 extern FLAC__bool FLAC__stream_encoder_set_do_md5(FLAC__StreamEncoder *encoder, FLAC__bool value);
141
142 /*
143  * local routines
144  */
145 static FLAC__bool EncoderSession_construct(EncoderSession *e, encode_options_t options, off_t infilesize, FILE *infile, const char *infilename, const char *outfilename, const FLAC__byte *lookahead, unsigned lookahead_length);
146 static void EncoderSession_destroy(EncoderSession *e);
147 static int EncoderSession_finish_ok(EncoderSession *e, int info_align_carry, int info_align_zero, foreign_metadata_t *foreign_metadata);
148 static int EncoderSession_finish_error(EncoderSession *e);
149 static FLAC__bool EncoderSession_init_encoder(EncoderSession *e, encode_options_t options);
150 static FLAC__bool EncoderSession_process(EncoderSession *e, const FLAC__int32 * const buffer[], unsigned samples);
151 static FLAC__bool EncoderSession_format_is_iff(const EncoderSession *e);
152 static FLAC__bool convert_to_seek_table_template(const char *requested_seek_points, int num_requested_seek_points, FLAC__StreamMetadata *cuesheet, EncoderSession *e);
153 static FLAC__bool canonicalize_until_specification(utils__SkipUntilSpecification *spec, const char *inbasefilename, unsigned sample_rate, FLAC__uint64 skip, FLAC__uint64 total_samples_in_input);
154 static FLAC__bool verify_metadata(const EncoderSession *e, FLAC__StreamMetadata **metadata, unsigned num_metadata);
155 static FLAC__bool format_input(FLAC__int32 *dest[], unsigned wide_samples, FLAC__bool is_big_endian, FLAC__bool is_unsigned_samples, unsigned channels, unsigned bps, unsigned shift, size_t *channel_map);
156 static void encoder_progress_callback(const FLAC__StreamEncoder *encoder, FLAC__uint64 bytes_written, FLAC__uint64 samples_written, unsigned frames_written, unsigned total_frames_estimate, void *client_data);
157 static FLAC__StreamDecoderReadStatus flac_decoder_read_callback(const FLAC__StreamDecoder *decoder, FLAC__byte buffer[], size_t *bytes, void *client_data);
158 static FLAC__StreamDecoderSeekStatus flac_decoder_seek_callback(const FLAC__StreamDecoder *decoder, FLAC__uint64 absolute_byte_offset, void *client_data);
159 static FLAC__StreamDecoderTellStatus flac_decoder_tell_callback(const FLAC__StreamDecoder *decoder, FLAC__uint64 *absolute_byte_offset, void *client_data);
160 static FLAC__StreamDecoderLengthStatus flac_decoder_length_callback(const FLAC__StreamDecoder *decoder, FLAC__uint64 *stream_length, void *client_data);
161 static FLAC__bool flac_decoder_eof_callback(const FLAC__StreamDecoder *decoder, void *client_data);
162 static FLAC__StreamDecoderWriteStatus flac_decoder_write_callback(const FLAC__StreamDecoder *decoder, const FLAC__Frame *frame, const FLAC__int32 * const buffer[], void *client_data);
163 static void flac_decoder_metadata_callback(const FLAC__StreamDecoder *decoder, const FLAC__StreamMetadata *metadata, void *client_data);
164 static void flac_decoder_error_callback(const FLAC__StreamDecoder *decoder, FLAC__StreamDecoderErrorStatus status, void *client_data);
165 static FLAC__bool parse_cuesheet(FLAC__StreamMetadata **cuesheet, const char *cuesheet_filename, const char *inbasefilename, FLAC__bool is_cdda, FLAC__uint64 lead_out_offset, FLAC__bool treat_warnings_as_errors);
166 static void print_stats(const EncoderSession *encoder_session);
167 static void print_error_with_init_status(const EncoderSession *e, const char *message, FLAC__StreamEncoderInitStatus init_status);
168 static void print_error_with_state(const EncoderSession *e, const char *message);
169 static void print_verify_error(EncoderSession *e);
170 static FLAC__bool read_bytes(FILE *f, FLAC__byte *buf, size_t n, FLAC__bool eof_ok, const char *fn);
171 static FLAC__bool read_uint16(FILE *f, FLAC__bool big_endian, FLAC__uint16 *val, const char *fn);
172 static FLAC__bool read_uint32(FILE *f, FLAC__bool big_endian, FLAC__uint32 *val, const char *fn);
173 static FLAC__bool read_uint64(FILE *f, FLAC__bool big_endian, FLAC__uint64 *val, const char *fn);
174 static FLAC__bool read_sane_extended(FILE *f, FLAC__uint32 *val, const char *fn);
175 static FLAC__bool fskip_ahead(FILE *f, FLAC__uint64 offset);
176 static unsigned count_channel_mask_bits(FLAC__uint32 mask);
177 #if 0
178 static FLAC__uint32 limit_channel_mask(FLAC__uint32 mask, unsigned channels);
179 #endif
180
181 static FLAC__bool get_sample_info_raw(EncoderSession *e, encode_options_t options)
182 {
183         e->info.sample_rate = options.format_options.raw.sample_rate;
184         e->info.channels = options.format_options.raw.channels;
185         e->info.bits_per_sample = options.format_options.raw.bps;
186         e->info.shift = 0;
187         e->info.bytes_per_wide_sample = options.format_options.raw.channels * ((options.format_options.raw.bps+7)/8);
188         e->info.is_unsigned_samples = options.format_options.raw.is_unsigned_samples;
189         e->info.is_big_endian = options.format_options.raw.is_big_endian;
190         e->info.channel_mask = 0;
191
192         return true;
193 }
194
195 static FLAC__bool get_sample_info_wave(EncoderSession *e, encode_options_t options)
196 {
197         FLAC__bool got_fmt_chunk = false, got_data_chunk = false, got_ds64_chunk = false;
198         unsigned sample_rate = 0, channels = 0, bps = 0, shift = 0;
199         FLAC__uint32 channel_mask = 0;
200         FLAC__uint64 ds64_data_size = 0;
201
202         e->info.is_unsigned_samples = false;
203         e->info.is_big_endian = false;
204
205         if(e->format == FORMAT_WAVE64) {
206                 /*
207                  * lookahead[] already has "riff\x2E\x91\xCF\x11\xD6\xA5\x28\xDB", skip over remaining header
208                  */
209                 if(!fskip_ahead(e->fin, 16+8+16-12)) { /* riff GUID + riff size + WAVE GUID - lookahead */
210                         flac__utils_printf(stderr, 1, "%s: ERROR during read while skipping over remaining \"riff\" header\n", e->inbasefilename);
211                         return false;
212                 }
213         }
214         /* else lookahead[] already has "RIFFxxxxWAVE" or "RF64xxxxWAVE" */
215
216         while(!feof(e->fin) && !got_data_chunk) {
217                 /* chunk IDs are 4 bytes for WAVE/RF64, 16 for Wave64 */
218                 /* for WAVE/RF64 we want the 5th char zeroed so we can treat it like a C string */
219                 char chunk_id[16] = { '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0' };
220
221                 if(!read_bytes(e->fin, (FLAC__byte*)chunk_id, e->format==FORMAT_WAVE64?16:4, /*eof_ok=*/true, e->inbasefilename)) {
222                         flac__utils_printf(stderr, 1, "%s: ERROR: incomplete chunk identifier\n", e->inbasefilename);
223                         return false;
224                 }
225                 if(feof(e->fin))
226                         break;
227
228                 if(e->format == FORMAT_RF64 && !memcmp(chunk_id, "ds64", 4)) { /* RF64 64-bit sizes chunk */
229                         FLAC__uint32 xx, data_bytes;
230
231                         if(got_ds64_chunk) {
232                                 flac__utils_printf(stderr, 1, "%s: ERROR: file has multiple 'ds64' chunks\n", e->inbasefilename);
233                                 return false;
234                         }
235                         if(got_fmt_chunk || got_data_chunk) {
236                                 flac__utils_printf(stderr, 1, "%s: ERROR: 'ds64' chunk appears after 'fmt ' or 'data' chunk\n", e->inbasefilename);
237                                 return false;
238                         }
239
240                         /* ds64 chunk size */
241                         if(!read_uint32(e->fin, /*big_endian=*/false, &xx, e->inbasefilename))
242                                 return false;
243                         data_bytes = xx;
244                         if(data_bytes < 28) {
245                                 flac__utils_printf(stderr, 1, "%s: ERROR: non-standard 'ds64' chunk has length = %u\n", e->inbasefilename, (unsigned)data_bytes);
246                                 return false;
247                         }
248                         if(data_bytes & 1) /* should never happen, but enforce WAVE alignment rules */
249                                 data_bytes++;
250
251                         /* RIFF 64-bit size, lo/hi */
252                         if(!read_uint32(e->fin, /*big_endian=*/false, &xx, e->inbasefilename))
253                                 return false;
254                         if(!read_uint32(e->fin, /*big_endian=*/false, &xx, e->inbasefilename))
255                                 return false;
256
257                         /* 'data' 64-bit size */
258                         if(!read_uint64(e->fin, /*big_endian=*/false, &ds64_data_size, e->inbasefilename))
259                                 return false;
260
261                         data_bytes -= 16;
262
263                         /* skip any extra data in the ds64 chunk */
264                         if(!fskip_ahead(e->fin, data_bytes)) {
265                                 flac__utils_printf(stderr, 1, "%s: ERROR during read while skipping over extra 'ds64' data\n", e->inbasefilename);
266                                 return false;
267                         }
268
269                         got_ds64_chunk = true;
270                 }
271                 else if(
272                         !memcmp(chunk_id, "fmt ", 4) &&
273                         (e->format!=FORMAT_WAVE64 || !memcmp(chunk_id, "fmt \xF3\xAC\xD3\x11\xD1\x8C\x00\xC0\x4F\x8E\xDB\x8A", 16))
274                 ) { /* format chunk */
275                         FLAC__uint16 x;
276                         FLAC__uint32 xx, data_bytes;
277                         FLAC__uint16 wFormatTag; /* wFormatTag word from the 'fmt ' chunk */
278                         unsigned block_align;
279
280                         if(got_fmt_chunk) {
281                                 flac__utils_printf(stderr, 1, "%s: ERROR: file has multiple 'fmt ' chunks\n", e->inbasefilename);
282                                 return false;
283                         }
284
285                         /* see
286                          *   http://www-mmsp.ece.mcgill.ca/Documents/AudioFormats/WAVE/WAVE.html
287                          *   http://windowssdk.msdn.microsoft.com/en-us/library/ms713497.aspx
288                          *   http://msdn.microsoft.com/library/default.asp?url=/library/en-us/audio_r/hh/Audio_r/aud-prop_d40f094e-44f9-4baa-8a15-03e4fb369501.xml.asp
289                          *
290                          * WAVEFORMAT is
291                          * 4 byte: chunk size
292                          * 2 byte: format type: 1 for WAVE_FORMAT_PCM, 65534 for WAVE_FORMAT_EXTENSIBLE
293                          * 2 byte: # channels
294                          * 4 byte: sample rate (Hz)
295                          * 4 byte: avg bytes per sec
296                          * 2 byte: block align
297                          * 2 byte: bits per sample (not necessarily all significant)
298                          * WAVEFORMATEX adds
299                          * 2 byte: extension size in bytes (usually 0 for WAVEFORMATEX and 22 for WAVEFORMATEXTENSIBLE with PCM)
300                          * WAVEFORMATEXTENSIBLE adds
301                          * 2 byte: valid bits per sample
302                          * 4 byte: channel mask
303                          * 16 byte: subformat GUID, first 2 bytes have format type, 1 being PCM
304                          *
305                          * Current spec says WAVEFORMATEX with PCM must have bps == 8 or 16, or any multiple of 8 for WAVEFORMATEXTENSIBLE.
306                          * Lots of old broken WAVEs/apps have don't follow it, e.g. 20 bps but a block align of 3/6 for mono/stereo.
307                          *
308                          * Block align for WAVE_FORMAT_PCM or WAVE_FORMAT_EXTENSIBLE is also supposed to be channels*bps/8
309                          *
310                          * If the channel mask has more set bits than # of channels, the extra MSBs are ignored.
311                          * If the channel mask has less set bits than # of channels, the extra channels are unassigned to any speaker.
312                          *
313                          * Data is supposed to be unsigned for bps <= 8 else signed.
314                          */
315
316                         /* fmt chunk size */
317                         if(!read_uint32(e->fin, /*big_endian=*/false, &xx, e->inbasefilename))
318                                 return false;
319                         data_bytes = xx;
320                         if(e->format == FORMAT_WAVE64) {
321                                 /* other half of the size field should be 0 */
322                                 if(!read_uint32(e->fin, /*big_endian=*/false, &xx, e->inbasefilename))
323                                         return false;
324                                 if(xx) {
325                                         flac__utils_printf(stderr, 1, "%s: ERROR: freakishly large Wave64 'fmt ' chunk has length = 0x%08X%08X\n", e->inbasefilename, (unsigned)xx, (unsigned)data_bytes);
326                                         return false;
327                                 }
328                                 /* subtract size of header */
329                                 if (data_bytes < 16+8) {
330                                         flac__utils_printf(stderr, 1, "%s: ERROR: freakishly small Wave64 'fmt ' chunk has length = 0x%08X%08X\n", e->inbasefilename, (unsigned)xx, (unsigned)data_bytes);
331                                         return false;
332                                 }
333                                 data_bytes -= (16+8);
334                         }
335                         if(data_bytes < 16) {
336                                 flac__utils_printf(stderr, 1, "%s: ERROR: non-standard 'fmt ' chunk has length = %u\n", e->inbasefilename, (unsigned)data_bytes);
337                                 return false;
338                         }
339                         if(e->format != FORMAT_WAVE64) {
340                                 if(data_bytes & 1) /* should never happen, but enforce WAVE alignment rules */
341                                         data_bytes++;
342                         }
343                         else { /* Wave64 */
344                                 data_bytes = (data_bytes+7) & (~7u); /* should never happen, but enforce Wave64 alignment rules */
345                         }
346
347                         /* format code */
348                         if(!read_uint16(e->fin, /*big_endian=*/false, &wFormatTag, e->inbasefilename))
349                                 return false;
350                         if(wFormatTag != 1 /*WAVE_FORMAT_PCM*/ && wFormatTag != 65534 /*WAVE_FORMAT_EXTENSIBLE*/) {
351                                 flac__utils_printf(stderr, 1, "%s: ERROR: unsupported format type %u\n", e->inbasefilename, (unsigned)wFormatTag);
352                                 return false;
353                         }
354
355                         /* number of channels */
356                         if(!read_uint16(e->fin, /*big_endian=*/false, &x, e->inbasefilename))
357                                 return false;
358                         channels = (unsigned)x;
359
360                         /* sample rate */
361                         if(!read_uint32(e->fin, /*big_endian=*/false, &xx, e->inbasefilename))
362                                 return false;
363                         sample_rate = xx;
364
365                         /* avg bytes per second (ignored) */
366                         if(!read_uint32(e->fin, /*big_endian=*/false, &xx, e->inbasefilename))
367                                 return false;
368                         /* block align */
369                         if(!read_uint16(e->fin, /*big_endian=*/false, &x, e->inbasefilename))
370                                 return false;
371                         block_align = (unsigned)x;
372                         /* bits per sample */
373                         if(!read_uint16(e->fin, /*big_endian=*/false, &x, e->inbasefilename))
374                                 return false;
375                         bps = (unsigned)x;
376
377                         e->info.is_unsigned_samples = (bps <= 8);
378
379                         if(wFormatTag == 1) {
380                                 if(bps != 8 && bps != 16) {
381                                         if(bps == 24 || bps == 32) {
382                                                 /* let these slide with a warning since they're unambiguous */
383                                                 flac__utils_printf(stderr, 1, "%s: WARNING: legacy WAVE file has format type %u but bits-per-sample=%u\n", e->inbasefilename, (unsigned)wFormatTag, bps);
384                                                 if(e->treat_warnings_as_errors)
385                                                         return false;
386                                         }
387                                         else {
388                                                 /* @@@ we could add an option to specify left- or right-justified blocks so we knew how to set 'shift' */
389                                                 flac__utils_printf(stderr, 1, "%s: ERROR: legacy WAVE file has format type %u but bits-per-sample=%u\n", e->inbasefilename, (unsigned)wFormatTag, bps);
390                                                 return false;
391                                         }
392                                 }
393 #if 0 /* @@@ reinstate once we can get an answer about whether the samples are left- or right-justified */
394                                 if((bps+7)/8 * channels == block_align) {
395                                         if(bps % 8) {
396                                                 /* assume legacy file is byte aligned with some LSBs zero; this is double-checked in format_input() */
397                                                 flac__utils_printf(stderr, 1, "%s: WARNING: legacy WAVE file (format type %d) has block alignment=%u, bits-per-sample=%u, channels=%u\n", e->inbasefilename, (unsigned)wFormatTag, block_align, bps, channels);
398                                                 if(e->treat_warnings_as_errors)
399                                                         return false;
400                                                 shift = 8 - (bps % 8);
401                                                 bps += shift;
402                                         }
403                                         else
404                                                 shift = 0;
405                                 }
406                                 else {
407                                         flac__utils_printf(stderr, 1, "%s: ERROR: illegal WAVE file (format type %d) has block alignment=%u, bits-per-sample=%u, channels=%u\n", e->inbasefilename, (unsigned)wFormatTag, block_align, bps, channels);
408                                         return false;
409                                 }
410 #else
411                                 shift = 0;
412 #endif
413                                 if(channels > 2 && !options.channel_map_none) {
414                                         flac__utils_printf(stderr, 1, "%s: ERROR: WAVE has >2 channels but is not WAVE_FORMAT_EXTENSIBLE; cannot assign channels\n", e->inbasefilename);
415                                         return false;
416                                 }
417                                 FLAC__ASSERT(data_bytes >= 16);
418                                 data_bytes -= 16;
419                         }
420                         else {
421                                 if(data_bytes < 40) {
422                                         flac__utils_printf(stderr, 1, "%s: ERROR: invalid WAVEFORMATEXTENSIBLE chunk with size %u\n", e->inbasefilename, (unsigned)data_bytes);
423                                         return false;
424                                 }
425                                 /* cbSize */
426                                 if(!read_uint16(e->fin, /*big_endian=*/false, &x, e->inbasefilename))
427                                         return false;
428                                 if(x < 22) {
429                                         flac__utils_printf(stderr, 1, "%s: ERROR: invalid WAVEFORMATEXTENSIBLE chunk with cbSize %u\n", e->inbasefilename, (unsigned)x);
430                                         return false;
431                                 }
432                                 /* valid bps */
433                                 if(!read_uint16(e->fin, /*big_endian=*/false, &x, e->inbasefilename))
434                                         return false;
435                                 if((unsigned)x > bps) {
436                                         flac__utils_printf(stderr, 1, "%s: ERROR: invalid WAVEFORMATEXTENSIBLE chunk with wValidBitsPerSample (%u) > wBitsPerSample (%u)\n", e->inbasefilename, (unsigned)x, bps);
437                                         return false;
438                                 }
439                                 shift = bps - (unsigned)x;
440                                 /* channel mask */
441                                 if(!read_uint32(e->fin, /*big_endian=*/false, &channel_mask, e->inbasefilename))
442                                         return false;
443                                 /* for mono/stereo and unassigned channels, we fake the mask */
444                                 if(channel_mask == 0) {
445                                         if(channels == 1)
446                                                 channel_mask = 0x0001;
447                                         else if(channels == 2)
448                                                 channel_mask = 0x0003;
449                                 }
450                                 /* set channel mapping */
451                                 /* FLAC order follows SMPTE and WAVEFORMATEXTENSIBLE but with fewer channels, which are: */
452                                 /* front left, front right, center, LFE, back left, back right, surround left, surround right */
453                                 /* the default mapping is sufficient for 1-6 channels and 7-8 are currently unspecified anyway */
454 #if 0
455                                 /* @@@ example for dolby/vorbis order, for reference later in case it becomes important */
456                                 if(
457                                         options.channel_map_none ||
458                                         channel_mask == 0x0001 || /* 1 channel: (mono) */
459                                         channel_mask == 0x0003 || /* 2 channels: front left, front right */
460                                         channel_mask == 0x0033 || /* 4 channels: front left, front right, back left, back right */
461                                         channel_mask == 0x0603    /* 4 channels: front left, front right, side left, side right */
462                                 ) {
463                                         /* keep default channel order */
464                                 }
465                                 else if(
466                                         channel_mask == 0x0007 || /* 3 channels: front left, front right, front center */
467                                         channel_mask == 0x0037 || /* 5 channels: front left, front right, front center, back left, back right */
468                                         channel_mask == 0x0607    /* 5 channels: front left, front right, front center, side left, side right */
469                                 ) {
470                                         /* to dolby order: front left, center, front right [, surround left, surround right ] */
471                                         channel_map[1] = 2;
472                                         channel_map[2] = 1;
473                                 }
474                                 else if(
475                                         channel_mask == 0x003f || /* 6 channels: front left, front right, front center, LFE, back left, back right */
476                                         channel_mask == 0x060f    /* 6 channels: front left, front right, front center, LFE, side left, side right */
477                                 ) {
478                                         /* to dolby order: front left, center, front right, surround left, surround right, LFE */
479                                         channel_map[1] = 2;
480                                         channel_map[2] = 1;
481                                         channel_map[3] = 5;
482                                         channel_map[4] = 3;
483                                         channel_map[5] = 4;
484                                 }
485 #else
486                                 if(
487                                         options.channel_map_none ||
488                                         channel_mask == 0x0001 || /* 1 channel: (mono) */
489                                         channel_mask == 0x0003 || /* 2 channels: front left, front right */
490                                         channel_mask == 0x0007 || /* 3 channels: front left, front right, front center */
491                                         channel_mask == 0x0033 || /* 4 channels: front left, front right, back left, back right */
492                                         channel_mask == 0x0603 || /* 4 channels: front left, front right, side left, side right */
493                                         channel_mask == 0x0037 || /* 5 channels: front left, front right, front center, back left, back right */
494                                         channel_mask == 0x0607 || /* 5 channels: front left, front right, front center, side left, side right */
495                                         channel_mask == 0x003f || /* 6 channels: front left, front right, front center, LFE, back left, back right */
496                                         channel_mask == 0x060f    /* 6 channels: front left, front right, front center, LFE, side left, side right */
497                                 ) {
498                                         /* keep default channel order */
499                                 }
500 #endif
501                                 else {
502                                         flac__utils_printf(stderr, 1, "%s: ERROR: WAVEFORMATEXTENSIBLE chunk with unsupported channel mask=0x%04X\n\nUse --channel-map=none option to store channels in current order; FLAC files\nmust also be decoded with --channel-map=none to restore correct order.\n", e->inbasefilename, (unsigned)channel_mask);
503                                         return false;
504                                 }
505                                 if(!options.channel_map_none) {
506                                         if(count_channel_mask_bits(channel_mask) < channels) {
507                                                 flac__utils_printf(stderr, 1, "%s: ERROR: WAVEFORMATEXTENSIBLE chunk: channel mask 0x%04X has unassigned channels (#channels=%u)\n", e->inbasefilename, (unsigned)channel_mask, channels);
508                                                 return false;
509                                         }
510 #if 0
511                                         /* supporting this is too difficult with channel mapping; e.g. what if mask is 0x003f but #channels=4?
512                                          * there would be holes in the order that would have to be filled in, or the mask would have to be
513                                          * limited and the logic above rerun to see if it still fits into the FLAC mapping.
514                                          */
515                                         else if(count_channel_mask_bits(channel_mask) > channels)
516                                                 channel_mask = limit_channel_mask(channel_mask, channels);
517 #else
518                                         else if(count_channel_mask_bits(channel_mask) > channels) {
519                                                 flac__utils_printf(stderr, 1, "%s: ERROR: WAVEFORMATEXTENSIBLE chunk: channel mask 0x%04X has extra bits for non-existant channels (#channels=%u)\n", e->inbasefilename, (unsigned)channel_mask, channels);
520                                                 return false;
521                                         }
522 #endif
523                                 }
524                                 /* first part of GUID */
525                                 if(!read_uint16(e->fin, /*big_endian=*/false, &x, e->inbasefilename))
526                                         return false;
527                                 if(x != 1) {
528                                         flac__utils_printf(stderr, 1, "%s: ERROR: unsupported WAVEFORMATEXTENSIBLE chunk with non-PCM format %u\n", e->inbasefilename, (unsigned)x);
529                                         return false;
530                                 }
531                                 data_bytes -= 26;
532                         }
533
534                         e->info.bytes_per_wide_sample = channels * (bps / 8);
535
536                         /* skip any extra data in the fmt chunk */
537                         if(!fskip_ahead(e->fin, data_bytes)) {
538                                 flac__utils_printf(stderr, 1, "%s: ERROR during read while skipping over extra 'fmt' data\n", e->inbasefilename);
539                                 return false;
540                         }
541
542                         got_fmt_chunk = true;
543                 }
544                 else if(
545                         !memcmp(chunk_id, "data", 4) &&
546                         (e->format!=FORMAT_WAVE64 || !memcmp(chunk_id, "data\xF3\xAC\xD3\x11\xD1\x8C\x00\xC0\x4F\x8E\xDB\x8A", 16))
547                 ) { /* data chunk */
548                         FLAC__uint32 xx;
549                         FLAC__uint64 data_bytes;
550
551                         if(!got_fmt_chunk) {
552                                 flac__utils_printf(stderr, 1, "%s: ERROR: got 'data' chunk before 'fmt' chunk\n", e->inbasefilename);
553                                 return false;
554                         }
555
556                         /* data size */
557                         if(e->format != FORMAT_WAVE64) {
558                                 if(!read_uint32(e->fin, /*big_endian=*/false, &xx, e->inbasefilename))
559                                         return false;
560                                 data_bytes = xx;
561                         }
562                         else { /* Wave64 */
563                                 if(!read_uint64(e->fin, /*big_endian=*/false, &data_bytes, e->inbasefilename))
564                                         return false;
565                                 /* subtract size of header */
566                                 if (data_bytes < 16+8) {
567                                         flac__utils_printf(stderr, 1, "%s: ERROR: freakishly small Wave64 'data' chunk has length = 0x00000000%08X\n", e->inbasefilename, (unsigned)data_bytes);
568                                         return false;
569                                 }
570                                 data_bytes -= (16+8);
571                         }
572                         if(e->format == FORMAT_RF64) {
573                                 if(!got_ds64_chunk) {
574                                         flac__utils_printf(stderr, 1, "%s: ERROR: RF64 file has no 'ds64' chunk before 'data' chunk\n", e->inbasefilename);
575                                         return false;
576                                 }
577                                 if(data_bytes == 0xffffffff)
578                                         data_bytes = ds64_data_size;
579                         }
580                         if(options.ignore_chunk_sizes) {
581                                 FLAC__ASSERT(!options.sector_align);
582                                 if(data_bytes) {
583                                         flac__utils_printf(stderr, 1, "%s: WARNING: 'data' chunk has non-zero size, using --ignore-chunk-sizes is probably a bad idea\n", e->inbasefilename, chunk_id);
584                                         if(e->treat_warnings_as_errors)
585                                                 return false;
586                                 }
587                                 data_bytes = (FLAC__uint64)0 - (FLAC__uint64)e->info.bytes_per_wide_sample; /* max out data_bytes; we'll use EOF as signal to stop reading */
588                         }
589                         else if(0 == data_bytes) {
590                                 flac__utils_printf(stderr, 1, "%s: ERROR: 'data' chunk has size of 0\n", e->inbasefilename);
591                                 return false;
592                         }
593
594                         e->fmt.iff.data_bytes = data_bytes;
595
596                         got_data_chunk = true;
597                         break;
598                 }
599                 else {
600                         FLAC__uint32 xx;
601                         FLAC__uint64 skip;
602                         if(!options.format_options.iff.foreign_metadata) {
603                                 if(e->format != FORMAT_WAVE64)
604                                         flac__utils_printf(stderr, 1, "%s: WARNING: skipping unknown chunk '%s' (use --keep-foreign-metadata to keep)\n", e->inbasefilename, chunk_id);
605                                 else
606                                         flac__utils_printf(stderr, 1, "%s: WARNING: skipping unknown chunk %02X%02X%02X%02X-%02X%02X-%02X%02X-%02X%02X-%02X%02X%02X%02X%02X%02X (use --keep-foreign-metadata to keep)\n",
607                                                 e->inbasefilename,
608                                                 (unsigned)((const unsigned char *)chunk_id)[3],
609                                                 (unsigned)((const unsigned char *)chunk_id)[2],
610                                                 (unsigned)((const unsigned char *)chunk_id)[1],
611                                                 (unsigned)((const unsigned char *)chunk_id)[0],
612                                                 (unsigned)((const unsigned char *)chunk_id)[5],
613                                                 (unsigned)((const unsigned char *)chunk_id)[4],
614                                                 (unsigned)((const unsigned char *)chunk_id)[7],
615                                                 (unsigned)((const unsigned char *)chunk_id)[6],
616                                                 (unsigned)((const unsigned char *)chunk_id)[9],
617                                                 (unsigned)((const unsigned char *)chunk_id)[8],
618                                                 (unsigned)((const unsigned char *)chunk_id)[10],
619                                                 (unsigned)((const unsigned char *)chunk_id)[11],
620                                                 (unsigned)((const unsigned char *)chunk_id)[12],
621                                                 (unsigned)((const unsigned char *)chunk_id)[13],
622                                                 (unsigned)((const unsigned char *)chunk_id)[14],
623                                                 (unsigned)((const unsigned char *)chunk_id)[15]
624                                         );
625                                 if(e->treat_warnings_as_errors)
626                                         return false;
627                         }
628
629                         /* chunk size */
630                         if(e->format != FORMAT_WAVE64) {
631                                 if(!read_uint32(e->fin, /*big_endian=*/false, &xx, e->inbasefilename))
632                                         return false;
633                                 skip = xx;
634                                 skip += skip & 1;
635                         }
636                         else { /* Wave64 */
637                                 if(!read_uint64(e->fin, /*big_endian=*/false, &skip, e->inbasefilename))
638                                         return false;
639                                 skip = (skip+7) & (~(FLAC__uint64)7);
640                                 /* subtract size of header */
641                                 if (skip < 16+8) {
642                                         flac__utils_printf(stderr, 1, "%s: ERROR: freakishly small Wave64 chunk has length = 0x00000000%08X\n", e->inbasefilename, (unsigned)skip);
643                                         return false;
644                                 }
645                                 skip -= (16+8);
646                         }
647                         if(skip) {
648                                 if(!fskip_ahead(e->fin, skip)) {
649                                         flac__utils_printf(stderr, 1, "%s: ERROR during read while skipping over chunk\n", e->inbasefilename);
650                                         return false;
651                                 }
652                         }
653                 }
654         }
655
656         if(!got_fmt_chunk) {
657                 flac__utils_printf(stderr, 1, "%s: ERROR: didn't find fmt chunk\n", e->inbasefilename);
658                 return false;
659         }
660         if(!got_data_chunk) {
661                 flac__utils_printf(stderr, 1, "%s: ERROR: didn't find data chunk\n", e->inbasefilename);
662                 return false;
663         }
664
665         e->info.sample_rate = sample_rate;
666         e->info.channels = channels;
667         e->info.bits_per_sample = bps;
668         e->info.shift = shift;
669         e->info.channel_mask = channel_mask;
670
671         return true;
672 }
673
674 static FLAC__bool get_sample_info_aiff(EncoderSession *e, encode_options_t options)
675 {
676         FLAC__bool got_comm_chunk = false, got_ssnd_chunk = false;
677         unsigned sample_rate = 0, channels = 0, bps = 0, shift = 0;
678         FLAC__uint64 sample_frames = 0;
679         FLAC__uint32 channel_mask = 0;
680
681         e->info.is_unsigned_samples = false;
682         e->info.is_big_endian = true;
683
684         /*
685          * lookahead[] already has "FORMxxxxAIFF", do chunks
686          */
687         while(!feof(e->fin) && !got_ssnd_chunk) {
688                 char chunk_id[5] = { '\0', '\0', '\0', '\0', '\0' }; /* one extra byte for terminating NUL so we can also treat it like a C string */
689                 if(!read_bytes(e->fin, (FLAC__byte*)chunk_id, 4, /*eof_ok=*/true, e->inbasefilename)) {
690                         flac__utils_printf(stderr, 1, "%s: ERROR: incomplete chunk identifier\n", e->inbasefilename);
691                         return false;
692                 }
693                 if(feof(e->fin))
694                         break;
695
696                 if(!memcmp(chunk_id, "COMM", 4)) { /* common chunk */
697                         FLAC__uint16 x;
698                         FLAC__uint32 xx;
699                         unsigned long skip;
700                         const FLAC__bool is_aifc = e->format == FORMAT_AIFF_C;
701                         const FLAC__uint32 minimum_comm_size = (is_aifc? 22 : 18);
702
703                         if(got_comm_chunk) {
704                                 flac__utils_printf(stderr, 1, "%s: ERROR: file has multiple 'COMM' chunks\n", e->inbasefilename);
705                                 return false;
706                         }
707
708                         /* COMM chunk size */
709                         if(!read_uint32(e->fin, /*big_endian=*/true, &xx, e->inbasefilename))
710                                 return false;
711                         else if(xx < minimum_comm_size) {
712                                 flac__utils_printf(stderr, 1, "%s: ERROR: non-standard %s 'COMM' chunk has length = %u\n", e->inbasefilename, is_aifc? "AIFF-C" : "AIFF", (unsigned int)xx);
713                                 return false;
714                         }
715                         else if(!is_aifc && xx != minimum_comm_size) {
716                                 flac__utils_printf(stderr, 1, "%s: WARNING: non-standard %s 'COMM' chunk has length = %u, expected %u\n", e->inbasefilename, is_aifc? "AIFF-C" : "AIFF", (unsigned int)xx, minimum_comm_size);
717                                 if(e->treat_warnings_as_errors)
718                                         return false;
719                         }
720                         skip = (xx-minimum_comm_size)+(xx & 1);
721
722                         /* number of channels */
723                         if(!read_uint16(e->fin, /*big_endian=*/true, &x, e->inbasefilename))
724                                 return false;
725                         channels = (unsigned)x;
726                         if(channels > 2 && !options.channel_map_none) {
727                                 flac__utils_printf(stderr, 1, "%s: ERROR: unsupported number of channels %u for AIFF\n", e->inbasefilename, channels);
728                                 return false;
729                         }
730
731                         /* number of sample frames */
732                         if(!read_uint32(e->fin, /*big_endian=*/true, &xx, e->inbasefilename))
733                                 return false;
734                         sample_frames = xx;
735
736                         /* bits per sample */
737                         if(!read_uint16(e->fin, /*big_endian=*/true, &x, e->inbasefilename))
738                                 return false;
739                         bps = (unsigned)x;
740                         shift = (bps%8)? 8-(bps%8) : 0; /* SSND data is always byte-aligned, left-justified but format_input() will double-check */
741                         bps += shift;
742
743                         /* sample rate */
744                         if(!read_sane_extended(e->fin, &xx, e->inbasefilename))
745                                 return false;
746                         sample_rate = xx;
747
748                         /* check compression type for AIFF-C */
749                         if(is_aifc) {
750                                 if(!read_uint32(e->fin, /*big_endian=*/true, &xx, e->inbasefilename))
751                                         return false;
752                                 if(xx == 0x736F7774) /* "sowt" */
753                                         e->info.is_big_endian = false;
754                                 else if(xx == 0x4E4F4E45) /* "NONE" */
755                                         ; /* nothing to do, we already default to big-endian */
756                                 else {
757                                         flac__utils_printf(stderr, 1, "%s: ERROR: can't handle AIFF-C compression type \"%c%c%c%c\"\n", e->inbasefilename, (char)(xx>>24), (char)((xx>>16)&8), (char)((xx>>8)&8), (char)(xx&8));
758                                         return false;
759                                 }
760                         }
761
762                         /* set channel mapping */
763                         /* FLAC order follows SMPTE and WAVEFORMATEXTENSIBLE but with fewer channels, which are: */
764                         /* front left, front right, center, LFE, back left, back right, surround left, surround right */
765                         /* specs say the channel ordering is:
766                          *                             1     2   3   4   5   6
767                          * ___________________________________________________
768                          * 2         stereo            l     r
769                          * 3                           l     r   c
770                          * 4                           l     c   r   S
771                          * quad (ambiguous with 4ch)  Fl    Fr   Bl  Br
772                          * 5                          Fl     Fr  Fc  Sl  Sr
773                          * 6                           l     lc  c   r   rc  S
774                          * l:left r:right c:center Fl:front-left Fr:front-right Bl:back-left Br:back-right Lc:left-center Rc:right-center S:surround
775                          * so we only have unambiguous mappings for 2, 3, and 5 channels
776                          */
777                         if(
778                                 options.channel_map_none ||
779                                 channels == 1 || /* 1 channel: (mono) */
780                                 channels == 2 || /* 2 channels: left, right */
781                                 channels == 3 || /* 3 channels: left, right, center */
782                                 channels == 5    /* 5 channels: front left, front right, center, surround left, surround right */
783                         ) {
784                                 /* keep default channel order */
785                         }
786                         else {
787                                 flac__utils_printf(stderr, 1, "%s: ERROR: unsupported number of channels %u for AIFF\n", e->inbasefilename, channels);
788                                 return false;
789                         }
790
791                         e->info.bytes_per_wide_sample = channels * (bps / 8);
792
793                         /* skip any extra data in the COMM chunk */
794                         if(!fskip_ahead(e->fin, skip)) {
795                                 flac__utils_printf(stderr, 1, "%s: ERROR during read while skipping over extra COMM data\n", e->inbasefilename);
796                                 return false;
797                         }
798
799                         got_comm_chunk = true;
800                 }
801                 else if(!memcmp(chunk_id, "SSND", 4) && !got_ssnd_chunk) { /* sound data chunk */
802                         FLAC__uint32 xx;
803                         FLAC__uint64 data_bytes;
804                         unsigned offset = 0, block_size = 0;
805
806                         if(!got_comm_chunk) {
807                                 flac__utils_printf(stderr, 1, "%s: ERROR: got 'SSND' chunk before 'COMM' chunk\n", e->inbasefilename);
808                                 return false;
809                         }
810
811                         /* SSND chunk size */
812                         if(!read_uint32(e->fin, /*big_endian=*/true, &xx, e->inbasefilename))
813                                 return false;
814                         data_bytes = xx;
815                         if(options.ignore_chunk_sizes) {
816                                 FLAC__ASSERT(!options.sector_align);
817                                 if(data_bytes) {
818                                         flac__utils_printf(stderr, 1, "%s: WARNING: 'SSND' chunk has non-zero size, using --ignore-chunk-sizes is probably a bad idea\n", e->inbasefilename, chunk_id);
819                                         if(e->treat_warnings_as_errors)
820                                                 return false;
821                                 }
822                                 data_bytes = (FLAC__uint64)0 - (FLAC__uint64)e->info.bytes_per_wide_sample; /* max out data_bytes; we'll use EOF as signal to stop reading */
823                         }
824                         else if(data_bytes <= 8) {
825                                 flac__utils_printf(stderr, 1, "%s: ERROR: 'SSND' chunk has size <= 8\n", e->inbasefilename);
826                                 return false;
827                         }
828                         else {
829                                 data_bytes -= 8; /* discount the offset and block size fields */
830                         }
831
832                         /* offset */
833                         if(!read_uint32(e->fin, /*big_endian=*/true, &xx, e->inbasefilename))
834                                 return false;
835                         offset = xx;
836                         data_bytes -= offset;
837
838                         /* block size */
839                         if(!read_uint32(e->fin, /*big_endian=*/true, &xx, e->inbasefilename))
840                                 return false;
841                         else if(xx != 0) {
842                                 flac__utils_printf(stderr, 1, "%s: ERROR: block size is %u; must be 0\n", e->inbasefilename, (unsigned)xx);
843                                 return false;
844                         }
845                         block_size = xx;
846
847                         /* skip any SSND offset bytes */
848                         if(!fskip_ahead(e->fin, offset)) {
849                                 flac__utils_printf(stderr, 1, "%s: ERROR: skipping offset in SSND chunk\n", e->inbasefilename);
850                                 return false;
851                         }
852                         if(data_bytes != (sample_frames * e->info.bytes_per_wide_sample)) {
853                                 flac__utils_printf(stderr, 1, "%s: ERROR: SSND chunk size inconsistent with sample frame count\n", e->inbasefilename);
854                                 return false;
855                         }
856
857                         e->fmt.iff.data_bytes = data_bytes;
858
859                         got_ssnd_chunk = true;
860                 }
861                 else {
862                         FLAC__uint32 xx;
863                         if(!options.format_options.iff.foreign_metadata) {
864                                 flac__utils_printf(stderr, 1, "%s: WARNING: skipping unknown chunk '%s' (use --keep-foreign-metadata to keep)\n", e->inbasefilename, chunk_id);
865                                 if(e->treat_warnings_as_errors)
866                                         return false;
867                         }
868
869                         /* chunk size */
870                         if(!read_uint32(e->fin, /*big_endian=*/true, &xx, e->inbasefilename))
871                                 return false;
872                         else {
873                                 unsigned long skip = xx + (xx & 1);
874
875                                 FLAC__ASSERT(skip <= LONG_MAX);
876                                 if(!fskip_ahead(e->fin, skip)) {
877                                         flac__utils_printf(stderr, 1, "%s: ERROR during read while skipping over chunk\n", e->inbasefilename);
878                                         return false;
879                                 }
880                         }
881                 }
882         }
883
884         if(!got_comm_chunk) {
885                 flac__utils_printf(stderr, 1, "%s: ERROR: didn't find COMM chunk\n", e->inbasefilename);
886                 return false;
887         }
888         if(!got_ssnd_chunk && sample_frames) {
889                 flac__utils_printf(stderr, 1, "%s: ERROR: didn't find SSND chunk\n", e->inbasefilename);
890                 return false;
891         }
892
893         e->info.sample_rate = sample_rate;
894         e->info.channels = channels;
895         e->info.bits_per_sample = bps;
896         e->info.shift = shift;
897         e->info.channel_mask = channel_mask;
898
899         return true;
900 }
901
902 static FLAC__bool get_sample_info_flac(EncoderSession *e)
903 {
904         if (!(
905                 FLAC__stream_decoder_set_md5_checking(e->fmt.flac.decoder, false) &&
906                 FLAC__stream_decoder_set_metadata_respond_all(e->fmt.flac.decoder)
907         )) {
908                 flac__utils_printf(stderr, 1, "%s: ERROR: setting up decoder for FLAC input\n", e->inbasefilename);
909                 return false;
910         }
911
912         if (e->format == FORMAT_OGGFLAC) {
913                 if (FLAC__stream_decoder_init_ogg_stream(e->fmt.flac.decoder, flac_decoder_read_callback, flac_decoder_seek_callback, flac_decoder_tell_callback, flac_decoder_length_callback, flac_decoder_eof_callback, flac_decoder_write_callback, flac_decoder_metadata_callback, flac_decoder_error_callback, /*client_data=*/e) != FLAC__STREAM_DECODER_INIT_STATUS_OK) {
914                         flac__utils_printf(stderr, 1, "%s: ERROR: initializing decoder for Ogg FLAC input, state = %s\n", e->inbasefilename, FLAC__stream_decoder_get_resolved_state_string(e->fmt.flac.decoder));
915                         return false;
916                 }
917         }
918         else if (FLAC__stream_decoder_init_stream(e->fmt.flac.decoder, flac_decoder_read_callback, flac_decoder_seek_callback, flac_decoder_tell_callback, flac_decoder_length_callback, flac_decoder_eof_callback, flac_decoder_write_callback, flac_decoder_metadata_callback, flac_decoder_error_callback, /*client_data=*/e) != FLAC__STREAM_DECODER_INIT_STATUS_OK) {
919                 flac__utils_printf(stderr, 1, "%s: ERROR: initializing decoder for FLAC input, state = %s\n", e->inbasefilename, FLAC__stream_decoder_get_resolved_state_string(e->fmt.flac.decoder));
920                 return false;
921         }
922
923         if (!FLAC__stream_decoder_process_until_end_of_metadata(e->fmt.flac.decoder) || e->fmt.flac.client_data.fatal_error) {
924                 if (e->fmt.flac.client_data.fatal_error)
925                         flac__utils_printf(stderr, 1, "%s: ERROR: out of memory or too many metadata blocks while reading metadata in FLAC input\n", e->inbasefilename);
926                 else
927                         flac__utils_printf(stderr, 1, "%s: ERROR: reading metadata in FLAC input, state = %s\n", e->inbasefilename, FLAC__stream_decoder_get_resolved_state_string(e->fmt.flac.decoder));
928                 return false;
929         }
930
931         if (e->fmt.flac.client_data.num_metadata_blocks == 0) {
932                 flac__utils_printf(stderr, 1, "%s: ERROR: reading metadata in FLAC input, got no metadata blocks\n", e->inbasefilename);
933                 return false;
934         }
935         else if (e->fmt.flac.client_data.metadata_blocks[0]->type != FLAC__METADATA_TYPE_STREAMINFO) {
936                 flac__utils_printf(stderr, 1, "%s: ERROR: reading metadata in FLAC input, first metadata block is not STREAMINFO\n", e->inbasefilename);
937                 return false;
938         }
939         else if (e->fmt.flac.client_data.metadata_blocks[0]->data.stream_info.total_samples == 0) {
940                 flac__utils_printf(stderr, 1, "%s: ERROR: FLAC input has STREAMINFO with unknown total samples which is not supported\n", e->inbasefilename);
941                 return false;
942         }
943
944         e->info.sample_rate = e->fmt.flac.client_data.metadata_blocks[0]->data.stream_info.sample_rate;
945         e->info.channels = e->fmt.flac.client_data.metadata_blocks[0]->data.stream_info.channels;
946         e->info.bits_per_sample = e->fmt.flac.client_data.metadata_blocks[0]->data.stream_info.bits_per_sample;
947         e->info.shift = 0;
948         e->info.bytes_per_wide_sample = 0;
949         e->info.is_unsigned_samples = false; /* not applicable for FLAC input */
950         e->info.is_big_endian = false; /* not applicable for FLAC input */
951         e->info.channel_mask = 0;
952
953         return true;
954 }
955
956 /*
957  * public routines
958  */
959 int flac__encode_file(FILE *infile, off_t infilesize, const char *infilename, const char *outfilename, const FLAC__byte *lookahead, unsigned lookahead_length, encode_options_t options)
960 {
961         EncoderSession encoder_session;
962         size_t channel_map[FLAC__MAX_CHANNELS];
963         int info_align_carry = -1, info_align_zero = -1;
964
965         if(!EncoderSession_construct(&encoder_session, options, infilesize, infile, infilename, outfilename, lookahead, lookahead_length))
966                 return 1;
967
968         /* initialize default channel map that preserves channel order */
969         {
970                 size_t i;
971                 for(i = 0; i < sizeof(channel_map)/sizeof(channel_map[0]); i++)
972                         channel_map[i] = i;
973         }
974
975         /* read foreign metadata if requested */
976         if(EncoderSession_format_is_iff(&encoder_session) && options.format_options.iff.foreign_metadata) {
977                 const char *error;
978                 if(!(
979                         options.format == FORMAT_WAVE || options.format == FORMAT_RF64?
980                                 flac__foreign_metadata_read_from_wave(options.format_options.iff.foreign_metadata, infilename, &error) :
981                         options.format == FORMAT_WAVE64?
982                                 flac__foreign_metadata_read_from_wave64(options.format_options.iff.foreign_metadata, infilename, &error) :
983                                 flac__foreign_metadata_read_from_aiff(options.format_options.iff.foreign_metadata, infilename, &error)
984                 )) {
985                         flac__utils_printf(stderr, 1, "%s: ERROR reading foreign metadata: %s\n", encoder_session.inbasefilename, error);
986                         return EncoderSession_finish_error(&encoder_session);
987                 }
988         }
989
990         /* initialize encoder session with info about the audio (channels/bps/resolution/endianness/etc) */
991         switch(options.format) {
992                 case FORMAT_RAW:
993                         if(!get_sample_info_raw(&encoder_session, options))
994                                 return EncoderSession_finish_error(&encoder_session);
995                         break;
996                 case FORMAT_WAVE:
997                 case FORMAT_WAVE64:
998                 case FORMAT_RF64:
999                         if(!get_sample_info_wave(&encoder_session, options))
1000                                 return EncoderSession_finish_error(&encoder_session);
1001                         break;
1002                 case FORMAT_AIFF:
1003                 case FORMAT_AIFF_C:
1004                         if(!get_sample_info_aiff(&encoder_session, options))
1005                                 return EncoderSession_finish_error(&encoder_session);
1006                         break;
1007                 case FORMAT_FLAC:
1008                 case FORMAT_OGGFLAC:
1009                         /*
1010                          * set up FLAC decoder for the input
1011                          */
1012                         if (0 == (encoder_session.fmt.flac.decoder = FLAC__stream_decoder_new())) {
1013                                 flac__utils_printf(stderr, 1, "%s: ERROR: creating decoder for FLAC input\n", encoder_session.inbasefilename);
1014                                 return EncoderSession_finish_error(&encoder_session);
1015                         }
1016                         if(!get_sample_info_flac(&encoder_session))
1017                                 return EncoderSession_finish_error(&encoder_session);
1018                         break;
1019                 default:
1020                         FLAC__ASSERT(0);
1021                         /* double protection */
1022                         return EncoderSession_finish_error(&encoder_session);
1023         }
1024
1025         /* some more checks */
1026         if(encoder_session.info.channels == 0 || encoder_session.info.channels > FLAC__MAX_CHANNELS) {
1027                 flac__utils_printf(stderr, 1, "%s: ERROR: unsupported number of channels %u\n", encoder_session.inbasefilename, encoder_session.info.channels);
1028                 return EncoderSession_finish_error(&encoder_session);
1029         }
1030         if(!FLAC__format_sample_rate_is_valid(encoder_session.info.sample_rate)) {
1031                 flac__utils_printf(stderr, 1, "%s: ERROR: unsupported sample rate %u\n", encoder_session.inbasefilename, encoder_session.info.sample_rate);
1032                 return EncoderSession_finish_error(&encoder_session);
1033         }
1034         if(encoder_session.info.bits_per_sample-encoder_session.info.shift < 4 || encoder_session.info.bits_per_sample-encoder_session.info.shift > 24) {
1035                 flac__utils_printf(stderr, 1, "%s: ERROR: unsupported bits-per-sample %u\n", encoder_session.inbasefilename, encoder_session.info.bits_per_sample-encoder_session.info.shift);
1036                 return EncoderSession_finish_error(&encoder_session);
1037         }
1038         if(options.sector_align) {
1039                 if(encoder_session.info.channels != 2) {
1040                         flac__utils_printf(stderr, 1, "%s: ERROR: file has %u channels, must be 2 for --sector-align\n", encoder_session.inbasefilename, encoder_session.info.channels);
1041                         return EncoderSession_finish_error(&encoder_session);
1042                 }
1043                 if(encoder_session.info.sample_rate != 44100) {
1044                         flac__utils_printf(stderr, 1, "%s: ERROR: file's sample rate is %u, must be 44100 for --sector-align\n", encoder_session.inbasefilename, encoder_session.info.sample_rate);
1045                         return EncoderSession_finish_error(&encoder_session);
1046                 }
1047                 if(encoder_session.info.bits_per_sample-encoder_session.info.shift != 16) {
1048                         flac__utils_printf(stderr, 1, "%s: ERROR: file has %u bits-per-sample, must be 16 for --sector-align\n", encoder_session.inbasefilename, encoder_session.info.bits_per_sample-encoder_session.info.shift);
1049                         return EncoderSession_finish_error(&encoder_session);
1050                 }
1051         }
1052
1053         {
1054                 FLAC__uint64 total_samples_in_input; /* WATCHOUT: may be 0 to mean "unknown" */
1055                 FLAC__uint64 skip;
1056                 FLAC__uint64 until; /* a value of 0 mean end-of-stream (i.e. --until=-0) */
1057                 unsigned align_remainder = 0;
1058
1059                 switch(options.format) {
1060                         case FORMAT_RAW:
1061                                 if(infilesize < 0)
1062                                         total_samples_in_input = 0;
1063                                 else
1064                                         total_samples_in_input = (FLAC__uint64)infilesize / encoder_session.info.bytes_per_wide_sample + *options.align_reservoir_samples;
1065                                 break;
1066                         case FORMAT_WAVE:
1067                         case FORMAT_WAVE64:
1068                         case FORMAT_RF64:
1069                         case FORMAT_AIFF:
1070                         case FORMAT_AIFF_C:
1071                                 total_samples_in_input = encoder_session.fmt.iff.data_bytes / encoder_session.info.bytes_per_wide_sample + *options.align_reservoir_samples;
1072                                 break;
1073                         case FORMAT_FLAC:
1074                         case FORMAT_OGGFLAC:
1075                                 total_samples_in_input = encoder_session.fmt.flac.client_data.metadata_blocks[0]->data.stream_info.total_samples + *options.align_reservoir_samples;
1076                                 break;
1077                         default:
1078                                 FLAC__ASSERT(0);
1079                                 /* double protection */
1080                                 return EncoderSession_finish_error(&encoder_session);
1081                 }
1082
1083                 /*
1084                  * now that we know the sample rate, canonicalize the
1085                  * --skip string to an absolute sample number:
1086                  */
1087                 flac__utils_canonicalize_skip_until_specification(&options.skip_specification, encoder_session.info.sample_rate);
1088                 FLAC__ASSERT(options.skip_specification.value.samples >= 0);
1089                 skip = (FLAC__uint64)options.skip_specification.value.samples;
1090                 FLAC__ASSERT(!options.sector_align || (options.format != FORMAT_FLAC && options.format != FORMAT_OGGFLAC && skip == 0));
1091                 /* *options.align_reservoir_samples will be 0 unless --sector-align is used */
1092                 FLAC__ASSERT(options.sector_align || *options.align_reservoir_samples == 0);
1093
1094                 /*
1095                  * now that we possibly know the input size, canonicalize the
1096                  * --until string to an absolute sample number:
1097                  */
1098                 if(!canonicalize_until_specification(&options.until_specification, encoder_session.inbasefilename, encoder_session.info.sample_rate, skip, total_samples_in_input))
1099                         return EncoderSession_finish_error(&encoder_session);
1100                 until = (FLAC__uint64)options.until_specification.value.samples;
1101                 FLAC__ASSERT(!options.sector_align || until == 0);
1102
1103                 /* adjust encoding parameters based on skip and until values */
1104                 switch(options.format) {
1105                         case FORMAT_RAW:
1106                                 infilesize -= (off_t)skip * encoder_session.info.bytes_per_wide_sample;
1107                                 encoder_session.total_samples_to_encode = total_samples_in_input - skip;
1108                                 break;
1109                         case FORMAT_WAVE:
1110                         case FORMAT_WAVE64:
1111                         case FORMAT_RF64:
1112                         case FORMAT_AIFF:
1113                         case FORMAT_AIFF_C:
1114                                 encoder_session.fmt.iff.data_bytes -= skip * encoder_session.info.bytes_per_wide_sample;
1115                                 if(options.ignore_chunk_sizes) {
1116                                         encoder_session.total_samples_to_encode = 0;
1117                                         flac__utils_printf(stderr, 2, "(No runtime statistics possible; please wait for encoding to finish...)\n");
1118                                         FLAC__ASSERT(0 == until);
1119                                 }
1120                                 else {
1121                                         encoder_session.total_samples_to_encode = total_samples_in_input - skip;
1122                                 }
1123                                 break;
1124                         case FORMAT_FLAC:
1125                         case FORMAT_OGGFLAC:
1126                                 encoder_session.total_samples_to_encode = total_samples_in_input - skip;
1127                                 break;
1128                         default:
1129                                 FLAC__ASSERT(0);
1130                                 /* double protection */
1131                                 return EncoderSession_finish_error(&encoder_session);
1132                 }
1133                 if(until > 0) {
1134                         const FLAC__uint64 trim = total_samples_in_input - until;
1135                         FLAC__ASSERT(total_samples_in_input > 0);
1136                         FLAC__ASSERT(!options.sector_align);
1137                         if(options.format == FORMAT_RAW)
1138                                 infilesize -= (off_t)trim * encoder_session.info.bytes_per_wide_sample;
1139                         else if(EncoderSession_format_is_iff(&encoder_session))
1140                                 encoder_session.fmt.iff.data_bytes -= trim * encoder_session.info.bytes_per_wide_sample;
1141                         encoder_session.total_samples_to_encode -= trim;
1142                 }
1143                 if(options.sector_align && (options.format != FORMAT_RAW || infilesize >=0)) { /* for RAW, need to know the filesize */
1144                         FLAC__ASSERT(skip == 0); /* asserted above too, but lest we forget */
1145                         align_remainder = (unsigned)(encoder_session.total_samples_to_encode % 588);
1146                         if(options.is_last_file)
1147                                 encoder_session.total_samples_to_encode += (588-align_remainder); /* will pad with zeroes */
1148                         else
1149                                 encoder_session.total_samples_to_encode -= align_remainder; /* will stop short and carry over to next file */
1150                 }
1151                 switch(options.format) {
1152                         case FORMAT_RAW:
1153                                 encoder_session.unencoded_size = encoder_session.total_samples_to_encode * encoder_session.info.bytes_per_wide_sample;
1154                                 break;
1155                         case FORMAT_WAVE:
1156                                 /* +44 for the size of the WAVE headers; this is just an estimate for the progress indicator and doesn't need to be exact */
1157                                 encoder_session.unencoded_size = encoder_session.total_samples_to_encode * encoder_session.info.bytes_per_wide_sample + 44;
1158                                 break;
1159                         case FORMAT_WAVE64:
1160                                 /* +44 for the size of the WAVE headers; this is just an estimate for the progress indicator and doesn't need to be exact */
1161                                 encoder_session.unencoded_size = encoder_session.total_samples_to_encode * encoder_session.info.bytes_per_wide_sample + 104;
1162                                 break;
1163                         case FORMAT_RF64:
1164                                 /* +72 for the size of the RF64 headers; this is just an estimate for the progress indicator and doesn't need to be exact */
1165                                 encoder_session.unencoded_size = encoder_session.total_samples_to_encode * encoder_session.info.bytes_per_wide_sample + 80;
1166                                 break;
1167                         case FORMAT_AIFF:
1168                         case FORMAT_AIFF_C:
1169                                 /* +54 for the size of the AIFF headers; this is just an estimate for the progress indicator and doesn't need to be exact */
1170                                 encoder_session.unencoded_size = encoder_session.total_samples_to_encode * encoder_session.info.bytes_per_wide_sample + 54;
1171                                 break;
1172                         case FORMAT_FLAC:
1173                         case FORMAT_OGGFLAC:
1174                                 if(infilesize < 0)
1175                                         /* if we don't know, use 0 as hint to progress indicator (which is the only place this is used): */
1176                                         encoder_session.unencoded_size = 0;
1177                                 else if(skip == 0 && until == 0)
1178                                         encoder_session.unencoded_size = (FLAC__uint64)infilesize;
1179                                 else if(total_samples_in_input)
1180                                         encoder_session.unencoded_size = (FLAC__uint64)infilesize * encoder_session.total_samples_to_encode / total_samples_in_input;
1181                                 else
1182                                         encoder_session.unencoded_size = (FLAC__uint64)infilesize;
1183                                 break;
1184                         default:
1185                                 FLAC__ASSERT(0);
1186                                 /* double protection */
1187                                 return EncoderSession_finish_error(&encoder_session);
1188                 }
1189
1190                 if(encoder_session.total_samples_to_encode == 0)
1191                         flac__utils_printf(stderr, 2, "(No runtime statistics possible; please wait for encoding to finish...)\n");
1192
1193                 if(options.format == FORMAT_FLAC || options.format == FORMAT_OGGFLAC)
1194                         encoder_session.fmt.flac.client_data.samples_left_to_process = encoder_session.total_samples_to_encode;
1195
1196                 /* init the encoder */
1197                 if(!EncoderSession_init_encoder(&encoder_session, options))
1198                         return EncoderSession_finish_error(&encoder_session);
1199
1200                 /* skip over any samples as requested */
1201                 if(skip > 0) {
1202                         switch(options.format) {
1203                                 case FORMAT_RAW:
1204                                         {
1205                                                 unsigned skip_bytes = encoder_session.info.bytes_per_wide_sample * (unsigned)skip;
1206                                                 if(skip_bytes > lookahead_length) {
1207                                                         skip_bytes -= lookahead_length;
1208                                                         lookahead_length = 0;
1209                                                         if(!fskip_ahead(encoder_session.fin, skip_bytes)) {
1210                                                                 flac__utils_printf(stderr, 1, "%s: ERROR during read while skipping samples\n", encoder_session.inbasefilename);
1211                                                                 return EncoderSession_finish_error(&encoder_session);
1212                                                         }
1213                                                 }
1214                                                 else {
1215                                                         lookahead += skip_bytes;
1216                                                         lookahead_length -= skip_bytes;
1217                                                 }
1218                                         }
1219                                         break;
1220                                 case FORMAT_WAVE:
1221                                 case FORMAT_WAVE64:
1222                                 case FORMAT_RF64:
1223                                 case FORMAT_AIFF:
1224                                 case FORMAT_AIFF_C:
1225                                         if(!fskip_ahead(encoder_session.fin, skip * encoder_session.info.bytes_per_wide_sample)) {
1226                                                 flac__utils_printf(stderr, 1, "%s: ERROR during read while skipping samples\n", encoder_session.inbasefilename);
1227                                                 return EncoderSession_finish_error(&encoder_session);
1228                                         }
1229                                         break;
1230                                 case FORMAT_FLAC:
1231                                 case FORMAT_OGGFLAC:
1232                                         /*
1233                                          * have to wait until the FLAC encoder is set up for writing
1234                                          * before any seeking in the input FLAC file, because the seek
1235                                          * itself will usually call the decoder's write callback, and
1236                                          * our decoder's write callback passes samples to our FLAC
1237                                          * encoder
1238                                          */
1239                                         if(!FLAC__stream_decoder_seek_absolute(encoder_session.fmt.flac.decoder, skip)) {
1240                                                 flac__utils_printf(stderr, 1, "%s: ERROR while skipping samples, FLAC decoder state = %s\n", encoder_session.inbasefilename, FLAC__stream_decoder_get_resolved_state_string(encoder_session.fmt.flac.decoder));
1241                                                 return EncoderSession_finish_error(&encoder_session);
1242                                         }
1243                                         break;
1244                                 default:
1245                                         FLAC__ASSERT(0);
1246                                         /* double protection */
1247                                         return EncoderSession_finish_error(&encoder_session);
1248                         }
1249                 }
1250
1251                 /*
1252                  * first do any samples in the reservoir
1253                  */
1254                 if(options.sector_align && *options.align_reservoir_samples > 0) {
1255                         FLAC__ASSERT(options.format != FORMAT_FLAC && options.format != FORMAT_OGGFLAC); /* check again */
1256                         if(!EncoderSession_process(&encoder_session, (const FLAC__int32 * const *)options.align_reservoir, *options.align_reservoir_samples)) {
1257                                 print_error_with_state(&encoder_session, "ERROR during encoding");
1258                                 return EncoderSession_finish_error(&encoder_session);
1259                         }
1260                 }
1261
1262                 /*
1263                  * decrement infilesize or the data_bytes counter if we need to align the file
1264                  */
1265                 if(options.sector_align) {
1266                         if(options.is_last_file) {
1267                                 *options.align_reservoir_samples = 0;
1268                         }
1269                         else {
1270                                 *options.align_reservoir_samples = align_remainder;
1271                                 if(options.format == FORMAT_RAW) {
1272                                         FLAC__ASSERT(infilesize >= 0);
1273                                         infilesize -= (off_t)((*options.align_reservoir_samples) * encoder_session.info.bytes_per_wide_sample);
1274                                         FLAC__ASSERT(infilesize >= 0);
1275                                 }
1276                                 else if(EncoderSession_format_is_iff(&encoder_session))
1277                                         encoder_session.fmt.iff.data_bytes -= (*options.align_reservoir_samples) * encoder_session.info.bytes_per_wide_sample;
1278                         }
1279                 }
1280
1281                 /*
1282                  * now do samples from the file
1283                  */
1284                 switch(options.format) {
1285                         case FORMAT_RAW:
1286                                 if(infilesize < 0) {
1287                                         size_t bytes_read;
1288                                         while(!feof(infile)) {
1289                                                 if(lookahead_length > 0) {
1290                                                         FLAC__ASSERT(lookahead_length < CHUNK_OF_SAMPLES * encoder_session.info.bytes_per_wide_sample);
1291                                                         memcpy(ucbuffer_, lookahead, lookahead_length);
1292                                                         bytes_read = fread(ucbuffer_+lookahead_length, sizeof(unsigned char), CHUNK_OF_SAMPLES * encoder_session.info.bytes_per_wide_sample - lookahead_length, infile) + lookahead_length;
1293                                                         if(ferror(infile)) {
1294                                                                 flac__utils_printf(stderr, 1, "%s: ERROR during read\n", encoder_session.inbasefilename);
1295                                                                 return EncoderSession_finish_error(&encoder_session);
1296                                                         }
1297                                                         lookahead_length = 0;
1298                                                 }
1299                                                 else
1300                                                         bytes_read = fread(ucbuffer_, sizeof(unsigned char), CHUNK_OF_SAMPLES * encoder_session.info.bytes_per_wide_sample, infile);
1301
1302                                                 if(bytes_read == 0) {
1303                                                         if(ferror(infile)) {
1304                                                                 flac__utils_printf(stderr, 1, "%s: ERROR during read\n", encoder_session.inbasefilename);
1305                                                                 return EncoderSession_finish_error(&encoder_session);
1306                                                         }
1307                                                 }
1308                                                 else if(bytes_read % encoder_session.info.bytes_per_wide_sample != 0) {
1309                                                         flac__utils_printf(stderr, 1, "%s: ERROR: got partial sample\n", encoder_session.inbasefilename);
1310                                                         return EncoderSession_finish_error(&encoder_session);
1311                                                 }
1312                                                 else {
1313                                                         unsigned wide_samples = bytes_read / encoder_session.info.bytes_per_wide_sample;
1314                                                         if(!format_input(input_, wide_samples, encoder_session.info.is_big_endian, encoder_session.info.is_unsigned_samples, encoder_session.info.channels, encoder_session.info.bits_per_sample, encoder_session.info.shift, channel_map))
1315                                                                 return EncoderSession_finish_error(&encoder_session);
1316
1317                                                         if(!EncoderSession_process(&encoder_session, (const FLAC__int32 * const *)input_, wide_samples)) {
1318                                                                 print_error_with_state(&encoder_session, "ERROR during encoding");
1319                                                                 return EncoderSession_finish_error(&encoder_session);
1320                                                         }
1321                                                 }
1322                                         }
1323                                 }
1324                                 else {
1325                                         size_t bytes_read;
1326                                         const FLAC__uint64 max_input_bytes = infilesize;
1327                                         FLAC__uint64 total_input_bytes_read = 0;
1328                                         while(total_input_bytes_read < max_input_bytes) {
1329                                                 {
1330                                                         size_t wanted = (CHUNK_OF_SAMPLES * encoder_session.info.bytes_per_wide_sample);
1331                                                         wanted = (size_t) min((FLAC__uint64)wanted, max_input_bytes - total_input_bytes_read);
1332
1333                                                         if(lookahead_length > 0) {
1334                                                                 FLAC__ASSERT(lookahead_length <= wanted);
1335                                                                 memcpy(ucbuffer_, lookahead, lookahead_length);
1336                                                                 wanted -= lookahead_length;
1337                                                                 bytes_read = lookahead_length;
1338                                                                 if(wanted > 0) {
1339                                                                         bytes_read += fread(ucbuffer_+lookahead_length, sizeof(unsigned char), wanted, infile);
1340                                                                         if(ferror(infile)) {
1341                                                                                 flac__utils_printf(stderr, 1, "%s: ERROR during read\n", encoder_session.inbasefilename);
1342                                                                                 return EncoderSession_finish_error(&encoder_session);
1343                                                                         }
1344                                                                 }
1345                                                                 lookahead_length = 0;
1346                                                         }
1347                                                         else
1348                                                                 bytes_read = fread(ucbuffer_, sizeof(unsigned char), wanted, infile);
1349                                                 }
1350
1351                                                 if(bytes_read == 0) {
1352                                                         if(ferror(infile)) {
1353                                                                 flac__utils_printf(stderr, 1, "%s: ERROR during read\n", encoder_session.inbasefilename);
1354                                                                 return EncoderSession_finish_error(&encoder_session);
1355                                                         }
1356                                                         else if(feof(infile)) {
1357                                                                 flac__utils_printf(stderr, 1, "%s: WARNING: unexpected EOF; expected %u samples, got %u samples\n", encoder_session.inbasefilename, (unsigned)encoder_session.total_samples_to_encode, (unsigned)encoder_session.samples_written);
1358                                                                 if(encoder_session.treat_warnings_as_errors)
1359                                                                         return EncoderSession_finish_error(&encoder_session);
1360                                                                 total_input_bytes_read = max_input_bytes;
1361                                                         }
1362                                                 }
1363                                                 else {
1364                                                         if(bytes_read % encoder_session.info.bytes_per_wide_sample != 0) {
1365                                                                 flac__utils_printf(stderr, 1, "%s: ERROR: got partial sample\n", encoder_session.inbasefilename);
1366                                                                 return EncoderSession_finish_error(&encoder_session);
1367                                                         }
1368                                                         else {
1369                                                                 unsigned wide_samples = bytes_read / encoder_session.info.bytes_per_wide_sample;
1370                                                                 if(!format_input(input_, wide_samples, encoder_session.info.is_big_endian, encoder_session.info.is_unsigned_samples, encoder_session.info.channels, encoder_session.info.bits_per_sample, encoder_session.info.shift, channel_map))
1371                                                                         return EncoderSession_finish_error(&encoder_session);
1372
1373                                                                 if(!EncoderSession_process(&encoder_session, (const FLAC__int32 * const *)input_, wide_samples)) {
1374                                                                         print_error_with_state(&encoder_session, "ERROR during encoding");
1375                                                                         return EncoderSession_finish_error(&encoder_session);
1376                                                                 }
1377                                                                 total_input_bytes_read += bytes_read;
1378                                                         }
1379                                                 }
1380                                         }
1381                                 }
1382                                 break;
1383                         case FORMAT_WAVE:
1384                         case FORMAT_WAVE64:
1385                         case FORMAT_RF64:
1386                         case FORMAT_AIFF:
1387                         case FORMAT_AIFF_C:
1388                                 while(encoder_session.fmt.iff.data_bytes > 0) {
1389                                         const size_t bytes_to_read = (size_t)min(
1390                                                 encoder_session.fmt.iff.data_bytes,
1391                                                 (FLAC__uint64)CHUNK_OF_SAMPLES * (FLAC__uint64)encoder_session.info.bytes_per_wide_sample
1392                                         );
1393                                         size_t bytes_read = fread(ucbuffer_, sizeof(unsigned char), bytes_to_read, infile);
1394                                         if(bytes_read == 0) {
1395                                                 if(ferror(infile)) {
1396                                                         flac__utils_printf(stderr, 1, "%s: ERROR during read\n", encoder_session.inbasefilename);
1397                                                         return EncoderSession_finish_error(&encoder_session);
1398                                                 }
1399                                                 else if(feof(infile)) {
1400                                                         if(options.ignore_chunk_sizes) {
1401                                                                 flac__utils_printf(stderr, 1, "%s: INFO: hit EOF with --ignore-chunk-sizes, got %u samples\n", encoder_session.inbasefilename, (unsigned)encoder_session.samples_written);
1402                                                         }
1403                                                         else {
1404                                                                 flac__utils_printf(stderr, 1, "%s: WARNING: unexpected EOF; expected %u samples, got %u samples\n", encoder_session.inbasefilename, (unsigned)encoder_session.total_samples_to_encode, (unsigned)encoder_session.samples_written);
1405                                                                 if(encoder_session.treat_warnings_as_errors)
1406                                                                         return EncoderSession_finish_error(&encoder_session);
1407                                                         }
1408                                                         encoder_session.fmt.iff.data_bytes = 0;
1409                                                 }
1410                                         }
1411                                         else {
1412                                                 if(bytes_read % encoder_session.info.bytes_per_wide_sample != 0) {
1413                                                         flac__utils_printf(stderr, 1, "%s: ERROR: got partial sample\n", encoder_session.inbasefilename);
1414                                                         return EncoderSession_finish_error(&encoder_session);
1415                                                 }
1416                                                 else {
1417                                                         unsigned wide_samples = bytes_read / encoder_session.info.bytes_per_wide_sample;
1418                                                         if(!format_input(input_, wide_samples, encoder_session.info.is_big_endian, encoder_session.info.is_unsigned_samples, encoder_session.info.channels, encoder_session.info.bits_per_sample, encoder_session.info.shift, channel_map))
1419                                                                 return EncoderSession_finish_error(&encoder_session);
1420
1421                                                         if(!EncoderSession_process(&encoder_session, (const FLAC__int32 * const *)input_, wide_samples)) {
1422                                                                 print_error_with_state(&encoder_session, "ERROR during encoding");
1423                                                                 return EncoderSession_finish_error(&encoder_session);
1424                                                         }
1425                                                         encoder_session.fmt.iff.data_bytes -= bytes_read;
1426                                                 }
1427                                         }
1428                                 }
1429                                 break;
1430                         case FORMAT_FLAC:
1431                         case FORMAT_OGGFLAC:
1432                                 while(!encoder_session.fmt.flac.client_data.fatal_error && encoder_session.fmt.flac.client_data.samples_left_to_process > 0) {
1433                                         /* We can also hit the end of stream without samples_left_to_process
1434                                          * going to 0 if there are errors and continue_through_decode_errors
1435                                          * is on, so we want to break in that case too:
1436                                          */
1437                                         if(encoder_session.continue_through_decode_errors && FLAC__stream_decoder_get_state(encoder_session.fmt.flac.decoder) == FLAC__STREAM_DECODER_END_OF_STREAM)
1438                                                 break;
1439                                         if(!FLAC__stream_decoder_process_single(encoder_session.fmt.flac.decoder)) {
1440                                                 flac__utils_printf(stderr, 1, "%s: ERROR: while decoding FLAC input, state = %s\n", encoder_session.inbasefilename, FLAC__stream_decoder_get_resolved_state_string(encoder_session.fmt.flac.decoder));
1441                                                 return EncoderSession_finish_error(&encoder_session);
1442                                         }
1443                                 }
1444                                 if(encoder_session.fmt.flac.client_data.fatal_error) {
1445                                         flac__utils_printf(stderr, 1, "%s: ERROR: while decoding FLAC input, state = %s\n", encoder_session.inbasefilename, FLAC__stream_decoder_get_resolved_state_string(encoder_session.fmt.flac.decoder));
1446                                         return EncoderSession_finish_error(&encoder_session);
1447                                 }
1448                                 break;
1449                         default:
1450                                 FLAC__ASSERT(0);
1451                                 /* double protection */
1452                                 return EncoderSession_finish_error(&encoder_session);
1453                 }
1454
1455                 /*
1456                  * now read unaligned samples into reservoir or pad with zeroes if necessary
1457                  */
1458                 if(options.sector_align) {
1459                         if(options.is_last_file) {
1460                                 unsigned wide_samples = 588 - align_remainder;
1461                                 if(wide_samples < 588) {
1462                                         unsigned channel;
1463
1464                                         info_align_zero = wide_samples;
1465                                         for(channel = 0; channel < encoder_session.info.channels; channel++)
1466                                                 memset(input_[channel], 0, sizeof(input_[0][0]) * wide_samples);
1467
1468                                         if(!EncoderSession_process(&encoder_session, (const FLAC__int32 * const *)input_, wide_samples)) {
1469                                                 print_error_with_state(&encoder_session, "ERROR during encoding");
1470                                                 return EncoderSession_finish_error(&encoder_session);
1471                                         }
1472                                 }
1473                         }
1474                         else {
1475                                 if(*options.align_reservoir_samples > 0) {
1476                                         size_t bytes_read;
1477                                         FLAC__ASSERT(CHUNK_OF_SAMPLES >= 588);
1478                                         bytes_read = fread(ucbuffer_, sizeof(unsigned char), (*options.align_reservoir_samples) * encoder_session.info.bytes_per_wide_sample, infile);
1479                                         if(bytes_read == 0 && ferror(infile)) {
1480                                                 flac__utils_printf(stderr, 1, "%s: ERROR during read\n", encoder_session.inbasefilename);
1481                                                 return EncoderSession_finish_error(&encoder_session);
1482                                         }
1483                                         else if(bytes_read != (*options.align_reservoir_samples) * encoder_session.info.bytes_per_wide_sample) {
1484                                                 flac__utils_printf(stderr, 1, "%s: WARNING: unexpected EOF; read %u bytes; expected %u samples, got %u samples\n", encoder_session.inbasefilename, (unsigned)bytes_read, (unsigned)encoder_session.total_samples_to_encode, (unsigned)encoder_session.samples_written);
1485                                                 if(encoder_session.treat_warnings_as_errors)
1486                                                         return EncoderSession_finish_error(&encoder_session);
1487                                         }
1488                                         else {
1489                                                 info_align_carry = *options.align_reservoir_samples;
1490                                                 if(!format_input(options.align_reservoir, *options.align_reservoir_samples, encoder_session.info.is_big_endian, encoder_session.info.is_unsigned_samples, encoder_session.info.channels, encoder_session.info.bits_per_sample, encoder_session.info.shift, channel_map))
1491                                                         return EncoderSession_finish_error(&encoder_session);
1492                                         }
1493                                 }
1494                         }
1495                 }
1496         }
1497
1498         return EncoderSession_finish_ok(
1499                 &encoder_session,
1500                 info_align_carry,
1501                 info_align_zero,
1502                 EncoderSession_format_is_iff(&encoder_session)? options.format_options.iff.foreign_metadata : 0
1503         );
1504 }
1505
1506 FLAC__bool EncoderSession_construct(EncoderSession *e, encode_options_t options, off_t infilesize, FILE *infile, const char *infilename, const char *outfilename, const FLAC__byte *lookahead, unsigned lookahead_length)
1507 {
1508         unsigned i;
1509         FLAC__uint32 test = 1;
1510
1511         /*
1512          * initialize globals
1513          */
1514
1515         is_big_endian_host_ = (*((FLAC__byte*)(&test)))? false : true;
1516
1517         for(i = 0; i < FLAC__MAX_CHANNELS; i++)
1518                 input_[i] = &(in_[i][0]);
1519
1520
1521         /*
1522          * initialize instance
1523          */
1524
1525 #if FLAC__HAS_OGG
1526         e->use_ogg = options.use_ogg;
1527 #endif
1528         e->verify = options.verify;
1529         e->treat_warnings_as_errors = options.treat_warnings_as_errors;
1530         e->continue_through_decode_errors = options.continue_through_decode_errors;
1531
1532         e->is_stdout = (0 == strcmp(outfilename, "-"));
1533         e->outputfile_opened = false;
1534
1535         e->inbasefilename = grabbag__file_get_basename(infilename);
1536         e->infilename = infilename;
1537         e->outfilename = outfilename;
1538
1539         e->total_samples_to_encode = 0;
1540         e->unencoded_size = 0;
1541         e->bytes_written = 0;
1542         e->samples_written = 0;
1543         e->stats_mask = 0;
1544
1545         memset(&e->info, 0, sizeof(e->info));
1546
1547         e->format = options.format;
1548
1549         switch(options.format) {
1550                 case FORMAT_RAW:
1551                         break;
1552                 case FORMAT_WAVE:
1553                 case FORMAT_WAVE64:
1554                 case FORMAT_RF64:
1555                 case FORMAT_AIFF:
1556                 case FORMAT_AIFF_C:
1557                         e->fmt.iff.data_bytes = 0;
1558                         break;
1559                 case FORMAT_FLAC:
1560                 case FORMAT_OGGFLAC:
1561                         e->fmt.flac.decoder = 0;
1562                         e->fmt.flac.client_data.filesize = infilesize;
1563                         e->fmt.flac.client_data.lookahead = lookahead;
1564                         e->fmt.flac.client_data.lookahead_length = lookahead_length;
1565                         e->fmt.flac.client_data.num_metadata_blocks = 0;
1566                         e->fmt.flac.client_data.samples_left_to_process = 0;
1567                         e->fmt.flac.client_data.fatal_error = false;
1568                         break;
1569                 default:
1570                         FLAC__ASSERT(0);
1571                         /* double protection */
1572                         return false;
1573         }
1574
1575         e->encoder = 0;
1576
1577         e->fin = infile;
1578         e->seek_table_template = 0;
1579
1580         if(0 == (e->seek_table_template = FLAC__metadata_object_new(FLAC__METADATA_TYPE_SEEKTABLE))) {
1581                 flac__utils_printf(stderr, 1, "%s: ERROR allocating memory for seek table\n", e->inbasefilename);
1582                 return false;
1583         }
1584
1585         e->encoder = FLAC__stream_encoder_new();
1586         if(0 == e->encoder) {
1587                 flac__utils_printf(stderr, 1, "%s: ERROR creating the encoder instance\n", e->inbasefilename);
1588                 EncoderSession_destroy(e);
1589                 return false;
1590         }
1591
1592         return true;
1593 }
1594
1595 void EncoderSession_destroy(EncoderSession *e)
1596 {
1597         if(e->format == FORMAT_FLAC || e->format == FORMAT_OGGFLAC) {
1598                 size_t i;
1599                 if(e->fmt.flac.decoder)
1600                         FLAC__stream_decoder_delete(e->fmt.flac.decoder);
1601                 e->fmt.flac.decoder = 0;
1602                 for(i = 0; i < e->fmt.flac.client_data.num_metadata_blocks; i++)
1603                         FLAC__metadata_object_delete(e->fmt.flac.client_data.metadata_blocks[i]);
1604                 e->fmt.flac.client_data.num_metadata_blocks = 0;
1605         }
1606
1607         if(e->fin != stdin)
1608                 fclose(e->fin);
1609
1610         if(0 != e->encoder) {
1611                 FLAC__stream_encoder_delete(e->encoder);
1612                 e->encoder = 0;
1613         }
1614
1615         if(0 != e->seek_table_template) {
1616                 FLAC__metadata_object_delete(e->seek_table_template);
1617                 e->seek_table_template = 0;
1618         }
1619 }
1620
1621 int EncoderSession_finish_ok(EncoderSession *e, int info_align_carry, int info_align_zero, foreign_metadata_t *foreign_metadata)
1622 {
1623         FLAC__StreamEncoderState fse_state = FLAC__STREAM_ENCODER_OK;
1624         int ret = 0;
1625         FLAC__bool verify_error = false;
1626
1627         if(e->encoder) {
1628                 fse_state = FLAC__stream_encoder_get_state(e->encoder);
1629                 ret = FLAC__stream_encoder_finish(e->encoder)? 0 : 1;
1630                 verify_error =
1631                         fse_state == FLAC__STREAM_ENCODER_VERIFY_MISMATCH_IN_AUDIO_DATA ||
1632                         FLAC__stream_encoder_get_state(e->encoder) == FLAC__STREAM_ENCODER_VERIFY_MISMATCH_IN_AUDIO_DATA
1633                 ;
1634         }
1635         /* all errors except verify errors should interrupt the stats */
1636         if(ret && !verify_error)
1637                 print_error_with_state(e, "ERROR during encoding");
1638         else if(e->total_samples_to_encode > 0) {
1639                 print_stats(e);
1640                 flac__utils_printf(stderr, 2, "\n");
1641         }
1642
1643         if(verify_error) {
1644                 print_verify_error(e);
1645                 ret = 1;
1646         }
1647         else {
1648                 if(info_align_carry >= 0) {
1649                         flac__utils_printf(stderr, 1, "%s: INFO: sector alignment causing %d samples to be carried over\n", e->inbasefilename, info_align_carry);
1650                 }
1651                 if(info_align_zero >= 0) {
1652                         flac__utils_printf(stderr, 1, "%s: INFO: sector alignment causing %d zero samples to be appended\n", e->inbasefilename, info_align_zero);
1653                 }
1654         }
1655
1656         /*@@@@@@ should this go here or somewhere else? */
1657         if(ret == 0 && foreign_metadata) {
1658                 const char *error;
1659                 if(!flac__foreign_metadata_write_to_flac(foreign_metadata, e->infilename, e->outfilename, &error)) {
1660                         flac__utils_printf(stderr, 1, "%s: ERROR: updating foreign metadata in FLAC file: %s\n", e->inbasefilename, error);
1661                         ret = 1;
1662                 }
1663         }
1664
1665         EncoderSession_destroy(e);
1666
1667         return ret;
1668 }
1669
1670 int EncoderSession_finish_error(EncoderSession *e)
1671 {
1672         FLAC__ASSERT(e->encoder);
1673
1674         if(e->total_samples_to_encode > 0)
1675                 flac__utils_printf(stderr, 2, "\n");
1676
1677         if(FLAC__stream_encoder_get_state(e->encoder) == FLAC__STREAM_ENCODER_VERIFY_MISMATCH_IN_AUDIO_DATA)
1678                 print_verify_error(e);
1679         else if(e->outputfile_opened)
1680                 /* only want to delete the file if we opened it; otherwise it could be an existing file and our overwrite failed */
1681                 unlink(e->outfilename);
1682
1683         EncoderSession_destroy(e);
1684
1685         return 1;
1686 }
1687
1688 typedef struct {
1689         unsigned num_metadata;
1690         FLAC__bool *needs_delete;
1691         FLAC__StreamMetadata **metadata;
1692         FLAC__StreamMetadata *cuesheet; /* always needs to be deleted */
1693 } static_metadata_t;
1694
1695 static void static_metadata_init(static_metadata_t *m)
1696 {
1697         m->num_metadata = 0;
1698         m->needs_delete = 0;
1699         m->metadata = 0;
1700         m->cuesheet = 0;
1701 }
1702
1703 static void static_metadata_clear(static_metadata_t *m)
1704 {
1705         unsigned i;
1706         for(i = 0; i < m->num_metadata; i++)
1707                 if(m->needs_delete[i])
1708                         FLAC__metadata_object_delete(m->metadata[i]);
1709         if(m->metadata)
1710                 free(m->metadata);
1711         if(m->needs_delete)
1712                 free(m->needs_delete);
1713         if(m->cuesheet)
1714                 FLAC__metadata_object_delete(m->cuesheet);
1715         static_metadata_init(m);
1716 }
1717
1718 static FLAC__bool static_metadata_append(static_metadata_t *m, FLAC__StreamMetadata *d, FLAC__bool needs_delete)
1719 {
1720         void *x;
1721         if(0 == (x = safe_realloc_muladd2_(m->metadata, sizeof(*m->metadata), /*times (*/m->num_metadata, /*+*/1/*)*/)))
1722                 return false;
1723         m->metadata = (FLAC__StreamMetadata**)x;
1724         if(0 == (x = safe_realloc_muladd2_(m->needs_delete, sizeof(*m->needs_delete), /*times (*/m->num_metadata, /*+*/1/*)*/)))
1725                 return false;
1726         m->needs_delete = (FLAC__bool*)x;
1727         m->metadata[m->num_metadata] = d;
1728         m->needs_delete[m->num_metadata] = needs_delete;
1729         m->num_metadata++;
1730         return true;
1731 }
1732
1733 FLAC__bool EncoderSession_init_encoder(EncoderSession *e, encode_options_t options)
1734 {
1735         const unsigned channels = e->info.channels;
1736         const unsigned bps = e->info.bits_per_sample - e->info.shift;
1737         const unsigned sample_rate = e->info.sample_rate;
1738         FLACDecoderData *flac_decoder_data = (e->format == FORMAT_FLAC || e->format == FORMAT_OGGFLAC)? &e->fmt.flac.client_data : 0;
1739         FLAC__StreamMetadata padding;
1740         FLAC__StreamMetadata **metadata = 0;
1741         static_metadata_t static_metadata;
1742         unsigned num_metadata = 0, i;
1743         FLAC__StreamEncoderInitStatus init_status;
1744         const FLAC__bool is_cdda = (channels == 1 || channels == 2) && (bps == 16) && (sample_rate == 44100);
1745         char apodizations[2000];
1746
1747         FLAC__ASSERT(sizeof(options.pictures)/sizeof(options.pictures[0]) <= 64);
1748
1749         static_metadata_init(&static_metadata);
1750
1751         e->replay_gain = options.replay_gain;
1752
1753         apodizations[0] = '\0';
1754
1755         if(e->replay_gain) {
1756                 if(channels != 1 && channels != 2) {
1757                         flac__utils_printf(stderr, 1, "%s: ERROR, number of channels (%u) must be 1 or 2 for --replay-gain\n", e->inbasefilename, channels);
1758                         return false;
1759                 }
1760                 if(!grabbag__replaygain_is_valid_sample_frequency(sample_rate)) {
1761                         flac__utils_printf(stderr, 1, "%s: ERROR, invalid sample rate (%u) for --replay-gain\n", e->inbasefilename, sample_rate);
1762                         return false;
1763                 }
1764                 if(options.is_first_file) {
1765                         if(!grabbag__replaygain_init(sample_rate)) {
1766                                 flac__utils_printf(stderr, 1, "%s: ERROR initializing ReplayGain stage\n", e->inbasefilename);
1767                                 return false;
1768                         }
1769                 }
1770         }
1771
1772         if(!parse_cuesheet(&static_metadata.cuesheet, options.cuesheet_filename, e->inbasefilename, is_cdda, e->total_samples_to_encode, e->treat_warnings_as_errors))
1773                 return false;
1774
1775         if(!convert_to_seek_table_template(options.requested_seek_points, options.num_requested_seek_points, options.cued_seekpoints? static_metadata.cuesheet : 0, e)) {
1776                 flac__utils_printf(stderr, 1, "%s: ERROR allocating memory for seek table\n", e->inbasefilename);
1777                 static_metadata_clear(&static_metadata);
1778                 return false;
1779         }
1780
1781         /* build metadata */
1782         if(flac_decoder_data) {
1783                 /*
1784                  * we're encoding from FLAC so we will use the FLAC file's
1785                  * metadata as the basis for the encoded file
1786                  */
1787                 {
1788                         /*
1789                          * first handle pictures: simple append any --pictures
1790                          * specified.
1791                          */
1792                         for(i = 0; i < options.num_pictures; i++) {
1793                                 FLAC__StreamMetadata *pic = FLAC__metadata_object_clone(options.pictures[i]);
1794                                 if(0 == pic) {
1795                                         flac__utils_printf(stderr, 1, "%s: ERROR allocating memory for PICTURE block\n", e->inbasefilename);
1796                                         static_metadata_clear(&static_metadata);
1797                                         return false;
1798                                 }
1799                                 flac_decoder_data->metadata_blocks[flac_decoder_data->num_metadata_blocks++] = pic;
1800                         }
1801                 }
1802                 {
1803                         /*
1804                          * next handle vorbis comment: if any tags were specified
1805                          * or there is no existing vorbis comment, we create a
1806                          * new vorbis comment (discarding any existing one); else
1807                          * we keep the existing one.  also need to make sure to
1808                          * propagate any channel mask tag.
1809                          */
1810                         /* @@@ change to append -T values from options.vorbis_comment if input has VC already? */
1811                         size_t i, j;
1812                         FLAC__bool vc_found = false;
1813                         for(i = 0, j = 0; i < flac_decoder_data->num_metadata_blocks; i++) {
1814                                 if(flac_decoder_data->metadata_blocks[i]->type == FLAC__METADATA_TYPE_VORBIS_COMMENT)
1815                                         vc_found = true;
1816                                 if(flac_decoder_data->metadata_blocks[i]->type == FLAC__METADATA_TYPE_VORBIS_COMMENT && options.vorbis_comment->data.vorbis_comment.num_comments > 0) {
1817                                         (void) flac__utils_get_channel_mask_tag(flac_decoder_data->metadata_blocks[i], &e->info.channel_mask);
1818                                         flac__utils_printf(stderr, 1, "%s: WARNING, replacing tags from input FLAC file with those given on the command-line\n", e->inbasefilename);
1819                                         if(e->treat_warnings_as_errors) {
1820                                                 static_metadata_clear(&static_metadata);
1821                                                 return false;
1822                                         }
1823                                         FLAC__metadata_object_delete(flac_decoder_data->metadata_blocks[i]);
1824                                         flac_decoder_data->metadata_blocks[i] = 0;
1825                                 }
1826                                 else
1827                                         flac_decoder_data->metadata_blocks[j++] = flac_decoder_data->metadata_blocks[i];
1828                         }
1829                         flac_decoder_data->num_metadata_blocks = j;
1830                         if((!vc_found || options.vorbis_comment->data.vorbis_comment.num_comments > 0) && flac_decoder_data->num_metadata_blocks < sizeof(flac_decoder_data->metadata_blocks)/sizeof(flac_decoder_data->metadata_blocks[0])) {
1831                                 /* prepend ours */
1832                                 FLAC__StreamMetadata *vc = FLAC__metadata_object_clone(options.vorbis_comment);
1833                                 if(0 == vc || (e->info.channel_mask && !flac__utils_set_channel_mask_tag(vc, e->info.channel_mask))) {
1834                                         flac__utils_printf(stderr, 1, "%s: ERROR allocating memory for VORBIS_COMMENT block\n", e->inbasefilename);
1835                                         static_metadata_clear(&static_metadata);
1836                                         return false;
1837                                 }
1838                                 for(i = flac_decoder_data->num_metadata_blocks; i > 1; i--)
1839                                         flac_decoder_data->metadata_blocks[i] = flac_decoder_data->metadata_blocks[i-1];
1840                                 flac_decoder_data->metadata_blocks[1] = vc;
1841                                 flac_decoder_data->num_metadata_blocks++;
1842                         }
1843                 }
1844                 {
1845                         /*
1846                          * next handle cuesheet: if --cuesheet was specified, use
1847                          * it; else if file has existing CUESHEET and cuesheet's
1848                          * lead-out offset is correct, keep it; else no CUESHEET
1849                          */
1850                         size_t i, j;
1851                         for(i = 0, j = 0; i < flac_decoder_data->num_metadata_blocks; i++) {
1852                                 FLAC__bool existing_cuesheet_is_bad = false;
1853                                 /* check if existing cuesheet matches the input audio */
1854                                 if(flac_decoder_data->metadata_blocks[i]->type == FLAC__METADATA_TYPE_CUESHEET && 0 == static_metadata.cuesheet) {
1855                                         const FLAC__StreamMetadata_CueSheet *cs = &flac_decoder_data->metadata_blocks[i]->data.cue_sheet;
1856                                         if(e->total_samples_to_encode == 0) {
1857                                                 flac__utils_printf(stderr, 1, "%s: WARNING, cuesheet in input FLAC file cannot be kept if input size is not known, dropping it...\n", e->inbasefilename);
1858                                                 if(e->treat_warnings_as_errors) {
1859                                                         static_metadata_clear(&static_metadata);
1860                                                         return false;
1861                                                 }
1862                                                 existing_cuesheet_is_bad = true;
1863                                         }
1864                                         else if(e->total_samples_to_encode != cs->tracks[cs->num_tracks-1].offset) {
1865                                                 flac__utils_printf(stderr, 1, "%s: WARNING, lead-out offset of cuesheet in input FLAC file does not match input length, dropping existing cuesheet...\n", e->inbasefilename);
1866                                                 if(e->treat_warnings_as_errors) {
1867                                                         static_metadata_clear(&static_metadata);
1868                                                         return false;
1869                                                 }
1870                                                 existing_cuesheet_is_bad = true;
1871                                         }
1872                                 }
1873                                 if(flac_decoder_data->metadata_blocks[i]->type == FLAC__METADATA_TYPE_CUESHEET && (existing_cuesheet_is_bad || 0 != static_metadata.cuesheet)) {
1874                                         if(0 != static_metadata.cuesheet) {
1875                                                 flac__utils_printf(stderr, 1, "%s: WARNING, replacing cuesheet in input FLAC file with the one given on the command-line\n", e->inbasefilename);
1876                                                 if(e->treat_warnings_as_errors) {
1877                                                         static_metadata_clear(&static_metadata);
1878                                                         return false;
1879                                                 }
1880                                         }
1881                                         FLAC__metadata_object_delete(flac_decoder_data->metadata_blocks[i]);
1882                                         flac_decoder_data->metadata_blocks[i] = 0;
1883                                 }
1884                                 else
1885                                         flac_decoder_data->metadata_blocks[j++] = flac_decoder_data->metadata_blocks[i];
1886                         }
1887                         flac_decoder_data->num_metadata_blocks = j;
1888                         if(0 != static_metadata.cuesheet && flac_decoder_data->num_metadata_blocks < sizeof(flac_decoder_data->metadata_blocks)/sizeof(flac_decoder_data->metadata_blocks[0])) {
1889                                 /* prepend ours */
1890                                 FLAC__StreamMetadata *cs = FLAC__metadata_object_clone(static_metadata.cuesheet);
1891                                 if(0 == cs) {
1892                                         flac__utils_printf(stderr, 1, "%s: ERROR allocating memory for CUESHEET block\n", e->inbasefilename);
1893                                         static_metadata_clear(&static_metadata);
1894                                         return false;
1895                                 }
1896                                 for(i = flac_decoder_data->num_metadata_blocks; i > 1; i--)
1897                                         flac_decoder_data->metadata_blocks[i] = flac_decoder_data->metadata_blocks[i-1];
1898                                 flac_decoder_data->metadata_blocks[1] = cs;
1899                                 flac_decoder_data->num_metadata_blocks++;
1900                         }
1901                 }
1902                 {
1903                         /*
1904                          * next handle seektable: if -S- was specified, no
1905                          * SEEKTABLE; else if -S was specified, use it/them;
1906                          * else if file has existing SEEKTABLE and input size is
1907                          * preserved (no --skip/--until/etc specified), keep it;
1908                          * else use default seektable options
1909                          *
1910                          * note: meanings of num_requested_seek_points:
1911                          *  -1 : no -S option given, default to some value
1912                          *   0 : -S- given (no seektable)
1913                          *  >0 : one or more -S options given
1914                          */
1915                         size_t i, j;
1916                         FLAC__bool existing_seektable = false;
1917                         for(i = 0, j = 0; i < flac_decoder_data->num_metadata_blocks; i++) {
1918                                 if(flac_decoder_data->metadata_blocks[i]->type == FLAC__METADATA_TYPE_SEEKTABLE)
1919                                         existing_seektable = true;
1920                                 if(flac_decoder_data->metadata_blocks[i]->type == FLAC__METADATA_TYPE_SEEKTABLE && (e->total_samples_to_encode != flac_decoder_data->metadata_blocks[0]->data.stream_info.total_samples || options.num_requested_seek_points >= 0)) {
1921                                         if(options.num_requested_seek_points > 0) {
1922                                                 flac__utils_printf(stderr, 1, "%s: WARNING, replacing seektable in input FLAC file with the one given on the command-line\n", e->inbasefilename);
1923                                                 if(e->treat_warnings_as_errors) {
1924                                                         static_metadata_clear(&static_metadata);
1925                                                         return false;
1926                                                 }
1927                                         }
1928                                         else if(options.num_requested_seek_points == 0)
1929                                                 ; /* no warning, silently delete existing SEEKTABLE since user specified --no-seektable (-S-) */
1930                                         else {
1931                                                 flac__utils_printf(stderr, 1, "%s: WARNING, can't use existing seektable in input FLAC since the input size is changing or unknown, dropping existing SEEKTABLE block...\n", e->inbasefilename);
1932                                                 if(e->treat_warnings_as_errors) {
1933                                                         static_metadata_clear(&static_metadata);
1934                                                         return false;
1935                                                 }
1936                                         }
1937                                         FLAC__metadata_object_delete(flac_decoder_data->metadata_blocks[i]);
1938                                         flac_decoder_data->metadata_blocks[i] = 0;
1939                                         existing_seektable = false;
1940                                 }
1941                                 else
1942                                         flac_decoder_data->metadata_blocks[j++] = flac_decoder_data->metadata_blocks[i];
1943                         }
1944                         flac_decoder_data->num_metadata_blocks = j;
1945                         if((options.num_requested_seek_points > 0 || (options.num_requested_seek_points < 0 && !existing_seektable)) && flac_decoder_data->num_metadata_blocks < sizeof(flac_decoder_data->metadata_blocks)/sizeof(flac_decoder_data->metadata_blocks[0])) {
1946                                 /* prepend ours */
1947                                 FLAC__StreamMetadata *st = FLAC__metadata_object_clone(e->seek_table_template);
1948                                 if(0 == st) {
1949                                         flac__utils_printf(stderr, 1, "%s: ERROR allocating memory for SEEKTABLE block\n", e->inbasefilename);
1950                                         static_metadata_clear(&static_metadata);
1951                                         return false;
1952                                 }
1953                                 for(i = flac_decoder_data->num_metadata_blocks; i > 1; i--)
1954                                         flac_decoder_data->metadata_blocks[i] = flac_decoder_data->metadata_blocks[i-1];
1955                                 flac_decoder_data->metadata_blocks[1] = st;
1956                                 flac_decoder_data->num_metadata_blocks++;
1957                         }
1958                 }
1959                 {
1960                         /*
1961                          * finally handle padding: if --no-padding was specified,
1962                          * then delete all padding; else if -P was specified,
1963                          * use that instead of existing padding (if any); else
1964                          * if existing file has padding, move all existing
1965                          * padding blocks to one padding block at the end; else
1966                          * use default padding.
1967                          */
1968                         int p = -1;
1969                         size_t i, j;
1970                         for(i = 0, j = 0; i < flac_decoder_data->num_metadata_blocks; i++) {
1971                                 if(flac_decoder_data->metadata_blocks[i]->type == FLAC__METADATA_TYPE_PADDING) {
1972                                         if(p < 0)
1973                                                 p = 0;
1974                                         p += flac_decoder_data->metadata_blocks[i]->length;
1975                                         FLAC__metadata_object_delete(flac_decoder_data->metadata_blocks[i]);
1976                                         flac_decoder_data->metadata_blocks[i] = 0;
1977                                 }
1978                                 else
1979                                         flac_decoder_data->metadata_blocks[j++] = flac_decoder_data->metadata_blocks[i];
1980                         }
1981                         flac_decoder_data->num_metadata_blocks = j;
1982                         if(options.padding > 0)
1983                                 p = options.padding;
1984                         if(p < 0)
1985                                 p = e->total_samples_to_encode / sample_rate < 20*60? FLAC_ENCODE__DEFAULT_PADDING : FLAC_ENCODE__DEFAULT_PADDING*8;
1986                         if(options.padding != 0) {
1987                                 if(p > 0 && flac_decoder_data->num_metadata_blocks < sizeof(flac_decoder_data->metadata_blocks)/sizeof(flac_decoder_data->metadata_blocks[0])) {
1988                                         flac_decoder_data->metadata_blocks[flac_decoder_data->num_metadata_blocks] = FLAC__metadata_object_new(FLAC__METADATA_TYPE_PADDING);
1989                                         if(0 == flac_decoder_data->metadata_blocks[flac_decoder_data->num_metadata_blocks]) {
1990                                                 flac__utils_printf(stderr, 1, "%s: ERROR allocating memory for PADDING block\n", e->inbasefilename);
1991                                                 static_metadata_clear(&static_metadata);
1992                                                 return false;
1993                                         }
1994                                         flac_decoder_data->metadata_blocks[flac_decoder_data->num_metadata_blocks]->is_last = false; /* the encoder will set this for us */
1995                                         flac_decoder_data->metadata_blocks[flac_decoder_data->num_metadata_blocks]->length = p;
1996                                         flac_decoder_data->num_metadata_blocks++;
1997                                 }
1998                         }
1999                 }
2000                 metadata = &flac_decoder_data->metadata_blocks[1]; /* don't include STREAMINFO */
2001                 num_metadata = flac_decoder_data->num_metadata_blocks - 1;
2002         }
2003         else {
2004                 /*
2005                  * we're not encoding from FLAC so we will build the metadata
2006                  * from scratch
2007                  */
2008                 const foreign_metadata_t *foreign_metadata = EncoderSession_format_is_iff(e)? options.format_options.iff.foreign_metadata : 0;
2009
2010                 if(e->seek_table_template->data.seek_table.num_points > 0) {
2011                         e->seek_table_template->is_last = false; /* the encoder will set this for us */
2012                         static_metadata_append(&static_metadata, e->seek_table_template, /*needs_delete=*/false);
2013                 }
2014                 if(0 != static_metadata.cuesheet)
2015                         static_metadata_append(&static_metadata, static_metadata.cuesheet, /*needs_delete=*/false);
2016                 if(e->info.channel_mask) {
2017                         if(!flac__utils_set_channel_mask_tag(options.vorbis_comment, e->info.channel_mask)) {
2018                                 flac__utils_printf(stderr, 1, "%s: ERROR adding channel mask tag\n", e->inbasefilename);
2019                                 static_metadata_clear(&static_metadata);
2020                                 return false;
2021                         }
2022                 }
2023                 static_metadata_append(&static_metadata, options.vorbis_comment, /*needs_delete=*/false);
2024                 for(i = 0; i < options.num_pictures; i++)
2025                         static_metadata_append(&static_metadata, options.pictures[i], /*needs_delete=*/false);
2026                 if(foreign_metadata) {
2027                         for(i = 0; i < foreign_metadata->num_blocks; i++) {
2028                                 FLAC__StreamMetadata *p = FLAC__metadata_object_new(FLAC__METADATA_TYPE_PADDING);
2029                                 if(!p) {
2030                                         flac__utils_printf(stderr, 1, "%s: ERROR: out of memory\n", e->inbasefilename);
2031                                         static_metadata_clear(&static_metadata);
2032                                         return false;
2033                                 }
2034                                 static_metadata_append(&static_metadata, p, /*needs_delete=*/true);
2035                                 static_metadata.metadata[static_metadata.num_metadata-1]->length = FLAC__STREAM_METADATA_APPLICATION_ID_LEN/8 + foreign_metadata->blocks[i].size;
2036                         }
2037                 }
2038                 if(options.padding != 0) {
2039                         padding.is_last = false; /* the encoder will set this for us */
2040                         padding.type = FLAC__METADATA_TYPE_PADDING;
2041                         padding.length = (unsigned)(options.padding>0? options.padding : (e->total_samples_to_encode / sample_rate < 20*60? FLAC_ENCODE__DEFAULT_PADDING : FLAC_ENCODE__DEFAULT_PADDING*8));
2042                         static_metadata_append(&static_metadata, &padding, /*needs_delete=*/false);
2043                 }
2044                 metadata = static_metadata.metadata;
2045                 num_metadata = static_metadata.num_metadata;
2046         }
2047
2048         /* check for a few things that have not already been checked.  the
2049          * FLAC__stream_encoder_init*() will check it but only return
2050          * FLAC__STREAM_ENCODER_INIT_STATUS_INVALID_METADATA so we check some
2051          * up front to give a better error message.
2052          */
2053         if(!verify_metadata(e, metadata, num_metadata)) {
2054                 static_metadata_clear(&static_metadata);
2055                 return false;
2056         }
2057
2058         FLAC__stream_encoder_set_verify(e->encoder, options.verify);
2059         FLAC__stream_encoder_set_streamable_subset(e->encoder, !options.lax);
2060         FLAC__stream_encoder_set_channels(e->encoder, channels);
2061         FLAC__stream_encoder_set_bits_per_sample(e->encoder, bps);
2062         FLAC__stream_encoder_set_sample_rate(e->encoder, sample_rate);
2063         for(i = 0; i < options.num_compression_settings; i++) {
2064                 switch(options.compression_settings[i].type) {
2065                         case CST_BLOCKSIZE:
2066                                 FLAC__stream_encoder_set_blocksize(e->encoder, options.compression_settings[i].value.t_unsigned);
2067                                 break;
2068                         case CST_COMPRESSION_LEVEL:
2069                                 FLAC__stream_encoder_set_compression_level(e->encoder, options.compression_settings[i].value.t_unsigned);
2070                                 apodizations[0] = '\0';
2071                                 break;
2072                         case CST_DO_MID_SIDE:
2073                                 FLAC__stream_encoder_set_do_mid_side_stereo(e->encoder, options.compression_settings[i].value.t_bool);
2074                                 break;
2075                         case CST_LOOSE_MID_SIDE:
2076                                 FLAC__stream_encoder_set_loose_mid_side_stereo(e->encoder, options.compression_settings[i].value.t_bool);
2077                                 break;
2078                         case CST_APODIZATION:
2079                                 if(strlen(apodizations)+strlen(options.compression_settings[i].value.t_string)+2 >= sizeof(apodizations)) {
2080                                         flac__utils_printf(stderr, 1, "%s: ERROR: too many apodization functions requested\n", e->inbasefilename);
2081                                         static_metadata_clear(&static_metadata);
2082                                         return false;
2083                                 }
2084                                 else {
2085                                         strcat(apodizations, options.compression_settings[i].value.t_string);
2086                                         strcat(apodizations, ";");
2087                                 }
2088                                 break;
2089                         case CST_MAX_LPC_ORDER:
2090                                 FLAC__stream_encoder_set_max_lpc_order(e->encoder, options.compression_settings[i].value.t_unsigned);
2091                                 break;
2092                         case CST_QLP_COEFF_PRECISION:
2093                                 FLAC__stream_encoder_set_qlp_coeff_precision(e->encoder, options.compression_settings[i].value.t_unsigned);
2094                                 break;
2095                         case CST_DO_QLP_COEFF_PREC_SEARCH:
2096                                 FLAC__stream_encoder_set_do_qlp_coeff_prec_search(e->encoder, options.compression_settings[i].value.t_bool);
2097                                 break;
2098                         case CST_DO_ESCAPE_CODING:
2099                                 FLAC__stream_encoder_set_do_escape_coding(e->encoder, options.compression_settings[i].value.t_bool);
2100                                 break;
2101                         case CST_DO_EXHAUSTIVE_MODEL_SEARCH:
2102                                 FLAC__stream_encoder_set_do_exhaustive_model_search(e->encoder, options.compression_settings[i].value.t_bool);
2103                                 break;
2104                         case CST_MIN_RESIDUAL_PARTITION_ORDER:
2105                                 FLAC__stream_encoder_set_min_residual_partition_order(e->encoder, options.compression_settings[i].value.t_unsigned);
2106                                 break;
2107                         case CST_MAX_RESIDUAL_PARTITION_ORDER:
2108                                 FLAC__stream_encoder_set_max_residual_partition_order(e->encoder, options.compression_settings[i].value.t_unsigned);
2109                                 break;
2110                         case CST_RICE_PARAMETER_SEARCH_DIST:
2111                                 FLAC__stream_encoder_set_rice_parameter_search_dist(e->encoder, options.compression_settings[i].value.t_unsigned);
2112                                 break;
2113                 }
2114         }
2115         if(*apodizations)
2116                 FLAC__stream_encoder_set_apodization(e->encoder, apodizations);
2117         FLAC__stream_encoder_set_total_samples_estimate(e->encoder, e->total_samples_to_encode);
2118         FLAC__stream_encoder_set_metadata(e->encoder, (num_metadata > 0)? metadata : 0, num_metadata);
2119
2120         FLAC__stream_encoder_disable_constant_subframes(e->encoder, options.debug.disable_constant_subframes);
2121         FLAC__stream_encoder_disable_fixed_subframes(e->encoder, options.debug.disable_fixed_subframes);
2122         FLAC__stream_encoder_disable_verbatim_subframes(e->encoder, options.debug.disable_verbatim_subframes);
2123         if(!options.debug.do_md5) {
2124                 flac__utils_printf(stderr, 1, "%s: WARNING, MD5 computation disabled, resulting file will not have MD5 sum\n", e->inbasefilename);
2125                 if(e->treat_warnings_as_errors) {
2126                         static_metadata_clear(&static_metadata);
2127                         return false;
2128                 }
2129                 FLAC__stream_encoder_set_do_md5(e->encoder, false);
2130         }
2131
2132 #if FLAC__HAS_OGG
2133         if(e->use_ogg) {
2134                 FLAC__stream_encoder_set_ogg_serial_number(e->encoder, options.serial_number);
2135
2136                 init_status = FLAC__stream_encoder_init_ogg_file(e->encoder, e->is_stdout? 0 : e->outfilename, encoder_progress_callback, /*client_data=*/e);
2137         }
2138         else
2139 #endif
2140         {
2141                 init_status = FLAC__stream_encoder_init_file(e->encoder, e->is_stdout? 0 : e->outfilename, encoder_progress_callback, /*client_data=*/e);
2142         }
2143
2144         if(init_status != FLAC__STREAM_ENCODER_INIT_STATUS_OK) {
2145                 print_error_with_init_status(e, "ERROR initializing encoder", init_status);
2146                 if(FLAC__stream_encoder_get_state(e->encoder) != FLAC__STREAM_ENCODER_IO_ERROR)
2147                         e->outputfile_opened = true;
2148                 static_metadata_clear(&static_metadata);
2149                 return false;
2150         }
2151         else
2152                 e->outputfile_opened = true;
2153
2154         e->stats_mask =
2155                 (FLAC__stream_encoder_get_do_exhaustive_model_search(e->encoder) && FLAC__stream_encoder_get_do_qlp_coeff_prec_search(e->encoder))? 0x07 :
2156                 (FLAC__stream_encoder_get_do_exhaustive_model_search(e->encoder) || FLAC__stream_encoder_get_do_qlp_coeff_prec_search(e->encoder))? 0x0f :
2157                 0x3f;
2158
2159         static_metadata_clear(&static_metadata);
2160
2161         return true;
2162 }
2163
2164 FLAC__bool EncoderSession_process(EncoderSession *e, const FLAC__int32 * const buffer[], unsigned samples)
2165 {
2166         if(e->replay_gain) {
2167                 if(!grabbag__replaygain_analyze(buffer, e->info.channels==2, e->info.bits_per_sample, samples)) {
2168                         flac__utils_printf(stderr, 1, "%s: WARNING, error while calculating ReplayGain\n", e->inbasefilename);
2169                         if(e->treat_warnings_as_errors)
2170                                 return false;
2171                 }
2172         }
2173
2174         return FLAC__stream_encoder_process(e->encoder, buffer, samples);
2175 }
2176
2177 FLAC__bool EncoderSession_format_is_iff(const EncoderSession *e)
2178 {
2179         return
2180                 e->format == FORMAT_WAVE ||
2181                 e->format == FORMAT_WAVE64 ||
2182                 e->format == FORMAT_RF64 ||
2183                 e->format == FORMAT_AIFF ||
2184                 e->format == FORMAT_AIFF_C;
2185 }
2186
2187 FLAC__bool convert_to_seek_table_template(const char *requested_seek_points, int num_requested_seek_points, FLAC__StreamMetadata *cuesheet, EncoderSession *e)
2188 {
2189         const FLAC__bool only_placeholders = e->is_stdout;
2190         FLAC__bool has_real_points;
2191
2192         if(num_requested_seek_points == 0 && 0 == cuesheet)
2193                 return true;
2194
2195         if(num_requested_seek_points < 0) {
2196 #if FLAC__HAS_OGG
2197                 /*@@@@@@ workaround ogg bug: too many seekpoints makes table not fit in one page */
2198                 if(e->use_ogg && e->total_samples_to_encode > 0 && e->total_samples_to_encode / e->info.sample_rate / 10 > 230)
2199                         requested_seek_points = "230x;";
2200                 else
2201 #endif
2202                         requested_seek_points = "10s;";
2203                 num_requested_seek_points = 1;
2204         }
2205
2206         if(num_requested_seek_points > 0) {
2207                 if(!grabbag__seektable_convert_specification_to_template(requested_seek_points, only_placeholders, e->total_samples_to_encode, e->info.sample_rate, e->seek_table_template, &has_real_points))
2208                         return false;
2209         }
2210
2211         if(0 != cuesheet) {
2212                 unsigned i, j;
2213                 const FLAC__StreamMetadata_CueSheet *cs = &cuesheet->data.cue_sheet;
2214                 for(i = 0; i < cs->num_tracks; i++) {
2215                         const FLAC__StreamMetadata_CueSheet_Track *tr = cs->tracks+i;
2216                         for(j = 0; j < tr->num_indices; j++) {
2217                                 if(!FLAC__metadata_object_seektable_template_append_point(e->seek_table_template, tr->offset + tr->indices[j].offset))
2218                                         return false;
2219                                 has_real_points = true;
2220                         }
2221                 }
2222                 if(has_real_points)
2223                         if(!FLAC__metadata_object_seektable_template_sort(e->seek_table_template, /*compact=*/true))
2224                                 return false;
2225         }
2226
2227         if(has_real_points) {
2228                 if(e->is_stdout) {
2229                         flac__utils_printf(stderr, 1, "%s: WARNING, cannot write back seekpoints when encoding to stdout\n", e->inbasefilename);
2230                         if(e->treat_warnings_as_errors)
2231                                 return false;
2232                 }
2233         }
2234
2235         return true;
2236 }
2237
2238 FLAC__bool canonicalize_until_specification(utils__SkipUntilSpecification *spec, const char *inbasefilename, unsigned sample_rate, FLAC__uint64 skip, FLAC__uint64 total_samples_in_input)
2239 {
2240         /* convert from mm:ss.sss to sample number if necessary */
2241         flac__utils_canonicalize_skip_until_specification(spec, sample_rate);
2242
2243         /* special case: if "--until=-0", use the special value '0' to mean "end-of-stream" */
2244         if(spec->is_relative && spec->value.samples == 0) {
2245                 spec->is_relative = false;
2246                 return true;
2247         }
2248
2249         /* in any other case the total samples in the input must be known */
2250         if(total_samples_in_input == 0) {
2251                 flac__utils_printf(stderr, 1, "%s: ERROR, cannot use --until when input length is unknown\n", inbasefilename);
2252                 return false;
2253         }
2254
2255         FLAC__ASSERT(spec->value_is_samples);
2256
2257         /* convert relative specifications to absolute */
2258         if(spec->is_relative) {
2259                 if(spec->value.samples <= 0)
2260                         spec->value.samples += (FLAC__int64)total_samples_in_input;
2261                 else
2262                         spec->value.samples += skip;
2263                 spec->is_relative = false;
2264         }
2265
2266         /* error check */
2267         if(spec->value.samples < 0) {
2268                 flac__utils_printf(stderr, 1, "%s: ERROR, --until value is before beginning of input\n", inbasefilename);
2269                 return false;
2270         }
2271         if((FLAC__uint64)spec->value.samples <= skip) {
2272                 flac__utils_printf(stderr, 1, "%s: ERROR, --until value is before --skip point\n", inbasefilename);
2273                 return false;
2274         }
2275         if((FLAC__uint64)spec->value.samples > total_samples_in_input) {
2276                 flac__utils_printf(stderr, 1, "%s: ERROR, --until value is after end of input\n", inbasefilename);
2277                 return false;
2278         }
2279
2280         return true;
2281 }
2282
2283 FLAC__bool verify_metadata(const EncoderSession *e, FLAC__StreamMetadata **metadata, unsigned num_metadata)
2284 {
2285         FLAC__bool metadata_picture_has_type1 = false;
2286         FLAC__bool metadata_picture_has_type2 = false;
2287         unsigned i;
2288
2289         FLAC__ASSERT(0 != metadata);
2290         for(i = 0; i < num_metadata; i++) {
2291                 const FLAC__StreamMetadata *m = metadata[i];
2292                 if(m->type == FLAC__METADATA_TYPE_SEEKTABLE) {
2293                         if(!FLAC__format_seektable_is_legal(&m->data.seek_table)) {
2294                                 flac__utils_printf(stderr, 1, "%s: ERROR: SEEKTABLE metadata block is invalid\n", e->inbasefilename);
2295                                 return false;
2296                         }
2297                 }
2298                 else if(m->type == FLAC__METADATA_TYPE_CUESHEET) {
2299                         if(!FLAC__format_cuesheet_is_legal(&m->data.cue_sheet, m->data.cue_sheet.is_cd, /*violation=*/0)) {
2300                                 flac__utils_printf(stderr, 1, "%s: ERROR: CUESHEET metadata block is invalid\n", e->inbasefilename);
2301                                 return false;
2302                         }
2303                 }
2304                 else if(m->type == FLAC__METADATA_TYPE_PICTURE) {
2305                         const char *error = 0;
2306                         if(!FLAC__format_picture_is_legal(&m->data.picture, &error)) {
2307                                 flac__utils_printf(stderr, 1, "%s: ERROR: PICTURE metadata block is invalid: %s\n", e->inbasefilename, error);
2308                                 return false;
2309                         }
2310                         if(m->data.picture.type == FLAC__STREAM_METADATA_PICTURE_TYPE_FILE_ICON_STANDARD) {
2311                                 if(metadata_picture_has_type1) {
2312                                         flac__utils_printf(stderr, 1, "%s: ERROR: there may only be one picture of type 1 (32x32 icon) in the file\n", e->inbasefilename);
2313                                         return false;
2314                                 }
2315                                 metadata_picture_has_type1 = true;
2316                         }
2317                         else if(m->data.picture.type == FLAC__STREAM_METADATA_PICTURE_TYPE_FILE_ICON) {
2318                                 if(metadata_picture_has_type2) {
2319                                         flac__utils_printf(stderr, 1, "%s: ERROR: there may only be one picture of type 2 (icon) in the file\n", e->inbasefilename);
2320                                         return false;
2321                                 }
2322                                 metadata_picture_has_type2 = true;
2323                         }
2324                 }
2325         }
2326
2327         return true;
2328 }
2329
2330 FLAC__bool format_input(FLAC__int32 *dest[], unsigned wide_samples, FLAC__bool is_big_endian, FLAC__bool is_unsigned_samples, unsigned channels, unsigned bps, unsigned shift, size_t *channel_map)
2331 {
2332         unsigned wide_sample, sample, channel, byte;
2333         FLAC__int32 *out[FLAC__MAX_CHANNELS];
2334
2335         if(0 == channel_map) {
2336                 for(channel = 0; channel < channels; channel++)
2337                         out[channel] = dest[channel];
2338         }
2339         else {
2340                 for(channel = 0; channel < channels; channel++)
2341                         out[channel] = dest[channel_map[channel]];
2342         }
2343
2344         if(bps == 8) {
2345                 if(is_unsigned_samples) {
2346                         for(sample = wide_sample = 0; wide_sample < wide_samples; wide_sample++)
2347                                 for(channel = 0; channel < channels; channel++, sample++)
2348                                         out[channel][wide_sample] = (FLAC__int32)ucbuffer_[sample] - 0x80;
2349                 }
2350                 else {
2351                         for(sample = wide_sample = 0; wide_sample < wide_samples; wide_sample++)
2352                                 for(channel = 0; channel < channels; channel++, sample++)
2353                                         out[channel][wide_sample] = (FLAC__int32)scbuffer_[sample];
2354                 }
2355         }
2356         else if(bps == 16) {
2357                 if(is_big_endian != is_big_endian_host_) {
2358                         unsigned char tmp;
2359                         const unsigned bytes = wide_samples * channels * (bps >> 3);
2360                         for(byte = 0; byte < bytes; byte += 2) {
2361                                 tmp = ucbuffer_[byte];
2362                                 ucbuffer_[byte] = ucbuffer_[byte+1];
2363                                 ucbuffer_[byte+1] = tmp;
2364                         }
2365                 }
2366                 if(is_unsigned_samples) {
2367                         for(sample = wide_sample = 0; wide_sample < wide_samples; wide_sample++)
2368                                 for(channel = 0; channel < channels; channel++, sample++)
2369                                         out[channel][wide_sample] = (FLAC__int32)usbuffer_[sample] - 0x8000;
2370                 }
2371                 else {
2372                         for(sample = wide_sample = 0; wide_sample < wide_samples; wide_sample++)
2373                                 for(channel = 0; channel < channels; channel++, sample++)
2374                                         out[channel][wide_sample] = (FLAC__int32)ssbuffer_[sample];
2375                 }
2376         }
2377         else if(bps == 24) {
2378                 if(!is_big_endian) {
2379                         unsigned char tmp;
2380                         const unsigned bytes = wide_samples * channels * (bps >> 3);
2381                         for(byte = 0; byte < bytes; byte += 3) {
2382                                 tmp = ucbuffer_[byte];
2383                                 ucbuffer_[byte] = ucbuffer_[byte+2];
2384                                 ucbuffer_[byte+2] = tmp;
2385                         }
2386                 }
2387                 if(is_unsigned_samples) {
2388                         for(byte = sample = wide_sample = 0; wide_sample < wide_samples; wide_sample++)
2389                                 for(channel = 0; channel < channels; channel++, sample++) {
2390                                         out[channel][wide_sample]  = ucbuffer_[byte++]; out[channel][wide_sample] <<= 8;
2391                                         out[channel][wide_sample] |= ucbuffer_[byte++]; out[channel][wide_sample] <<= 8;
2392                                         out[channel][wide_sample] |= ucbuffer_[byte++];
2393                                         out[channel][wide_sample] -= 0x800000;
2394                                 }
2395                 }
2396                 else {
2397                         for(byte = sample = wide_sample = 0; wide_sample < wide_samples; wide_sample++)
2398                                 for(channel = 0; channel < channels; channel++, sample++) {
2399                                         out[channel][wide_sample]  = scbuffer_[byte++]; out[channel][wide_sample] <<= 8;
2400                                         out[channel][wide_sample] |= ucbuffer_[byte++]; out[channel][wide_sample] <<= 8;
2401                                         out[channel][wide_sample] |= ucbuffer_[byte++];
2402                                 }
2403                 }
2404         }
2405         else {
2406                 FLAC__ASSERT(0);
2407         }
2408         if(shift > 0) {
2409                 FLAC__int32 mask = (1<<shift)-1;
2410                 for(wide_sample = 0; wide_sample < wide_samples; wide_sample++)
2411                         for(channel = 0; channel < channels; channel++) {
2412                                 if(out[channel][wide_sample] & mask) {
2413                                         flac__utils_printf(stderr, 1, "ERROR during read, sample data (channel#%u sample#%u = %d) has non-zero least-significant bits\n  WAVE/AIFF header said the last %u bits are not significant and should be zero.\n", channel, wide_sample, out[channel][wide_sample], shift);
2414                                         return false;
2415                                 }
2416                                 out[channel][wide_sample] >>= shift;
2417                         }
2418         }
2419         return true;
2420 }
2421
2422 void encoder_progress_callback(const FLAC__StreamEncoder *encoder, FLAC__uint64 bytes_written, FLAC__uint64 samples_written, unsigned frames_written, unsigned total_frames_estimate, void *client_data)
2423 {
2424         EncoderSession *e = (EncoderSession*)client_data;
2425
2426         (void)encoder, (void)total_frames_estimate;
2427
2428         e->bytes_written = bytes_written;
2429         e->samples_written = samples_written;
2430
2431         if(e->total_samples_to_encode > 0 && !((frames_written-1) & e->stats_mask))
2432                 print_stats(e);
2433 }
2434
2435 FLAC__StreamDecoderReadStatus flac_decoder_read_callback(const FLAC__StreamDecoder *decoder, FLAC__byte buffer[], size_t *bytes, void *client_data)
2436 {
2437         size_t n = 0;
2438         EncoderSession *e = (EncoderSession*)client_data;
2439     FLACDecoderData *data = &e->fmt.flac.client_data;
2440
2441         (void)decoder;
2442
2443         if (data->fatal_error)
2444                 return FLAC__STREAM_DECODER_READ_STATUS_ABORT;
2445
2446         /* use up lookahead first */
2447         if (data->lookahead_length) {
2448                 n = min(data->lookahead_length, *bytes);
2449                 memcpy(buffer, data->lookahead, n);
2450                 buffer += n;
2451                 data->lookahead += n;
2452                 data->lookahead_length -= n;
2453         }
2454
2455         /* get the rest from file */
2456         if (*bytes > n) {
2457                 *bytes = n + fread(buffer, 1, *bytes-n, e->fin);
2458                 if(ferror(e->fin))
2459                         return FLAC__STREAM_DECODER_READ_STATUS_ABORT;
2460                 else if(0 == *bytes)
2461                         return FLAC__STREAM_DECODER_READ_STATUS_END_OF_STREAM;
2462                 else
2463                         return FLAC__STREAM_DECODER_READ_STATUS_CONTINUE;
2464         }
2465         else
2466                 return FLAC__STREAM_DECODER_READ_STATUS_CONTINUE;
2467 }
2468
2469 FLAC__StreamDecoderSeekStatus flac_decoder_seek_callback(const FLAC__StreamDecoder *decoder, FLAC__uint64 absolute_byte_offset, void *client_data)
2470 {
2471         EncoderSession *e = (EncoderSession*)client_data;
2472         (void)decoder;
2473
2474         if(fseeko(e->fin, (off_t)absolute_byte_offset, SEEK_SET) < 0)
2475                 return FLAC__STREAM_DECODER_SEEK_STATUS_ERROR;
2476         else
2477                 return FLAC__STREAM_DECODER_SEEK_STATUS_OK;
2478 }
2479
2480 FLAC__StreamDecoderTellStatus flac_decoder_tell_callback(const FLAC__StreamDecoder *decoder, FLAC__uint64 *absolute_byte_offset, void *client_data)
2481 {
2482         EncoderSession *e = (EncoderSession*)client_data;
2483         off_t pos;
2484         (void)decoder;
2485
2486         if((pos = ftello(e->fin)) < 0)
2487                 return FLAC__STREAM_DECODER_TELL_STATUS_ERROR;
2488         else {
2489                 *absolute_byte_offset = (FLAC__uint64)pos;
2490                 return FLAC__STREAM_DECODER_TELL_STATUS_OK;
2491         }
2492 }
2493
2494 FLAC__StreamDecoderLengthStatus flac_decoder_length_callback(const FLAC__StreamDecoder *decoder, FLAC__uint64 *stream_length, void *client_data)
2495 {
2496         const EncoderSession *e = (EncoderSession*)client_data;
2497     const FLACDecoderData *data = &e->fmt.flac.client_data;
2498         (void)decoder;
2499
2500         if(data->filesize < 0)
2501                 return FLAC__STREAM_DECODER_LENGTH_STATUS_ERROR;
2502         else {
2503                 *stream_length = (FLAC__uint64)data->filesize;
2504                 return FLAC__STREAM_DECODER_LENGTH_STATUS_OK;
2505         }
2506 }
2507
2508 FLAC__bool flac_decoder_eof_callback(const FLAC__StreamDecoder *decoder, void *client_data)
2509 {
2510         EncoderSession *e = (EncoderSession*)client_data;
2511         (void)decoder;
2512
2513         return feof(e->fin)? true : false;
2514 }
2515
2516 FLAC__StreamDecoderWriteStatus flac_decoder_write_callback(const FLAC__StreamDecoder *decoder, const FLAC__Frame *frame, const FLAC__int32 * const buffer[], void *client_data)
2517 {
2518         EncoderSession *e = (EncoderSession*)client_data;
2519     FLACDecoderData *data = &e->fmt.flac.client_data;
2520         FLAC__uint64 n = min(data->samples_left_to_process, frame->header.blocksize);
2521         (void)decoder;
2522
2523         if(!EncoderSession_process(e, buffer, (unsigned)n)) {
2524                 print_error_with_state(e, "ERROR during encoding");
2525                 data->fatal_error = true;
2526                 return FLAC__STREAM_DECODER_WRITE_STATUS_ABORT;
2527         }
2528
2529         data->samples_left_to_process -= n;
2530         return FLAC__STREAM_DECODER_WRITE_STATUS_CONTINUE;
2531 }
2532
2533 void flac_decoder_metadata_callback(const FLAC__StreamDecoder *decoder, const FLAC__StreamMetadata *metadata, void *client_data)
2534 {
2535         EncoderSession *e = (EncoderSession*)client_data;
2536     FLACDecoderData *data = &e->fmt.flac.client_data;
2537         (void)decoder;
2538
2539         if (data->fatal_error)
2540                 return;
2541
2542         if (
2543                 data->num_metadata_blocks == sizeof(data->metadata_blocks)/sizeof(data->metadata_blocks[0]) ||
2544                 0 == (data->metadata_blocks[data->num_metadata_blocks] = FLAC__metadata_object_clone(metadata))
2545         )
2546                 data->fatal_error = true;
2547         else
2548                 data->num_metadata_blocks++;
2549 }
2550
2551 void flac_decoder_error_callback(const FLAC__StreamDecoder *decoder, FLAC__StreamDecoderErrorStatus status, void *client_data)
2552 {
2553         EncoderSession *e = (EncoderSession*)client_data;
2554     FLACDecoderData *data = &e->fmt.flac.client_data;
2555         (void)decoder;
2556
2557         flac__utils_printf(stderr, 1, "%s: ERROR got %s while decoding FLAC input\n", e->inbasefilename, FLAC__StreamDecoderErrorStatusString[status]);
2558         if(!e->continue_through_decode_errors)
2559                 data->fatal_error = true;
2560 }
2561
2562 FLAC__bool parse_cuesheet(FLAC__StreamMetadata **cuesheet, const char *cuesheet_filename, const char *inbasefilename, FLAC__bool is_cdda, FLAC__uint64 lead_out_offset, FLAC__bool treat_warnings_as_errors)
2563 {
2564         FILE *f;
2565         unsigned last_line_read;
2566         const char *error_message;
2567
2568         if(0 == cuesheet_filename)
2569                 return true;
2570
2571         if(lead_out_offset == 0) {
2572                 flac__utils_printf(stderr, 1, "%s: ERROR cannot import cuesheet when the number of input samples to encode is unknown\n", inbasefilename);
2573                 return false;
2574         }
2575
2576         if(0 == (f = fopen(cuesheet_filename, "r"))) {
2577                 flac__utils_printf(stderr, 1, "%s: ERROR opening cuesheet \"%s\" for reading: %s\n", inbasefilename, cuesheet_filename, strerror(errno));
2578                 return false;
2579         }
2580
2581         *cuesheet = grabbag__cuesheet_parse(f, &error_message, &last_line_read, is_cdda, lead_out_offset);
2582
2583         fclose(f);
2584
2585         if(0 == *cuesheet) {
2586                 flac__utils_printf(stderr, 1, "%s: ERROR parsing cuesheet \"%s\" on line %u: %s\n", inbasefilename, cuesheet_filename, last_line_read, error_message);
2587                 return false;
2588         }
2589
2590         if(!FLAC__format_cuesheet_is_legal(&(*cuesheet)->data.cue_sheet, /*check_cd_da_subset=*/false, &error_message)) {
2591                 flac__utils_printf(stderr, 1, "%s: ERROR parsing cuesheet \"%s\": %s\n", inbasefilename, cuesheet_filename, error_message);
2592                 return false;
2593         }
2594
2595         /* if we're expecting CDDA, warn about non-compliance */
2596         if(is_cdda && !FLAC__format_cuesheet_is_legal(&(*cuesheet)->data.cue_sheet, /*check_cd_da_subset=*/true, &error_message)) {
2597                 flac__utils_printf(stderr, 1, "%s: WARNING cuesheet \"%s\" is not audio CD compliant: %s\n", inbasefilename, cuesheet_filename, error_message);
2598                 if(treat_warnings_as_errors)
2599                         return false;
2600                 (*cuesheet)->data.cue_sheet.is_cd = false;
2601         }
2602
2603         return true;
2604 }
2605
2606 void print_stats(const EncoderSession *encoder_session)
2607 {
2608         const FLAC__uint64 samples_written = min(encoder_session->total_samples_to_encode, encoder_session->samples_written);
2609         const FLAC__uint64 uesize = encoder_session->unencoded_size;
2610 #if defined _MSC_VER || defined __MINGW32__
2611         /* with MSVC you have to spoon feed it the casting */
2612         const double progress = (double)(FLAC__int64)samples_written / (double)(FLAC__int64)encoder_session->total_samples_to_encode;
2613         const double ratio = (double)(FLAC__int64)encoder_session->bytes_written / ((double)(FLAC__int64)(uesize? uesize:1) * min(1.0, progress));
2614 #else
2615         const double progress = (double)samples_written / (double)encoder_session->total_samples_to_encode;
2616         const double ratio = (double)encoder_session->bytes_written / ((double)(uesize? uesize:1) * min(1.0, progress));
2617 #endif
2618
2619         FLAC__ASSERT(encoder_session->total_samples_to_encode > 0);
2620
2621         if(samples_written == encoder_session->total_samples_to_encode) {
2622                 flac__utils_printf(stderr, 2, "\r%s:%s wrote %u bytes, ratio=",
2623                         encoder_session->inbasefilename,
2624                         encoder_session->verify? " Verify OK," : "",
2625                         (unsigned)encoder_session->bytes_written
2626                 );
2627         }
2628         else {
2629                 flac__utils_printf(stderr, 2, "\r%s: %u%% complete, ratio=", encoder_session->inbasefilename, (unsigned)floor(progress * 100.0 + 0.5));
2630         }
2631         if(uesize)
2632                 flac__utils_printf(stderr, 2, "%0.3f", ratio);
2633         else
2634                 flac__utils_printf(stderr, 2, "N/A");
2635 }
2636
2637 void print_error_with_init_status(const EncoderSession *e, const char *message, FLAC__StreamEncoderInitStatus init_status)
2638 {
2639         const int ilen = strlen(e->inbasefilename) + 1;
2640         const char *state_string = "";
2641
2642         flac__utils_printf(stderr, 1, "\n%s: %s\n", e->inbasefilename, message);
2643
2644         flac__utils_printf(stderr, 1, "%*s init_status = %s\n", ilen, "", FLAC__StreamEncoderInitStatusString[init_status]);
2645
2646         if(init_status == FLAC__STREAM_ENCODER_INIT_STATUS_ENCODER_ERROR) {
2647                 state_string = FLAC__stream_encoder_get_resolved_state_string(e->encoder);
2648
2649                 flac__utils_printf(stderr, 1, "%*s state = %s\n", ilen, "", state_string);
2650
2651                 /* print out some more info for some errors: */
2652                 if(0 == strcmp(state_string, FLAC__StreamEncoderStateString[FLAC__STREAM_ENCODER_CLIENT_ERROR])) {
2653                         flac__utils_printf(stderr, 1,
2654                                 "\n"
2655                                 "An error occurred while writing; the most common cause is that the disk is full.\n"
2656                         );
2657                 }
2658                 else if(0 == strcmp(state_string, FLAC__StreamEncoderStateString[FLAC__STREAM_ENCODER_IO_ERROR])) {
2659                         flac__utils_printf(stderr, 1,
2660                                 "\n"
2661                                 "An error occurred opening the output file; it is likely that the output\n"
2662                                 "directory does not exist or is not writable, the output file already exists and\n"
2663                                 "is not writable, or the disk is full.\n"
2664                         );
2665                 }
2666         }
2667         else if(init_status == FLAC__STREAM_ENCODER_INIT_STATUS_NOT_STREAMABLE) {
2668                 flac__utils_printf(stderr, 1,
2669                         "\n"
2670                         "The encoding parameters specified do not conform to the FLAC Subset and may not\n"
2671                         "be streamable or playable in hardware devices.  If you really understand the\n"
2672                         "consequences, you can add --lax to the command-line options to encode with\n"
2673                         "these parameters anyway.  See http://flac.sourceforge.net/format.html#subset\n"
2674                 );
2675         }
2676 }
2677
2678 void print_error_with_state(const EncoderSession *e, const char *message)
2679 {
2680         const int ilen = strlen(e->inbasefilename) + 1;
2681         const char *state_string;
2682
2683         flac__utils_printf(stderr, 1, "\n%s: %s\n", e->inbasefilename, message);
2684
2685         state_string = FLAC__stream_encoder_get_resolved_state_string(e->encoder);
2686
2687         flac__utils_printf(stderr, 1, "%*s state = %s\n", ilen, "", state_string);
2688
2689         /* print out some more info for some errors: */
2690         if(0 == strcmp(state_string, FLAC__StreamEncoderStateString[FLAC__STREAM_ENCODER_CLIENT_ERROR])) {
2691                 flac__utils_printf(stderr, 1,
2692                         "\n"
2693                         "An error occurred while writing; the most common cause is that the disk is full.\n"
2694                 );
2695         }
2696 }
2697
2698 void print_verify_error(EncoderSession *e)
2699 {
2700         FLAC__uint64 absolute_sample;
2701         unsigned frame_number;
2702         unsigned channel;
2703         unsigned sample;
2704         FLAC__int32 expected;
2705         FLAC__int32 got;
2706
2707         FLAC__stream_encoder_get_verify_decoder_error_stats(e->encoder, &absolute_sample, &frame_number, &channel, &sample, &expected, &got);
2708
2709         flac__utils_printf(stderr, 1, "%s: ERROR: mismatch in decoded data, verify FAILED!\n", e->inbasefilename);
2710         flac__utils_printf(stderr, 1, "       Absolute sample=%u, frame=%u, channel=%u, sample=%u, expected %d, got %d\n", (unsigned)absolute_sample, frame_number, channel, sample, expected, got);
2711         flac__utils_printf(stderr, 1, "       In all known cases, verify errors are caused by hardware problems,\n");
2712         flac__utils_printf(stderr, 1, "       usually overclocking or bad RAM.  Delete %s\n", e->outfilename);
2713         flac__utils_printf(stderr, 1, "       and repeat the flac command exactly as before.  If it does not give a\n");
2714         flac__utils_printf(stderr, 1, "       verify error in the exact same place each time you try it, then there is\n");
2715         flac__utils_printf(stderr, 1, "       a problem with your hardware; please see the FAQ:\n");
2716         flac__utils_printf(stderr, 1, "           http://flac.sourceforge.net/faq.html#tools__hardware_prob\n");
2717         flac__utils_printf(stderr, 1, "       If it does fail in the exact same place every time, keep\n");
2718         flac__utils_printf(stderr, 1, "       %s and submit a bug report to:\n", e->outfilename);
2719         flac__utils_printf(stderr, 1, "           https://sourceforge.net/bugs/?func=addbug&group_id=13478\n");
2720         flac__utils_printf(stderr, 1, "       Make sure to upload the FLAC file and use the \"Monitor\" feature to\n");
2721         flac__utils_printf(stderr, 1, "       monitor the bug status.\n");
2722         flac__utils_printf(stderr, 1, "Verify FAILED!  Do not trust %s\n", e->outfilename);
2723 }
2724
2725 FLAC__bool read_bytes(FILE *f, FLAC__byte *buf, size_t n, FLAC__bool eof_ok, const char *fn)
2726 {
2727         size_t bytes_read = fread(buf, 1, n, f);
2728
2729         if(bytes_read == 0) {
2730                 if(!eof_ok) {
2731                         flac__utils_printf(stderr, 1, "%s: ERROR: unexpected EOF\n", fn);
2732                         return false;
2733                 }
2734                 else
2735                         return true;
2736         }
2737         if(bytes_read < n) {
2738                 flac__utils_printf(stderr, 1, "%s: ERROR: unexpected EOF\n", fn);
2739                 return false;
2740         }
2741         return true;
2742 }
2743
2744 FLAC__bool read_uint16(FILE *f, FLAC__bool big_endian, FLAC__uint16 *val, const char *fn)
2745 {
2746         if(!read_bytes(f, (FLAC__byte*)val, 2, /*eof_ok=*/false, fn))
2747                 return false;
2748         if(is_big_endian_host_ != big_endian) {
2749                 FLAC__byte tmp, *b = (FLAC__byte*)val;
2750                 tmp = b[1]; b[1] = b[0]; b[0] = tmp;
2751         }
2752         return true;
2753 }
2754
2755 FLAC__bool read_uint32(FILE *f, FLAC__bool big_endian, FLAC__uint32 *val, const char *fn)
2756 {
2757         if(!read_bytes(f, (FLAC__byte*)val, 4, /*eof_ok=*/false, fn))
2758                 return false;
2759         if(is_big_endian_host_ != big_endian) {
2760                 FLAC__byte tmp, *b = (FLAC__byte*)val;
2761                 tmp = b[3]; b[3] = b[0]; b[0] = tmp;
2762                 tmp = b[2]; b[2] = b[1]; b[1] = tmp;
2763         }
2764         return true;
2765 }
2766
2767 FLAC__bool read_uint64(FILE *f, FLAC__bool big_endian, FLAC__uint64 *val, const char *fn)
2768 {
2769         if(!read_bytes(f, (FLAC__byte*)val, 8, /*eof_ok=*/false, fn))
2770                 return false;
2771         if(is_big_endian_host_ != big_endian) {
2772                 FLAC__byte tmp, *b = (FLAC__byte*)val;
2773                 tmp = b[7]; b[7] = b[0]; b[0] = tmp;
2774                 tmp = b[6]; b[6] = b[1]; b[1] = tmp;
2775                 tmp = b[5]; b[5] = b[2]; b[2] = tmp;
2776                 tmp = b[4]; b[4] = b[3]; b[3] = tmp;
2777         }
2778         return true;
2779 }
2780
2781 FLAC__bool read_sane_extended(FILE *f, FLAC__uint32 *val, const char *fn)
2782         /* Read an IEEE 754 80-bit (aka SANE) extended floating point value from 'f',
2783          * convert it into an integral value and store in 'val'.  Return false if only
2784          * between 1 and 9 bytes remain in 'f', if 0 bytes remain in 'f', or if the
2785          * value is negative, between zero and one, or too large to be represented by
2786          * 'val'; return true otherwise.
2787          */
2788 {
2789         unsigned int i;
2790         FLAC__byte buf[10];
2791         FLAC__uint64 p = 0;
2792         FLAC__int16 e;
2793         FLAC__int16 shift;
2794
2795         if(!read_bytes(f, buf, sizeof(buf), /*eof_ok=*/false, fn))
2796                 return false;
2797         e = ((FLAC__uint16)(buf[0])<<8 | (FLAC__uint16)(buf[1]))-0x3FFF;
2798         shift = 63-e;
2799         if((buf[0]>>7)==1U || e<0 || e>63) {
2800                 flac__utils_printf(stderr, 1, "%s: ERROR: invalid floating-point value\n", fn);
2801                 return false;
2802         }
2803
2804         for(i = 0; i < 8; ++i)
2805                 p |= (FLAC__uint64)(buf[i+2])<<(56U-i*8);
2806         *val = (FLAC__uint32)((p>>shift)+(p>>(shift-1) & 0x1));
2807
2808         return true;
2809 }
2810
2811 FLAC__bool fskip_ahead(FILE *f, FLAC__uint64 offset)
2812 {
2813         static unsigned char dump[8192];
2814
2815 #ifdef _MSC_VER
2816         if(f == stdin) {
2817                 /* MS' stdio impl can't even seek forward on stdin, have to use pure non-fseek() version: */
2818                 while(offset > 0) {
2819                         const long need = (long)min(offset, sizeof(dump));
2820                         if((long)fread(dump, 1, need, f) < need)
2821                                 return false;
2822                         offset -= need;
2823                 }
2824         }
2825         else
2826 #endif
2827         {
2828                 while(offset > 0) {
2829                         long need = (long)min(offset, LONG_MAX);
2830                         if(fseeko(f, need, SEEK_CUR) < 0) {
2831                                 need = (long)min(offset, sizeof(dump));
2832                                 if((long)fread(dump, 1, need, f) < need)
2833                                         return false;
2834                         }
2835                         offset -= need;
2836                 }
2837         }
2838         return true;
2839 }
2840
2841 unsigned count_channel_mask_bits(FLAC__uint32 mask)
2842 {
2843         unsigned count = 0;
2844         while(mask) {
2845                 if(mask & 1)
2846                         count++;
2847                 mask >>= 1;
2848         }
2849         return count;
2850 }
2851
2852 #if 0
2853 FLAC__uint32 limit_channel_mask(FLAC__uint32 mask, unsigned channels)
2854 {
2855         FLAC__uint32 x = 0x80000000;
2856         unsigned count = count_channel_mask_bits(mask);
2857         while(x && count > channels) {
2858                 if(mask & x) {
2859                         mask &= ~x;
2860                         count--;
2861                 }
2862                 x >>= 1;
2863         }
2864         FLAC__ASSERT(count_channel_mask_bits(mask) == channels);
2865         return mask;
2866 }
2867 #endif