add functions/switches for disabling certain subframe types for use by the test suite
[flac.git] / src / flac / encode.c
1 /* flac - Command-line FLAC encoder/decoder
2  * Copyright (C) 2000,2001,2002  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 defined _WIN32 && !defined __CYGWIN__
20 /* where MSVC puts unlink() */
21 # include <io.h>
22 #else
23 # include <unistd.h>
24 #endif
25 #include <limits.h> /* for LONG_MAX */
26 #include <math.h> /* for floor() */
27 #include <stdarg.h>
28 #include <stdio.h> /* for FILE etc. */
29 #include <stdlib.h> /* for malloc */
30 #include <string.h> /* for strcmp() */
31 #include "FLAC/all.h"
32 #include "encode.h"
33 #include "file.h"
34 #ifdef FLAC__HAS_OGG
35 #include "OggFLAC/stream_encoder.h"
36 #endif
37
38 #ifdef min
39 #undef min
40 #endif
41 #define min(x,y) ((x)<(y)?(x):(y))
42
43 /* this MUST be >= 588 so that sector aligning can take place with one read */
44 #define CHUNK_OF_SAMPLES 2048
45
46 typedef struct {
47 #ifdef FLAC__HAS_OGG
48         FLAC__bool use_ogg;
49 #endif
50         FLAC__bool verify;
51         FLAC__bool verbose;
52         FLAC__bool is_stdout;
53         const char *inbasefilename;
54         const char *outfilename;
55
56         FLAC__uint64 unencoded_size;
57         FLAC__uint64 total_samples_to_encode;
58         FLAC__uint64 bytes_written;
59         FLAC__uint64 samples_written;
60         unsigned blocksize;
61         unsigned stats_mask;
62
63         /*
64          * We use flac.stream for encoding native FLAC to stdout
65          * We use flac.file for encoding native FLAC to a regular file
66          * We use ogg.stream for encoding Ogg FLAC to either stdout or a regular file
67          */
68         union {
69                 union {
70                         FLAC__StreamEncoder *stream;
71                         FLAC__FileEncoder *file;
72                 } flac;
73 #ifdef FLAC__HAS_OGG
74                 union {
75                         OggFLAC__StreamEncoder *stream;
76                 } ogg;
77 #endif
78         } encoder;
79
80         FILE *fin;
81         FILE *fout;
82         FLAC__StreamMetadata *seek_table_template;
83 } EncoderSession;
84
85
86 static FLAC__bool is_big_endian_host_;
87
88 static unsigned char ucbuffer_[CHUNK_OF_SAMPLES*FLAC__MAX_CHANNELS*((FLAC__REFERENCE_CODEC_MAX_BITS_PER_SAMPLE+7)/8)];
89 static signed char *scbuffer_ = (signed char *)ucbuffer_;
90 static FLAC__uint16 *usbuffer_ = (FLAC__uint16 *)ucbuffer_;
91 static FLAC__int16 *ssbuffer_ = (FLAC__int16 *)ucbuffer_;
92
93 static FLAC__int32 in_[FLAC__MAX_CHANNELS][CHUNK_OF_SAMPLES];
94 static FLAC__int32 *input_[FLAC__MAX_CHANNELS];
95
96
97 /*
98  * unpublished debug routines from the FLAC libs
99  */
100 extern FLAC__bool FLAC__stream_encoder_disable_constant_subframes(FLAC__StreamEncoder *encoder, FLAC__bool value);
101 extern FLAC__bool FLAC__stream_encoder_disable_fixed_subframes(FLAC__StreamEncoder *encoder, FLAC__bool value);
102 extern FLAC__bool FLAC__stream_encoder_disable_verbatim_subframes(FLAC__StreamEncoder *encoder, FLAC__bool value);
103 extern FLAC__bool FLAC__file_encoder_disable_constant_subframes(FLAC__FileEncoder *encoder, FLAC__bool value);
104 extern FLAC__bool FLAC__file_encoder_disable_fixed_subframes(FLAC__FileEncoder *encoder, FLAC__bool value);
105 extern FLAC__bool FLAC__file_encoder_disable_verbatim_subframes(FLAC__FileEncoder *encoder, FLAC__bool value);
106 extern FLAC__bool OggFLAC__stream_encoder_disable_constant_subframes(OggFLAC__StreamEncoder *encoder, FLAC__bool value);
107 extern FLAC__bool OggFLAC__stream_encoder_disable_fixed_subframes(OggFLAC__StreamEncoder *encoder, FLAC__bool value);
108 extern FLAC__bool OggFLAC__stream_encoder_disable_verbatim_subframes(OggFLAC__StreamEncoder *encoder, FLAC__bool value);
109
110 /*
111  * local routines
112  */
113 static FLAC__bool EncoderSession_construct(EncoderSession *e, FLAC__bool use_ogg, FLAC__bool verify, FLAC__bool verbose, FILE *infile, const char *infilename, const char *outfilename);
114 static void EncoderSession_destroy(EncoderSession *e);
115 static int EncoderSession_finish_ok(EncoderSession *e, int info_align_carry, int info_align_zero);
116 static int EncoderSession_finish_error(EncoderSession *e);
117 static FLAC__bool EncoderSession_init_encoder(EncoderSession *e, encode_options_t options, unsigned channels, unsigned bps, unsigned sample_rate);
118 static FLAC__bool EncoderSession_process(EncoderSession *e, const FLAC__int32 * const buffer[], unsigned samples);
119 static FLAC__bool convert_to_seek_table_template(char *requested_seek_points, int num_requested_seek_points, EncoderSession *e);
120 static void format_input(FLAC__int32 *dest[], unsigned wide_samples, FLAC__bool is_big_endian, FLAC__bool is_unsigned_samples, unsigned channels, unsigned bps);
121 #ifdef FLAC__HAS_OGG
122 static FLAC__StreamEncoderWriteStatus ogg_stream_encoder_write_callback(const OggFLAC__StreamEncoder *encoder, const FLAC__byte buffer[], unsigned bytes, unsigned samples, unsigned current_frame, void *client_data);
123 #endif
124 static FLAC__StreamEncoderWriteStatus flac_stream_encoder_write_callback(const FLAC__StreamEncoder *encoder, const FLAC__byte buffer[], unsigned bytes, unsigned samples, unsigned current_frame, void *client_data);
125 static void flac_stream_encoder_metadata_callback(const FLAC__StreamEncoder *encoder, const FLAC__StreamMetadata *metadata, void *client_data);
126 static void flac_file_encoder_progress_callback(const FLAC__FileEncoder *encoder, FLAC__uint64 bytes_written, FLAC__uint64 samples_written, unsigned frames_written, unsigned total_frames_estimate, void *client_data);
127 static void print_stats(const EncoderSession *encoder_session);
128 static void print_error_with_state(const EncoderSession *e, const char *message);
129 static void print_verify_error(EncoderSession *e);
130 static FLAC__bool read_little_endian_uint16(FILE *f, FLAC__uint16 *val, FLAC__bool eof_ok, const char *fn);
131 static FLAC__bool read_little_endian_uint32(FILE *f, FLAC__uint32 *val, FLAC__bool eof_ok, const char *fn);
132 static FLAC__bool read_big_endian_uint16(FILE *f, FLAC__uint16 *val, FLAC__bool eof_ok, const char *fn);
133 static FLAC__bool read_big_endian_uint32(FILE *f, FLAC__uint32 *val, FLAC__bool eof_ok, const char *fn);
134 static FLAC__bool read_sane_extended(FILE *f, FLAC__uint32 *val, FLAC__bool eof_ok, const char *fn);
135
136 /*
137  * public routines
138  */
139 int
140 flac__encode_aif(FILE *infile, long infilesize, const char *infilename, const char *outfilename,
141         const FLAC__byte *lookahead, unsigned lookahead_length, wav_encode_options_t options)
142 {
143         EncoderSession encoder_session;
144         FLAC__uint16 x;
145         FLAC__uint32 xx;
146         unsigned int channels= 0U, bps= 0U, sample_rate= 0U, sample_frames= 0U;
147         FLAC__bool got_comm_chunk= false, got_ssnd_chunk= false;
148         int info_align_carry= -1, info_align_zero= -1;
149
150         FLAC__ASSERT(!options.common.sector_align || options.common.skip == 0);
151
152         (void)infilesize; /* silence compiler warning about unused parameter */
153         (void)lookahead; /* silence compiler warning about unused parameter */
154         (void)lookahead_length; /* silence compiler warning about unused parameter */
155
156         if(!
157                 EncoderSession_construct(
158                         &encoder_session,
159 #ifdef FLAC__HAS_OGG
160                         options.common.use_ogg,
161 #else
162                         /*use_ogg=*/false,
163 #endif
164                         options.common.verify,
165                         options.common.verbose,
166                         infile,
167                         infilename,
168                         outfilename
169                 )
170         )
171                 return 1;
172
173         /* lookahead[] already has "FORMxxxxAIFF", do sub-chunks */
174
175         while(1) {
176                 size_t c= 0U;
177                 char chunk_id[4];
178
179                 /* chunk identifier; really conservative about behavior of fread() and feof() */
180                 if(feof(infile) || ((c= fread(chunk_id, 1U, 4U, infile)), c==0U && feof(infile)))
181                         break;
182                 else if(c<4U || feof(infile)) {
183                         fprintf(stderr, "%s: ERROR: incomplete chunk identifier\n", encoder_session.inbasefilename);
184                         return EncoderSession_finish_error(&encoder_session);
185                 }
186
187                 if(got_comm_chunk==false && !strncmp(chunk_id, "COMM", 4)) { /* common chunk */
188                         unsigned long skip;
189
190                         /* COMM chunk size */
191                         if(!read_big_endian_uint32(infile, &xx, false, encoder_session.inbasefilename))
192                                 return EncoderSession_finish_error(&encoder_session);
193                         else if(xx<18U) {
194                                 fprintf(stderr, "%s: ERROR: non-standard 'COMM' chunk has length = %u\n", encoder_session.inbasefilename, (unsigned int)xx);
195                                 return EncoderSession_finish_error(&encoder_session);
196                         }
197                         else if(xx!=18U)
198                                 fprintf(stderr, "%s: WARNING: non-standard 'COMM' chunk has length = %u\n", encoder_session.inbasefilename, (unsigned int)xx);
199                         skip= (xx-18U)+(xx & 1U);
200
201                         /* number of channels */
202                         if(!read_big_endian_uint16(infile, &x, false, encoder_session.inbasefilename))
203                                 return EncoderSession_finish_error(&encoder_session);
204                         else if(x==0U || x>FLAC__MAX_CHANNELS) {
205                                 fprintf(stderr, "%s: ERROR: unsupported number channels %u\n", encoder_session.inbasefilename, (unsigned int)x);
206                                 return EncoderSession_finish_error(&encoder_session);
207                         }
208                         else if(options.common.sector_align && x!=2U) {
209                                 fprintf(stderr, "%s: ERROR: file has %u channels, must be 2 for --sector-align\n", encoder_session.inbasefilename, (unsigned int)x);
210                                 return EncoderSession_finish_error(&encoder_session);
211                         }
212                         channels= x;
213
214                         /* number of sample frames */
215                         if(!read_big_endian_uint32(infile, &xx, false, encoder_session.inbasefilename))
216                                 return EncoderSession_finish_error(&encoder_session);
217                         sample_frames= xx;
218
219                         /* bits per sample */
220                         if(!read_big_endian_uint16(infile, &x, false, encoder_session.inbasefilename))
221                                 return EncoderSession_finish_error(&encoder_session);
222                         else if(x!=8U && x!=16U && x!=24U) {
223                                 fprintf(stderr, "%s: ERROR: unsupported bits per sample %u\n", encoder_session.inbasefilename, (unsigned int)x);
224                                 return EncoderSession_finish_error(&encoder_session);
225                         }
226                         else if(options.common.sector_align && x!=16U) {
227                                 fprintf(stderr, "%s: ERROR: file has %u bits per sample, must be 16 for --sector-align\n", encoder_session.inbasefilename, (unsigned int)x);
228                                 return EncoderSession_finish_error(&encoder_session);
229                         }
230                         bps= x;
231
232                         /* sample rate */
233                         if(!read_sane_extended(infile, &xx, false, encoder_session.inbasefilename))
234                                 return EncoderSession_finish_error(&encoder_session);
235                         else if(!FLAC__format_sample_rate_is_valid(xx)) {
236                                 fprintf(stderr, "%s: ERROR: unsupported sample rate %u\n", encoder_session.inbasefilename, (unsigned int)xx);
237                                 return EncoderSession_finish_error(&encoder_session);
238                         }
239                         else if(options.common.sector_align && xx!=44100U) {
240                                 fprintf(stderr, "%s: ERROR: file's sample rate is %u, must be 44100 for --sector-align\n", encoder_session.inbasefilename, (unsigned int)xx);
241                                 return EncoderSession_finish_error(&encoder_session);
242                         }
243                         sample_rate= xx;
244
245                         /* skip any extra data in the COMM chunk */
246                         FLAC__ASSERT(skip<=LONG_MAX);
247                         while(skip>0U && fseek(infile, skip, SEEK_CUR)<0) {
248                                 unsigned int need= min(skip, sizeof ucbuffer_);
249                                 if(fread(ucbuffer_, 1U, need, infile)<need) {
250                                         fprintf(stderr, "%s: ERROR during read while skipping extra COMM data\n", encoder_session.inbasefilename);
251                                         return EncoderSession_finish_error(&encoder_session);
252                                 }
253                                 skip-= need;
254                         }
255
256                         got_comm_chunk= true;
257                 }
258                 else if(got_ssnd_chunk==false && !strncmp(chunk_id, "SSND", 4)) { /* sound data chunk */
259                         unsigned int offset= 0U, block_size= 0U, align_remainder= 0U, data_bytes;
260                         size_t bytes_per_frame= channels*(bps>>3);
261                         FLAC__bool pad= false;
262
263                         if(got_comm_chunk==false) {
264                                 fprintf(stderr, "%s: ERROR: got 'SSND' chunk before 'COMM' chunk\n", encoder_session.inbasefilename);
265                                 return EncoderSession_finish_error(&encoder_session);
266                         }
267
268                         /* SSND chunk size */
269                         if(!read_big_endian_uint32(infile, &xx, false, encoder_session.inbasefilename))
270                                 return EncoderSession_finish_error(&encoder_session);
271                         else if(xx!=(sample_frames*bytes_per_frame + 8U)) {
272                                 fprintf(stderr, "%s: ERROR: SSND chunk size inconsistent with sample frame count\n", encoder_session.inbasefilename);
273                                 return EncoderSession_finish_error(&encoder_session);
274                         }
275                         data_bytes= xx;
276                         pad= (data_bytes & 1U) ? true : false;
277
278                         /* offset */
279                         if(!read_big_endian_uint32(infile, &xx, false, encoder_session.inbasefilename))
280                                 return EncoderSession_finish_error(&encoder_session);
281                         else if(xx!=0U) {
282                                 fprintf(stderr, "%s: ERROR: offset is %u; must be 0\n", encoder_session.inbasefilename, (unsigned int)xx);
283                                 return EncoderSession_finish_error(&encoder_session);
284                         }
285                         offset= xx;
286
287                         /* block size */
288                         if(!read_big_endian_uint32(infile, &xx, false, encoder_session.inbasefilename))
289                                 return EncoderSession_finish_error(&encoder_session);
290                         else if(xx!=0U) {
291                                 fprintf(stderr, "%s: ERROR: block size is %u; must be 0\n", encoder_session.inbasefilename, (unsigned int)xx);
292                                 return EncoderSession_finish_error(&encoder_session);
293                         }
294                         block_size= xx;
295
296                         if(options.common.skip>0U) {
297                                 FLAC__uint64 remaining= options.common.skip*bytes_per_frame;
298
299                                 /* do 1<<30 bytes at a time, since 1<<30 is a nice round number, and */
300                                 /* is guaranteed to be less than LONG_MAX */
301                                 for(; remaining>0U; remaining-= remaining>(1U<<30) ? remaining : (1U<<30))
302                                 {
303                                         unsigned long skip= (unsigned long)(remaining % (1U<<30));
304
305                                         FLAC__ASSERT(skip<=LONG_MAX);
306                                         while(skip>0 && fseek(infile, skip, SEEK_CUR)<0) {
307                                                 unsigned int need= min(skip, sizeof ucbuffer_);
308                                                 if(fread(ucbuffer_, 1U, need, infile)<need) {
309                                                         fprintf(stderr, "%s: ERROR during read while skipping samples\n", encoder_session.inbasefilename);
310                                                         return EncoderSession_finish_error(&encoder_session);
311                                                 }
312                                                 skip-= need;
313                                         }
314                                 }
315                         }
316
317                         data_bytes-= (8U + (unsigned int)options.common.skip*bytes_per_frame); /*@@@ WATCHOUT: 4GB limit */
318                         encoder_session.total_samples_to_encode= data_bytes/bytes_per_frame + *options.common.align_reservoir_samples;
319                         if(options.common.sector_align) {
320                                 align_remainder= (unsigned int)(encoder_session.total_samples_to_encode % 588U);
321                                 if(options.common.is_last_file)
322                                         encoder_session.total_samples_to_encode+= (588U-align_remainder); /* will pad with zeroes */
323                                 else
324                                         encoder_session.total_samples_to_encode-= align_remainder; /* will stop short and carry over to next file */
325                         }
326
327                         /* +54 for the size of the AIFF headers; this is just an estimate for the progress indicator and doesn't need to be exact */
328                         encoder_session.unencoded_size= encoder_session.total_samples_to_encode*bytes_per_frame+54;
329
330                         if(!EncoderSession_init_encoder(&encoder_session, options.common, channels, bps, sample_rate))
331                                 return EncoderSession_finish_error(&encoder_session);
332
333                         /* first do any samples in the reservoir */
334                         if(options.common.sector_align && *options.common.align_reservoir_samples>0U) {
335
336                                 if(!EncoderSession_process(&encoder_session, (const FLAC__int32 *const *)options.common.align_reservoir, *options.common.align_reservoir_samples)) {
337                                         print_error_with_state(&encoder_session, "ERROR during encoding");
338                                         return EncoderSession_finish_error(&encoder_session);
339                                 }
340                         }
341
342                         /* decrement the data_bytes counter if we need to align the file */
343                         if(options.common.sector_align) {
344                                 if(options.common.is_last_file)
345                                         *options.common.align_reservoir_samples= 0U;
346                                 else {
347                                         *options.common.align_reservoir_samples= align_remainder;
348                                         data_bytes-= (*options.common.align_reservoir_samples)*bytes_per_frame;
349                                 }
350                         }
351
352                         /* now do from the file */
353                         while(data_bytes>0) {
354                                 size_t bytes_read= fread(ucbuffer_, 1U, min(data_bytes, CHUNK_OF_SAMPLES*bytes_per_frame), infile);
355
356                                 if(bytes_read==0U) {
357                                         if(ferror(infile)) {
358                                                 fprintf(stderr, "%s: ERROR during read\n", encoder_session.inbasefilename);
359                                                 return EncoderSession_finish_error(&encoder_session);
360                                         }
361                                         else if(feof(infile)) {
362                                                 fprintf(stderr, "%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);
363                                                 data_bytes= 0;
364                                         }
365                                 }
366                                 else {
367                                         if(bytes_read % bytes_per_frame != 0U) {
368                                                 fprintf(stderr, "%s: ERROR: got partial sample\n", encoder_session.inbasefilename);
369                                                 return EncoderSession_finish_error(&encoder_session);
370                                         }
371                                         else {
372                                                 unsigned int frames= bytes_read/bytes_per_frame;
373                                                 format_input(input_, frames, true, false, channels, bps);
374
375                                                 if(!EncoderSession_process(&encoder_session, (const FLAC__int32 *const *)input_, frames)) {
376                                                         print_error_with_state(&encoder_session, "ERROR during encoding");
377                                                         return EncoderSession_finish_error(&encoder_session);
378                                                 }
379                                                 else
380                                                         data_bytes-= bytes_read;
381                                         }
382                                 }
383                         }
384
385                         /* now read unaligned samples into reservoir or pad with zeroes if necessary */
386                         if(options.common.sector_align) {
387                                 if(options.common.is_last_file) {
388                                         unsigned int pad_frames= 588U-align_remainder;
389
390                                         if(pad_frames<588U) {
391                                                 unsigned int i;
392
393                                                 info_align_zero= pad_frames;
394                                                 for(i= 0U; i<channels; ++i)
395                                                         memset(input_[i], 0, pad_frames*(bps>>3));
396
397                                                 if(!EncoderSession_process(&encoder_session, (const FLAC__int32 *const *)input_, pad_frames)) {
398                                                         print_error_with_state(&encoder_session, "ERROR during encoding");
399                                                         return EncoderSession_finish_error(&encoder_session);
400                                                 }
401                                         }
402                                 }
403                                 else {
404                                         if(*options.common.align_reservoir_samples > 0) {
405                                                 size_t bytes_read= fread(ucbuffer_, 1U, (*options.common.align_reservoir_samples)*bytes_per_frame, infile);
406
407                                                 FLAC__ASSERT(CHUNK_OF_SAMPLES>=588U);
408                                                 if(bytes_read==0U && ferror(infile)) {
409                                                         fprintf(stderr, "%s: ERROR during read\n", encoder_session.inbasefilename);
410                                                         return EncoderSession_finish_error(&encoder_session);
411                                                 }
412                                                 else if(bytes_read != (*options.common.align_reservoir_samples) * bytes_per_frame)
413                                                         fprintf(stderr, "%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);
414                                                 else {
415                                                         info_align_carry= *options.common.align_reservoir_samples;
416                                                         format_input(options.common.align_reservoir, *options.common.align_reservoir_samples, true, false, channels, bps);
417                                                 }
418                                         }
419                                 }
420                         }
421
422                         if(pad==true) {
423                                 unsigned char tmp;
424
425                                 if(fread(&tmp, 1U, 1U, infile)<1U) {
426                                         fprintf(stderr, "%s: ERROR during read of SSND pad byte\n", encoder_session.inbasefilename);
427                                         return EncoderSession_finish_error(&encoder_session);
428                                 }
429                         }
430
431                         got_ssnd_chunk= true;
432                 }
433                 else { /* other chunk */
434                         if(!strncmp(chunk_id, "COMM", 4))
435                                 fprintf(stderr, "%s: WARNING: skipping extra 'COMM' chunk\n", encoder_session.inbasefilename);
436                         else if(!strncmp(chunk_id, "SSND", 4))
437                                 fprintf(stderr, "%s: WARNING: skipping extra 'SSND' chunk\n", encoder_session.inbasefilename);
438                         else
439                                 fprintf(stderr, "%s: WARNING: skipping unknown chunk '%s'\n", encoder_session.inbasefilename, chunk_id);
440
441                         /* chunk size */
442                         if(!read_big_endian_uint32(infile, &xx, false, encoder_session.inbasefilename))
443                                 return EncoderSession_finish_error(&encoder_session);
444                         else {
445                                 unsigned long skip= xx+(xx & 1U);
446
447                                 FLAC__ASSERT(skip<=LONG_MAX);
448                                 while(skip>0U && fseek(infile, skip, SEEK_CUR)<0) {
449                                         unsigned int need= min(skip, sizeof ucbuffer_);
450                                         if(fread(ucbuffer_, 1U, need, infile)<need) {
451                                                 fprintf(stderr, "%s: ERROR during read while skipping unknown chunk\n", encoder_session.inbasefilename);
452                                                 return EncoderSession_finish_error(&encoder_session);
453                                         }
454                                         skip-= need;
455                                 }
456                         }
457                 }
458         }
459
460         if(got_ssnd_chunk==false && sample_frames!=0U) {
461                 fprintf(stderr, "%s: ERROR: missing SSND chunk\n", encoder_session.inbasefilename);
462                 return EncoderSession_finish_error(&encoder_session);
463         }
464
465         return EncoderSession_finish_ok(&encoder_session, info_align_carry, info_align_zero);
466 }
467
468 int flac__encode_wav(FILE *infile, long infilesize, const char *infilename, const char *outfilename, const FLAC__byte *lookahead, unsigned lookahead_length, wav_encode_options_t options)
469 {
470         EncoderSession encoder_session;
471         FLAC__bool is_unsigned_samples = false;
472         unsigned channels = 0, bps = 0, sample_rate = 0, data_bytes;
473         size_t bytes_per_wide_sample, bytes_read;
474         FLAC__uint16 x;
475         FLAC__uint32 xx;
476         FLAC__bool got_fmt_chunk = false, got_data_chunk = false;
477         unsigned align_remainder = 0;
478         int info_align_carry = -1, info_align_zero = -1;
479
480         FLAC__ASSERT(!options.common.sector_align || options.common.skip == 0);
481
482         (void)infilesize;
483         (void)lookahead;
484         (void)lookahead_length;
485
486         if(!
487                 EncoderSession_construct(
488                         &encoder_session,
489 #ifdef FLAC__HAS_OGG
490                         options.common.use_ogg,
491 #else
492                         /*use_ogg=*/false,
493 #endif
494                         options.common.verify,
495                         options.common.verbose,
496                         infile,
497                         infilename,
498                         outfilename
499                 )
500         )
501                 return 1;
502
503         /*
504          * lookahead[] already has "RIFFxxxxWAVE", do sub-chunks
505          */
506         while(!feof(infile)) {
507                 if(!read_little_endian_uint32(infile, &xx, true, encoder_session.inbasefilename))
508                         return EncoderSession_finish_error(&encoder_session);
509                 if(feof(infile))
510                         break;
511                 if(xx == 0x20746d66 && !got_fmt_chunk) { /* "fmt " */
512                         /* fmt sub-chunk size */
513                         if(!read_little_endian_uint32(infile, &xx, false, encoder_session.inbasefilename))
514                                 return EncoderSession_finish_error(&encoder_session);
515                         if(xx < 16) {
516                                 fprintf(stderr, "%s: ERROR: found non-standard 'fmt ' sub-chunk which has length = %u\n", encoder_session.inbasefilename, (unsigned)xx);
517                                 return EncoderSession_finish_error(&encoder_session);
518                         }
519                         else if(xx != 16 && xx != 18) {
520                                 fprintf(stderr, "%s: WARNING: found non-standard 'fmt ' sub-chunk which has length = %u\n", encoder_session.inbasefilename, (unsigned)xx);
521                         }
522                         data_bytes = xx;
523                         /* compression code */
524                         if(!read_little_endian_uint16(infile, &x, false, encoder_session.inbasefilename))
525                                 return EncoderSession_finish_error(&encoder_session);
526                         if(x != 1) {
527                                 fprintf(stderr, "%s: ERROR: unsupported compression type %u\n", encoder_session.inbasefilename, (unsigned)x);
528                                 return EncoderSession_finish_error(&encoder_session);
529                         }
530                         /* number of channels */
531                         if(!read_little_endian_uint16(infile, &x, false, encoder_session.inbasefilename))
532                                 return EncoderSession_finish_error(&encoder_session);
533                         if(x == 0 || x > FLAC__MAX_CHANNELS) {
534                                 fprintf(stderr, "%s: ERROR: unsupported number channels %u\n", encoder_session.inbasefilename, (unsigned)x);
535                                 return EncoderSession_finish_error(&encoder_session);
536                         }
537                         else if(options.common.sector_align && x != 2) {
538                                 fprintf(stderr, "%s: ERROR: file has %u channels, must be 2 for --sector-align\n", encoder_session.inbasefilename, (unsigned)x);
539                                 return EncoderSession_finish_error(&encoder_session);
540                         }
541                         channels = x;
542                         /* sample rate */
543                         if(!read_little_endian_uint32(infile, &xx, false, encoder_session.inbasefilename))
544                                 return EncoderSession_finish_error(&encoder_session);
545                         if(!FLAC__format_sample_rate_is_valid(xx)) {
546                                 fprintf(stderr, "%s: ERROR: unsupported sample rate %u\n", encoder_session.inbasefilename, (unsigned)xx);
547                                 return EncoderSession_finish_error(&encoder_session);
548                         }
549                         else if(options.common.sector_align && xx != 44100) {
550                                 fprintf(stderr, "%s: ERROR: file's sample rate is %u, must be 44100 for --sector-align\n", encoder_session.inbasefilename, (unsigned)xx);
551                                 return EncoderSession_finish_error(&encoder_session);
552                         }
553                         sample_rate = xx;
554                         /* avg bytes per second (ignored) */
555                         if(!read_little_endian_uint32(infile, &xx, false, encoder_session.inbasefilename))
556                                 return EncoderSession_finish_error(&encoder_session);
557                         /* block align (ignored) */
558                         if(!read_little_endian_uint16(infile, &x, false, encoder_session.inbasefilename))
559                                 return EncoderSession_finish_error(&encoder_session);
560                         /* bits per sample */
561                         if(!read_little_endian_uint16(infile, &x, false, encoder_session.inbasefilename))
562                                 return EncoderSession_finish_error(&encoder_session);
563                         if(x != 8 && x != 16 && x != 24) {
564                                 fprintf(stderr, "%s: ERROR: unsupported bits per sample %u\n", encoder_session.inbasefilename, (unsigned)x);
565                                 return EncoderSession_finish_error(&encoder_session);
566                         }
567                         else if(options.common.sector_align && x != 16) {
568                                 fprintf(stderr, "%s: ERROR: file has %u bits per sample, must be 16 for --sector-align\n", encoder_session.inbasefilename, (unsigned)x);
569                                 return EncoderSession_finish_error(&encoder_session);
570                         }
571                         bps = x;
572                         is_unsigned_samples = (x == 8);
573
574                         /* skip any extra data in the fmt sub-chunk */
575                         data_bytes -= 16;
576                         if(data_bytes > 0) {
577                                 unsigned left, need;
578                                 for(left = data_bytes; left > 0; ) {
579                                         need = min(left, CHUNK_OF_SAMPLES);
580                                         if(fread(ucbuffer_, 1U, need, infile) < need) {
581                                                 fprintf(stderr, "%s: ERROR during read while skipping samples\n", encoder_session.inbasefilename);
582                                                 return EncoderSession_finish_error(&encoder_session);
583                                         }
584                                         left -= need;
585                                 }
586                         }
587
588                         got_fmt_chunk = true;
589                 }
590                 else if(xx == 0x61746164 && !got_data_chunk && got_fmt_chunk) { /* "data" */
591                         /* data size */
592                         if(!read_little_endian_uint32(infile, &xx, false, encoder_session.inbasefilename))
593                                 return EncoderSession_finish_error(&encoder_session);
594                         data_bytes = xx;
595
596                         bytes_per_wide_sample = channels * (bps >> 3);
597
598                         if(options.common.skip > 0) {
599                                 if(fseek(infile, bytes_per_wide_sample * (unsigned)options.common.skip, SEEK_CUR) < 0) {
600                                         /* can't seek input, read ahead manually... */
601                                         unsigned left, need;
602                                         for(left = (unsigned)options.common.skip; left > 0; ) { /*@@@ WATCHOUT: 4GB limit */
603                                                 need = min(left, CHUNK_OF_SAMPLES);
604                                                 if(fread(ucbuffer_, bytes_per_wide_sample, need, infile) < need) {
605                                                         fprintf(stderr, "%s: ERROR during read while skipping samples\n", encoder_session.inbasefilename);
606                                                         return EncoderSession_finish_error(&encoder_session);
607                                                 }
608                                                 left -= need;
609                                         }
610                                 }
611                         }
612
613                         data_bytes -= (unsigned)options.common.skip * bytes_per_wide_sample; /*@@@ WATCHOUT: 4GB limit */
614                         encoder_session.total_samples_to_encode = data_bytes / bytes_per_wide_sample + *options.common.align_reservoir_samples;
615                         if(options.common.sector_align) {
616                                 align_remainder = (unsigned)(encoder_session.total_samples_to_encode % 588);
617                                 if(options.common.is_last_file)
618                                         encoder_session.total_samples_to_encode += (588-align_remainder); /* will pad with zeroes */
619                                 else
620                                         encoder_session.total_samples_to_encode -= align_remainder; /* will stop short and carry over to next file */
621                         }
622
623                         /* +44 for the size of the WAV headers; this is just an estimate for the progress indicator and doesn't need to be exact */
624                         encoder_session.unencoded_size = encoder_session.total_samples_to_encode * bytes_per_wide_sample + 44;
625
626                         if(!EncoderSession_init_encoder(&encoder_session, options.common, channels, bps, sample_rate))
627                                 return EncoderSession_finish_error(&encoder_session);
628
629                         /*
630                          * first do any samples in the reservoir
631                          */
632                         if(options.common.sector_align && *options.common.align_reservoir_samples > 0) {
633                                 if(!EncoderSession_process(&encoder_session, (const FLAC__int32 * const *)options.common.align_reservoir, *options.common.align_reservoir_samples)) {
634                                         print_error_with_state(&encoder_session, "ERROR during encoding");
635                                         return EncoderSession_finish_error(&encoder_session);
636                                 }
637                         }
638
639                         /*
640                          * decrement the data_bytes counter if we need to align the file
641                          */
642                         if(options.common.sector_align) {
643                                 if(options.common.is_last_file) {
644                                         *options.common.align_reservoir_samples = 0;
645                                 }
646                                 else {
647                                         *options.common.align_reservoir_samples = align_remainder;
648                                         data_bytes -= (*options.common.align_reservoir_samples) * bytes_per_wide_sample;
649                                 }
650                         }
651
652                         /*
653                          * now do from the file
654                          */
655                         while(data_bytes > 0) {
656                                 bytes_read = fread(ucbuffer_, sizeof(unsigned char), min(data_bytes, CHUNK_OF_SAMPLES * bytes_per_wide_sample), infile);
657                                 if(bytes_read == 0) {
658                                         if(ferror(infile)) {
659                                                 fprintf(stderr, "%s: ERROR during read\n", encoder_session.inbasefilename);
660                                                 return EncoderSession_finish_error(&encoder_session);
661                                         }
662                                         else if(feof(infile)) {
663                                                 fprintf(stderr, "%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);
664                                                 data_bytes = 0;
665                                         }
666                                 }
667                                 else {
668                                         if(bytes_read % bytes_per_wide_sample != 0) {
669                                                 fprintf(stderr, "%s: ERROR: got partial sample\n", encoder_session.inbasefilename);
670                                                 return EncoderSession_finish_error(&encoder_session);
671                                         }
672                                         else {
673                                                 unsigned wide_samples = bytes_read / bytes_per_wide_sample;
674                                                 format_input(input_, wide_samples, false, is_unsigned_samples, channels, bps);
675
676                                                 if(!EncoderSession_process(&encoder_session, (const FLAC__int32 * const *)input_, wide_samples)) {
677                                                         print_error_with_state(&encoder_session, "ERROR during encoding");
678                                                         return EncoderSession_finish_error(&encoder_session);
679                                                 }
680                                                 data_bytes -= bytes_read;
681                                         }
682                                 }
683                         }
684
685                         /*
686                          * now read unaligned samples into reservoir or pad with zeroes if necessary
687                          */
688                         if(options.common.sector_align) {
689                                 if(options.common.is_last_file) {
690                                         unsigned wide_samples = 588 - align_remainder;
691                                         if(wide_samples < 588) {
692                                                 unsigned channel;
693
694                                                 info_align_zero = wide_samples;
695                                                 data_bytes = wide_samples * (bps >> 3);
696                                                 for(channel = 0; channel < channels; channel++)
697                                                         memset(input_[channel], 0, data_bytes);
698
699                                                 if(!EncoderSession_process(&encoder_session, (const FLAC__int32 * const *)input_, wide_samples)) {
700                                                         print_error_with_state(&encoder_session, "ERROR during encoding");
701                                                         return EncoderSession_finish_error(&encoder_session);
702                                                 }
703                                         }
704                                 }
705                                 else {
706                                         if(*options.common.align_reservoir_samples > 0) {
707                                                 FLAC__ASSERT(CHUNK_OF_SAMPLES >= 588);
708                                                 bytes_read = fread(ucbuffer_, sizeof(unsigned char), (*options.common.align_reservoir_samples) * bytes_per_wide_sample, infile);
709                                                 if(bytes_read == 0 && ferror(infile)) {
710                                                         fprintf(stderr, "%s: ERROR during read\n", encoder_session.inbasefilename);
711                                                         return EncoderSession_finish_error(&encoder_session);
712                                                 }
713                                                 else if(bytes_read != (*options.common.align_reservoir_samples) * bytes_per_wide_sample) {
714                                                         fprintf(stderr, "%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);
715                                                         data_bytes = 0;
716                                                 }
717                                                 else {
718                                                         info_align_carry = *options.common.align_reservoir_samples;
719                                                         format_input(options.common.align_reservoir, *options.common.align_reservoir_samples, false, is_unsigned_samples, channels, bps);
720                                                 }
721                                         }
722                                 }
723                         }
724
725                         got_data_chunk = true;
726                 }
727                 else {
728                         if(xx == 0x20746d66 && got_fmt_chunk) { /* "fmt " */
729                                 fprintf(stderr, "%s: WARNING: skipping extra 'fmt ' sub-chunk\n", encoder_session.inbasefilename);
730                         }
731                         else if(xx == 0x61746164) { /* "data" */
732                                 if(got_data_chunk) {
733                                         fprintf(stderr, "%s: WARNING: skipping extra 'data' sub-chunk\n", encoder_session.inbasefilename);
734                                 }
735                                 else if(!got_fmt_chunk) {
736                                         fprintf(stderr, "%s: ERROR: got 'data' sub-chunk before 'fmt' sub-chunk\n", encoder_session.inbasefilename);
737                                         return EncoderSession_finish_error(&encoder_session);
738                                 }
739                                 else {
740                                         FLAC__ASSERT(0);
741                                 }
742                         }
743                         else {
744                                 fprintf(stderr, "%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));
745                         }
746                         /* sub-chunk size */
747                         if(!read_little_endian_uint32(infile, &xx, false, encoder_session.inbasefilename))
748                                 return EncoderSession_finish_error(&encoder_session);
749                         if(fseek(infile, xx, SEEK_CUR) < 0) {
750                                 /* can't seek input, read ahead manually... */
751                                 unsigned left, need;
752                                 const unsigned chunk = sizeof(ucbuffer_);
753                                 for(left = xx; left > 0; ) {
754                                         need = min(left, chunk);
755                                         if(fread(ucbuffer_, 1, need, infile) < need) {
756                                                 fprintf(stderr, "%s: ERROR during read while skipping unsupported sub-chunk\n", encoder_session.inbasefilename);
757                                                 return EncoderSession_finish_error(&encoder_session);
758                                         }
759                                         left -= need;
760                                 }
761                         }
762                 }
763         }
764
765         return EncoderSession_finish_ok(&encoder_session, info_align_carry, info_align_zero);
766 }
767
768 int flac__encode_raw(FILE *infile, long infilesize, const char *infilename, const char *outfilename, const FLAC__byte *lookahead, unsigned lookahead_length, raw_encode_options_t options)
769 {
770         EncoderSession encoder_session;
771         size_t bytes_read;
772         const size_t bytes_per_wide_sample = options.channels * (options.bps >> 3);
773         unsigned align_remainder = 0;
774         int info_align_carry = -1, info_align_zero = -1;
775
776         FLAC__ASSERT(!options.common.sector_align || options.common.skip == 0);
777         FLAC__ASSERT(!options.common.sector_align || options.channels == 2);
778         FLAC__ASSERT(!options.common.sector_align || options.bps == 16);
779         FLAC__ASSERT(!options.common.sector_align || options.sample_rate == 44100);
780         FLAC__ASSERT(!options.common.sector_align || infilesize >= 0);
781
782         if(!
783                 EncoderSession_construct(
784                         &encoder_session,
785 #ifdef FLAC__HAS_OGG
786                         options.common.use_ogg,
787 #else
788                         /*use_ogg=*/false,
789 #endif
790                         options.common.verify,
791                         options.common.verbose,
792                         infile,
793                         infilename,
794                         outfilename
795                 )
796         )
797                 return 1;
798
799         /* get the file length */
800         if(infilesize < 0) {
801                 encoder_session.total_samples_to_encode = encoder_session.unencoded_size = 0;
802         }
803         else {
804                 if(options.common.sector_align) {
805                         FLAC__ASSERT(options.common.skip == 0);
806                         encoder_session.total_samples_to_encode = (unsigned)infilesize / bytes_per_wide_sample + *options.common.align_reservoir_samples;
807                         align_remainder = (unsigned)(encoder_session.total_samples_to_encode % 588);
808                         if(options.common.is_last_file)
809                                 encoder_session.total_samples_to_encode += (588-align_remainder); /* will pad with zeroes */
810                         else
811                                 encoder_session.total_samples_to_encode -= align_remainder; /* will stop short and carry over to next file */
812                 }
813                 else {
814                         encoder_session.total_samples_to_encode = (unsigned)infilesize / bytes_per_wide_sample - options.common.skip;
815                 }
816
817                 encoder_session.unencoded_size = encoder_session.total_samples_to_encode * bytes_per_wide_sample;
818         }
819
820         if(encoder_session.verbose && encoder_session.total_samples_to_encode <= 0)
821                 fprintf(stderr, "(No runtime statistics possible; please wait for encoding to finish...)\n");
822
823         if(options.common.skip > 0) {
824                 unsigned skip_bytes = bytes_per_wide_sample * (unsigned)options.common.skip;
825                 if(skip_bytes > lookahead_length) {
826                         skip_bytes -= lookahead_length;
827                         lookahead_length = 0;
828                         if(fseek(infile, (long)skip_bytes, SEEK_CUR) < 0) {
829                                 /* can't seek input, read ahead manually... */
830                                 unsigned left, need;
831                                 const unsigned chunk = sizeof(ucbuffer_);
832                                 for(left = skip_bytes; left > 0; ) {
833                                         need = min(left, chunk);
834                                         if(fread(ucbuffer_, 1, need, infile) < need) {
835                                                 fprintf(stderr, "%s: ERROR during read while skipping samples\n", encoder_session.inbasefilename);
836                                                 return EncoderSession_finish_error(&encoder_session);
837                                         }
838                                         left -= need;
839                                 }
840                         }
841                 }
842                 else {
843                         lookahead += skip_bytes;
844                         lookahead_length -= skip_bytes;
845                 }
846         }
847
848         if(!EncoderSession_init_encoder(&encoder_session, options.common, options.channels, options.bps, options.sample_rate))
849                 return EncoderSession_finish_error(&encoder_session);
850
851         /*
852          * first do any samples in the reservoir
853          */
854         if(options.common.sector_align && *options.common.align_reservoir_samples > 0) {
855                 if(!EncoderSession_process(&encoder_session, (const FLAC__int32 * const *)options.common.align_reservoir, *options.common.align_reservoir_samples)) {
856                         print_error_with_state(&encoder_session, "ERROR during encoding");
857                         return EncoderSession_finish_error(&encoder_session);
858                 }
859         }
860
861         /*
862          * decrement infilesize if we need to align the file
863          */
864         if(options.common.sector_align) {
865                 FLAC__ASSERT(infilesize >= 0);
866                 if(options.common.is_last_file) {
867                         *options.common.align_reservoir_samples = 0;
868                 }
869                 else {
870                         *options.common.align_reservoir_samples = align_remainder;
871                         infilesize -= (long)((*options.common.align_reservoir_samples) * bytes_per_wide_sample);
872                 }
873         }
874
875         /*
876          * now do from the file
877          */
878         while(!feof(infile)) {
879                 if(lookahead_length > 0) {
880                         FLAC__ASSERT(lookahead_length < CHUNK_OF_SAMPLES * bytes_per_wide_sample);
881                         memcpy(ucbuffer_, lookahead, lookahead_length);
882                         bytes_read = fread(ucbuffer_+lookahead_length, sizeof(unsigned char), CHUNK_OF_SAMPLES * bytes_per_wide_sample - lookahead_length, infile) + lookahead_length;
883                         if(ferror(infile)) {
884                                 fprintf(stderr, "%s: ERROR during read\n", encoder_session.inbasefilename);
885                                 return EncoderSession_finish_error(&encoder_session);
886                         }
887                         lookahead_length = 0;
888                 }
889                 else
890                         bytes_read = fread(ucbuffer_, sizeof(unsigned char), CHUNK_OF_SAMPLES * bytes_per_wide_sample, infile);
891
892                 if(bytes_read == 0) {
893                         if(ferror(infile)) {
894                                 fprintf(stderr, "%s: ERROR during read\n", encoder_session.inbasefilename);
895                                 return EncoderSession_finish_error(&encoder_session);
896                         }
897                 }
898                 else if(bytes_read % bytes_per_wide_sample != 0) {
899                         fprintf(stderr, "%s: ERROR: got partial sample\n", encoder_session.inbasefilename);
900                         return EncoderSession_finish_error(&encoder_session);
901                 }
902                 else {
903                         unsigned wide_samples = bytes_read / bytes_per_wide_sample;
904                         format_input(input_, wide_samples, options.is_big_endian, options.is_unsigned_samples, options.channels, options.bps);
905
906                         if(!EncoderSession_process(&encoder_session, (const FLAC__int32 * const *)input_, wide_samples)) {
907                                 print_error_with_state(&encoder_session, "ERROR during encoding");
908                                 return EncoderSession_finish_error(&encoder_session);
909                         }
910                 }
911         }
912
913         /*
914          * now read unaligned samples into reservoir or pad with zeroes if necessary
915          */
916         if(options.common.sector_align) {
917                 if(options.common.is_last_file) {
918                         unsigned wide_samples = 588 - align_remainder;
919                         if(wide_samples < 588) {
920                                 unsigned channel, data_bytes;
921
922                                 info_align_zero = wide_samples;
923                                 data_bytes = wide_samples * (options.bps >> 3);
924                                 for(channel = 0; channel < options.channels; channel++)
925                                         memset(input_[channel], 0, data_bytes);
926
927                                 if(!EncoderSession_process(&encoder_session, (const FLAC__int32 * const *)input_, wide_samples)) {
928                                         print_error_with_state(&encoder_session, "ERROR during encoding");
929                                         return EncoderSession_finish_error(&encoder_session);
930                                 }
931                         }
932                 }
933                 else {
934                         if(*options.common.align_reservoir_samples > 0) {
935                                 FLAC__ASSERT(CHUNK_OF_SAMPLES >= 588);
936                                 bytes_read = fread(ucbuffer_, sizeof(unsigned char), (*options.common.align_reservoir_samples) * bytes_per_wide_sample, infile);
937                                 if(bytes_read == 0 && ferror(infile)) {
938                                         fprintf(stderr, "%s: ERROR during read\n", encoder_session.inbasefilename);
939                                         return EncoderSession_finish_error(&encoder_session);
940                                 }
941                                 else if(bytes_read != (*options.common.align_reservoir_samples) * bytes_per_wide_sample) {
942                                         fprintf(stderr, "%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);
943                                 }
944                                 else {
945                                         info_align_carry = *options.common.align_reservoir_samples;
946                                         format_input(options.common.align_reservoir, *options.common.align_reservoir_samples, false, options.is_unsigned_samples, options.channels, options.bps);
947                                 }
948                         }
949                 }
950         }
951
952         return EncoderSession_finish_ok(&encoder_session, info_align_carry, info_align_zero);
953 }
954
955 FLAC__bool EncoderSession_construct(EncoderSession *e, FLAC__bool use_ogg, FLAC__bool verify, FLAC__bool verbose, FILE *infile, const char *infilename, const char *outfilename)
956 {
957         unsigned i;
958         FLAC__uint32 test = 1;
959
960         /*
961          * initialize globals
962          */
963
964         is_big_endian_host_ = (*((FLAC__byte*)(&test)))? false : true;
965
966         for(i = 0; i < FLAC__MAX_CHANNELS; i++)
967                 input_[i] = &(in_[i][0]);
968
969
970         /*
971          * initialize instance
972          */
973
974 #ifdef FLAC__HAS_OGG
975         e->use_ogg = use_ogg;
976 #else
977         (void)use_ogg;
978 #endif
979         e->verify = verify;
980         e->verbose = verbose;
981
982         e->is_stdout = (0 == strcmp(outfilename, "-"));
983
984         e->inbasefilename = flac__file_get_basename(infilename);
985         e->outfilename = outfilename;
986
987         e->unencoded_size = 0;
988         e->total_samples_to_encode = 0;
989         e->bytes_written = 0;
990         e->samples_written = 0;
991         e->blocksize = 0;
992         e->stats_mask = 0;
993
994         e->encoder.flac.stream = 0;
995         e->encoder.flac.file = 0;
996 #ifdef FLAC__HAS_OGG
997         e->encoder.ogg.stream = 0;
998 #endif
999
1000         e->fin = infile;
1001         e->fout = 0;
1002         e->seek_table_template = 0;
1003
1004         if(e->is_stdout) {
1005                 e->fout = file__get_binary_stdout();
1006         }
1007 #ifdef FLAC__HAS_OGG
1008         else {
1009                 if(e->use_ogg) {
1010                         if(0 == (e->fout = fopen(outfilename, "wb"))) {
1011                                 fprintf(stderr, "%s: ERROR: can't open output file %s\n", e->inbasefilename, outfilename);
1012                                 EncoderSession_destroy(e);
1013                                 return false;
1014                         }
1015                 }
1016         }
1017 #endif
1018
1019         if(0 == (e->seek_table_template = FLAC__metadata_object_new(FLAC__METADATA_TYPE_SEEKTABLE))) {
1020                 fprintf(stderr, "%s: ERROR allocating memory for seek table\n", e->inbasefilename);
1021                 return false;
1022         }
1023
1024 #ifdef FLAC__HAS_OGG
1025         if(e->use_ogg) {
1026                 e->encoder.ogg.stream = OggFLAC__stream_encoder_new();
1027                 if(0 == e->encoder.ogg.stream) {
1028                         fprintf(stderr, "%s: ERROR creating the encoder instance\n", e->inbasefilename);
1029                         EncoderSession_destroy(e);
1030                         return false;
1031                 }
1032         }
1033         else
1034 #endif
1035         if(e->is_stdout) {
1036                 e->encoder.flac.stream = FLAC__stream_encoder_new();
1037                 if(0 == e->encoder.flac.stream) {
1038                         fprintf(stderr, "%s: ERROR creating the encoder instance\n", e->inbasefilename);
1039                         EncoderSession_destroy(e);
1040                         return false;
1041                 }
1042         }
1043         else {
1044                 e->encoder.flac.file = FLAC__file_encoder_new();
1045                 if(0 == e->encoder.flac.file) {
1046                         fprintf(stderr, "%s: ERROR creating the encoder instance\n", e->inbasefilename);
1047                         EncoderSession_destroy(e);
1048                         return false;
1049                 }
1050         }
1051
1052         return true;
1053 }
1054
1055 void EncoderSession_destroy(EncoderSession *e)
1056 {
1057         if(e->fin != stdin)
1058                 fclose(e->fin);
1059
1060 #ifdef FLAC__HAS_OGG
1061         if(e->use_ogg) {
1062                 if(0 != e->encoder.ogg.stream) {
1063                         OggFLAC__stream_encoder_delete(e->encoder.ogg.stream);
1064                         e->encoder.ogg.stream = 0;
1065                 }
1066         }
1067         else
1068 #endif
1069         if(e->is_stdout) {
1070                 if(0 != e->encoder.flac.stream) {
1071                         FLAC__stream_encoder_delete(e->encoder.flac.stream);
1072                         e->encoder.flac.stream = 0;
1073                 }
1074         }
1075         else {
1076                 if(0 != e->encoder.flac.file) {
1077                         FLAC__file_encoder_delete(e->encoder.flac.file);
1078                         e->encoder.flac.file = 0;
1079                 }
1080         }
1081
1082         if(0 != e->seek_table_template) {
1083                 FLAC__metadata_object_delete(e->seek_table_template);
1084                 e->seek_table_template = 0;
1085         }
1086 }
1087
1088 int EncoderSession_finish_ok(EncoderSession *e, int info_align_carry, int info_align_zero)
1089 {
1090         FLAC__StreamEncoderState fse_state = FLAC__STREAM_ENCODER_OK;
1091         int ret = 0;
1092
1093 #ifdef FLAC__HAS_OGG
1094         if(e->use_ogg) {
1095                 if(e->encoder.ogg.stream) {
1096                         fse_state = OggFLAC__stream_encoder_get_FLAC_stream_encoder_state(e->encoder.ogg.stream);
1097                         OggFLAC__stream_encoder_finish(e->encoder.ogg.stream);
1098                 }
1099         }
1100         else
1101 #endif
1102         if(e->is_stdout) {
1103                 if(e->encoder.flac.stream) {
1104                         fse_state = FLAC__stream_encoder_get_state(e->encoder.flac.stream);
1105                         FLAC__stream_encoder_finish(e->encoder.flac.stream);
1106                 }
1107         }
1108         else {
1109                 if(e->encoder.flac.file) {
1110                         fse_state = FLAC__file_encoder_get_stream_encoder_state(e->encoder.flac.file);
1111                         FLAC__file_encoder_finish(e->encoder.flac.file);
1112                 }
1113         }
1114
1115         if(e->verbose && e->total_samples_to_encode > 0) {
1116                 print_stats(e);
1117                 fprintf(stderr, "\n");
1118         }
1119
1120         if(fse_state == FLAC__STREAM_ENCODER_VERIFY_MISMATCH_IN_AUDIO_DATA) {
1121                 print_verify_error(e);
1122                 ret = 1;
1123         }
1124         else {
1125                 if(info_align_carry >= 0)
1126                         fprintf(stderr, "%s: INFO: sector alignment causing %d samples to be carried over\n", e->inbasefilename, info_align_carry);
1127                 if(info_align_zero >= 0)
1128                         fprintf(stderr, "%s: INFO: sector alignment causing %d zero samples to be appended\n", e->inbasefilename, info_align_zero);
1129         }
1130
1131         EncoderSession_destroy(e);
1132
1133         return ret;
1134 }
1135
1136 int EncoderSession_finish_error(EncoderSession *e)
1137 {
1138         FLAC__StreamEncoderState fse_state;
1139
1140         if(e->verbose && e->total_samples_to_encode > 0)
1141                 fprintf(stderr, "\n");
1142
1143 #ifdef FLAC__HAS_OGG
1144         if(e->use_ogg) {
1145                 fse_state = OggFLAC__stream_encoder_get_FLAC_stream_encoder_state(e->encoder.ogg.stream);
1146         }
1147         else
1148 #endif
1149         if(e->is_stdout) {
1150                 fse_state = FLAC__stream_encoder_get_state(e->encoder.flac.stream);
1151         }
1152         else {
1153                 fse_state = FLAC__file_encoder_get_stream_encoder_state(e->encoder.flac.file);
1154         }
1155
1156         if(fse_state == FLAC__STREAM_ENCODER_VERIFY_MISMATCH_IN_AUDIO_DATA)
1157                 print_verify_error(e);
1158         else
1159                 unlink(e->outfilename);
1160
1161         EncoderSession_destroy(e);
1162
1163         return 1;
1164 }
1165
1166 FLAC__bool EncoderSession_init_encoder(EncoderSession *e, encode_options_t options, unsigned channels, unsigned bps, unsigned sample_rate)
1167 {
1168         unsigned num_metadata;
1169         FLAC__StreamMetadata padding;
1170         FLAC__StreamMetadata *metadata[3];
1171
1172         if(channels != 2)
1173                 options.do_mid_side = options.loose_mid_side = false;
1174
1175         if(!convert_to_seek_table_template(options.requested_seek_points, options.num_requested_seek_points, e)) {
1176                 fprintf(stderr, "%s: ERROR allocating memory for seek table\n", e->inbasefilename);
1177                 return false;
1178         }
1179
1180         num_metadata = 0;
1181         metadata[num_metadata++] = options.vorbis_comment;
1182         if(e->seek_table_template->data.seek_table.num_points > 0) {
1183                 e->seek_table_template->is_last = false; /* the encoder will set this for us */
1184                 metadata[num_metadata++] = e->seek_table_template;
1185         }
1186         if(options.padding > 0) {
1187                 padding.is_last = false; /* the encoder will set this for us */
1188                 padding.type = FLAC__METADATA_TYPE_PADDING;
1189                 padding.length = (unsigned)options.padding;
1190                 metadata[num_metadata++] = &padding;
1191         }
1192
1193         e->blocksize = options.blocksize;
1194         e->stats_mask = (options.do_exhaustive_model_search || options.do_qlp_coeff_prec_search)? 0x0f : 0x3f;
1195
1196 #ifdef FLAC__HAS_OGG
1197         if(e->use_ogg) {
1198                 if(options.has_serial_number)
1199                         OggFLAC__stream_encoder_set_serial_number(e->encoder.ogg.stream, options.serial_number);
1200                 OggFLAC__stream_encoder_set_verify(e->encoder.ogg.stream, options.verify);
1201                 OggFLAC__stream_encoder_set_streamable_subset(e->encoder.ogg.stream, !options.lax);
1202                 OggFLAC__stream_encoder_set_do_mid_side_stereo(e->encoder.ogg.stream, options.do_mid_side);
1203                 OggFLAC__stream_encoder_set_loose_mid_side_stereo(e->encoder.ogg.stream, options.loose_mid_side);
1204                 OggFLAC__stream_encoder_set_channels(e->encoder.ogg.stream, channels);
1205                 OggFLAC__stream_encoder_set_bits_per_sample(e->encoder.ogg.stream, bps);
1206                 OggFLAC__stream_encoder_set_sample_rate(e->encoder.ogg.stream, sample_rate);
1207                 OggFLAC__stream_encoder_set_blocksize(e->encoder.ogg.stream, options.blocksize);
1208                 OggFLAC__stream_encoder_set_max_lpc_order(e->encoder.ogg.stream, options.max_lpc_order);
1209                 OggFLAC__stream_encoder_set_qlp_coeff_precision(e->encoder.ogg.stream, options.qlp_coeff_precision);
1210                 OggFLAC__stream_encoder_set_do_qlp_coeff_prec_search(e->encoder.ogg.stream, options.do_qlp_coeff_prec_search);
1211                 OggFLAC__stream_encoder_set_do_escape_coding(e->encoder.ogg.stream, options.do_escape_coding);
1212                 OggFLAC__stream_encoder_set_do_exhaustive_model_search(e->encoder.ogg.stream, options.do_exhaustive_model_search);
1213                 OggFLAC__stream_encoder_set_min_residual_partition_order(e->encoder.ogg.stream, options.min_residual_partition_order);
1214                 OggFLAC__stream_encoder_set_max_residual_partition_order(e->encoder.ogg.stream, options.max_residual_partition_order);
1215                 OggFLAC__stream_encoder_set_rice_parameter_search_dist(e->encoder.ogg.stream, options.rice_parameter_search_dist);
1216                 OggFLAC__stream_encoder_set_total_samples_estimate(e->encoder.ogg.stream, e->total_samples_to_encode);
1217                 OggFLAC__stream_encoder_set_metadata(e->encoder.ogg.stream, (num_metadata > 0)? metadata : 0, num_metadata);
1218                 OggFLAC__stream_encoder_set_write_callback(e->encoder.ogg.stream, ogg_stream_encoder_write_callback);
1219                 OggFLAC__stream_encoder_set_client_data(e->encoder.ogg.stream, e);
1220
1221                 OggFLAC__stream_encoder_disable_constant_subframes(e->encoder.ogg.stream, options.debug.disable_constant_subframes);
1222                 OggFLAC__stream_encoder_disable_fixed_subframes(e->encoder.ogg.stream, options.debug.disable_fixed_subframes);
1223                 OggFLAC__stream_encoder_disable_verbatim_subframes(e->encoder.ogg.stream, options.debug.disable_verbatim_subframes);
1224
1225                 if(OggFLAC__stream_encoder_init(e->encoder.ogg.stream) != FLAC__STREAM_ENCODER_OK) {
1226                         print_error_with_state(e, "ERROR initializing encoder");
1227                         return false;
1228                 }
1229         }
1230         else
1231 #endif
1232         if(e->is_stdout) {
1233                 FLAC__stream_encoder_set_verify(e->encoder.flac.stream, options.verify);
1234                 FLAC__stream_encoder_set_streamable_subset(e->encoder.flac.stream, !options.lax);
1235                 FLAC__stream_encoder_set_do_mid_side_stereo(e->encoder.flac.stream, options.do_mid_side);
1236                 FLAC__stream_encoder_set_loose_mid_side_stereo(e->encoder.flac.stream, options.loose_mid_side);
1237                 FLAC__stream_encoder_set_channels(e->encoder.flac.stream, channels);
1238                 FLAC__stream_encoder_set_bits_per_sample(e->encoder.flac.stream, bps);
1239                 FLAC__stream_encoder_set_sample_rate(e->encoder.flac.stream, sample_rate);
1240                 FLAC__stream_encoder_set_blocksize(e->encoder.flac.stream, options.blocksize);
1241                 FLAC__stream_encoder_set_max_lpc_order(e->encoder.flac.stream, options.max_lpc_order);
1242                 FLAC__stream_encoder_set_qlp_coeff_precision(e->encoder.flac.stream, options.qlp_coeff_precision);
1243                 FLAC__stream_encoder_set_do_qlp_coeff_prec_search(e->encoder.flac.stream, options.do_qlp_coeff_prec_search);
1244                 FLAC__stream_encoder_set_do_escape_coding(e->encoder.flac.stream, options.do_escape_coding);
1245                 FLAC__stream_encoder_set_do_exhaustive_model_search(e->encoder.flac.stream, options.do_exhaustive_model_search);
1246                 FLAC__stream_encoder_set_min_residual_partition_order(e->encoder.flac.stream, options.min_residual_partition_order);
1247                 FLAC__stream_encoder_set_max_residual_partition_order(e->encoder.flac.stream, options.max_residual_partition_order);
1248                 FLAC__stream_encoder_set_rice_parameter_search_dist(e->encoder.flac.stream, options.rice_parameter_search_dist);
1249                 FLAC__stream_encoder_set_total_samples_estimate(e->encoder.flac.stream, e->total_samples_to_encode);
1250                 FLAC__stream_encoder_set_metadata(e->encoder.flac.stream, (num_metadata > 0)? metadata : 0, num_metadata);
1251                 FLAC__stream_encoder_set_write_callback(e->encoder.flac.stream, flac_stream_encoder_write_callback);
1252                 FLAC__stream_encoder_set_metadata_callback(e->encoder.flac.stream, flac_stream_encoder_metadata_callback);
1253                 FLAC__stream_encoder_set_client_data(e->encoder.flac.stream, e);
1254
1255                 FLAC__stream_encoder_disable_constant_subframes(e->encoder.flac.stream, options.debug.disable_constant_subframes);
1256                 FLAC__stream_encoder_disable_fixed_subframes(e->encoder.flac.stream, options.debug.disable_fixed_subframes);
1257                 FLAC__stream_encoder_disable_verbatim_subframes(e->encoder.flac.stream, options.debug.disable_verbatim_subframes);
1258
1259                 if(FLAC__stream_encoder_init(e->encoder.flac.stream) != FLAC__STREAM_ENCODER_OK) {
1260                         print_error_with_state(e, "ERROR initializing encoder");
1261                         return false;
1262                 }
1263         }
1264         else {
1265                 FLAC__file_encoder_set_filename(e->encoder.flac.file, e->outfilename);
1266                 FLAC__file_encoder_set_verify(e->encoder.flac.file, options.verify);
1267                 FLAC__file_encoder_set_streamable_subset(e->encoder.flac.file, !options.lax);
1268                 FLAC__file_encoder_set_do_mid_side_stereo(e->encoder.flac.file, options.do_mid_side);
1269                 FLAC__file_encoder_set_loose_mid_side_stereo(e->encoder.flac.file, options.loose_mid_side);
1270                 FLAC__file_encoder_set_channels(e->encoder.flac.file, channels);
1271                 FLAC__file_encoder_set_bits_per_sample(e->encoder.flac.file, bps);
1272                 FLAC__file_encoder_set_sample_rate(e->encoder.flac.file, sample_rate);
1273                 FLAC__file_encoder_set_blocksize(e->encoder.flac.file, options.blocksize);
1274                 FLAC__file_encoder_set_max_lpc_order(e->encoder.flac.file, options.max_lpc_order);
1275                 FLAC__file_encoder_set_qlp_coeff_precision(e->encoder.flac.file, options.qlp_coeff_precision);
1276                 FLAC__file_encoder_set_do_qlp_coeff_prec_search(e->encoder.flac.file, options.do_qlp_coeff_prec_search);
1277                 FLAC__file_encoder_set_do_escape_coding(e->encoder.flac.file, options.do_escape_coding);
1278                 FLAC__file_encoder_set_do_exhaustive_model_search(e->encoder.flac.file, options.do_exhaustive_model_search);
1279                 FLAC__file_encoder_set_min_residual_partition_order(e->encoder.flac.file, options.min_residual_partition_order);
1280                 FLAC__file_encoder_set_max_residual_partition_order(e->encoder.flac.file, options.max_residual_partition_order);
1281                 FLAC__file_encoder_set_rice_parameter_search_dist(e->encoder.flac.file, options.rice_parameter_search_dist);
1282                 FLAC__file_encoder_set_total_samples_estimate(e->encoder.flac.file, e->total_samples_to_encode);
1283                 FLAC__file_encoder_set_metadata(e->encoder.flac.file, (num_metadata > 0)? metadata : 0, num_metadata);
1284                 FLAC__file_encoder_set_progress_callback(e->encoder.flac.file, flac_file_encoder_progress_callback);
1285                 FLAC__file_encoder_set_client_data(e->encoder.flac.file, e);
1286
1287                 FLAC__file_encoder_disable_constant_subframes(e->encoder.flac.file, options.debug.disable_constant_subframes);
1288                 FLAC__file_encoder_disable_fixed_subframes(e->encoder.flac.file, options.debug.disable_fixed_subframes);
1289                 FLAC__file_encoder_disable_verbatim_subframes(e->encoder.flac.file, options.debug.disable_verbatim_subframes);
1290
1291                 if(FLAC__file_encoder_init(e->encoder.flac.file) != FLAC__FILE_ENCODER_OK) {
1292                         print_error_with_state(e, "ERROR initializing encoder");
1293                         return false;
1294                 }
1295         }
1296
1297         return true;
1298 }
1299
1300 FLAC__bool EncoderSession_process(EncoderSession *e, const FLAC__int32 * const buffer[], unsigned samples)
1301 {
1302 #ifdef FLAC__HAS_OGG
1303         if(e->use_ogg) {
1304                 return OggFLAC__stream_encoder_process(e->encoder.ogg.stream, buffer, samples);
1305         }
1306         else
1307 #endif
1308         if(e->is_stdout) {
1309                 return FLAC__stream_encoder_process(e->encoder.flac.stream, buffer, samples);
1310         }
1311         else {
1312                 return FLAC__file_encoder_process(e->encoder.flac.file, buffer, samples);
1313         }
1314 }
1315
1316 FLAC__bool convert_to_seek_table_template(char *requested_seek_points, int num_requested_seek_points, EncoderSession *e)
1317 {
1318         unsigned i;
1319         char *pt = requested_seek_points, *q;
1320         FLAC__bool only_placeholders = false;
1321         FLAC__bool needs_warning = false;
1322
1323         if(num_requested_seek_points == 0)
1324                 return true;
1325
1326         if(num_requested_seek_points < 0) {
1327                 strcpy(requested_seek_points, "100x<");
1328                 num_requested_seek_points = 1;
1329         }
1330
1331         if(e->is_stdout) {
1332                 only_placeholders = true;
1333         }
1334 #ifdef HAS_OGG
1335         else if(e->is_ogg) {
1336                 only_placeholders = true;
1337         }
1338 #endif
1339
1340         for(i = 0; i < (unsigned)num_requested_seek_points; i++) {
1341                 q = strchr(pt, '<');
1342                 FLAC__ASSERT(0 != q);
1343                 *q++ = '\0';
1344
1345                 if(0 == strcmp(pt, "X")) { /* -S X */
1346                         if(!FLAC__metadata_object_seektable_template_append_placeholders(e->seek_table_template, 1))
1347                                 return false;
1348                 }
1349                 else if(!only_placeholders) {
1350                         if(pt[strlen(pt)-1] == 'x') { /* -S #x */
1351                                 if(e->total_samples_to_encode > 0) { /* we can only do these if we know the number of samples to encode up front */
1352                                         if(!FLAC__metadata_object_seektable_template_append_spaced_points(e->seek_table_template, atoi(pt), e->total_samples_to_encode))
1353                                                 return false;
1354                                 }
1355                         }
1356                         else { /* -S # */
1357                                 FLAC__uint64 n = (unsigned)atoi(pt);
1358                                 if(!FLAC__metadata_object_seektable_template_append_point(e->seek_table_template, n))
1359                                         return false;
1360                         }
1361                 }
1362                 else
1363                         needs_warning = true;
1364
1365                 pt = q;
1366         }
1367
1368         if(!FLAC__metadata_object_seektable_template_sort(e->seek_table_template, /*compact=*/true))
1369                 return false;
1370
1371         if(needs_warning) {
1372                 if(e->is_stdout) {
1373                         fprintf(stderr, "%s: WARNING, cannot write back seektable when encoding to stdout\n", e->inbasefilename);
1374                 }
1375 #ifdef HAS_OGG
1376                 else if(e->is_ogg) {
1377                         fprintf(stderr, "%s: WARNING, cannot write back seektable when encoding to Ogg\n", e->inbasefilename);
1378                 }
1379 #endif
1380                 else {
1381                         FLAC__ASSERT(0);
1382                 }
1383         }
1384
1385         return true;
1386 }
1387
1388 void format_input(FLAC__int32 *dest[], unsigned wide_samples, FLAC__bool is_big_endian, FLAC__bool is_unsigned_samples, unsigned channels, unsigned bps)
1389 {
1390         unsigned wide_sample, sample, channel, byte;
1391
1392         if(bps == 8) {
1393                 if(is_unsigned_samples) {
1394                         for(sample = wide_sample = 0; wide_sample < wide_samples; wide_sample++)
1395                                 for(channel = 0; channel < channels; channel++, sample++)
1396                                         dest[channel][wide_sample] = (FLAC__int32)ucbuffer_[sample] - 0x80;
1397                 }
1398                 else {
1399                         for(sample = wide_sample = 0; wide_sample < wide_samples; wide_sample++)
1400                                 for(channel = 0; channel < channels; channel++, sample++)
1401                                         dest[channel][wide_sample] = (FLAC__int32)scbuffer_[sample];
1402                 }
1403         }
1404         else if(bps == 16) {
1405                 if(is_big_endian != is_big_endian_host_) {
1406                         unsigned char tmp;
1407                         const unsigned bytes = wide_samples * channels * (bps >> 3);
1408                         for(byte = 0; byte < bytes; byte += 2) {
1409                                 tmp = ucbuffer_[byte];
1410                                 ucbuffer_[byte] = ucbuffer_[byte+1];
1411                                 ucbuffer_[byte+1] = tmp;
1412                         }
1413                 }
1414                 if(is_unsigned_samples) {
1415                         for(sample = wide_sample = 0; wide_sample < wide_samples; wide_sample++)
1416                                 for(channel = 0; channel < channels; channel++, sample++)
1417                                         dest[channel][wide_sample] = (FLAC__int32)usbuffer_[sample] - 0x8000;
1418                 }
1419                 else {
1420                         for(sample = wide_sample = 0; wide_sample < wide_samples; wide_sample++)
1421                                 for(channel = 0; channel < channels; channel++, sample++)
1422                                         dest[channel][wide_sample] = (FLAC__int32)ssbuffer_[sample];
1423                 }
1424         }
1425         else if(bps == 24) {
1426                 if(!is_big_endian) {
1427                         unsigned char tmp;
1428                         const unsigned bytes = wide_samples * channels * (bps >> 3);
1429                         for(byte = 0; byte < bytes; byte += 3) {
1430                                 tmp = ucbuffer_[byte];
1431                                 ucbuffer_[byte] = ucbuffer_[byte+2];
1432                                 ucbuffer_[byte+2] = tmp;
1433                         }
1434                 }
1435                 if(is_unsigned_samples) {
1436                         for(byte = sample = wide_sample = 0; wide_sample < wide_samples; wide_sample++)
1437                                 for(channel = 0; channel < channels; channel++, sample++) {
1438                                         dest[channel][wide_sample]  = ucbuffer_[byte++]; dest[channel][wide_sample] <<= 8;
1439                                         dest[channel][wide_sample] |= ucbuffer_[byte++]; dest[channel][wide_sample] <<= 8;
1440                                         dest[channel][wide_sample] |= ucbuffer_[byte++];
1441                                         dest[channel][wide_sample] -= 0x800000;
1442                                 }
1443                 }
1444                 else {
1445                         for(byte = sample = wide_sample = 0; wide_sample < wide_samples; wide_sample++)
1446                                 for(channel = 0; channel < channels; channel++, sample++) {
1447                                         dest[channel][wide_sample]  = scbuffer_[byte++]; dest[channel][wide_sample] <<= 8;
1448                                         dest[channel][wide_sample] |= ucbuffer_[byte++]; dest[channel][wide_sample] <<= 8;
1449                                         dest[channel][wide_sample] |= ucbuffer_[byte++];
1450                                 }
1451                 }
1452         }
1453         else {
1454                 FLAC__ASSERT(0);
1455         }
1456 }
1457
1458 #ifdef FLAC__HAS_OGG
1459 FLAC__StreamEncoderWriteStatus ogg_stream_encoder_write_callback(const OggFLAC__StreamEncoder *encoder, const FLAC__byte buffer[], unsigned bytes, unsigned samples, unsigned current_frame, void *client_data)
1460 {
1461         EncoderSession *encoder_session = (EncoderSession*)client_data;
1462
1463         (void)encoder;
1464
1465         encoder_session->bytes_written += bytes;
1466         /*
1467          * With Ogg FLAC we don't get one write callback per frame and
1468          * we don't have good number for 'samples', so we estimate based
1469          * on the frame number and the knowledge that all blocks (except
1470          * the last) are the same size.
1471          */
1472         (void)samples;
1473         encoder_session->samples_written = (current_frame+1) * encoder_session->blocksize;
1474
1475         if(encoder_session->verbose && encoder_session->total_samples_to_encode > 0 && !(current_frame & encoder_session->stats_mask))
1476                 print_stats(encoder_session);
1477
1478         if(fwrite(buffer, sizeof(FLAC__byte), bytes, encoder_session->fout) == bytes)
1479                 return FLAC__STREAM_ENCODER_WRITE_STATUS_OK;
1480         else
1481                 return FLAC__STREAM_ENCODER_WRITE_STATUS_FATAL_ERROR;
1482 }
1483 #endif
1484
1485 FLAC__StreamEncoderWriteStatus flac_stream_encoder_write_callback(const FLAC__StreamEncoder *encoder, const FLAC__byte buffer[], unsigned bytes, unsigned samples, unsigned current_frame, void *client_data)
1486 {
1487         EncoderSession *encoder_session = (EncoderSession*)client_data;
1488
1489         (void)encoder;
1490
1491         encoder_session->bytes_written += bytes;
1492         encoder_session->samples_written += samples;
1493
1494         if(samples && encoder_session->verbose && encoder_session->total_samples_to_encode > 0 && !(current_frame & encoder_session->stats_mask))
1495                 print_stats(encoder_session);
1496
1497         if(fwrite(buffer, sizeof(FLAC__byte), bytes, encoder_session->fout) == bytes)
1498                 return FLAC__STREAM_ENCODER_WRITE_STATUS_OK;
1499         else
1500                 return FLAC__STREAM_ENCODER_WRITE_STATUS_FATAL_ERROR;
1501 }
1502
1503 void flac_stream_encoder_metadata_callback(const FLAC__StreamEncoder *encoder, const FLAC__StreamMetadata *metadata, void *client_data)
1504 {
1505         /*
1506          * Nothing to do; if we get here, we're decoding to stdout, in
1507          * which case we can't seek backwards to write new metadata.
1508          */
1509         (void)encoder, (void)metadata, (void)client_data;
1510 }
1511
1512 void flac_file_encoder_progress_callback(const FLAC__FileEncoder *encoder, FLAC__uint64 bytes_written, FLAC__uint64 samples_written, unsigned frames_written, unsigned total_frames_estimate, void *client_data)
1513 {
1514         EncoderSession *encoder_session = (EncoderSession*)client_data;
1515
1516         (void)encoder, (void)total_frames_estimate;
1517
1518         encoder_session->bytes_written = bytes_written;
1519         encoder_session->samples_written = samples_written;
1520
1521         if(encoder_session->verbose && encoder_session->total_samples_to_encode > 0 && !((frames_written-1) & encoder_session->stats_mask))
1522                 print_stats(encoder_session);
1523 }
1524
1525 void print_stats(const EncoderSession *encoder_session)
1526 {
1527         const FLAC__uint64 samples_written = min(encoder_session->total_samples_to_encode, encoder_session->samples_written);
1528 #if defined _MSC_VER || defined __MINGW32__
1529         /* with VC++ you have to spoon feed it the casting */
1530         const double progress = (double)(FLAC__int64)samples_written / (double)(FLAC__int64)encoder_session->total_samples_to_encode;
1531         const double ratio = (double)(FLAC__int64)encoder_session->bytes_written / ((double)(FLAC__int64)encoder_session->unencoded_size * progress);
1532 #else
1533         const double progress = (double)samples_written / (double)encoder_session->total_samples_to_encode;
1534         const double ratio = (double)encoder_session->bytes_written / ((double)encoder_session->unencoded_size * progress);
1535 #endif
1536
1537         if(samples_written == encoder_session->total_samples_to_encode) {
1538                 fprintf(stderr, "\r%s:%s wrote %u bytes, ratio=%0.3f",
1539                         encoder_session->inbasefilename,
1540                         encoder_session->verify? " Verify OK," : "",
1541                         (unsigned)encoder_session->bytes_written,
1542                         ratio
1543                 );
1544         }
1545         else {
1546                 fprintf(stderr, "\r%s: %u%% complete, ratio=%0.3f", encoder_session->inbasefilename, (unsigned)floor(progress * 100.0 + 0.5), ratio);
1547         }
1548 }
1549
1550 void print_error_with_state(const EncoderSession *e, const char *message)
1551 {
1552         const int ilen = strlen(e->inbasefilename) + 1;
1553
1554         fprintf(stderr, "\n%s: %s\n", e->inbasefilename, message);
1555
1556 #ifdef FLAC__HAS_OGG
1557         if(e->use_ogg) {
1558                 const OggFLAC__StreamEncoderState ose_state = OggFLAC__stream_encoder_get_state(e->encoder.ogg.stream);
1559                 if(ose_state != OggFLAC__STREAM_ENCODER_FLAC_STREAM_ENCODER_ERROR) {
1560                         fprintf(stderr, "%*s state = %d:%s\n", ilen, "", (int)ose_state, OggFLAC__StreamEncoderStateString[ose_state]);
1561                 }
1562                 else {
1563                         const FLAC__StreamEncoderState fse_state = OggFLAC__stream_encoder_get_FLAC_stream_encoder_state(e->encoder.ogg.stream);
1564                         if(fse_state != FLAC__STREAM_ENCODER_VERIFY_DECODER_ERROR) {
1565                                 fprintf(stderr, "%*s state = %d:%s\n", ilen, "", (int)fse_state, FLAC__StreamEncoderStateString[fse_state]);
1566                         }
1567                         else {
1568                                 const FLAC__StreamDecoderState fsd_state = OggFLAC__stream_encoder_get_verify_decoder_state(e->encoder.ogg.stream);
1569                                 fprintf(stderr, "%*s state = %d:%s\n", ilen, "", (int)fsd_state, FLAC__StreamDecoderStateString[fsd_state]);
1570                         }
1571                 }
1572         }
1573         else
1574 #endif
1575         if(e->is_stdout) {
1576                 const FLAC__StreamEncoderState fse_state = FLAC__stream_encoder_get_state(e->encoder.flac.stream);
1577                 if(fse_state != FLAC__STREAM_ENCODER_VERIFY_DECODER_ERROR) {
1578                         fprintf(stderr, "%*s state = %d:%s\n", ilen, "", (int)fse_state, FLAC__StreamEncoderStateString[fse_state]);
1579                 }
1580                 else {
1581                         const FLAC__StreamDecoderState fsd_state = FLAC__stream_encoder_get_verify_decoder_state(e->encoder.flac.stream);
1582                         fprintf(stderr, "%*s state = %d:%s\n", ilen, "", (int)fsd_state, FLAC__StreamDecoderStateString[fsd_state]);
1583                 }
1584         }
1585         else {
1586                 const FLAC__FileEncoderState ffe_state = FLAC__file_encoder_get_state(e->encoder.flac.file);
1587                 if(ffe_state != FLAC__FILE_ENCODER_SEEKABLE_STREAM_ENCODER_ERROR) {
1588                         fprintf(stderr, "%*s state = %d:%s\n", ilen, "", (int)ffe_state, FLAC__FileEncoderStateString[ffe_state]);
1589                 }
1590                 else {
1591                         const FLAC__SeekableStreamEncoderState fsse_state = FLAC__file_encoder_get_seekable_stream_encoder_state(e->encoder.flac.file);
1592                         if(fsse_state != FLAC__SEEKABLE_STREAM_ENCODER_STREAM_ENCODER_ERROR) {
1593                                 fprintf(stderr, "%*s state = %d:%s\n", ilen, "", (int)fsse_state, FLAC__SeekableStreamEncoderStateString[fsse_state]);
1594                         }
1595                         else {
1596                                 const FLAC__StreamEncoderState fse_state = FLAC__file_encoder_get_stream_encoder_state(e->encoder.flac.file);
1597                                 if(fse_state != FLAC__STREAM_ENCODER_VERIFY_DECODER_ERROR) {
1598                                         fprintf(stderr, "%*s state = %d:%s\n", ilen, "", (int)fse_state, FLAC__StreamEncoderStateString[fse_state]);
1599                                 }
1600                                 else {
1601                                         const FLAC__StreamDecoderState fsd_state = FLAC__file_encoder_get_verify_decoder_state(e->encoder.flac.file);
1602                                         fprintf(stderr, "%*s state = %d:%s\n", ilen, "", (int)fsd_state, FLAC__StreamDecoderStateString[fsd_state]);
1603                                 }
1604                         }
1605                 }
1606         }
1607 }
1608
1609 void print_verify_error(EncoderSession *e)
1610 {
1611         FLAC__uint64 absolute_sample;
1612         unsigned frame_number;
1613         unsigned channel;
1614         unsigned sample;
1615         FLAC__int32 expected;
1616         FLAC__int32 got;
1617
1618 #ifdef FLAC__HAS_OGG
1619         if(e->use_ogg) {
1620                 OggFLAC__stream_encoder_get_verify_decoder_error_stats(e->encoder.ogg.stream, &absolute_sample, &frame_number, &channel, &sample, &expected, &got);
1621         }
1622         else
1623 #endif
1624         if(e->is_stdout) {
1625                 FLAC__stream_encoder_get_verify_decoder_error_stats(e->encoder.flac.stream, &absolute_sample, &frame_number, &channel, &sample, &expected, &got);
1626         }
1627         else {
1628                 FLAC__file_encoder_get_verify_decoder_error_stats(e->encoder.flac.file, &absolute_sample, &frame_number, &channel, &sample, &expected, &got);
1629         }
1630
1631         fprintf(stderr, "%s: ERROR: mismatch in decoded data, verify FAILED!\n", e->inbasefilename);
1632         fprintf(stderr, "       Absolute sample=%u, frame=%u, channel=%u, sample=%u, expected %d, got %d\n", (unsigned)absolute_sample, frame_number, channel, sample, expected, got);
1633         fprintf(stderr, "       Please submit a bug report to\n");
1634         fprintf(stderr, "           http://sourceforge.net/bugs/?func=addbug&group_id=13478\n");
1635         fprintf(stderr, "       Make sure to include an email contact in the comment and/or use the\n");
1636         fprintf(stderr, "       \"Monitor\" feature to monitor the bug status.\n");
1637         fprintf(stderr, "Verify FAILED!  Do not trust %s\n", e->outfilename);
1638 }
1639
1640 FLAC__bool read_little_endian_uint16(FILE *f, FLAC__uint16 *val, FLAC__bool eof_ok, const char *fn)
1641 {
1642         size_t bytes_read = fread(val, 1, 2, f);
1643
1644         if(bytes_read == 0) {
1645                 if(!eof_ok) {
1646                         fprintf(stderr, "%s: ERROR: unexpected EOF\n", fn);
1647                         return false;
1648                 }
1649                 else
1650                         return true;
1651         }
1652         else if(bytes_read < 2) {
1653                 fprintf(stderr, "%s: ERROR: unexpected EOF\n", fn);
1654                 return false;
1655         }
1656         else {
1657                 if(is_big_endian_host_) {
1658                         FLAC__byte tmp, *b = (FLAC__byte*)val;
1659                         tmp = b[1]; b[1] = b[0]; b[0] = tmp;
1660                 }
1661                 return true;
1662         }
1663 }
1664
1665 FLAC__bool read_little_endian_uint32(FILE *f, FLAC__uint32 *val, FLAC__bool eof_ok, const char *fn)
1666 {
1667         size_t bytes_read = fread(val, 1, 4, f);
1668
1669         if(bytes_read == 0) {
1670                 if(!eof_ok) {
1671                         fprintf(stderr, "%s: ERROR: unexpected EOF\n", fn);
1672                         return false;
1673                 }
1674                 else
1675                         return true;
1676         }
1677         else if(bytes_read < 4) {
1678                 fprintf(stderr, "%s: ERROR: unexpected EOF\n", fn);
1679                 return false;
1680         }
1681         else {
1682                 if(is_big_endian_host_) {
1683                         FLAC__byte tmp, *b = (FLAC__byte*)val;
1684                         tmp = b[3]; b[3] = b[0]; b[0] = tmp;
1685                         tmp = b[2]; b[2] = b[1]; b[1] = tmp;
1686                 }
1687                 return true;
1688         }
1689 }
1690
1691 FLAC__bool
1692 read_big_endian_uint16(FILE *f, FLAC__uint16 *val, FLAC__bool eof_ok, const char *fn)
1693 {
1694         unsigned char buf[4];
1695         size_t bytes_read= fread(buf, 1, 2, f);
1696
1697         if(bytes_read==0U && eof_ok)
1698                 return true;
1699         else if(bytes_read<2U) {
1700                 fprintf(stderr, "%s: ERROR: unexpected EOF\n", fn);
1701                 return false;
1702         }
1703
1704         /* this is independent of host endianness */
1705         *val= (FLAC__uint16)(buf[0])<<8 | buf[1];
1706
1707         return true;
1708 }
1709
1710 FLAC__bool
1711 read_big_endian_uint32(FILE *f, FLAC__uint32 *val, FLAC__bool eof_ok, const char *fn)
1712 {
1713         unsigned char buf[4];
1714         size_t bytes_read= fread(buf, 1, 4, f);
1715
1716         if(bytes_read==0U && eof_ok)
1717                 return true;
1718         else if(bytes_read<4U) {
1719                 fprintf(stderr, "%s: ERROR: unexpected EOF\n", fn);
1720                 return false;
1721         }
1722
1723         /* this is independent of host endianness */
1724         *val= (FLAC__uint32)(buf[0])<<24 | (FLAC__uint32)(buf[1])<<16 |
1725                 (FLAC__uint32)(buf[2])<<8 | buf[3];
1726
1727         return true;
1728 }
1729
1730 FLAC__bool
1731 read_sane_extended(FILE *f, FLAC__uint32 *val, FLAC__bool eof_ok, const char *fn)
1732         /* Read an IEEE 754 80-bit (aka SANE) extended floating point value from 'f',
1733          * convert it into an integral value and store in 'val'.  Return false if only
1734          * between 1 and 9 bytes remain in 'f', if 0 bytes remain in 'f' and 'eof_ok' is
1735          * false, or if the value is negative, between zero and one, or too large to be
1736          * represented by 'val'; return true otherwise.
1737          */
1738 {
1739         unsigned int i;
1740         unsigned char buf[10];
1741         size_t bytes_read= fread(buf, 1U, 10U, f);
1742         FLAC__int16 e= ((FLAC__uint16)(buf[0])<<8 | (FLAC__uint16)(buf[1]))-0x3FFF;
1743         FLAC__int16 shift= 63-e;
1744         FLAC__uint64 p= 0U;
1745
1746         if(bytes_read==0U && eof_ok)
1747                 return true;
1748         else if(bytes_read<10U) {
1749                 fprintf(stderr, "%s: ERROR: unexpected EOF\n", fn);
1750                 return false;
1751         }
1752         else if((buf[0]>>7)==1U || e<0 || e>63) {
1753                 fprintf(stderr, "%s: ERROR: invalid floating-point value\n", fn);
1754                 return false;
1755         }
1756
1757         for(i= 0U; i<8U; ++i)
1758                 p|= (FLAC__uint64)(buf[i+2])<<(56U-i*8);
1759         *val= (FLAC__uint32)((p>>shift)+(p>>(shift-1) & 0x1));
1760
1761         return true;
1762 }