src/flac/encode.c

   1 /* flac - Command-line FLAC encoder/decoder
   2  * Copyright (C) 2000,2001,2002,2003,2004,2005,2006,2007,2008,2009  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, unsigned sample_rate, 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
 279                         if(got_fmt_chunk) {
 280                                 flac__utils_printf(stderr, 1, "%s: ERROR: file has multiple 'fmt ' chunks\n", e->inbasefilename);
 281                                 return false;
 282                         }
 283
 284                         /* see
 285                          *   http://www-mmsp.ece.mcgill.ca/Documents/AudioFormats/WAVE/WAVE.html
 286                          *   http://windowssdk.msdn.microsoft.com/en-us/library/ms713497.aspx
 287                          *   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
 288                          *
 289                          * WAVEFORMAT is
 290                          * 4 byte: chunk size
 291                          * 2 byte: format type: 1 for WAVE_FORMAT_PCM, 65534 for WAVE_FORMAT_EXTENSIBLE
 292                          * 2 byte: # channels
 293                          * 4 byte: sample rate (Hz)
 294                          * 4 byte: avg bytes per sec
 295                          * 2 byte: block align
 296                          * 2 byte: bits per sample (not necessarily all significant)
 297                          * WAVEFORMATEX adds
 298                          * 2 byte: extension size in bytes (usually 0 for WAVEFORMATEX and 22 for WAVEFORMATEXTENSIBLE with PCM)
 299                          * WAVEFORMATEXTENSIBLE adds
 300                          * 2 byte: valid bits per sample
 301                          * 4 byte: channel mask
 302                          * 16 byte: subformat GUID, first 2 bytes have format type, 1 being PCM
 303                          *
 304                          * Current spec says WAVEFORMATEX with PCM must have bps == 8 or 16, or any multiple of 8 for WAVEFORMATEXTENSIBLE.
 305                          * 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.
 306                          *
 307                          * Block align for WAVE_FORMAT_PCM or WAVE_FORMAT_EXTENSIBLE is also supposed to be channels*bps/8
 308                          *
 309                          * If the channel mask has more set bits than # of channels, the extra MSBs are ignored.
 310                          * If the channel mask has less set bits than # of channels, the extra channels are unassigned to any speaker.
 311                          *
 312                          * Data is supposed to be unsigned for bps <= 8 else signed.
 313                          */
 314
 315                         /* fmt chunk size */
 316                         if(!read_uint32(e->fin, /*big_endian=*/false, &xx, e->inbasefilename))
 317                                 return false;
 318                         data_bytes = xx;
 319                         if(e->format == FORMAT_WAVE64) {
 320                                 /* other half of the size field should be 0 */
 321                                 if(!read_uint32(e->fin, /*big_endian=*/false, &xx, e->inbasefilename))
 322                                         return false;
 323                                 if(xx) {
 324                                         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);
 325                                         return false;
 326                                 }
 327                                 /* subtract size of header */
 328                                 if (data_bytes < 16+8) {
 329                                         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);
 330                                         return false;
 331                                 }
 332                                 data_bytes -= (16+8);
 333                         }
 334                         if(data_bytes < 16) {
 335                                 flac__utils_printf(stderr, 1, "%s: ERROR: non-standard 'fmt ' chunk has length = %u\n", e->inbasefilename, (unsigned)data_bytes);
 336                                 return false;
 337                         }
 338                         if(e->format != FORMAT_WAVE64) {
 339                                 if(data_bytes & 1) /* should never happen, but enforce WAVE alignment rules */
 340                                         data_bytes++;
 341                         }
 342                         else { /* Wave64 */
 343                                 data_bytes = (data_bytes+7) & (~7u); /* should never happen, but enforce Wave64 alignment rules */
 344                         }
 345
 346                         /* format code */
 347                         if(!read_uint16(e->fin, /*big_endian=*/false, &wFormatTag, e->inbasefilename))
 348                                 return false;
 349                         if(wFormatTag != 1 /*WAVE_FORMAT_PCM*/ && wFormatTag != 65534 /*WAVE_FORMAT_EXTENSIBLE*/) {
 350                                 flac__utils_printf(stderr, 1, "%s: ERROR: unsupported format type %u\n", e->inbasefilename, (unsigned)wFormatTag);
 351                                 return false;
 352                         }
 353
 354                         /* number of channels */
 355                         if(!read_uint16(e->fin, /*big_endian=*/false, &x, e->inbasefilename))
 356                                 return false;
 357                         channels = (unsigned)x;
 358
 359                         /* sample rate */
 360                         if(!read_uint32(e->fin, /*big_endian=*/false, &xx, e->inbasefilename))
 361                                 return false;
 362                         sample_rate = xx;
 363
 364                         /* avg bytes per second (ignored) */
 365                         if(!read_uint32(e->fin, /*big_endian=*/false, &xx, e->inbasefilename))
 366                                 return false;
 367                         /* block align */
 368                         if(!read_uint16(e->fin, /*big_endian=*/false, &x, e->inbasefilename))
 369                                 return false;
 370
 371                         /* bits per sample */
 372                         if(!read_uint16(e->fin, /*big_endian=*/false, &x, e->inbasefilename))
 373                                 return false;
 374                         bps = (unsigned)x;
 375
 376                         e->info.is_unsigned_samples = (bps <= 8);
 377
 378                         if(wFormatTag == 1) {
 379                                 if(bps != 8 && bps != 16) {
 380                                         if(bps == 24 || bps == 32) {
 381                                                 /* let these slide with a warning since they're unambiguous */
 382                                                 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);
 383                                                 if(e->treat_warnings_as_errors)
 384                                                         return false;
 385                                         }
 386                                         else {
 387                                                 /* @@@ we could add an option to specify left- or right-justified blocks so we knew how to set 'shift' */
 388                                                 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);
 389                                                 return false;
 390                                         }
 391                                 }
 392 #if 0 /* @@@ reinstate once we can get an answer about whether the samples are left- or right-justified */
 393                                 if((bps+7)/8 * channels == block_align) {
 394                                         if(bps % 8) {
 395                                                 /* assume legacy file is byte aligned with some LSBs zero; this is double-checked in format_input() */
 396                                                 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);
 397                                                 if(e->treat_warnings_as_errors)
 398                                                         return false;
 399                                                 shift = 8 - (bps % 8);
 400                                                 bps += shift;
 401                                         }
 402                                         else
 403                                                 shift = 0;
 404                                 }
 405                                 else {
 406                                         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);
 407                                         return false;
 408                                 }
 409 #else
 410                                 shift = 0;
 411 #endif
 412                                 if(channels > 2 && !options.channel_map_none) {
 413                                         flac__utils_printf(stderr, 1, "%s: ERROR: WAVE has >2 channels but is not WAVE_FORMAT_EXTENSIBLE; cannot assign channels\n", e->inbasefilename);
 414                                         return false;
 415                                 }
 416                                 FLAC__ASSERT(data_bytes >= 16);
 417                                 data_bytes -= 16;
 418                         }
 419                         else {
 420                                 if(data_bytes < 40) {
 421                                         flac__utils_printf(stderr, 1, "%s: ERROR: invalid WAVEFORMATEXTENSIBLE chunk with size %u\n", e->inbasefilename, (unsigned)data_bytes);
 422                                         return false;
 423                                 }
 424                                 /* cbSize */
 425                                 if(!read_uint16(e->fin, /*big_endian=*/false, &x, e->inbasefilename))
 426                                         return false;
 427                                 if(x < 22) {
 428                                         flac__utils_printf(stderr, 1, "%s: ERROR: invalid WAVEFORMATEXTENSIBLE chunk with cbSize %u\n", e->inbasefilename, (unsigned)x);
 429                                         return false;
 430                                 }
 431                                 /* valid bps */
 432                                 if(!read_uint16(e->fin, /*big_endian=*/false, &x, e->inbasefilename))
 433                                         return false;
 434                                 if((unsigned)x > bps) {
 435                                         flac__utils_printf(stderr, 1, "%s: ERROR: invalid WAVEFORMATEXTENSIBLE chunk with wValidBitsPerSample (%u) > wBitsPerSample (%u)\n", e->inbasefilename, (unsigned)x, bps);
 436                                         return false;
 437                                 }
 438                                 shift = bps - (unsigned)x;
 439                                 /* channel mask */
 440                                 if(!read_uint32(e->fin, /*big_endian=*/false, &channel_mask, e->inbasefilename))
 441                                         return false;
 442                                 /* for mono/stereo and unassigned channels, we fake the mask */
 443                                 if(channel_mask == 0) {
 444                                         if(channels == 1)
 445                                                 channel_mask = 0x0001;
 446                                         else if(channels == 2)
 447                                                 channel_mask = 0x0003;
 448                                 }
 449                                 /* set channel mapping */
 450                                 /* FLAC order follows SMPTE and WAVEFORMATEXTENSIBLE but with fewer channels, which are: */
 451                                 /* front left, front right, center, LFE, back left, back right, surround left, surround right */
 452                                 /* the default mapping is sufficient for 1-6 channels and 7-8 are currently unspecified anyway */
 453 #if 0
 454                                 /* @@@ example for dolby/vorbis order, for reference later in case it becomes important */
 455                                 if(
 456                                         options.channel_map_none ||
 457                                         channel_mask == 0x0001 || /* 1 channel: (mono) */
 458                                         channel_mask == 0x0003 || /* 2 channels: front left, front right */
 459                                         channel_mask == 0x0033 || /* 4 channels: front left, front right, back left, back right */
 460                                         channel_mask == 0x0603    /* 4 channels: front left, front right, side left, side right */
 461                                 ) {
 462                                         /* keep default channel order */
 463                                 }
 464                                 else if(
 465                                         channel_mask == 0x0007 || /* 3 channels: front left, front right, front center */
 466                                         channel_mask == 0x0037 || /* 5 channels: front left, front right, front center, back left, back right */
 467                                         channel_mask == 0x0607    /* 5 channels: front left, front right, front center, side left, side right */
 468                                 ) {
 469                                         /* to dolby order: front left, center, front right [, surround left, surround right ] */
 470                                         channel_map[1] = 2;
 471                                         channel_map[2] = 1;
 472                                 }
 473                                 else if(
 474                                         channel_mask == 0x003f || /* 6 channels: front left, front right, front center, LFE, back left, back right */
 475                                         channel_mask == 0x060f    /* 6 channels: front left, front right, front center, LFE, side left, side right */
 476                                 ) {
 477                                         /* to dolby order: front left, center, front right, surround left, surround right, LFE */
 478                                         channel_map[1] = 2;
 479                                         channel_map[2] = 1;
 480                                         channel_map[3] = 5;
 481                                         channel_map[4] = 3;
 482                                         channel_map[5] = 4;
 483                                 }
 484 #else
 485                                 if(
 486                                         options.channel_map_none ||
 487                                         channel_mask == 0x0001 || /* 1 channel: (mono) */
 488                                         channel_mask == 0x0003 || /* 2 channels: front left, front right */
 489                                         channel_mask == 0x0007 || /* 3 channels: front left, front right, front center */
 490                                         channel_mask == 0x0033 || /* 4 channels: front left, front right, back left, back right */
 491                                         channel_mask == 0x0603 || /* 4 channels: front left, front right, side left, side right */
 492                                         channel_mask == 0x0037 || /* 5 channels: front left, front right, front center, back left, back right */
 493                                         channel_mask == 0x0607 || /* 5 channels: front left, front right, front center, side left, side right */
 494                                         channel_mask == 0x003f || /* 6 channels: front left, front right, front center, LFE, back left, back right */
 495                                         channel_mask == 0x060f    /* 6 channels: front left, front right, front center, LFE, side left, side right */
 496                                 ) {
 497                                         /* keep default channel order */
 498                                 }
 499 #endif
 500                                 else {
 501                                         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);
 502                                         return false;
 503                                 }
 504                                 if(!options.channel_map_none) {
 505                                         if(count_channel_mask_bits(channel_mask) < channels) {
 506                                                 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);
 507                                                 return false;
 508                                         }
 509 #if 0
 510                                         /* supporting this is too difficult with channel mapping; e.g. what if mask is 0x003f but #channels=4?
 511                                          * there would be holes in the order that would have to be filled in, or the mask would have to be
 512                                          * limited and the logic above rerun to see if it still fits into the FLAC mapping.
 513                                          */
 514                                         else if(count_channel_mask_bits(channel_mask) > channels)
 515                                                 channel_mask = limit_channel_mask(channel_mask, channels);
 516 #else
 517                                         else if(count_channel_mask_bits(channel_mask) > channels) {
 518                                                 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);
 519                                                 return false;
 520                                         }
 521 #endif
 522                                 }
 523                                 /* first part of GUID */
 524                                 if(!read_uint16(e->fin, /*big_endian=*/false, &x, e->inbasefilename))
 525                                         return false;
 526                                 if(x != 1) {
 527                                         flac__utils_printf(stderr, 1, "%s: ERROR: unsupported WAVEFORMATEXTENSIBLE chunk with non-PCM format %u\n", e->inbasefilename, (unsigned)x);
 528                                         return false;
 529                                 }
 530                                 data_bytes -= 26;
 531                         }
 532
 533                         e->info.bytes_per_wide_sample = channels * (bps / 8);
 534
 535                         /* skip any extra data in the fmt chunk */
 536                         if(!fskip_ahead(e->fin, data_bytes)) {
 537                                 flac__utils_printf(stderr, 1, "%s: ERROR during read while skipping over extra 'fmt' data\n", e->inbasefilename);
 538                                 return false;
 539                         }
 540
 541                         got_fmt_chunk = true;
 542                 }
 543                 else if(
 544                         !memcmp(chunk_id, "data", 4) &&
 545                         (e->format!=FORMAT_WAVE64 || !memcmp(chunk_id, "data\xF3\xAC\xD3\x11\xD1\x8C\x00\xC0\x4F\x8E\xDB\x8A", 16))
 546                 ) { /* data chunk */
 547                         FLAC__uint32 xx;
 548                         FLAC__uint64 data_bytes;
 549
 550                         if(!got_fmt_chunk) {
 551                                 flac__utils_printf(stderr, 1, "%s: ERROR: got 'data' chunk before 'fmt' chunk\n", e->inbasefilename);
 552                                 return false;
 553                         }
 554
 555                         /* data size */
 556                         if(e->format != FORMAT_WAVE64) {
 557                                 if(!read_uint32(e->fin, /*big_endian=*/false, &xx, e->inbasefilename))
 558                                         return false;
 559                                 data_bytes = xx;
 560                         }
 561                         else { /* Wave64 */
 562                                 if(!read_uint64(e->fin, /*big_endian=*/false, &data_bytes, e->inbasefilename))
 563                                         return false;
 564                                 /* subtract size of header */
 565                                 if (data_bytes < 16+8) {
 566                                         flac__utils_printf(stderr, 1, "%s: ERROR: freakishly small Wave64 'data' chunk has length = 0x00000000%08X\n", e->inbasefilename, (unsigned)data_bytes);
 567                                         return false;
 568                                 }
 569                                 data_bytes -= (16+8);
 570                         }
 571                         if(e->format == FORMAT_RF64) {
 572                                 if(!got_ds64_chunk) {
 573                                         flac__utils_printf(stderr, 1, "%s: ERROR: RF64 file has no 'ds64' chunk before 'data' chunk\n", e->inbasefilename);
 574                                         return false;
 575                                 }
 576                                 if(data_bytes == 0xffffffff)
 577                                         data_bytes = ds64_data_size;
 578                         }
 579                         if(options.ignore_chunk_sizes) {
 580                                 FLAC__ASSERT(!options.sector_align);
 581                                 if(data_bytes) {
 582                                         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);
 583                                         if(e->treat_warnings_as_errors)
 584                                                 return false;
 585                                 }
 586                                 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 */
 587                         }
 588                         else if(0 == data_bytes) {
 589                                 flac__utils_printf(stderr, 1, "%s: ERROR: 'data' chunk has size of 0\n", e->inbasefilename);
 590                                 return false;
 591                         }
 592
 593                         e->fmt.iff.data_bytes = data_bytes;
 594
 595                         got_data_chunk = true;
 596                         break;
 597                 }
 598                 else {
 599                         FLAC__uint32 xx;
 600                         FLAC__uint64 skip;
 601                         if(!options.format_options.iff.foreign_metadata) {
 602                                 if(e->format != FORMAT_WAVE64)
 603                                         flac__utils_printf(stderr, 1, "%s: WARNING: skipping unknown chunk '%s' (use --keep-foreign-metadata to keep)\n", e->inbasefilename, chunk_id);
 604                                 else
 605                                         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",
 606                                                 e->inbasefilename,
 607                                                 (unsigned)((const unsigned char *)chunk_id)[3],
 608                                                 (unsigned)((const unsigned char *)chunk_id)[2],
 609                                                 (unsigned)((const unsigned char *)chunk_id)[1],
 610                                                 (unsigned)((const unsigned char *)chunk_id)[0],
 611                                                 (unsigned)((const unsigned char *)chunk_id)[5],
 612                                                 (unsigned)((const unsigned char *)chunk_id)[4],
 613                                                 (unsigned)((const unsigned char *)chunk_id)[7],
 614                                                 (unsigned)((const unsigned char *)chunk_id)[6],
 615                                                 (unsigned)((const unsigned char *)chunk_id)[9],
 616                                                 (unsigned)((const unsigned char *)chunk_id)[8],
 617                                                 (unsigned)((const unsigned char *)chunk_id)[10],
 618                                                 (unsigned)((const unsigned char *)chunk_id)[11],
 619                                                 (unsigned)((const unsigned char *)chunk_id)[12],
 620                                                 (unsigned)((const unsigned char *)chunk_id)[13],
 621                                                 (unsigned)((const unsigned char *)chunk_id)[14],
 622                                                 (unsigned)((const unsigned char *)chunk_id)[15]
 623                                         );
 624                                 if(e->treat_warnings_as_errors)
 625                                         return false;
 626                         }
 627
 628                         /* chunk size */
 629                         if(e->format != FORMAT_WAVE64) {
 630                                 if(!read_uint32(e->fin, /*big_endian=*/false, &xx, e->inbasefilename))
 631                                         return false;
 632                                 skip = xx;
 633                                 skip += skip & 1;
 634                         }
 635                         else { /* Wave64 */
 636                                 if(!read_uint64(e->fin, /*big_endian=*/false, &skip, e->inbasefilename))
 637                                         return false;
 638                                 skip = (skip+7) & (~(FLAC__uint64)7);
 639                                 /* subtract size of header */
 640                                 if (skip < 16+8) {
 641                                         flac__utils_printf(stderr, 1, "%s: ERROR: freakishly small Wave64 chunk has length = 0x00000000%08X\n", e->inbasefilename, (unsigned)skip);
 642                                         return false;
 643                                 }
 644                                 skip -= (16+8);
 645                         }
 646                         if(skip) {
 647                                 if(!fskip_ahead(e->fin, skip)) {
 648                                         flac__utils_printf(stderr, 1, "%s: ERROR during read while skipping over chunk\n", e->inbasefilename);
 649                                         return false;
 650                                 }
 651                         }
 652                 }
 653         }
 654
 655         if(!got_fmt_chunk) {
 656                 flac__utils_printf(stderr, 1, "%s: ERROR: didn't find fmt chunk\n", e->inbasefilename);
 657                 return false;
 658         }
 659         if(!got_data_chunk) {
 660                 flac__utils_printf(stderr, 1, "%s: ERROR: didn't find data chunk\n", e->inbasefilename);
 661                 return false;
 662         }
 663
 664         e->info.sample_rate = sample_rate;
 665         e->info.channels = channels;
 666         e->info.bits_per_sample = bps;
 667         e->info.shift = shift;
 668         e->info.channel_mask = channel_mask;
 669
 670         return true;
 671 }
 672
 673 static FLAC__bool get_sample_info_aiff(EncoderSession *e, encode_options_t options)
 674 {
 675         FLAC__bool got_comm_chunk = false, got_ssnd_chunk = false;
 676         unsigned sample_rate = 0, channels = 0, bps = 0, shift = 0;
 677         FLAC__uint64 sample_frames = 0;
 678         FLAC__uint32 channel_mask = 0;
 679
 680         e->info.is_unsigned_samples = false;
 681         e->info.is_big_endian = true;
 682
 683         /*
 684          * lookahead[] already has "FORMxxxxAIFF", do chunks
 685          */
 686         while(!feof(e->fin) && !got_ssnd_chunk) {
 687                 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 */
 688                 if(!read_bytes(e->fin, (FLAC__byte*)chunk_id, 4, /*eof_ok=*/true, e->inbasefilename)) {
 689                         flac__utils_printf(stderr, 1, "%s: ERROR: incomplete chunk identifier\n", e->inbasefilename);
 690                         return false;
 691                 }
 692                 if(feof(e->fin))
 693                         break;
 694
 695                 if(!memcmp(chunk_id, "COMM", 4)) { /* common chunk */
 696                         FLAC__uint16 x;
 697                         FLAC__uint32 xx;
 698                         unsigned long skip;
 699                         const FLAC__bool is_aifc = e->format == FORMAT_AIFF_C;
 700                         const FLAC__uint32 minimum_comm_size = (is_aifc? 22 : 18);
 701
 702                         if(got_comm_chunk) {
 703                                 flac__utils_printf(stderr, 1, "%s: ERROR: file has multiple 'COMM' chunks\n", e->inbasefilename);
 704                                 return false;
 705                         }
 706
 707                         /* COMM chunk size */
 708                         if(!read_uint32(e->fin, /*big_endian=*/true, &xx, e->inbasefilename))
 709                                 return false;
 710                         else if(xx < minimum_comm_size) {
 711                                 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);
 712                                 return false;
 713                         }
 714                         else if(!is_aifc && xx != minimum_comm_size) {
 715                                 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);
 716                                 if(e->treat_warnings_as_errors)
 717                                         return false;
 718                         }
 719                         skip = (xx-minimum_comm_size)+(xx & 1);
 720
 721                         /* number of channels */
 722                         if(!read_uint16(e->fin, /*big_endian=*/true, &x, e->inbasefilename))
 723                                 return false;
 724                         channels = (unsigned)x;
 725                         if(channels > 2 && !options.channel_map_none) {
 726                                 flac__utils_printf(stderr, 1, "%s: ERROR: unsupported number of channels %u for AIFF\n", e->inbasefilename, channels);
 727                                 return false;
 728                         }
 729
 730                         /* number of sample frames */
 731                         if(!read_uint32(e->fin, /*big_endian=*/true, &xx, e->inbasefilename))
 732                                 return false;
 733                         sample_frames = xx;
 734
 735                         /* bits per sample */
 736                         if(!read_uint16(e->fin, /*big_endian=*/true, &x, e->inbasefilename))
 737                                 return false;
 738                         bps = (unsigned)x;
 739                         shift = (bps%8)? 8-(bps%8) : 0; /* SSND data is always byte-aligned, left-justified but format_input() will double-check */
 740                         bps += shift;
 741
 742                         /* sample rate */
 743                         if(!read_sane_extended(e->fin, &xx, e->inbasefilename))
 744                                 return false;
 745                         sample_rate = xx;
 746
 747                         /* check compression type for AIFF-C */
 748                         if(is_aifc) {
 749                                 if(!read_uint32(e->fin, /*big_endian=*/true, &xx, e->inbasefilename))
 750                                         return false;
 751                                 if(xx == 0x736F7774) /* "sowt" */
 752                                         e->info.is_big_endian = false;
 753                                 else if(xx == 0x4E4F4E45) /* "NONE" */
 754                                         ; /* nothing to do, we already default to big-endian */
 755                                 else {
 756                                         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));
 757                                         return false;
 758                                 }
 759                         }
 760
 761                         /* set channel mapping */
 762                         /* FLAC order follows SMPTE and WAVEFORMATEXTENSIBLE but with fewer channels, which are: */
 763                         /* front left, front right, center, LFE, back left, back right, surround left, surround right */
 764                         /* specs say the channel ordering is:
 765                          *                             1     2   3   4   5   6
 766                          * ___________________________________________________
 767                          * 2         stereo            l     r
 768                          * 3                           l     r   c
 769                          * 4                           l     c   r   S
 770                          * quad (ambiguous with 4ch)  Fl    Fr   Bl  Br
 771                          * 5                          Fl     Fr  Fc  Sl  Sr
 772                          * 6                           l     lc  c   r   rc  S
 773                          * 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
 774                          * so we only have unambiguous mappings for 2, 3, and 5 channels
 775                          */
 776                         if(
 777                                 options.channel_map_none ||
 778                                 channels == 1 || /* 1 channel: (mono) */
 779                                 channels == 2 || /* 2 channels: left, right */
 780                                 channels == 3 || /* 3 channels: left, right, center */
 781                                 channels == 5    /* 5 channels: front left, front right, center, surround left, surround right */
 782                         ) {
 783                                 /* keep default channel order */
 784                         }
 785                         else {
 786                                 flac__utils_printf(stderr, 1, "%s: ERROR: unsupported number of channels %u for AIFF\n", e->inbasefilename, channels);
 787                                 return false;
 788                         }
 789
 790                         e->info.bytes_per_wide_sample = channels * (bps / 8);
 791
 792                         /* skip any extra data in the COMM chunk */
 793                         if(!fskip_ahead(e->fin, skip)) {
 794                                 flac__utils_printf(stderr, 1, "%s: ERROR during read while skipping over extra COMM data\n", e->inbasefilename);
 795                                 return false;
 796                         }
 797
 798                         got_comm_chunk = true;
 799                 }
 800                 else if(!memcmp(chunk_id, "SSND", 4) && !got_ssnd_chunk) { /* sound data chunk */
 801                         FLAC__uint32 xx;
 802                         FLAC__uint64 data_bytes;
 803                         unsigned offset = 0;
 804
 805                         if(!got_comm_chunk) {
 806                                 flac__utils_printf(stderr, 1, "%s: ERROR: got 'SSND' chunk before 'COMM' chunk\n", e->inbasefilename);
 807                                 return false;
 808                         }
 809
 810                         /* SSND chunk size */
 811                         if(!read_uint32(e->fin, /*big_endian=*/true, &xx, e->inbasefilename))
 812                                 return false;
 813                         data_bytes = xx;
 814                         if(options.ignore_chunk_sizes) {
 815                                 FLAC__ASSERT(!options.sector_align);
 816                                 if(data_bytes) {
 817                                         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);
 818                                         if(e->treat_warnings_as_errors)
 819                                                 return false;
 820                                 }
 821                                 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 */
 822                         }
 823                         else if(data_bytes <= 8) {
 824                                 flac__utils_printf(stderr, 1, "%s: ERROR: 'SSND' chunk has size <= 8\n", e->inbasefilename);
 825                                 return false;
 826                         }
 827                         else {
 828                                 data_bytes -= 8; /* discount the offset and block size fields */
 829                         }
 830
 831                         /* offset */
 832                         if(!read_uint32(e->fin, /*big_endian=*/true, &xx, e->inbasefilename))
 833                                 return false;
 834                         offset = xx;
 835                         data_bytes -= offset;
 836
 837                         /* block size */
 838                         if(!read_uint32(e->fin, /*big_endian=*/true, &xx, e->inbasefilename))
 839                                 return false;
 840                         if(xx && !options.ignore_chunk_sizes)
 841                                 data_bytes -= (xx - (data_bytes % xx));
 842                         if(options.ignore_chunk_sizes) {
 843                                 if(xx) {
 844                                         flac__utils_printf(stderr, 1, "%s: WARNING: 'SSND' chunk has non-zero blocksize, using --ignore-chunk-sizes is probably a bad idea\n", e->inbasefilename, chunk_id);
 845                                         if(e->treat_warnings_as_errors)
 846                                                 return false;
 847                                 }
 848                         }
 849
 850                         /* skip any SSND offset bytes */
 851                         if(!fskip_ahead(e->fin, offset)) {
 852                                 flac__utils_printf(stderr, 1, "%s: ERROR: skipping offset in SSND chunk\n", e->inbasefilename);
 853                                 return false;
 854                         }
 855
 856                         e->fmt.iff.data_bytes = data_bytes;
 857
 858                         got_ssnd_chunk = true;
 859                 }
 860                 else {
 861                         FLAC__uint32 xx;
 862                         if(!options.format_options.iff.foreign_metadata) {
 863                                 flac__utils_printf(stderr, 1, "%s: WARNING: skipping unknown chunk '%s' (use --keep-foreign-metadata to keep)\n", e->inbasefilename, chunk_id);
 864                                 if(e->treat_warnings_as_errors)
 865                                         return false;
 866                         }
 867
 868                         /* chunk size */
 869                         if(!read_uint32(e->fin, /*big_endian=*/true, &xx, e->inbasefilename))
 870                                 return false;
 871                         else {
 872                                 unsigned long skip = xx + (xx & 1);
 873
 874                                 FLAC__ASSERT(skip <= LONG_MAX);
 875                                 if(!fskip_ahead(e->fin, skip)) {
 876                                         flac__utils_printf(stderr, 1, "%s: ERROR during read while skipping over chunk\n", e->inbasefilename);
 877                                         return false;
 878                                 }
 879                         }
 880                 }
 881         }
 882
 883         if(!got_comm_chunk) {
 884                 flac__utils_printf(stderr, 1, "%s: ERROR: didn't find COMM chunk\n", e->inbasefilename);
 885                 return false;
 886         }
 887         if(!got_ssnd_chunk && sample_frames) {
 888                 flac__utils_printf(stderr, 1, "%s: ERROR: didn't find SSND chunk\n", e->inbasefilename);
 889                 return false;
 890         }
 891
 892         e->info.sample_rate = sample_rate;
 893         e->info.channels = channels;
 894         e->info.bits_per_sample = bps;
 895         e->info.shift = shift;
 896         e->info.channel_mask = channel_mask;
 897
 898         return true;
 899 }
 900
 901 static FLAC__bool get_sample_info_flac(EncoderSession *e)
 902 {
 903         if (!(
 904                 FLAC__stream_decoder_set_md5_checking(e->fmt.flac.decoder, false) &&
 905                 FLAC__stream_decoder_set_metadata_respond_all(e->fmt.flac.decoder)
 906         )) {
 907                 flac__utils_printf(stderr, 1, "%s: ERROR: setting up decoder for FLAC input\n", e->inbasefilename);
 908                 return false;
 909         }
 910
 911         if (e->format == FORMAT_OGGFLAC) {
 912                 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) {
 913                         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));
 914                         return false;
 915                 }
 916         }
 917         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) {
 918                 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));
 919                 return false;
 920         }
 921
 922         if (!FLAC__stream_decoder_process_until_end_of_metadata(e->fmt.flac.decoder) || e->fmt.flac.client_data.fatal_error) {
 923                 if (e->fmt.flac.client_data.fatal_error)
 924                         flac__utils_printf(stderr, 1, "%s: ERROR: out of memory or too many metadata blocks while reading metadata in FLAC input\n", e->inbasefilename);
 925                 else
 926                         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));
 927                 return false;
 928         }
 929
 930         if (e->fmt.flac.client_data.num_metadata_blocks == 0) {
 931                 flac__utils_printf(stderr, 1, "%s: ERROR: reading metadata in FLAC input, got no metadata blocks\n", e->inbasefilename);
 932                 return false;
 933         }
 934         else if (e->fmt.flac.client_data.metadata_blocks[0]->type != FLAC__METADATA_TYPE_STREAMINFO) {
 935                 flac__utils_printf(stderr, 1, "%s: ERROR: reading metadata in FLAC input, first metadata block is not STREAMINFO\n", e->inbasefilename);
 936                 return false;
 937         }
 938         else if (e->fmt.flac.client_data.metadata_blocks[0]->data.stream_info.total_samples == 0) {
 939                 flac__utils_printf(stderr, 1, "%s: ERROR: FLAC input has STREAMINFO with unknown total samples which is not supported\n", e->inbasefilename);
 940                 return false;
 941         }
 942
 943         e->info.sample_rate = e->fmt.flac.client_data.metadata_blocks[0]->data.stream_info.sample_rate;
 944         e->info.channels = e->fmt.flac.client_data.metadata_blocks[0]->data.stream_info.channels;
 945         e->info.bits_per_sample = e->fmt.flac.client_data.metadata_blocks[0]->data.stream_info.bits_per_sample;
 946         e->info.shift = 0;
 947         e->info.bytes_per_wide_sample = 0;
 948         e->info.is_unsigned_samples = false; /* not applicable for FLAC input */
 949         e->info.is_big_endian = false; /* not applicable for FLAC input */
 950         e->info.channel_mask = 0;
 951
 952         return true;
 953 }
 954
 955 /*
 956  * public routines
 957  */
 958 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)
 959 {
 960         EncoderSession encoder_session;
 961         size_t channel_map[FLAC__MAX_CHANNELS];
 962         int info_align_carry = -1, info_align_zero = -1;
 963
 964         if(!EncoderSession_construct(&encoder_session, options, infilesize, infile, infilename, outfilename, lookahead, lookahead_length))
 965                 return 1;
 966
 967         /* initialize default channel map that preserves channel order */
 968         {
 969                 size_t i;
 970                 for(i = 0; i < sizeof(channel_map)/sizeof(channel_map[0]); i++)
 971                         channel_map[i] = i;
 972         }
 973
 974         /* read foreign metadata if requested */
 975         if(EncoderSession_format_is_iff(&encoder_session) && options.format_options.iff.foreign_metadata) {
 976                 const char *error;
 977                 if(!(
 978                         options.format == FORMAT_WAVE || options.format == FORMAT_RF64?
 979                                 flac__foreign_metadata_read_from_wave(options.format_options.iff.foreign_metadata, infilename, &error) :
 980                         options.format == FORMAT_WAVE64?
 981                                 flac__foreign_metadata_read_from_wave64(options.format_options.iff.foreign_metadata, infilename, &error) :
 982                                 flac__foreign_metadata_read_from_aiff(options.format_options.iff.foreign_metadata, infilename, &error)
 983                 )) {
 984                         flac__utils_printf(stderr, 1, "%s: ERROR reading foreign metadata: %s\n", encoder_session.inbasefilename, error);
 985                         return EncoderSession_finish_error(&encoder_session);
 986                 }
 987         }
 988
 989         /* initialize encoder session with info about the audio (channels/bps/resolution/endianness/etc) */
 990         switch(options.format) {
 991                 case FORMAT_RAW:
 992                         if(!get_sample_info_raw(&encoder_session, options))
 993                                 return EncoderSession_finish_error(&encoder_session);
 994                         break;
 995                 case FORMAT_WAVE:
 996                 case FORMAT_WAVE64:
 997                 case FORMAT_RF64:
 998                         if(!get_sample_info_wave(&encoder_session, options))
 999                                 return EncoderSession_finish_error(&encoder_session);
1000                         break;
1001                 case FORMAT_AIFF:
1002                 case FORMAT_AIFF_C:
1003                         if(!get_sample_info_aiff(&encoder_session, options))
1004                                 return EncoderSession_finish_error(&encoder_session);
1005                         break;
1006                 case FORMAT_FLAC:
1007                 case FORMAT_OGGFLAC:
1008                         /*
1009                          * set up FLAC decoder for the input
1010                          */
1011                         if (0 == (encoder_session.fmt.flac.decoder = FLAC__stream_decoder_new())) {
1012                                 flac__utils_printf(stderr, 1, "%s: ERROR: creating decoder for FLAC input\n", encoder_session.inbasefilename);
1013                                 return EncoderSession_finish_error(&encoder_session);
1014                         }
1015                         if(!get_sample_info_flac(&encoder_session))
1016                                 return EncoderSession_finish_error(&encoder_session);
1017                         break;
1018                 default:
1019                         FLAC__ASSERT(0);
1020                         /* double protection */
1021                         return EncoderSession_finish_error(&encoder_session);
1022         }
1023
1024         /* some more checks */
1025         if(encoder_session.info.channels == 0 || encoder_session.info.channels > FLAC__MAX_CHANNELS) {
1026                 flac__utils_printf(stderr, 1, "%s: ERROR: unsupported number of channels %u\n", encoder_session.inbasefilename, encoder_session.info.channels);
1027                 return EncoderSession_finish_error(&encoder_session);
1028         }
1029         if(!FLAC__format_sample_rate_is_valid(encoder_session.info.sample_rate)) {
1030                 flac__utils_printf(stderr, 1, "%s: ERROR: unsupported sample rate %u\n", encoder_session.inbasefilename, encoder_session.info.sample_rate);
1031                 return EncoderSession_finish_error(&encoder_session);
1032         }
1033         if(encoder_session.info.bits_per_sample-encoder_session.info.shift < 4 || encoder_session.info.bits_per_sample-encoder_session.info.shift > 24) {
1034                 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);
1035                 return EncoderSession_finish_error(&encoder_session);
1036         }
1037         if(options.sector_align) {
1038                 if(encoder_session.info.channels != 2) {
1039                         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);
1040                         return EncoderSession_finish_error(&encoder_session);
1041                 }
1042                 if(encoder_session.info.sample_rate != 44100) {
1043                         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);
1044                         return EncoderSession_finish_error(&encoder_session);
1045                 }
1046                 if(encoder_session.info.bits_per_sample-encoder_session.info.shift != 16) {
1047                         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);
1048                         return EncoderSession_finish_error(&encoder_session);
1049                 }
1050         }
1051
1052         {
1053                 FLAC__uint64 total_samples_in_input; /* WATCHOUT: may be 0 to mean "unknown" */
1054                 FLAC__uint64 skip;
1055                 FLAC__uint64 until; /* a value of 0 mean end-of-stream (i.e. --until=-0) */
1056                 unsigned align_remainder = 0;
1057
1058                 switch(options.format) {
1059                         case FORMAT_RAW:
1060                                 if(infilesize < 0)
1061                                         total_samples_in_input = 0;
1062                                 else
1063                                         total_samples_in_input = (FLAC__uint64)infilesize / encoder_session.info.bytes_per_wide_sample + *options.align_reservoir_samples;
1064                                 break;
1065                         case FORMAT_WAVE:
1066                         case FORMAT_WAVE64:
1067                         case FORMAT_RF64:
1068                         case FORMAT_AIFF:
1069                         case FORMAT_AIFF_C:
1070                                 /* truncation in the division removes any padding byte that was counted in encoder_session.fmt.iff.data_bytes */
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, sample_rate, 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, unsigned sample_rate, 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, sample_rate, 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