fix 24-bit support
[flac.git] / src / flac / decode.c
1 /* flac - Command-line FLAC encoder/decoder
2  * Copyright (C) 2000,2001  Josh Coalson
3  *
4  * This program is free software; you can redistribute it and/or
5  * modify it under the terms of the GNU General Public License
6  * as published by the Free Software Foundation; either version 2
7  * of the License, or (at your option) any later version.
8  *
9  * This program is distributed in the hope that it will be useful,
10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
12  * GNU General Public License for more details.
13  *
14  * You should have received a copy of the GNU General Public License
15  * along with this program; if not, write to the Free Software
16  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
17  */
18
19 #if defined _WIN32 && !defined __CYGWIN__
20 /* where MSVC puts unlink() */
21 # include <io.h>
22 #else
23 # include <unistd.h>
24 #endif
25 #include <assert.h> /* for FILE */
26 #include <stdio.h> /* for FILE */
27 #include <string.h> /* for strcmp() */
28 #include "FLAC/all.h"
29 #include "decode.h"
30
31 typedef struct {
32         FILE *fout;
33         bool abort_flag;
34         bool analysis_mode;
35         bool test_only;
36         bool is_wave_out;
37         bool is_big_endian;
38         bool is_unsigned_samples;
39         uint64 total_samples;
40         unsigned bps;
41         unsigned channels;
42         unsigned sample_rate;
43         bool verbose;
44         uint64 skip;
45         uint64 samples_processed;
46         unsigned frame_counter;
47 } stream_info_struct;
48
49 static FLAC__FileDecoder *decoder;
50 static bool is_big_endian_host;
51
52 /* local routines */
53 static bool init(const char *infile, stream_info_struct *stream_info);
54 static bool write_little_endian_uint16(FILE *f, uint16 val);
55 static bool write_little_endian_uint32(FILE *f, uint32 val);
56 static FLAC__StreamDecoderWriteStatus write_callback(const FLAC__FileDecoder *decoder, const FLAC__Frame *frame, const int32 *buffer[], void *client_data);
57 static void metadata_callback(const FLAC__FileDecoder *decoder, const FLAC__StreamMetaData *metadata, void *client_data);
58 static void error_callback(const FLAC__FileDecoder *decoder, FLAC__StreamDecoderErrorStatus status, void *client_data);
59 static void print_stats(const stream_info_struct *stream_info);
60
61 int decode_wav(const char *infile, const char *outfile, bool analysis_mode, bool verbose, uint64 skip)
62 {
63         bool md5_failure = false;
64         stream_info_struct stream_info;
65
66         decoder = 0;
67         stream_info.abort_flag = false;
68         stream_info.analysis_mode = analysis_mode;
69         stream_info.test_only = (outfile == 0);
70         stream_info.is_wave_out = true;
71         stream_info.verbose = verbose;
72         stream_info.skip = skip;
73         stream_info.samples_processed = 0;
74         stream_info.frame_counter = 0;
75
76         assert(!(stream_info.test_only && stream_info.analysis_mode));
77
78         if(!stream_info.test_only) {
79                 if(0 == strcmp(outfile, "-")) {
80                         stream_info.fout = stdout;
81                 }
82                 else {
83                         if(0 == (stream_info.fout = fopen(outfile, "wb"))) {
84                                 fprintf(stderr, "ERROR: can't open output file %s\n", outfile);
85                                 return false;
86                         }
87                 }
88         }
89
90         if(!init(infile, &stream_info))
91                 goto wav_abort_;
92
93         if(skip > 0) {
94                 if(!FLAC__file_decoder_process_metadata(decoder)) {
95                         fprintf(stderr, "%s: ERROR during decoding\n", infile);
96                         goto wav_abort_;
97                 }
98                 if(!FLAC__file_decoder_seek_absolute(decoder, skip)) {
99                         fprintf(stderr, "%s: ERROR seeking while skipping bytes\n", infile);
100                         goto wav_abort_;
101                 }
102                 if(!FLAC__file_decoder_process_remaining_frames(decoder)) {
103                         if(verbose) { printf("\n"); fflush(stdout); }
104                         fprintf(stderr, "%s: ERROR during decoding\n", infile);
105                         goto wav_abort_;
106                 }
107                 if(decoder->state != FLAC__FILE_DECODER_OK && decoder->state != FLAC__FILE_DECODER_END_OF_FILE) {
108                         if(verbose) { printf("\n"); fflush(stdout); }
109                         fprintf(stderr, "%s: ERROR during decoding\n", infile);
110                         goto wav_abort_;
111                 }
112         }
113         else {
114                 if(!FLAC__file_decoder_process_whole_file(decoder)) {
115                         if(verbose) { printf("\n"); fflush(stdout); }
116                         fprintf(stderr, "%s: ERROR during decoding\n", infile);
117                         goto wav_abort_;
118                 }
119                 if(decoder->state != FLAC__FILE_DECODER_OK && decoder->state != FLAC__FILE_DECODER_END_OF_FILE) {
120                         if(verbose) { printf("\n"); fflush(stdout); }
121                         fprintf(stderr, "%s: ERROR during decoding, state=%d:%s\n", infile, decoder->state, FLAC__FileDecoderStateString[decoder->state]);
122                         goto wav_abort_;
123                 }
124         }
125
126         if(decoder) {
127                 if(decoder->state != FLAC__FILE_DECODER_UNINITIALIZED)
128                         md5_failure = !FLAC__file_decoder_finish(decoder);
129                 print_stats(&stream_info);
130                 FLAC__file_decoder_free_instance(decoder);
131         }
132         if(!stream_info.test_only)
133                 fclose(stream_info.fout);
134         if(verbose)
135                 printf("\n");
136         fflush(stdout);
137         if(md5_failure) {
138                 fprintf(stderr, "%s: WARNING, MD5 signature mismatch\n", infile);
139                 return 1;
140         }
141         else {
142                 if(stream_info.test_only)
143                         printf("%s: ok\n", infile);
144         }
145         return 0;
146 wav_abort_:
147         if(decoder) {
148                 if(decoder->state != FLAC__FILE_DECODER_UNINITIALIZED)
149                         FLAC__file_decoder_finish(decoder);
150                 FLAC__file_decoder_free_instance(decoder);
151         }
152         if(!stream_info.test_only) {
153                 fclose(stream_info.fout);
154                 unlink(outfile);
155         }
156         return 1;
157 }
158
159 int decode_raw(const char *infile, const char *outfile, bool analysis_mode, bool verbose, uint64 skip, bool is_big_endian, bool is_unsigned_samples)
160 {
161         bool md5_failure = false;
162         stream_info_struct stream_info;
163
164         decoder = 0;
165         stream_info.abort_flag = false;
166         stream_info.analysis_mode = analysis_mode;
167         stream_info.test_only = (outfile == 0);
168         stream_info.is_wave_out = false;
169         stream_info.is_big_endian = is_big_endian;
170         stream_info.is_unsigned_samples = is_unsigned_samples;
171         stream_info.verbose = verbose;
172         stream_info.skip = skip;
173         stream_info.samples_processed = 0;
174         stream_info.frame_counter = 0;
175
176         assert(!(stream_info.test_only && stream_info.analysis_mode));
177
178         if(!stream_info.test_only) {
179                 if(0 == strcmp(outfile, "-")) {
180                         stream_info.fout = stdout;
181                 }
182                 else {
183                         if(0 == (stream_info.fout = fopen(outfile, "wb"))) {
184                                 fprintf(stderr, "ERROR: can't open output file %s\n", outfile);
185                                 return false;
186                         }
187                 }
188         }
189
190         if(!init(infile, &stream_info))
191                 goto raw_abort_;
192
193         if(skip > 0) {
194                 if(!FLAC__file_decoder_process_metadata(decoder)) {
195                         fprintf(stderr, "%s: ERROR during decoding\n", infile);
196                         goto raw_abort_;
197                 }
198                 if(!FLAC__file_decoder_seek_absolute(decoder, skip)) {
199                         fprintf(stderr, "%s: ERROR seeking while skipping bytes\n", infile);
200                         goto raw_abort_;
201                 }
202                 if(!FLAC__file_decoder_process_remaining_frames(decoder)) {
203                         if(verbose) { printf("\n"); fflush(stdout); }
204                         fprintf(stderr, "%s: ERROR during decoding\n", infile);
205                         goto raw_abort_;
206                 }
207                 if(decoder->state != FLAC__FILE_DECODER_OK && decoder->state != FLAC__FILE_DECODER_END_OF_FILE) {
208                         if(verbose) { printf("\n"); fflush(stdout); }
209                         fprintf(stderr, "%s: ERROR during decoding\n", infile);
210                         goto raw_abort_;
211                 }
212         }
213         else {
214                 if(!FLAC__file_decoder_process_whole_file(decoder)) {
215                         if(verbose) { printf("\n"); fflush(stdout); }
216                         fprintf(stderr, "%s: ERROR during decoding\n", infile);
217                         goto raw_abort_;
218                 }
219                 if(decoder->state != FLAC__FILE_DECODER_OK && decoder->state != FLAC__FILE_DECODER_END_OF_FILE) {
220                         if(verbose) { printf("\n"); fflush(stdout); }
221                         fprintf(stderr, "%s: ERROR during decoding\n", infile);
222                         goto raw_abort_;
223                 }
224         }
225
226         if(decoder) {
227                 if(decoder->state != FLAC__FILE_DECODER_UNINITIALIZED)
228                         md5_failure = !FLAC__file_decoder_finish(decoder);
229                 print_stats(&stream_info);
230                 FLAC__file_decoder_free_instance(decoder);
231         }
232         if(!stream_info.test_only)
233                 fclose(stream_info.fout);
234         if(verbose)
235                 printf("\n");
236         fflush(stdout);
237         if(md5_failure) {
238                 fprintf(stderr, "%s: WARNING, MD5 signature mismatch\n", infile);
239                 return 1;
240         }
241         else {
242                 if(stream_info.test_only)
243                         printf("%s: ok\n", infile);
244         }
245         return 0;
246 raw_abort_:
247         if(decoder) {
248                 if(decoder->state != FLAC__FILE_DECODER_UNINITIALIZED)
249                         FLAC__file_decoder_finish(decoder);
250                 FLAC__file_decoder_free_instance(decoder);
251         }
252         if(!stream_info.test_only) {
253                 fclose(stream_info.fout);
254                 unlink(outfile);
255         }
256         return 1;
257 }
258
259 bool init(const char *infile, stream_info_struct *stream_info)
260 {
261         uint32 test = 1;
262
263         is_big_endian_host = (*((byte*)(&test)))? false : true;
264
265         decoder = FLAC__file_decoder_get_new_instance();
266         if(0 == decoder) {
267                 fprintf(stderr, "ERROR creating the decoder instance\n");
268                 return false;
269         }
270         decoder->check_md5 = true;
271
272         if(FLAC__file_decoder_init(decoder, infile, write_callback, metadata_callback, error_callback, stream_info) != FLAC__FILE_DECODER_OK) {
273                 fprintf(stderr, "ERROR initializing decoder, state = %d\n", decoder->state);
274                 return false;
275         }
276
277         return true;
278 }
279
280 bool write_little_endian_uint16(FILE *f, uint16 val)
281 {
282         byte *b = (byte*)(&val);
283         if(is_big_endian_host) {
284                 byte tmp;
285                 tmp = b[1]; b[1] = b[0]; b[0] = tmp;
286         }
287         return fwrite(b, 1, 2, f) == 2;
288 }
289
290 bool write_little_endian_uint32(FILE *f, uint32 val)
291 {
292         byte *b = (byte*)(&val);
293         if(is_big_endian_host) {
294                 byte tmp;
295                 tmp = b[3]; b[3] = b[0]; b[0] = tmp;
296                 tmp = b[2]; b[2] = b[1]; b[1] = tmp;
297         }
298         return fwrite(b, 1, 4, f) == 4;
299 }
300
301 FLAC__StreamDecoderWriteStatus write_callback(const FLAC__FileDecoder *decoder, const FLAC__Frame *frame, const int32 *buffer[], void *client_data)
302 {
303         stream_info_struct *stream_info = (stream_info_struct *)client_data;
304         FILE *fout = stream_info->fout;
305         unsigned bps = stream_info->bps, channels = stream_info->channels;
306         bool is_big_endian = (stream_info->is_wave_out? false : stream_info->is_big_endian);
307         bool is_unsigned_samples = (stream_info->is_wave_out? bps<=8 : stream_info->is_unsigned_samples);
308         unsigned wide_samples = frame->header.blocksize, wide_sample, sample, channel, byte;
309         static int8 s8buffer[FLAC__MAX_BLOCK_SIZE * FLAC__MAX_CHANNELS * ((FLAC__MAX_BITS_PER_SAMPLE+7)>>3)]; /* WATCHOUT: can be up to 2 megs */
310         uint8  *u8buffer  = (uint8  *)s8buffer;
311         int16  *s16buffer = (int16  *)s8buffer;
312         uint16 *u16buffer = (uint16 *)s8buffer;
313         int32  *s32buffer = (int32  *)s8buffer;
314         uint32 *u32buffer = (uint32 *)s8buffer;
315
316         (void)decoder;
317
318         if(stream_info->abort_flag)
319                 return FLAC__STREAM_DECODER_WRITE_ABORT;
320
321         stream_info->samples_processed += wide_samples;
322         stream_info->frame_counter++;
323
324         if(stream_info->verbose && !(stream_info->frame_counter & 0x1f))
325                 print_stats(stream_info);
326
327         if(stream_info->analysis_mode) {
328                 unsigned i;
329                 fprintf(fout, "frame=%u\tblocksize=%u\tsample_rate=%u\tchannels=%u\tchannel_assignment=%s\n", stream_info->frame_counter-1, frame->header.blocksize, frame->header.sample_rate, frame->header.channels, FLAC__ChannelAssignmentString[frame->header.channel_assignment]);
330                 for(channel = 0; channel < channels; channel++) {
331                         const FLAC__Subframe *subframe = frame->subframes+channel;
332                         fprintf(fout, "\tsubframe=%u\ttype=%s", channel, FLAC__SubframeTypeString[subframe->type]);
333                         switch(subframe->type) {
334                                 case FLAC__SUBFRAME_TYPE_CONSTANT:
335                                         fprintf(fout, "\tvalue=%d\n", subframe->data.constant.value);
336                                         break;
337                                 case FLAC__SUBFRAME_TYPE_FIXED:
338                                         fprintf(fout, "\torder=%u\tpartition_order=%u\n", subframe->data.fixed.order, subframe->data.fixed.entropy_coding_method.data.partitioned_rice.order); /*@@@ assumes method is partitioned-rice */
339                                         for(i = 0; i < subframe->data.fixed.order; i++)
340                                                 fprintf(fout, "\twarmup[%u]=%d\n", i, subframe->data.fixed.warmup[i]);
341                                         break;
342                                 case FLAC__SUBFRAME_TYPE_LPC:
343                                         fprintf(fout, "\torder=%u\tpartition_order=%u\tqlp_coeff_precision=%u\tquantization_level=%d\n", subframe->data.lpc.order, subframe->data.lpc.entropy_coding_method.data.partitioned_rice.order, subframe->data.lpc.qlp_coeff_precision, subframe->data.lpc.quantization_level); /*@@@ assumes method is partitioned-rice */
344                                         for(i = 0; i < subframe->data.lpc.order; i++)
345                                                 fprintf(fout, "\twarmup[%u]=%d\n", i, subframe->data.lpc.warmup[i]);
346                                         break;
347                                 case FLAC__SUBFRAME_TYPE_VERBATIM:
348                                         fprintf(fout, "\n");
349                                         break;
350                         }
351                 }
352         }
353         else if(!stream_info->test_only) {
354                 if(bps == 8) {
355                         if(is_unsigned_samples) {
356                                 for(sample = wide_sample = 0; wide_sample < wide_samples; wide_sample++)
357                                         for(channel = 0; channel < channels; channel++, sample++)
358                                                 u8buffer[sample] = buffer[channel][wide_sample] + 0x80;
359                         }
360                         else {
361                                 for(sample = wide_sample = 0; wide_sample < wide_samples; wide_sample++)
362                                         for(channel = 0; channel < channels; channel++, sample++)
363                                                 s8buffer[sample] = buffer[channel][wide_sample];
364                         }
365                         if(fwrite(u8buffer, 1, sample, fout) != sample)
366                                 return FLAC__STREAM_DECODER_WRITE_ABORT;
367                 }
368                 else if(bps == 16) {
369                         if(is_unsigned_samples) {
370                                 for(sample = wide_sample = 0; wide_sample < wide_samples; wide_sample++)
371                                         for(channel = 0; channel < channels; channel++, sample++)
372                                                 u16buffer[sample] = buffer[channel][wide_sample] + 0x8000;
373                         }
374                         else {
375                                 for(sample = wide_sample = 0; wide_sample < wide_samples; wide_sample++)
376                                         for(channel = 0; channel < channels; channel++, sample++)
377                                                 s16buffer[sample] = buffer[channel][wide_sample];
378                         }
379                         if(is_big_endian != is_big_endian_host) {
380                                 unsigned char tmp;
381                                 const unsigned bytes = sample * 2;
382                                 for(byte = 0; byte < bytes; byte += 2) {
383                                         tmp = u8buffer[byte];
384                                         u8buffer[byte] = u8buffer[byte+1];
385                                         u8buffer[byte+1] = tmp;
386                                 }
387                         }
388                         if(fwrite(u16buffer, 2, sample, fout) != sample)
389                                 return FLAC__STREAM_DECODER_WRITE_ABORT;
390                 }
391                 else if(bps == 24) {
392                         if(is_unsigned_samples) {
393                                 for(sample = wide_sample = 0; wide_sample < wide_samples; wide_sample++)
394                                         for(channel = 0; channel < channels; channel++, sample++)
395                                                 u32buffer[sample] = buffer[channel][wide_sample] + 0x800000;
396                         }
397                         else {
398                                 for(sample = wide_sample = 0; wide_sample < wide_samples; wide_sample++)
399                                         for(channel = 0; channel < channels; channel++, sample++)
400                                                 s32buffer[sample] = buffer[channel][wide_sample];
401                         }
402                         if(is_big_endian != is_big_endian_host) {
403                                 unsigned char tmp;
404                                 const unsigned bytes = sample * 4;
405                                 for(byte = 0; byte < bytes; byte += 4) {
406                                         tmp = u8buffer[byte];
407                                         u8buffer[byte] = u8buffer[byte+3];
408                                         u8buffer[byte+3] = tmp;
409                                         tmp = u8buffer[byte+1];
410                                         u8buffer[byte+1] = u8buffer[byte+2];
411                                         u8buffer[byte+2] = tmp;
412                                 }
413                         }
414                         if(is_big_endian) {
415                                 unsigned lbyte;
416                                 const unsigned bytes = sample * 4;
417                                 for(lbyte = byte = 0; byte < bytes; ) {
418                                         byte++;
419                                         u8buffer[lbyte++] = u8buffer[byte++];
420                                         u8buffer[lbyte++] = u8buffer[byte++];
421                                         u8buffer[lbyte++] = u8buffer[byte++];
422                                 }
423                         }
424                         else {
425                                 unsigned lbyte;
426                                 const unsigned bytes = sample * 4;
427                                 for(lbyte = byte = 0; byte < bytes; ) {
428                                         u8buffer[lbyte++] = u8buffer[byte++];
429                                         u8buffer[lbyte++] = u8buffer[byte++];
430                                         u8buffer[lbyte++] = u8buffer[byte++];
431                                         byte++;
432                                 }
433                         }
434                         if(fwrite(u8buffer, 3, sample, fout) != sample)
435                                 return FLAC__STREAM_DECODER_WRITE_ABORT;
436                 }
437                 else {
438                         assert(0);
439                 }
440         }
441         return FLAC__STREAM_DECODER_WRITE_CONTINUE;
442 }
443
444 void metadata_callback(const FLAC__FileDecoder *decoder, const FLAC__StreamMetaData *metadata, void *client_data)
445 {
446         stream_info_struct *stream_info = (stream_info_struct *)client_data;
447         (void)decoder;
448         if(metadata->type == FLAC__METADATA_TYPE_STREAMINFO) {
449                 stream_info->total_samples = metadata->data.stream_info.total_samples - stream_info->skip;
450                 stream_info->bps = metadata->data.stream_info.bits_per_sample;
451                 stream_info->channels = metadata->data.stream_info.channels;
452                 stream_info->sample_rate = metadata->data.stream_info.sample_rate;
453
454                 if(stream_info->bps != 8 && stream_info->bps != 16 && stream_info->bps != 24) {
455                         fprintf(stderr, "ERROR: bits per sample is not 8/16/24\n");
456                         stream_info->abort_flag = true;
457                         return;
458                 }
459
460                 /* write the WAVE headers if necessary */
461                 if(!stream_info->analysis_mode && !stream_info->test_only && stream_info->is_wave_out) {
462                         uint64 data_size = stream_info->total_samples * stream_info->channels * ((stream_info->bps+7)/8);
463                         if(data_size >= 0xFFFFFFDC) {
464                                 fprintf(stderr, "ERROR: stream is too big for a wave file\n");
465                                 stream_info->abort_flag = true;
466                                 return;
467                         }
468                         if(fwrite("RIFF", 1, 4, stream_info->fout) != 4) stream_info->abort_flag = true;
469                         if(!write_little_endian_uint32(stream_info->fout, (uint32)(data_size+36))) stream_info->abort_flag = true; /* filesize-8 */
470                         if(fwrite("WAVEfmt ", 1, 8, stream_info->fout) != 8) stream_info->abort_flag = true;
471                         if(fwrite("\020\000\000\000", 1, 4, stream_info->fout) != 4) stream_info->abort_flag = true; /* chunk size = 16 */
472                         if(fwrite("\001\000", 1, 2, stream_info->fout) != 2) stream_info->abort_flag = true; /* compression code == 1 */
473                         if(!write_little_endian_uint16(stream_info->fout, (uint16)(stream_info->channels))) stream_info->abort_flag = true;
474                         if(!write_little_endian_uint32(stream_info->fout, stream_info->sample_rate)) stream_info->abort_flag = true;
475                         if(!write_little_endian_uint32(stream_info->fout, stream_info->sample_rate * stream_info->channels * ((stream_info->bps+7) / 8))) stream_info->abort_flag = true; /* @@@ or is it (sample_rate*channels*bps) / 8 ??? */
476                         if(!write_little_endian_uint16(stream_info->fout, (uint16)(stream_info->channels * ((stream_info->bps+7) / 8)))) stream_info->abort_flag = true; /* block align */
477                         if(!write_little_endian_uint16(stream_info->fout, (uint16)(stream_info->bps))) stream_info->abort_flag = true; /* bits per sample */
478                         if(fwrite("data", 1, 4, stream_info->fout) != 4) stream_info->abort_flag = true;
479                         if(!write_little_endian_uint32(stream_info->fout, (uint32)data_size)) stream_info->abort_flag = true; /* data size */
480                 }
481         }
482 }
483
484 void error_callback(const FLAC__FileDecoder *decoder, FLAC__StreamDecoderErrorStatus status, void *client_data)
485 {
486         stream_info_struct *stream_info = (stream_info_struct *)client_data;
487         (void)decoder;
488         fprintf(stderr, "*** Got error code %d\n", status);
489         stream_info->abort_flag = true;
490 }
491
492 void print_stats(const stream_info_struct *stream_info)
493 {
494         if(stream_info->verbose) {
495                 printf("\r%s %u of %u samples, %6.2f%% complete",
496                         stream_info->test_only? "tested" : stream_info->analysis_mode? "analyzed" : "wrote",
497                         (unsigned)stream_info->samples_processed,
498                         (unsigned)stream_info->total_samples,
499 #ifdef _MSC_VER
500                         /* with VC++ you have to spoon feed it the casting */
501                         (double)(int64)stream_info->samples_processed / (double)(int64)stream_info->total_samples * 100.0
502 #else
503                         (double)stream_info->samples_processed / (double)stream_info->total_samples * 100.0
504 #endif
505                 );
506                 fflush(stdout);
507         }
508 }