src/flac/encode.c

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