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