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