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