src/flac/encode.c

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