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 <math.h> /* for floor() */
  26 #include <stdio.h> /* for FILE et al. */
  27 #include <string.h> /* for strcmp() */
  28 #include "FLAC/all.h"
  29 #include "decode.h"
  30 #include "file.h"
  31
  32 typedef struct {
  33         const char *inbasefilename;
  34         FILE *fout;
  35         bool abort_flag;
  36         bool analysis_mode;
  37         analysis_options aopts;
  38         bool test_only;
  39         bool is_wave_out;
  40         bool is_big_endian;
  41         bool is_unsigned_samples;
  42         uint64 total_samples;
  43         unsigned bps;
  44         unsigned channels;
  45         unsigned sample_rate;
  46         bool verbose;
  47         uint64 skip;
  48         bool skip_count_too_high;
  49         uint64 samples_processed;
  50         unsigned frame_counter;
  51 } stream_info_struct;
  52
  53 static FLAC__FileDecoder *decoder;
  54 static bool is_big_endian_host;
  55
  56 /* local routines */
  57 static bool init(const char *infilename, stream_info_struct *stream_info);
  58 static bool write_little_endian_uint16(FILE *f, uint16 val);
  59 static bool write_little_endian_uint32(FILE *f, uint32 val);
  60 static FLAC__StreamDecoderWriteStatus write_callback(const FLAC__FileDecoder *decoder, const FLAC__Frame *frame, const int32 *buffer[], void *client_data);
  61 static void metadata_callback(const FLAC__FileDecoder *decoder, const FLAC__StreamMetaData *metadata, void *client_data);
  62 static void error_callback(const FLAC__FileDecoder *decoder, FLAC__StreamDecoderErrorStatus status, void *client_data);
  63 static void print_stats(const stream_info_struct *stream_info);
  64
  65 int flac__decode_wav(const char *infile, const char *outfile, bool analysis_mode, analysis_options aopts, bool verbose, uint64 skip)
  66 {
  67         bool md5_failure = false;
  68         stream_info_struct stream_info;
  69
  70         decoder = 0;
  71         stream_info.abort_flag = false;
  72         stream_info.analysis_mode = analysis_mode;
  73         stream_info.aopts = aopts;
  74         stream_info.test_only = (outfile == 0);
  75         stream_info.is_wave_out = true;
  76         stream_info.verbose = verbose;
  77         stream_info.skip = skip;
  78         stream_info.skip_count_too_high = false;
  79         stream_info.samples_processed = 0;
  80         stream_info.frame_counter = 0;
  81         stream_info.inbasefilename = flac__file_get_basename(infile);
  82         stream_info.fout = 0; /* initialized with an open file later if necessary */
  83
  84         FLAC__ASSERT(!(stream_info.test_only && stream_info.analysis_mode));
  85
  86         if(!stream_info.test_only) {
  87                 if(0 == strcmp(outfile, "-")) {
  88                         stream_info.fout = stdout;
  89                 }
  90                 else {
  91                         if(0 == (stream_info.fout = fopen(outfile, "wb"))) {
  92                                 fprintf(stderr, "%s: ERROR: can't open output file %s\n", stream_info.inbasefilename, outfile);
  93                                 return 1;
  94                         }
  95                 }
  96         }
  97
  98         if(analysis_mode)
  99                 flac__analyze_init(aopts);
 100
 101         if(!init(infile, &stream_info))
 102                 goto wav_abort_;
 103
 104         if(skip > 0) {
 105                 if(!FLAC__file_decoder_process_metadata(decoder)) {
 106                         fprintf(stderr, "%s: ERROR while decoding metadata, state=%d:%s\n", stream_info.inbasefilename, FLAC__file_decoder_get_state(decoder), FLAC__FileDecoderStateString[FLAC__file_decoder_get_state(decoder)]);
 107                         goto wav_abort_;
 108                 }
 109                 if(stream_info.skip_count_too_high) {
 110                         fprintf(stderr, "%s: ERROR trying to skip more samples than in stream\n", stream_info.inbasefilename);
 111                         goto wav_abort_;
 112                 }
 113                 if(!FLAC__file_decoder_seek_absolute(decoder, skip)) {
 114                         fprintf(stderr, "%s: ERROR seeking while skipping bytes, state=%d:%s\n", stream_info.inbasefilename, FLAC__file_decoder_get_state(decoder), FLAC__FileDecoderStateString[FLAC__file_decoder_get_state(decoder)]);
 115                         goto wav_abort_;
 116                 }
 117                 if(!FLAC__file_decoder_process_remaining_frames(decoder)) {
 118                         if(verbose) fprintf(stderr, "\n");
 119                         fprintf(stderr, "%s: ERROR while decoding frames, state=%d:%s\n", stream_info.inbasefilename, FLAC__file_decoder_get_state(decoder), FLAC__FileDecoderStateString[FLAC__file_decoder_get_state(decoder)]);
 120                         goto wav_abort_;
 121                 }
 122                 if(FLAC__file_decoder_get_state(decoder) != FLAC__FILE_DECODER_OK && FLAC__file_decoder_get_state(decoder) != FLAC__FILE_DECODER_END_OF_FILE) {
 123                         if(verbose) fprintf(stderr, "\n");
 124                         fprintf(stderr, "%s: ERROR during decoding, state=%d:%s\n", stream_info.inbasefilename, FLAC__file_decoder_get_state(decoder), FLAC__FileDecoderStateString[FLAC__file_decoder_get_state(decoder)]);
 125                         goto wav_abort_;
 126                 }
 127         }
 128         else {
 129                 if(!FLAC__file_decoder_process_whole_file(decoder)) {
 130                         if(verbose) fprintf(stderr, "\n");
 131                         fprintf(stderr, "%s: ERROR while decoding data, state=%d:%s\n", stream_info.inbasefilename, FLAC__file_decoder_get_state(decoder), FLAC__FileDecoderStateString[FLAC__file_decoder_get_state(decoder)]);
 132                         goto wav_abort_;
 133                 }
 134                 if(FLAC__file_decoder_get_state(decoder) != FLAC__FILE_DECODER_OK && FLAC__file_decoder_get_state(decoder) != FLAC__FILE_DECODER_END_OF_FILE) {
 135                         if(verbose) fprintf(stderr, "\n");
 136                         fprintf(stderr, "%s: ERROR during decoding, state=%d:%s\n", stream_info.inbasefilename, FLAC__file_decoder_get_state(decoder), FLAC__FileDecoderStateString[FLAC__file_decoder_get_state(decoder)]);
 137                         goto wav_abort_;
 138                 }
 139         }
 140
 141         if(decoder) {
 142                 if(FLAC__file_decoder_get_state(decoder) != FLAC__FILE_DECODER_UNINITIALIZED)
 143                         md5_failure = !FLAC__file_decoder_finish(decoder);
 144                 print_stats(&stream_info);
 145                 FLAC__file_decoder_delete(decoder);
 146         }
 147         if(0 != stream_info.fout && stream_info.fout != stdout)
 148                 fclose(stream_info.fout);
 149         if(analysis_mode)
 150                 flac__analyze_finish(aopts);
 151         if(md5_failure) {
 152                 fprintf(stderr, "\r%s: WARNING, MD5 signature mismatch\n", stream_info.inbasefilename);
 153         }
 154         else {
 155                 if(verbose)
 156                         fprintf(stderr, "\r%s: %s         \n", stream_info.inbasefilename, stream_info.test_only? "ok           ":analysis_mode?"done           ":"done");
 157         }
 158         return 0;
 159 wav_abort_:
 160         if(decoder) {
 161                 if(FLAC__file_decoder_get_state(decoder) != FLAC__FILE_DECODER_UNINITIALIZED)
 162                         FLAC__file_decoder_finish(decoder);
 163                 FLAC__file_decoder_delete(decoder);
 164         }
 165         if(0 != stream_info.fout && stream_info.fout != stdout) {
 166                 fclose(stream_info.fout);
 167                 unlink(outfile);
 168         }
 169         if(analysis_mode)
 170                 flac__analyze_finish(aopts);
 171         return 1;
 172 }
 173
 174 int flac__decode_raw(const char *infile, const char *outfile, bool analysis_mode, analysis_options aopts, bool verbose, uint64 skip, bool is_big_endian, bool is_unsigned_samples)
 175 {
 176         bool md5_failure = false;
 177         stream_info_struct stream_info;
 178
 179         decoder = 0;
 180         stream_info.abort_flag = false;
 181         stream_info.analysis_mode = analysis_mode;
 182         stream_info.aopts = aopts;
 183         stream_info.test_only = (outfile == 0);
 184         stream_info.is_wave_out = false;
 185         stream_info.is_big_endian = is_big_endian;
 186         stream_info.is_unsigned_samples = is_unsigned_samples;
 187         stream_info.verbose = verbose;
 188         stream_info.skip = skip;
 189         stream_info.skip_count_too_high = false;
 190         stream_info.samples_processed = 0;
 191         stream_info.frame_counter = 0;
 192         stream_info.inbasefilename = flac__file_get_basename(infile);
 193         stream_info.fout = 0; /* initialized with an open file later if necessary */
 194
 195         FLAC__ASSERT(!(stream_info.test_only && stream_info.analysis_mode));
 196
 197         if(!stream_info.test_only) {
 198                 if(0 == strcmp(outfile, "-")) {
 199                         stream_info.fout = stdout;
 200                 }
 201                 else {
 202                         if(0 == (stream_info.fout = fopen(outfile, "wb"))) {
 203                                 fprintf(stderr, "%s: ERROR: can't open output file %s\n", stream_info.inbasefilename, outfile);
 204                                 return 1;
 205                         }
 206                 }
 207         }
 208
 209         if(analysis_mode)
 210                 flac__analyze_init(aopts);
 211
 212         if(!init(infile, &stream_info))
 213                 goto raw_abort_;
 214
 215         if(skip > 0) {
 216                 if(!FLAC__file_decoder_process_metadata(decoder)) {
 217                         fprintf(stderr, "%s: ERROR while decoding metadata, state=%d:%s\n", stream_info.inbasefilename, FLAC__file_decoder_get_state(decoder), FLAC__FileDecoderStateString[FLAC__file_decoder_get_state(decoder)]);
 218                         goto raw_abort_;
 219                 }
 220                 if(stream_info.skip_count_too_high) {
 221                         fprintf(stderr, "%s: ERROR trying to skip more samples than in stream\n", stream_info.inbasefilename);
 222                         goto raw_abort_;
 223                 }
 224                 if(!FLAC__file_decoder_seek_absolute(decoder, skip)) {
 225                         fprintf(stderr, "%s: ERROR seeking while skipping bytes, state=%d:%s\n", stream_info.inbasefilename, FLAC__file_decoder_get_state(decoder), FLAC__FileDecoderStateString[FLAC__file_decoder_get_state(decoder)]);
 226                         goto raw_abort_;
 227                 }
 228                 if(!FLAC__file_decoder_process_remaining_frames(decoder)) {
 229                         if(verbose) fprintf(stderr, "\n");
 230                         fprintf(stderr, "%s: ERROR while decoding frames, state=%d:%s\n", stream_info.inbasefilename, FLAC__file_decoder_get_state(decoder), FLAC__FileDecoderStateString[FLAC__file_decoder_get_state(decoder)]);
 231                         goto raw_abort_;
 232                 }
 233                 if(FLAC__file_decoder_get_state(decoder) != FLAC__FILE_DECODER_OK && FLAC__file_decoder_get_state(decoder) != FLAC__FILE_DECODER_END_OF_FILE) {
 234                         if(verbose) fprintf(stderr, "\n");
 235                         fprintf(stderr, "%s: ERROR during decoding, state=%d:%s\n", stream_info.inbasefilename, FLAC__file_decoder_get_state(decoder), FLAC__FileDecoderStateString[FLAC__file_decoder_get_state(decoder)]);
 236                         goto raw_abort_;
 237                 }
 238         }
 239         else {
 240                 if(!FLAC__file_decoder_process_whole_file(decoder)) {
 241                         if(verbose) fprintf(stderr, "\n");
 242                         fprintf(stderr, "%s: ERROR while decoding data, state=%d:%s\n", stream_info.inbasefilename, FLAC__file_decoder_get_state(decoder), FLAC__FileDecoderStateString[FLAC__file_decoder_get_state(decoder)]);
 243                         goto raw_abort_;
 244                 }
 245                 if(FLAC__file_decoder_get_state(decoder) != FLAC__FILE_DECODER_OK && FLAC__file_decoder_get_state(decoder) != FLAC__FILE_DECODER_END_OF_FILE) {
 246                         if(verbose) fprintf(stderr, "\n");
 247                         fprintf(stderr, "%s: ERROR during decoding, state=%d:%s\n", stream_info.inbasefilename, FLAC__file_decoder_get_state(decoder), FLAC__FileDecoderStateString[FLAC__file_decoder_get_state(decoder)]);
 248                         goto raw_abort_;
 249                 }
 250         }
 251
 252         if(decoder) {
 253                 if(FLAC__file_decoder_get_state(decoder) != FLAC__FILE_DECODER_UNINITIALIZED)
 254                         md5_failure = !FLAC__file_decoder_finish(decoder);
 255                 print_stats(&stream_info);
 256                 FLAC__file_decoder_delete(decoder);
 257         }
 258         if(0 != stream_info.fout && stream_info.fout != stdout)
 259                 fclose(stream_info.fout);
 260         if(analysis_mode)
 261                 flac__analyze_finish(aopts);
 262         if(md5_failure) {
 263                 fprintf(stderr, "\r%s: WARNING, MD5 signature mismatch\n", stream_info.inbasefilename);
 264         }
 265         else {
 266                 if(verbose)
 267                         fprintf(stderr, "\r%s: %s         \n", stream_info.inbasefilename, stream_info.test_only? "ok           ":analysis_mode?"done           ":"done");
 268         }
 269         return 0;
 270 raw_abort_:
 271         if(decoder) {
 272                 if(FLAC__file_decoder_get_state(decoder) != FLAC__FILE_DECODER_UNINITIALIZED)
 273                         FLAC__file_decoder_finish(decoder);
 274                 FLAC__file_decoder_delete(decoder);
 275         }
 276         if(0 != stream_info.fout && stream_info.fout != stdout) {
 277                 fclose(stream_info.fout);
 278                 unlink(outfile);
 279         }
 280         if(analysis_mode)
 281                 flac__analyze_finish(aopts);
 282         return 1;
 283 }
 284
 285 bool init(const char *infilename, stream_info_struct *stream_info)
 286 {
 287         uint32 test = 1;
 288
 289         is_big_endian_host = (*((byte*)(&test)))? false : true;
 290
 291         decoder = FLAC__file_decoder_new();
 292         if(0 == decoder) {
 293                 fprintf(stderr, "%s: ERROR creating the decoder instance\n", stream_info->inbasefilename);
 294                 return false;
 295         }
 296
 297         FLAC__file_decoder_set_md5_checking(decoder, true);
 298         FLAC__file_decoder_set_filename(decoder, infilename);
 299         FLAC__file_decoder_set_write_callback(decoder, write_callback);
 300         FLAC__file_decoder_set_metadata_callback(decoder, metadata_callback);
 301         FLAC__file_decoder_set_error_callback(decoder, error_callback);
 302         FLAC__file_decoder_set_client_data(decoder, stream_info);
 303
 304         if(FLAC__file_decoder_init(decoder) != FLAC__FILE_DECODER_OK) {
 305                 fprintf(stderr, "%s: ERROR initializing decoder, state=%d:%s\n", stream_info->inbasefilename, FLAC__file_decoder_get_state(decoder), FLAC__FileDecoderStateString[FLAC__file_decoder_get_state(decoder)]);
 306                 return false;
 307         }
 308
 309         return true;
 310 }
 311
 312 bool write_little_endian_uint16(FILE *f, uint16 val)
 313 {
 314         byte *b = (byte*)(&val);
 315         if(is_big_endian_host) {
 316                 byte tmp;
 317                 tmp = b[1]; b[1] = b[0]; b[0] = tmp;
 318         }
 319         return fwrite(b, 1, 2, f) == 2;
 320 }
 321
 322 bool write_little_endian_uint32(FILE *f, uint32 val)
 323 {
 324         byte *b = (byte*)(&val);
 325         if(is_big_endian_host) {
 326                 byte tmp;
 327                 tmp = b[3]; b[3] = b[0]; b[0] = tmp;
 328                 tmp = b[2]; b[2] = b[1]; b[1] = tmp;
 329         }
 330         return fwrite(b, 1, 4, f) == 4;
 331 }
 332
 333 FLAC__StreamDecoderWriteStatus write_callback(const FLAC__FileDecoder *decoder, const FLAC__Frame *frame, const int32 *buffer[], void *client_data)
 334 {
 335         stream_info_struct *stream_info = (stream_info_struct *)client_data;
 336         FILE *fout = stream_info->fout;
 337         unsigned bps = stream_info->bps, channels = stream_info->channels;
 338         bool is_big_endian = (stream_info->is_wave_out? false : stream_info->is_big_endian);
 339         bool is_unsigned_samples = (stream_info->is_wave_out? bps<=8 : stream_info->is_unsigned_samples);
 340         unsigned wide_samples = frame->header.blocksize, wide_sample, sample, channel, byte;
 341         static int8 s8buffer[FLAC__MAX_BLOCK_SIZE * FLAC__MAX_CHANNELS * sizeof(int32)]; /* WATCHOUT: can be up to 2 megs */
 342         /* WATCHOUT: we say 'sizeof(int32)' above instead of '(FLAC__MAX_BITS_PER_SAMPLE+7)/8' because we have to use an array int32 even for 24 bps */
 343         uint8  *u8buffer  = (uint8  *)s8buffer;
 344         int16  *s16buffer = (int16  *)s8buffer;
 345         uint16 *u16buffer = (uint16 *)s8buffer;
 346         int32  *s32buffer = (int32  *)s8buffer;
 347         uint32 *u32buffer = (uint32 *)s8buffer;
 348
 349         (void)decoder;
 350
 351         if(stream_info->abort_flag)
 352                 return FLAC__STREAM_DECODER_WRITE_ABORT;
 353
 354         stream_info->samples_processed += wide_samples;
 355         stream_info->frame_counter++;
 356
 357         if(stream_info->verbose && !(stream_info->frame_counter & 0x7f))
 358                 print_stats(stream_info);
 359
 360         if(stream_info->analysis_mode) {
 361                 flac__analyze_frame(frame, stream_info->frame_counter-1, stream_info->aopts, fout);
 362         }
 363         else if(!stream_info->test_only) {
 364                 if(bps == 8) {
 365                         if(is_unsigned_samples) {
 366                                 for(sample = wide_sample = 0; wide_sample < wide_samples; wide_sample++)
 367                                         for(channel = 0; channel < channels; channel++, sample++)
 368                                                 u8buffer[sample] = buffer[channel][wide_sample] + 0x80;
 369                         }
 370                         else {
 371                                 for(sample = wide_sample = 0; wide_sample < wide_samples; wide_sample++)
 372                                         for(channel = 0; channel < channels; channel++, sample++)
 373                                                 s8buffer[sample] = buffer[channel][wide_sample];
 374                         }
 375                         if(fwrite(u8buffer, 1, sample, fout) != sample)
 376                                 return FLAC__STREAM_DECODER_WRITE_ABORT;
 377                 }
 378                 else if(bps == 16) {
 379                         if(is_unsigned_samples) {
 380                                 for(sample = wide_sample = 0; wide_sample < wide_samples; wide_sample++)
 381                                         for(channel = 0; channel < channels; channel++, sample++)
 382                                                 u16buffer[sample] = buffer[channel][wide_sample] + 0x8000;
 383                         }
 384                         else {
 385                                 for(sample = wide_sample = 0; wide_sample < wide_samples; wide_sample++)
 386                                         for(channel = 0; channel < channels; channel++, sample++)
 387                                                 s16buffer[sample] = buffer[channel][wide_sample];
 388                         }
 389                         if(is_big_endian != is_big_endian_host) {
 390                                 unsigned char tmp;
 391                                 const unsigned bytes = sample * 2;
 392                                 for(byte = 0; byte < bytes; byte += 2) {
 393                                         tmp = u8buffer[byte];
 394                                         u8buffer[byte] = u8buffer[byte+1];
 395                                         u8buffer[byte+1] = tmp;
 396                                 }
 397                         }
 398                         if(fwrite(u16buffer, 2, sample, fout) != sample)
 399                                 return FLAC__STREAM_DECODER_WRITE_ABORT;
 400                 }
 401                 else if(bps == 24) {
 402                         if(is_unsigned_samples) {
 403                                 for(sample = wide_sample = 0; wide_sample < wide_samples; wide_sample++)
 404                                         for(channel = 0; channel < channels; channel++, sample++)
 405                                                 u32buffer[sample] = buffer[channel][wide_sample] + 0x800000;
 406                         }
 407                         else {
 408                                 for(sample = wide_sample = 0; wide_sample < wide_samples; wide_sample++)
 409                                         for(channel = 0; channel < channels; channel++, sample++)
 410                                                 s32buffer[sample] = buffer[channel][wide_sample];
 411                         }
 412                         if(is_big_endian != is_big_endian_host) {
 413                                 unsigned char tmp;
 414                                 const unsigned bytes = sample * 4;
 415                                 for(byte = 0; byte < bytes; byte += 4) {
 416                                         tmp = u8buffer[byte];
 417                                         u8buffer[byte] = u8buffer[byte+3];
 418                                         u8buffer[byte+3] = tmp;
 419                                         tmp = u8buffer[byte+1];
 420                                         u8buffer[byte+1] = u8buffer[byte+2];
 421                                         u8buffer[byte+2] = tmp;
 422                                 }
 423                         }
 424                         if(is_big_endian) {
 425                                 unsigned lbyte;
 426                                 const unsigned bytes = sample * 4;
 427                                 for(lbyte = byte = 0; byte < bytes; ) {
 428                                         byte++;
 429                                         u8buffer[lbyte++] = u8buffer[byte++];
 430                                         u8buffer[lbyte++] = u8buffer[byte++];
 431                                         u8buffer[lbyte++] = u8buffer[byte++];
 432                                 }
 433                         }
 434                         else {
 435                                 unsigned lbyte;
 436                                 const unsigned bytes = sample * 4;
 437                                 for(lbyte = byte = 0; byte < bytes; ) {
 438                                         u8buffer[lbyte++] = u8buffer[byte++];
 439                                         u8buffer[lbyte++] = u8buffer[byte++];
 440                                         u8buffer[lbyte++] = u8buffer[byte++];
 441                                         byte++;
 442                                 }
 443                         }
 444                         if(fwrite(u8buffer, 3, sample, fout) != sample)
 445                                 return FLAC__STREAM_DECODER_WRITE_ABORT;
 446                 }
 447                 else {
 448                         FLAC__ASSERT(0);
 449                 }
 450         }
 451         return FLAC__STREAM_DECODER_WRITE_CONTINUE;
 452 }
 453
 454 void metadata_callback(const FLAC__FileDecoder *decoder, const FLAC__StreamMetaData *metadata, void *client_data)
 455 {
 456         stream_info_struct *stream_info = (stream_info_struct *)client_data;
 457         (void)decoder;
 458         if(metadata->type == FLAC__METADATA_TYPE_STREAMINFO) {
 459                 /* remember, metadata->data.stream_info.total_samples can be 0, meaning 'unknown' */
 460                 if(metadata->data.stream_info.total_samples > 0 && stream_info->skip >= metadata->data.stream_info.total_samples) {
 461                         stream_info->total_samples = 0;
 462                         stream_info->skip_count_too_high = true;
 463                 }
 464                 else
 465                         stream_info->total_samples = metadata->data.stream_info.total_samples - stream_info->skip;
 466                 stream_info->bps = metadata->data.stream_info.bits_per_sample;
 467                 stream_info->channels = metadata->data.stream_info.channels;
 468                 stream_info->sample_rate = metadata->data.stream_info.sample_rate;
 469
 470                 if(stream_info->bps != 8 && stream_info->bps != 16 && stream_info->bps != 24) {
 471                         fprintf(stderr, "%s: ERROR: bits per sample is not 8/16/24\n", stream_info->inbasefilename);
 472                         stream_info->abort_flag = true;
 473                         return;
 474                 }
 475
 476                 /* write the WAVE headers if necessary */
 477                 if(!stream_info->analysis_mode && !stream_info->test_only && stream_info->is_wave_out) {
 478                         uint64 data_size = stream_info->total_samples * stream_info->channels * ((stream_info->bps+7)/8);
 479                         if(data_size >= 0xFFFFFFDC) {
 480                                 fprintf(stderr, "%s: ERROR: stream is too big to fit in a single WAVE file chunk\n", stream_info->inbasefilename);
 481                                 stream_info->abort_flag = true;
 482                                 return;
 483                         }
 484                         if(fwrite("RIFF", 1, 4, stream_info->fout) != 4) stream_info->abort_flag = true;
 485                         if(!write_little_endian_uint32(stream_info->fout, (uint32)(data_size+36))) stream_info->abort_flag = true; /* filesize-8 */
 486                         if(fwrite("WAVEfmt ", 1, 8, stream_info->fout) != 8) stream_info->abort_flag = true;
 487                         if(fwrite("\020\000\000\000", 1, 4, stream_info->fout) != 4) stream_info->abort_flag = true; /* chunk size = 16 */
 488                         if(fwrite("\001\000", 1, 2, stream_info->fout) != 2) stream_info->abort_flag = true; /* compression code == 1 */
 489                         if(!write_little_endian_uint16(stream_info->fout, (uint16)(stream_info->channels))) stream_info->abort_flag = true;
 490                         if(!write_little_endian_uint32(stream_info->fout, stream_info->sample_rate)) stream_info->abort_flag = true;
 491                         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 ??? */
 492                         if(!write_little_endian_uint16(stream_info->fout, (uint16)(stream_info->channels * ((stream_info->bps+7) / 8)))) stream_info->abort_flag = true; /* block align */
 493                         if(!write_little_endian_uint16(stream_info->fout, (uint16)(stream_info->bps))) stream_info->abort_flag = true; /* bits per sample */
 494                         if(fwrite("data", 1, 4, stream_info->fout) != 4) stream_info->abort_flag = true;
 495                         if(!write_little_endian_uint32(stream_info->fout, (uint32)data_size)) stream_info->abort_flag = true; /* data size */
 496                 }
 497         }
 498 }
 499
 500 void error_callback(const FLAC__FileDecoder *decoder, FLAC__StreamDecoderErrorStatus status, void *client_data)
 501 {
 502         stream_info_struct *stream_info = (stream_info_struct *)client_data;
 503         (void)decoder;
 504         fprintf(stderr, "%s: *** Got error code %d:%s\n", stream_info->inbasefilename, status, FLAC__StreamDecoderErrorStatusString[status]);
 505         stream_info->abort_flag = true;
 506 }
 507
 508 void print_stats(const stream_info_struct *stream_info)
 509 {
 510         if(stream_info->verbose) {
 511 #ifdef _MSC_VER
 512                 /* with VC++ you have to spoon feed it the casting */
 513                 const double progress = (double)(int64)stream_info->samples_processed / (double)(int64)stream_info->total_samples * 100.0;
 514 #else
 515                 const double progress = (double)stream_info->samples_processed / (double)stream_info->total_samples * 100.0;
 516 #endif
 517                 if(stream_info->total_samples > 0) {
 518                         fprintf(stderr, "\r%s: %s%u%% complete",
 519                                 stream_info->inbasefilename,
 520                                 stream_info->test_only? "testing, " : stream_info->analysis_mode? "analyzing, " : "",
 521                                 (unsigned)floor(progress + 0.5)
 522                         );
 523                 }
 524                 else {
 525                         fprintf(stderr, "\r%s: %s %u samples",
 526                                 stream_info->inbasefilename,
 527                                 stream_info->test_only? "tested" : stream_info->analysis_mode? "analyzed" : "wrote",
 528                                 (unsigned)stream_info->samples_processed
 529                         );
 530                 }
 531         }
 532 }