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