src/flac/decode.c

   1 /* flac - Command-line FLAC encoder/decoder
   2  * Copyright (C) 2000,2001,2002  Josh Coalson
   3  *
   4  * This program is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU General Public License
   6  * as published by the Free Software Foundation; either version 2
   7  * of the License, or (at your option) any later version.
   8  *
   9  * This program is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12  * GNU General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU General Public License
  15  * along with this program; if not, write to the Free Software
  16  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
  17  */
  18
  19 #if defined _WIN32 && !defined __CYGWIN__
  20 /* where MSVC puts unlink() */
  21 # include <io.h>
  22 #else
  23 # include <unistd.h>
  24 #endif
  25 #include <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 #ifdef FLAC__HAS_OGG
  32 #include "ogg/ogg.h"
  33 #endif
  34
  35 #ifdef FLAC__HAS_OGG
  36 typedef struct {
  37         ogg_sync_state oy;
  38         ogg_stream_state os;
  39 } ogg_info_struct;
  40 #endif
  41
  42 typedef struct {
  43         const char *inbasefilename;
  44 #ifdef FLAC__HAS_OGG
  45         FILE *fin;
  46 #endif
  47         FILE *fout;
  48         FLAC__bool abort_flag;
  49         FLAC__bool analysis_mode;
  50         analysis_options aopts;
  51         FLAC__bool test_only;
  52         FLAC__bool is_wave_out;
  53         FLAC__bool is_big_endian;
  54         FLAC__bool is_unsigned_samples;
  55         FLAC__uint64 total_samples;
  56         unsigned bps;
  57         unsigned channels;
  58         unsigned sample_rate;
  59         FLAC__bool verbose;
  60         FLAC__bool continue_through_decode_errors;
  61         struct {
  62                 FLAC__bool needs_fixup;
  63                 unsigned riff_offset;
  64                 unsigned data_offset;
  65         } wave_chunk_size_fixup;
  66         FLAC__uint64 skip;
  67         FLAC__uint64 samples_processed;
  68         unsigned frame_counter;
  69 #ifdef FLAC__HAS_OGG
  70         FLAC__bool is_ogg;
  71 #endif
  72         union {
  73                 FLAC__FileDecoder *file;
  74                 FLAC__StreamDecoder *stream;
  75         } decoder;
  76 #ifdef FLAC__HAS_OGG
  77         ogg_info_struct ogg;
  78 #endif
  79 } stream_info_struct;
  80
  81 static FLAC__bool is_big_endian_host;
  82
  83 /* local routines */
  84 static FLAC__bool init(const char *infilename, stream_info_struct *stream_info);
  85 static FLAC__bool write_little_endian_uint16(FILE *f, FLAC__uint16 val);
  86 static FLAC__bool write_little_endian_uint32(FILE *f, FLAC__uint32 val);
  87 static FLAC__bool fixup_wave_chunk_size(const char *outfilename, unsigned riff_offset, unsigned data_offset, FLAC__uint32 data_size);
  88 #ifdef FLAC__HAS_OGG
  89 static FLAC__StreamDecoderReadStatus read_callback(const FLAC__StreamDecoder *decoder, FLAC__byte buffer[], unsigned *bytes, void *client_data);
  90 #endif
  91 /*
  92  * We use 'void *' so that we can use the same callbacks for the
  93  * FLAC__StreamDecoder and FLAC__FileDecoder.  The 'decoder' argument is
  94  * actually never used in the callbacks.
  95  */
  96 static FLAC__StreamDecoderWriteStatus write_callback(const void *decoder, const FLAC__Frame *frame, const FLAC__int32 *buffer[], void *client_data);
  97 static void metadata_callback(const void *decoder, const FLAC__StreamMetadata *metadata, void *client_data);
  98 static void error_callback(const void *decoder, FLAC__StreamDecoderErrorStatus status, void *client_data);
  99 static void print_stats(const stream_info_struct *stream_info);
 100
 101
 102 int flac__decode_wav(const char *infilename, const char *outfilename, FLAC__bool analysis_mode, analysis_options aopts, wav_decode_options_t options)
 103 {
 104         FLAC__bool md5_failure = false;
 105         stream_info_struct stream_info;
 106
 107         stream_info.abort_flag = false;
 108         stream_info.analysis_mode = analysis_mode;
 109         stream_info.aopts = aopts;
 110         stream_info.test_only = (outfilename == 0);
 111         stream_info.is_wave_out = true;
 112         stream_info.verbose = options.common.verbose;
 113         stream_info.continue_through_decode_errors = options.common.continue_through_decode_errors;
 114         stream_info.wave_chunk_size_fixup.needs_fixup = false;
 115         stream_info.skip = options.common.skip;
 116         stream_info.samples_processed = 0;
 117         stream_info.frame_counter = 0;
 118 #ifdef FLAC__HAS_OGG
 119         stream_info.is_ogg = options.common.is_ogg;
 120 #endif
 121         stream_info.decoder.file = 0; /* this zeroes stream_info.decoder.stream also */
 122         stream_info.inbasefilename = flac__file_get_basename(infilename);
 123         stream_info.fout = 0; /* initialized with an open file later if necessary */
 124
 125         FLAC__ASSERT(!(stream_info.test_only && stream_info.analysis_mode));
 126
 127         if(!stream_info.test_only) {
 128                 if(0 == strcmp(outfilename, "-")) {
 129                         stream_info.fout = file__get_binary_stdout();
 130                 }
 131                 else {
 132                         if(0 == (stream_info.fout = fopen(outfilename, "wb"))) {
 133                                 fprintf(stderr, "%s: ERROR: can't open output file %s\n", stream_info.inbasefilename, outfilename);
 134                                 return 1;
 135                         }
 136                 }
 137         }
 138
 139 #ifdef FLAC__HAS_OGG
 140         if(stream_info.is_ogg) {
 141                 if (0 == strcmp(infilename, "-")) {
 142                         stream_info.fin = file__get_binary_stdin();
 143                 } else {
 144                         if (0 == (stream_info.fin = fopen(infilename, "rb"))) {
 145                                 fprintf(stderr, "%s: ERROR: can't open input file %s\n", stream_info.inbasefilename, infilename);
 146                                 if(0 != stream_info.fout && stream_info.fout != stdout)
 147                                         fclose(stream_info.fout);
 148                                 return 1;
 149                         }
 150                 }
 151         }
 152 #endif
 153
 154         if(analysis_mode)
 155                 flac__analyze_init(aopts);
 156
 157         if(!init(infilename, &stream_info))
 158                 goto wav_abort_;
 159
 160         if(stream_info.skip > 0) {
 161 #ifdef FLAC__HAS_OGG
 162                 if(stream_info.is_ogg) { /*@@@ (move this check into main.c) */
 163                         fprintf(stderr, "%s: ERROR, can't skip when decoding Ogg-FLAC yet; convert to native-FLAC first\n", stream_info.inbasefilename);
 164                         goto wav_abort_;
 165                 }
 166 #endif
 167                 if(!FLAC__file_decoder_process_metadata(stream_info.decoder.file)) {
 168                         fprintf(stderr, "%s: ERROR while decoding metadata, state=%d:%s\n", stream_info.inbasefilename, FLAC__file_decoder_get_state(stream_info.decoder.file), FLAC__FileDecoderStateString[FLAC__file_decoder_get_state(stream_info.decoder.file)]);
 169                         goto wav_abort_;
 170                 }
 171                 if(stream_info.abort_flag)
 172                         goto wav_abort_;
 173                 if(!FLAC__file_decoder_seek_absolute(stream_info.decoder.file, stream_info.skip)) {
 174                         fprintf(stderr, "%s: ERROR seeking while skipping bytes, state=%d:%s\n", stream_info.inbasefilename, FLAC__file_decoder_get_state(stream_info.decoder.file), FLAC__FileDecoderStateString[FLAC__file_decoder_get_state(stream_info.decoder.file)]);
 175                         goto wav_abort_;
 176                 }
 177                 if(!FLAC__file_decoder_process_remaining_frames(stream_info.decoder.file)) {
 178                         if(stream_info.verbose) fprintf(stderr, "\n");
 179                         fprintf(stderr, "%s: ERROR while decoding frames, state=%d:%s\n", stream_info.inbasefilename, FLAC__file_decoder_get_state(stream_info.decoder.file), FLAC__FileDecoderStateString[FLAC__file_decoder_get_state(stream_info.decoder.file)]);
 180                         goto wav_abort_;
 181                 }
 182                 if(FLAC__file_decoder_get_state(stream_info.decoder.file) != FLAC__FILE_DECODER_OK && FLAC__file_decoder_get_state(stream_info.decoder.file) != FLAC__FILE_DECODER_END_OF_FILE) {
 183                         if(stream_info.verbose) fprintf(stderr, "\n");
 184                         fprintf(stderr, "%s: ERROR during decoding, state=%d:%s\n", stream_info.inbasefilename, FLAC__file_decoder_get_state(stream_info.decoder.file), FLAC__FileDecoderStateString[FLAC__file_decoder_get_state(stream_info.decoder.file)]);
 185                         goto wav_abort_;
 186                 }
 187         }
 188         else {
 189 #ifdef FLAC__HAS_OGG
 190                 if(stream_info.is_ogg) {
 191                         if(!FLAC__stream_decoder_process_whole_stream(stream_info.decoder.stream)) {
 192                                 if(stream_info.verbose) fprintf(stderr, "\n");
 193                                 fprintf(stderr, "%s: ERROR while decoding data, state=%d:%s\n", stream_info.inbasefilename, FLAC__stream_decoder_get_state(stream_info.decoder.stream), FLAC__StreamDecoderStateString[FLAC__stream_decoder_get_state(stream_info.decoder.stream)]);
 194                                 goto wav_abort_;
 195                         }
 196                         if(FLAC__stream_decoder_get_state(stream_info.decoder.stream) != FLAC__STREAM_DECODER_SEARCH_FOR_METADATA && FLAC__stream_decoder_get_state(stream_info.decoder.stream) != FLAC__STREAM_DECODER_END_OF_STREAM) {
 197                                 if(stream_info.verbose) fprintf(stderr, "\n");
 198                                 fprintf(stderr, "%s: ERROR during decoding, state=%d:%s\n", stream_info.inbasefilename, FLAC__stream_decoder_get_state(stream_info.decoder.stream), FLAC__StreamDecoderStateString[FLAC__stream_decoder_get_state(stream_info.decoder.stream)]);
 199                                 goto wav_abort_;
 200                         }
 201                 }
 202                 else
 203 #endif
 204                 {
 205                         if(!FLAC__file_decoder_process_whole_file(stream_info.decoder.file)) {
 206                                 if(stream_info.verbose) fprintf(stderr, "\n");
 207                                 fprintf(stderr, "%s: ERROR while decoding data, state=%d:%s\n", stream_info.inbasefilename, FLAC__file_decoder_get_state(stream_info.decoder.file), FLAC__FileDecoderStateString[FLAC__file_decoder_get_state(stream_info.decoder.file)]);
 208                                 goto wav_abort_;
 209                         }
 210                         if(FLAC__file_decoder_get_state(stream_info.decoder.file) != FLAC__FILE_DECODER_OK && FLAC__file_decoder_get_state(stream_info.decoder.file) != FLAC__FILE_DECODER_END_OF_FILE) {
 211                                 if(stream_info.verbose) fprintf(stderr, "\n");
 212                                 fprintf(stderr, "%s: ERROR during decoding, state=%d:%s\n", stream_info.inbasefilename, FLAC__file_decoder_get_state(stream_info.decoder.file), FLAC__FileDecoderStateString[FLAC__file_decoder_get_state(stream_info.decoder.file)]);
 213                                 goto wav_abort_;
 214                         }
 215                 }
 216         }
 217
 218 #ifdef FLAC__HAS_OGG
 219         if(stream_info.is_ogg) {
 220                 if(stream_info.decoder.stream) {
 221                         FLAC__stream_decoder_finish(stream_info.decoder.stream);
 222                         md5_failure = false;
 223                         print_stats(&stream_info);
 224                         FLAC__stream_decoder_delete(stream_info.decoder.stream);
 225                 }
 226         }
 227         else
 228 #endif
 229         {
 230                 if(stream_info.decoder.file) {
 231                         md5_failure = !FLAC__file_decoder_finish(stream_info.decoder.file);
 232                         print_stats(&stream_info);
 233                         FLAC__file_decoder_delete(stream_info.decoder.file);
 234                 }
 235         }
 236         if(0 != stream_info.fout && stream_info.fout != stdout)
 237                 fclose(stream_info.fout);
 238 #ifdef FLAC__HAS_OGG
 239         if(stream_info.is_ogg) {
 240                 if(0 != stream_info.fin && stream_info.fin != stdin)
 241                         fclose(stream_info.fin);
 242         }
 243 #endif
 244         if(analysis_mode)
 245                 flac__analyze_finish(aopts);
 246         if(stream_info.wave_chunk_size_fixup.needs_fixup)
 247                 if(!fixup_wave_chunk_size(outfilename, stream_info.wave_chunk_size_fixup.riff_offset, stream_info.wave_chunk_size_fixup.data_offset, (FLAC__uint32)stream_info.samples_processed))
 248                         return 1;
 249         if(md5_failure) {
 250                 fprintf(stderr, "\r%s: WARNING, MD5 signature mismatch\n", stream_info.inbasefilename);
 251         }
 252         else {
 253                 if(stream_info.verbose)
 254                         fprintf(stderr, "\r%s: %s         \n", stream_info.inbasefilename, stream_info.test_only? "ok           ":analysis_mode?"done           ":"done");
 255         }
 256         return 0;
 257 wav_abort_:
 258 #ifdef FLAC__HAS_OGG
 259         if(stream_info.is_ogg) {
 260                 if(stream_info.decoder.stream) {
 261                         FLAC__stream_decoder_finish(stream_info.decoder.stream);
 262                         FLAC__stream_decoder_delete(stream_info.decoder.stream);
 263                 }
 264         }
 265         else
 266 #endif
 267         {
 268                 if(stream_info.decoder.file) {
 269                         FLAC__file_decoder_finish(stream_info.decoder.file);
 270                         FLAC__file_decoder_delete(stream_info.decoder.file);
 271                 }
 272         }
 273         if(0 != stream_info.fout && stream_info.fout != stdout) {
 274                 fclose(stream_info.fout);
 275                 unlink(outfilename);
 276         }
 277 #ifdef FLAC__HAS_OGG
 278         if(stream_info.is_ogg) {
 279                 if(0 != stream_info.fin && stream_info.fin != stdin)
 280                         fclose(stream_info.fin);
 281         }
 282 #endif
 283         if(analysis_mode)
 284                 flac__analyze_finish(aopts);
 285         return 1;
 286 }
 287
 288 int flac__decode_raw(const char *infilename, const char *outfilename, FLAC__bool analysis_mode, analysis_options aopts, raw_decode_options_t options)
 289 {
 290         FLAC__bool md5_failure = false;
 291         stream_info_struct stream_info;
 292
 293         stream_info.abort_flag = false;
 294         stream_info.analysis_mode = analysis_mode;
 295         stream_info.aopts = aopts;
 296         stream_info.test_only = (outfilename == 0);
 297         stream_info.is_wave_out = false;
 298         stream_info.is_big_endian = options.is_big_endian;
 299         stream_info.is_unsigned_samples = options.is_unsigned_samples;
 300         stream_info.verbose = options.common.verbose;
 301         stream_info.continue_through_decode_errors = options.common.continue_through_decode_errors;
 302         stream_info.wave_chunk_size_fixup.needs_fixup = false;
 303         stream_info.skip = options.common.skip;
 304         stream_info.samples_processed = 0;
 305         stream_info.frame_counter = 0;
 306 #ifdef FLAC__HAS_OGG
 307         stream_info.is_ogg = options.common.is_ogg;
 308 #endif
 309         stream_info.decoder.file = 0; /* this zeroes stream_info.decoder.stream also */
 310         stream_info.inbasefilename = flac__file_get_basename(infilename);
 311         stream_info.fout = 0; /* initialized with an open file later if necessary */
 312
 313         FLAC__ASSERT(!(stream_info.test_only && stream_info.analysis_mode));
 314
 315         if(!stream_info.test_only) {
 316                 if(0 == strcmp(outfilename, "-")) {
 317                         stream_info.fout = file__get_binary_stdout();
 318                 }
 319                 else {
 320                         if(0 == (stream_info.fout = fopen(outfilename, "wb"))) {
 321                                 fprintf(stderr, "%s: ERROR: can't open output file %s\n", stream_info.inbasefilename, outfilename);
 322                                 return 1;
 323                         }
 324                 }
 325         }
 326
 327 #ifdef FLAC__HAS_OGG
 328         if(stream_info.is_ogg) {
 329                 if (0 == strcmp(infilename, "-")) {
 330                         stream_info.fin = file__get_binary_stdin();
 331                 } else {
 332                         if (0 == (stream_info.fin = fopen(infilename, "rb"))) {
 333                                 fprintf(stderr, "%s: ERROR: can't open input file %s\n", stream_info.inbasefilename, infilename);
 334                                 if(0 != stream_info.fout && stream_info.fout != stdout)
 335                                         fclose(stream_info.fout);
 336                                 return 1;
 337                         }
 338                 }
 339         }
 340 #endif
 341
 342         if(analysis_mode)
 343                 flac__analyze_init(aopts);
 344
 345         if(!init(infilename, &stream_info))
 346                 goto raw_abort_;
 347
 348         if(stream_info.skip > 0) {
 349 #ifdef FLAC__HAS_OGG
 350                 if(stream_info.is_ogg) { /*@@@ (move this check into main.c) */
 351                         fprintf(stderr, "%s: ERROR, can't skip when decoding Ogg-FLAC yet; convert to native-FLAC first\n", stream_info.inbasefilename);
 352                         goto raw_abort_;
 353                 }
 354 #endif
 355                 if(!FLAC__file_decoder_process_metadata(stream_info.decoder.file)) {
 356                         fprintf(stderr, "%s: ERROR while decoding metadata, state=%d:%s\n", stream_info.inbasefilename, FLAC__file_decoder_get_state(stream_info.decoder.file), FLAC__FileDecoderStateString[FLAC__file_decoder_get_state(stream_info.decoder.file)]);
 357                         goto raw_abort_;
 358                 }
 359                 if(stream_info.abort_flag)
 360                         goto raw_abort_;
 361                 if(!FLAC__file_decoder_seek_absolute(stream_info.decoder.file, stream_info.skip)) {
 362                         fprintf(stderr, "%s: ERROR seeking while skipping bytes, state=%d:%s\n", stream_info.inbasefilename, FLAC__file_decoder_get_state(stream_info.decoder.file), FLAC__FileDecoderStateString[FLAC__file_decoder_get_state(stream_info.decoder.file)]);
 363                         goto raw_abort_;
 364                 }
 365                 if(!FLAC__file_decoder_process_remaining_frames(stream_info.decoder.file)) {
 366                         if(stream_info.verbose) fprintf(stderr, "\n");
 367                         fprintf(stderr, "%s: ERROR while decoding frames, state=%d:%s\n", stream_info.inbasefilename, FLAC__file_decoder_get_state(stream_info.decoder.file), FLAC__FileDecoderStateString[FLAC__file_decoder_get_state(stream_info.decoder.file)]);
 368                         goto raw_abort_;
 369                 }
 370                 if(FLAC__file_decoder_get_state(stream_info.decoder.file) != FLAC__FILE_DECODER_OK && FLAC__file_decoder_get_state(stream_info.decoder.file) != FLAC__FILE_DECODER_END_OF_FILE) {
 371                         if(stream_info.verbose) fprintf(stderr, "\n");
 372                         fprintf(stderr, "%s: ERROR during decoding, state=%d:%s\n", stream_info.inbasefilename, FLAC__file_decoder_get_state(stream_info.decoder.file), FLAC__FileDecoderStateString[FLAC__file_decoder_get_state(stream_info.decoder.file)]);
 373                         goto raw_abort_;
 374                 }
 375         }
 376         else {
 377 #ifdef FLAC__HAS_OGG
 378                 if(stream_info.is_ogg) {
 379                         if(!FLAC__stream_decoder_process_whole_stream(stream_info.decoder.stream)) {
 380                                 if(stream_info.verbose) fprintf(stderr, "\n");
 381                                 fprintf(stderr, "%s: ERROR while decoding data, state=%d:%s\n", stream_info.inbasefilename, FLAC__stream_decoder_get_state(stream_info.decoder.stream), FLAC__StreamDecoderStateString[FLAC__stream_decoder_get_state(stream_info.decoder.stream)]);
 382                                 goto raw_abort_;
 383                         }
 384                         if(FLAC__stream_decoder_get_state(stream_info.decoder.stream) != FLAC__STREAM_DECODER_SEARCH_FOR_METADATA && FLAC__stream_decoder_get_state(stream_info.decoder.stream) != FLAC__STREAM_DECODER_END_OF_STREAM) {
 385                                 if(stream_info.verbose) fprintf(stderr, "\n");
 386                                 fprintf(stderr, "%s: ERROR during decoding, state=%d:%s\n", stream_info.inbasefilename, FLAC__stream_decoder_get_state(stream_info.decoder.stream), FLAC__StreamDecoderStateString[FLAC__stream_decoder_get_state(stream_info.decoder.stream)]);
 387                                 goto raw_abort_;
 388                         }
 389                 }
 390                 else
 391 #endif
 392                 {
 393                         if(!FLAC__file_decoder_process_whole_file(stream_info.decoder.file)) {
 394                                 if(stream_info.verbose) fprintf(stderr, "\n");
 395                                 fprintf(stderr, "%s: ERROR while decoding data, state=%d:%s\n", stream_info.inbasefilename, FLAC__file_decoder_get_state(stream_info.decoder.file), FLAC__FileDecoderStateString[FLAC__file_decoder_get_state(stream_info.decoder.file)]);
 396                                 goto raw_abort_;
 397                         }
 398                         if(FLAC__file_decoder_get_state(stream_info.decoder.file) != FLAC__FILE_DECODER_OK && FLAC__file_decoder_get_state(stream_info.decoder.file) != FLAC__FILE_DECODER_END_OF_FILE) {
 399                                 if(stream_info.verbose) fprintf(stderr, "\n");
 400                                 fprintf(stderr, "%s: ERROR during decoding, state=%d:%s\n", stream_info.inbasefilename, FLAC__file_decoder_get_state(stream_info.decoder.file), FLAC__FileDecoderStateString[FLAC__file_decoder_get_state(stream_info.decoder.file)]);
 401                                 goto raw_abort_;
 402                         }
 403                 }
 404         }
 405
 406 #ifdef FLAC__HAS_OGG
 407         if(stream_info.is_ogg) {
 408                 if(stream_info.decoder.stream) {
 409                         FLAC__stream_decoder_finish(stream_info.decoder.stream);
 410                         md5_failure = false;
 411                         print_stats(&stream_info);
 412                         FLAC__stream_decoder_delete(stream_info.decoder.stream);
 413                 }
 414         }
 415         else
 416 #endif
 417         {
 418                 if(stream_info.decoder.file) {
 419                         md5_failure = !FLAC__file_decoder_finish(stream_info.decoder.file);
 420                         print_stats(&stream_info);
 421                         FLAC__file_decoder_delete(stream_info.decoder.file);
 422                 }
 423         }
 424         if(0 != stream_info.fout && stream_info.fout != stdout)
 425                 fclose(stream_info.fout);
 426 #ifdef FLAC__HAS_OGG
 427         if(stream_info.is_ogg) {
 428                 if(0 != stream_info.fin && stream_info.fin != stdin)
 429                         fclose(stream_info.fin);
 430         }
 431 #endif
 432         if(analysis_mode)
 433                 flac__analyze_finish(aopts);
 434         if(md5_failure) {
 435                 fprintf(stderr, "\r%s: WARNING, MD5 signature mismatch\n", stream_info.inbasefilename);
 436         }
 437         else {
 438                 if(stream_info.verbose)
 439                         fprintf(stderr, "\r%s: %s         \n", stream_info.inbasefilename, stream_info.test_only? "ok           ":analysis_mode?"done           ":"done");
 440         }
 441         return 0;
 442 raw_abort_:
 443 #ifdef FLAC__HAS_OGG
 444         if(stream_info.is_ogg) {
 445                 if(stream_info.decoder.stream) {
 446                         FLAC__stream_decoder_finish(stream_info.decoder.stream);
 447                         FLAC__stream_decoder_delete(stream_info.decoder.stream);
 448                 }
 449         }
 450         else
 451 #endif
 452         {
 453                 if(stream_info.decoder.file) {
 454                         FLAC__file_decoder_finish(stream_info.decoder.file);
 455                         FLAC__file_decoder_delete(stream_info.decoder.file);
 456                 }
 457         }
 458         if(0 != stream_info.fout && stream_info.fout != stdout) {
 459                 fclose(stream_info.fout);
 460                 unlink(outfilename);
 461         }
 462 #ifdef FLAC__HAS_OGG
 463         if(stream_info.is_ogg) {
 464                 if(0 != stream_info.fin && stream_info.fin != stdin)
 465                         fclose(stream_info.fin);
 466         }
 467 #endif
 468         if(analysis_mode)
 469                 flac__analyze_finish(aopts);
 470         return 1;
 471 }
 472
 473 FLAC__bool init(const char *infilename, stream_info_struct *stream_info)
 474 {
 475         FLAC__uint32 test = 1;
 476
 477         is_big_endian_host = (*((FLAC__byte*)(&test)))? false : true;
 478
 479 #ifdef FLAC__HAS_OGG
 480         if(stream_info->is_ogg) {
 481                 stream_info->decoder.stream = FLAC__stream_decoder_new();
 482
 483                 if(0 == stream_info->decoder.stream) {
 484                         fprintf(stderr, "%s: ERROR creating the decoder instance\n", stream_info->inbasefilename);
 485                         return false;
 486                 }
 487
 488                 FLAC__stream_decoder_set_read_callback(stream_info->decoder.stream, read_callback);
 489                 /*
 490                  * The three ugly casts here are to 'downcast' the 'void *' argument of
 491                  * the callback down to 'FLAC__StreamDecoder *'.  In C++ this would be
 492                  * unnecessary but here the cast makes the C compiler happy.
 493                  */
 494                 FLAC__stream_decoder_set_write_callback(stream_info->decoder.stream, (FLAC__StreamDecoderWriteStatus (*)(const FLAC__StreamDecoder *, const FLAC__Frame *, const FLAC__int32 *[], void *))write_callback);
 495                 FLAC__stream_decoder_set_metadata_callback(stream_info->decoder.stream, (void (*)(const FLAC__StreamDecoder *, const FLAC__StreamMetadata *, void *))metadata_callback);
 496                 FLAC__stream_decoder_set_error_callback(stream_info->decoder.stream, (void (*)(const FLAC__StreamDecoder *, FLAC__StreamDecoderErrorStatus, void *))error_callback);
 497                 FLAC__stream_decoder_set_client_data(stream_info->decoder.stream, stream_info);
 498
 499                 if(FLAC__stream_decoder_init(stream_info->decoder.stream) != FLAC__STREAM_DECODER_SEARCH_FOR_METADATA) {
 500                         fprintf(stderr, "%s: ERROR initializing decoder, state=%d:%s\n", stream_info->inbasefilename, FLAC__stream_decoder_get_state(stream_info->decoder.stream), FLAC__StreamDecoderStateString[FLAC__stream_decoder_get_state(stream_info->decoder.stream)]);
 501                         return false;
 502                 }
 503
 504                 ogg_stream_init(&stream_info->ogg.os, 0);
 505                 ogg_sync_init(&stream_info->ogg.oy);
 506         }
 507         else
 508 #endif
 509         {
 510                 stream_info->decoder.file = FLAC__file_decoder_new();
 511
 512                 if(0 == stream_info->decoder.file) {
 513                         fprintf(stderr, "%s: ERROR creating the decoder instance\n", stream_info->inbasefilename);
 514                         return false;
 515                 }
 516
 517                 FLAC__file_decoder_set_md5_checking(stream_info->decoder.file, true);
 518                 FLAC__file_decoder_set_filename(stream_info->decoder.file, infilename);
 519                 /*
 520                  * The three ugly casts here are to 'downcast' the 'void *' argument of
 521                  * the callback down to 'FLAC__FileDecoder *'.
 522                  */
 523                 FLAC__file_decoder_set_write_callback(stream_info->decoder.file, (FLAC__StreamDecoderWriteStatus (*)(const FLAC__FileDecoder *, const FLAC__Frame *, const FLAC__int32 * const [], void *))write_callback);
 524                 FLAC__file_decoder_set_metadata_callback(stream_info->decoder.file, (void (*)(const FLAC__FileDecoder *, const FLAC__StreamMetadata *, void *))metadata_callback);
 525                 FLAC__file_decoder_set_error_callback(stream_info->decoder.file, (void (*)(const FLAC__FileDecoder *, FLAC__StreamDecoderErrorStatus, void *))error_callback);
 526                 FLAC__file_decoder_set_client_data(stream_info->decoder.file, stream_info);
 527
 528                 if(FLAC__file_decoder_init(stream_info->decoder.file) != FLAC__FILE_DECODER_OK) {
 529                         fprintf(stderr, "%s: ERROR initializing decoder, state=%d:%s\n", stream_info->inbasefilename, FLAC__file_decoder_get_state(stream_info->decoder.file), FLAC__FileDecoderStateString[FLAC__file_decoder_get_state(stream_info->decoder.file)]);
 530                         return false;
 531                 }
 532         }
 533
 534         return true;
 535 }
 536
 537 FLAC__bool write_little_endian_uint16(FILE *f, FLAC__uint16 val)
 538 {
 539         FLAC__byte *b = (FLAC__byte*)(&val);
 540         if(is_big_endian_host) {
 541                 FLAC__byte tmp;
 542                 tmp = b[1]; b[1] = b[0]; b[0] = tmp;
 543         }
 544         return fwrite(b, 1, 2, f) == 2;
 545 }
 546
 547 FLAC__bool write_little_endian_uint32(FILE *f, FLAC__uint32 val)
 548 {
 549         FLAC__byte *b = (FLAC__byte*)(&val);
 550         if(is_big_endian_host) {
 551                 FLAC__byte tmp;
 552                 tmp = b[3]; b[3] = b[0]; b[0] = tmp;
 553                 tmp = b[2]; b[2] = b[1]; b[1] = tmp;
 554         }
 555         return fwrite(b, 1, 4, f) == 4;
 556 }
 557
 558 FLAC__bool fixup_wave_chunk_size(const char *outfilename, unsigned riff_offset, unsigned data_offset, FLAC__uint32 data_size)
 559 {
 560         FILE *f = fopen(outfilename, "r+b");
 561         if(0 == f) {
 562                 fprintf(stderr, "ERROR, couldn't open file %s while fixing up WAVE chunk size\n", outfilename);
 563                 return false;
 564         }
 565         if(fseek(f, riff_offset, SEEK_SET) < 0) {
 566                 fprintf(stderr, "ERROR, couldn't seek in file %s while fixing up WAVE chunk size\n", outfilename);
 567                 fclose(f);
 568                 return false;
 569         }
 570         if(!write_little_endian_uint32(f, data_size + 36)) {
 571                 fprintf(stderr, "ERROR, couldn't write size in file %s while fixing up WAVE chunk size\n", outfilename);
 572                 fclose(f);
 573                 return false;
 574         }
 575         if(fseek(f, data_offset, SEEK_SET) < 0) {
 576                 fprintf(stderr, "ERROR, couldn't seek in file %s while fixing up WAVE chunk size\n", outfilename);
 577                 fclose(f);
 578                 return false;
 579         }
 580         if(!write_little_endian_uint32(f, data_size)) {
 581                 fprintf(stderr, "ERROR, couldn't write size in file %s while fixing up WAVE chunk size\n", outfilename);
 582                 fclose(f);
 583                 return false;
 584         }
 585         fclose(f);
 586         return true;
 587 }
 588
 589 #ifdef FLAC__HAS_OGG
 590 #define OGG_READ_BUFFER_SIZE 4096
 591 FLAC__StreamDecoderReadStatus read_callback(const FLAC__StreamDecoder *decoder, FLAC__byte buffer[], unsigned *bytes, void *client_data)
 592 {
 593         stream_info_struct *stream_info = (stream_info_struct *)client_data;
 594         FILE *fin = stream_info->fin;
 595         size_t bytes_read;
 596         ogg_page og;
 597         char *oggbuf;
 598         unsigned int offset = 0;
 599
 600         *bytes = 0;
 601
 602         if (stream_info->abort_flag)
 603                 return FLAC__STREAM_DECODER_READ_STATUS_ABORT;
 604
 605         oggbuf = ogg_sync_buffer(&stream_info->ogg.oy, OGG_READ_BUFFER_SIZE);
 606
 607         (void)decoder; /* avoid compiler warning */
 608
 609         if(feof(fin))
 610                 return FLAC__STREAM_DECODER_READ_STATUS_END_OF_STREAM;
 611
 612         bytes_read = fread(oggbuf, 1, OGG_READ_BUFFER_SIZE, fin);
 613
 614         if(ferror(fin))
 615                 return FLAC__STREAM_DECODER_READ_STATUS_ABORT;
 616
 617         if(ogg_sync_wrote(&stream_info->ogg.oy, bytes_read) < 0)
 618                 return FLAC__STREAM_DECODER_READ_STATUS_ABORT;
 619
 620         while(ogg_sync_pageout(&stream_info->ogg.oy, &og) == 1) {
 621                 if(ogg_stream_pagein(&stream_info->ogg.os, &og) == 0) {
 622                         ogg_packet op;
 623
 624                         while(ogg_stream_packetout(&stream_info->ogg.os, &op) == 1) {
 625                                 memcpy(buffer + offset, op.packet, op.bytes);
 626                                 *bytes += op.bytes;
 627                                 offset += op.bytes;
 628                         }
 629                 } else {
 630                         return FLAC__STREAM_DECODER_READ_STATUS_ABORT;
 631                 }
 632         }
 633
 634         return FLAC__STREAM_DECODER_READ_STATUS_CONTINUE;
 635 }
 636 #endif
 637
 638 FLAC__StreamDecoderWriteStatus write_callback(const void *decoder, const FLAC__Frame *frame, const FLAC__int32 *buffer[], void *client_data)
 639 {
 640         stream_info_struct *stream_info = (stream_info_struct *)client_data;
 641         FILE *fout = stream_info->fout;
 642         unsigned bps = stream_info->bps, channels = stream_info->channels;
 643         FLAC__bool is_big_endian = (stream_info->is_wave_out? false : stream_info->is_big_endian);
 644         FLAC__bool is_unsigned_samples = (stream_info->is_wave_out? bps<=8 : stream_info->is_unsigned_samples);
 645         unsigned wide_samples = frame->header.blocksize, wide_sample, sample, channel, byte;
 646         static FLAC__int8 s8buffer[FLAC__MAX_BLOCK_SIZE * FLAC__MAX_CHANNELS * sizeof(FLAC__int32)]; /* WATCHOUT: can be up to 2 megs */
 647         FLAC__uint8  *u8buffer  = (FLAC__uint8  *)s8buffer;
 648         FLAC__int16  *s16buffer = (FLAC__int16  *)s8buffer;
 649         FLAC__uint16 *u16buffer = (FLAC__uint16 *)s8buffer;
 650         FLAC__int32  *s32buffer = (FLAC__int32  *)s8buffer;
 651         FLAC__uint32 *u32buffer = (FLAC__uint32 *)s8buffer;
 652
 653         (void)decoder;
 654
 655         if(stream_info->abort_flag)
 656                 return FLAC__STREAM_DECODER_WRITE_STATUS_ABORT;
 657
 658         stream_info->samples_processed += wide_samples;
 659         stream_info->frame_counter++;
 660
 661         if(stream_info->verbose && !(stream_info->frame_counter & 0x7f))
 662                 print_stats(stream_info);
 663
 664         if(stream_info->analysis_mode) {
 665                 flac__analyze_frame(frame, stream_info->frame_counter-1, stream_info->aopts, fout);
 666         }
 667         else if(!stream_info->test_only) {
 668                 if(bps == 8) {
 669                         if(is_unsigned_samples) {
 670                                 for(sample = wide_sample = 0; wide_sample < wide_samples; wide_sample++)
 671                                         for(channel = 0; channel < channels; channel++, sample++)
 672                                                 u8buffer[sample] = (FLAC__uint8)(buffer[channel][wide_sample] + 0x80);
 673                         }
 674                         else {
 675                                 for(sample = wide_sample = 0; wide_sample < wide_samples; wide_sample++)
 676                                         for(channel = 0; channel < channels; channel++, sample++)
 677                                                 s8buffer[sample] = (FLAC__int8)(buffer[channel][wide_sample]);
 678                         }
 679                         if(fwrite(u8buffer, 1, sample, fout) != sample)
 680                                 return FLAC__STREAM_DECODER_WRITE_STATUS_ABORT;
 681                 }
 682                 else if(bps == 16) {
 683                         if(is_unsigned_samples) {
 684                                 for(sample = wide_sample = 0; wide_sample < wide_samples; wide_sample++)
 685                                         for(channel = 0; channel < channels; channel++, sample++)
 686                                                 u16buffer[sample] = (FLAC__uint16)(buffer[channel][wide_sample] + 0x8000);
 687                         }
 688                         else {
 689                                 for(sample = wide_sample = 0; wide_sample < wide_samples; wide_sample++)
 690                                         for(channel = 0; channel < channels; channel++, sample++)
 691                                                 s16buffer[sample] = (FLAC__int16)(buffer[channel][wide_sample]);
 692                         }
 693                         if(is_big_endian != is_big_endian_host) {
 694                                 unsigned char tmp;
 695                                 const unsigned bytes = sample * 2;
 696                                 for(byte = 0; byte < bytes; byte += 2) {
 697                                         tmp = u8buffer[byte];
 698                                         u8buffer[byte] = u8buffer[byte+1];
 699                                         u8buffer[byte+1] = tmp;
 700                                 }
 701                         }
 702                         if(fwrite(u16buffer, 2, sample, fout) != sample)
 703                                 return FLAC__STREAM_DECODER_WRITE_STATUS_ABORT;
 704                 }
 705                 else if(bps == 24) {
 706                         if(is_unsigned_samples) {
 707                                 for(sample = wide_sample = 0; wide_sample < wide_samples; wide_sample++)
 708                                         for(channel = 0; channel < channels; channel++, sample++)
 709                                                 u32buffer[sample] = buffer[channel][wide_sample] + 0x800000;
 710                         }
 711                         else {
 712                                 for(sample = wide_sample = 0; wide_sample < wide_samples; wide_sample++)
 713                                         for(channel = 0; channel < channels; channel++, sample++)
 714                                                 s32buffer[sample] = buffer[channel][wide_sample];
 715                         }
 716                         if(is_big_endian != is_big_endian_host) {
 717                                 unsigned char tmp;
 718                                 const unsigned bytes = sample * 4;
 719                                 for(byte = 0; byte < bytes; byte += 4) {
 720                                         tmp = u8buffer[byte];
 721                                         u8buffer[byte] = u8buffer[byte+3];
 722                                         u8buffer[byte+3] = tmp;
 723                                         tmp = u8buffer[byte+1];
 724                                         u8buffer[byte+1] = u8buffer[byte+2];
 725                                         u8buffer[byte+2] = tmp;
 726                                 }
 727                         }
 728                         if(is_big_endian) {
 729                                 unsigned lbyte;
 730                                 const unsigned bytes = sample * 4;
 731                                 for(lbyte = byte = 0; byte < bytes; ) {
 732                                         byte++;
 733                                         u8buffer[lbyte++] = u8buffer[byte++];
 734                                         u8buffer[lbyte++] = u8buffer[byte++];
 735                                         u8buffer[lbyte++] = u8buffer[byte++];
 736                                 }
 737                         }
 738                         else {
 739                                 unsigned lbyte;
 740                                 const unsigned bytes = sample * 4;
 741                                 for(lbyte = byte = 0; byte < bytes; ) {
 742                                         u8buffer[lbyte++] = u8buffer[byte++];
 743                                         u8buffer[lbyte++] = u8buffer[byte++];
 744                                         u8buffer[lbyte++] = u8buffer[byte++];
 745                                         byte++;
 746                                 }
 747                         }
 748                         if(fwrite(u8buffer, 3, sample, fout) != sample)
 749                                 return FLAC__STREAM_DECODER_WRITE_STATUS_ABORT;
 750                 }
 751                 else {
 752                         FLAC__ASSERT(0);
 753                 }
 754         }
 755         return FLAC__STREAM_DECODER_WRITE_STATUS_CONTINUE;
 756 }
 757
 758 void metadata_callback(const void *decoder, const FLAC__StreamMetadata *metadata, void *client_data)
 759 {
 760         stream_info_struct *stream_info = (stream_info_struct *)client_data;
 761         (void)decoder;
 762         if(metadata->type == FLAC__METADATA_TYPE_STREAMINFO) {
 763                 /* remember, metadata->data.stream_info.total_samples can be 0, meaning 'unknown' */
 764                 if(metadata->data.stream_info.total_samples > 0 && stream_info->skip >= metadata->data.stream_info.total_samples) {
 765                         fprintf(stderr, "%s: ERROR trying to skip more samples than in stream\n", stream_info->inbasefilename);
 766                         stream_info->abort_flag = true;
 767                         return;
 768                 }
 769                 else if(metadata->data.stream_info.total_samples == 0 && stream_info->skip > 0) {
 770                         fprintf(stderr, "%s: ERROR, can't skip when FLAC metadata has total sample count of 0\n", stream_info->inbasefilename);
 771                         stream_info->abort_flag = true;
 772                         return;
 773                 }
 774                 else
 775                         stream_info->total_samples = metadata->data.stream_info.total_samples - stream_info->skip;
 776                 stream_info->bps = metadata->data.stream_info.bits_per_sample;
 777                 stream_info->channels = metadata->data.stream_info.channels;
 778                 stream_info->sample_rate = metadata->data.stream_info.sample_rate;
 779
 780                 if(stream_info->bps != 8 && stream_info->bps != 16 && stream_info->bps != 24) {
 781                         fprintf(stderr, "%s: ERROR: bits per sample is not 8/16/24\n", stream_info->inbasefilename);
 782                         stream_info->abort_flag = true;
 783                         return;
 784                 }
 785
 786                 /* write the WAVE headers if necessary */
 787                 if(!stream_info->analysis_mode && !stream_info->test_only && stream_info->is_wave_out) {
 788                         FLAC__uint64 data_size = stream_info->total_samples * stream_info->channels * ((stream_info->bps+7)/8);
 789                         if(stream_info->total_samples == 0) {
 790                                 if(stream_info->fout == stdout) {
 791                                         fprintf(stderr, "%s: WARNING, don't have accurate sample count available for WAVE header.\n", stream_info->inbasefilename);
 792                                         fprintf(stderr, "             Generated WAVE file will have a data chunk size of 0.  Try\n");
 793                                         fprintf(stderr, "             decoding directly to a file instead.\n");
 794                                 }
 795                                 else {
 796                                         stream_info->wave_chunk_size_fixup.needs_fixup = true;
 797                                 }
 798                         }
 799                         if(data_size >= 0xFFFFFFDC) {
 800                                 fprintf(stderr, "%s: ERROR: stream is too big to fit in a single WAVE file chunk\n", stream_info->inbasefilename);
 801                                 stream_info->abort_flag = true;
 802                                 return;
 803                         }
 804                         if(fwrite("RIFF", 1, 4, stream_info->fout) != 4) stream_info->abort_flag = true;
 805                         if(stream_info->wave_chunk_size_fixup.needs_fixup)
 806                                 stream_info->wave_chunk_size_fixup.riff_offset = ftell(stream_info->fout);
 807                         if(!write_little_endian_uint32(stream_info->fout, (FLAC__uint32)(data_size+36))) stream_info->abort_flag = true; /* filesize-8 */
 808                         if(fwrite("WAVEfmt ", 1, 8, stream_info->fout) != 8) stream_info->abort_flag = true;
 809                         if(fwrite("\020\000\000\000", 1, 4, stream_info->fout) != 4) stream_info->abort_flag = true; /* chunk size = 16 */
 810                         if(fwrite("\001\000", 1, 2, stream_info->fout) != 2) stream_info->abort_flag = true; /* compression code == 1 */
 811                         if(!write_little_endian_uint16(stream_info->fout, (FLAC__uint16)(stream_info->channels))) stream_info->abort_flag = true;
 812                         if(!write_little_endian_uint32(stream_info->fout, stream_info->sample_rate)) stream_info->abort_flag = true;
 813                         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 ??? */
 814                         if(!write_little_endian_uint16(stream_info->fout, (FLAC__uint16)(stream_info->channels * ((stream_info->bps+7) / 8)))) stream_info->abort_flag = true; /* block align */
 815                         if(!write_little_endian_uint16(stream_info->fout, (FLAC__uint16)(stream_info->bps))) stream_info->abort_flag = true; /* bits per sample */
 816                         if(fwrite("data", 1, 4, stream_info->fout) != 4) stream_info->abort_flag = true;
 817                         if(stream_info->wave_chunk_size_fixup.needs_fixup)
 818                                 stream_info->wave_chunk_size_fixup.data_offset = ftell(stream_info->fout);
 819                         if(!write_little_endian_uint32(stream_info->fout, (FLAC__uint32)data_size)) stream_info->abort_flag = true; /* data size */
 820                 }
 821         }
 822 }
 823
 824 void error_callback(const void *decoder, FLAC__StreamDecoderErrorStatus status, void *client_data)
 825 {
 826         stream_info_struct *stream_info = (stream_info_struct *)client_data;
 827         (void)decoder;
 828         fprintf(stderr, "%s: *** Got error code %d:%s\n", stream_info->inbasefilename, status, FLAC__StreamDecoderErrorStatusString[status]);
 829         if(!stream_info->continue_through_decode_errors)
 830                 stream_info->abort_flag = true;
 831 }
 832
 833 void print_stats(const stream_info_struct *stream_info)
 834 {
 835         if(stream_info->verbose) {
 836 #if defined _MSC_VER || defined __MINGW32__
 837                 /* with VC++ you have to spoon feed it the casting */
 838                 const double progress = (double)(FLAC__int64)stream_info->samples_processed / (double)(FLAC__int64)stream_info->total_samples * 100.0;
 839 #else
 840                 const double progress = (double)stream_info->samples_processed / (double)stream_info->total_samples * 100.0;
 841 #endif
 842                 if(stream_info->total_samples > 0) {
 843                         fprintf(stderr, "\r%s: %s%u%% complete",
 844                                 stream_info->inbasefilename,
 845                                 stream_info->test_only? "testing, " : stream_info->analysis_mode? "analyzing, " : "",
 846                                 (unsigned)floor(progress + 0.5)
 847                         );
 848                 }
 849                 else {
 850                         fprintf(stderr, "\r%s: %s %u samples",
 851                                 stream_info->inbasefilename,
 852                                 stream_info->test_only? "tested" : stream_info->analysis_mode? "analyzed" : "wrote",
 853                                 (unsigned)stream_info->samples_processed
 854                         );
 855                 }
 856         }
 857 }
 858 #if 0
 859 void metadata_callback(const FLAC__StreamEncoder *encoder, const FLAC__StreamMetadata *metadata, void *client_data)
 860 {
 861         encoder_wrapper_struct *encoder_wrapper = (encoder_wrapper_struct *)client_data;
 862         FLAC__byte b;
 863         FILE *f = encoder_wrapper->fout;
 864         const FLAC__uint64 samples = metadata->data.stream_info.total_samples;
 865         const unsigned min_framesize = metadata->data.stream_info.min_framesize;
 866         const unsigned max_framesize = metadata->data.stream_info.max_framesize;
 867
 868         FLAC__ASSERT(metadata->type == FLAC__METADATA_TYPE_STREAMINFO);
 869
 870         /*
 871          * If we are writing to an ogg stream, there is no need to go back
 872          * and update the STREAMINFO or SEEKTABLE blocks; the values we would
 873          * update are not necessary with Ogg as the transport.  We can't do
 874          * it reliably anyway without knowing the Ogg structure.
 875          */
 876 #ifdef FLAC__HAS_OGG
 877         if(encoder_wrapper->use_ogg)
 878                 return;
 879 #endif
 880
 881         /*
 882          * we get called by the encoder when the encoding process has
 883          * finished so that we can update the STREAMINFO and SEEKTABLE
 884          * blocks.
 885          */
 886
 887         (void)encoder; /* silence compiler warning about unused parameter */
 888
 889         if(f != stdout) {
 890                 fclose(encoder_wrapper->fout);
 891                 if(0 == (f = fopen(encoder_wrapper->outfilename, "r+b")))
 892                         return;
 893         }
 894
 895         /* all this is based on intimate knowledge of the stream header
 896          * layout, but a change to the header format that would break this
 897          * would also break all streams encoded in the previous format.
 898          */
 899
 900         if(-1 == fseek(f, 26, SEEK_SET)) goto end_;
 901         fwrite(metadata->data.stream_info.md5sum, 1, 16, f);
 902
 903 samples_:
 904         /* if we get this far we know we can seek so no need to check the
 905          * return value from fseek()
 906          */
 907         fseek(f, 21, SEEK_SET);
 908         if(fread(&b, 1, 1, f) != 1) goto framesize_;
 909         fseek(f, 21, SEEK_SET);
 910         b = (b & 0xf0) | (FLAC__byte)((samples >> 32) & 0x0F);
 911         if(fwrite(&b, 1, 1, f) != 1) goto framesize_;
 912         b = (FLAC__byte)((samples >> 24) & 0xFF);
 913         if(fwrite(&b, 1, 1, f) != 1) goto framesize_;
 914         b = (FLAC__byte)((samples >> 16) & 0xFF);
 915         if(fwrite(&b, 1, 1, f) != 1) goto framesize_;
 916         b = (FLAC__byte)((samples >> 8) & 0xFF);
 917         if(fwrite(&b, 1, 1, f) != 1) goto framesize_;
 918         b = (FLAC__byte)(samples & 0xFF);
 919         if(fwrite(&b, 1, 1, f) != 1) goto framesize_;
 920
 921 framesize_:
 922         fseek(f, 12, SEEK_SET);
 923         b = (FLAC__byte)((min_framesize >> 16) & 0xFF);
 924         if(fwrite(&b, 1, 1, f) != 1) goto seektable_;
 925         b = (FLAC__byte)((min_framesize >> 8) & 0xFF);
 926         if(fwrite(&b, 1, 1, f) != 1) goto seektable_;
 927         b = (FLAC__byte)(min_framesize & 0xFF);
 928         if(fwrite(&b, 1, 1, f) != 1) goto seektable_;
 929         b = (FLAC__byte)((max_framesize >> 16) & 0xFF);
 930         if(fwrite(&b, 1, 1, f) != 1) goto seektable_;
 931         b = (FLAC__byte)((max_framesize >> 8) & 0xFF);
 932         if(fwrite(&b, 1, 1, f) != 1) goto seektable_;
 933         b = (FLAC__byte)(max_framesize & 0xFF);
 934         if(fwrite(&b, 1, 1, f) != 1) goto seektable_;
 935
 936 seektable_:
 937         if(encoder_wrapper->seek_table.num_points > 0) {
 938                 long pos;
 939                 unsigned i;
 940
 941                 /* convert any unused seek points to placeholders */
 942                 for(i = 0; i < encoder_wrapper->seek_table.num_points; i++) {
 943                         if(encoder_wrapper->seek_table.points[i].sample_number == FLAC__STREAM_METADATA_SEEKPOINT_PLACEHOLDER)
 944                                 break;
 945                         else if(encoder_wrapper->seek_table.points[i].frame_samples == 0)
 946                                 encoder_wrapper->seek_table.points[i].sample_number = FLAC__STREAM_METADATA_SEEKPOINT_PLACEHOLDER;
 947                 }
 948
 949                 /* the offset of the seek table data 'pos' should be after then stream sync and STREAMINFO block and SEEKTABLE header */
 950                 pos = (FLAC__STREAM_SYNC_LEN + FLAC__STREAM_METADATA_IS_LAST_LEN + FLAC__STREAM_METADATA_TYPE_LEN + FLAC__STREAM_METADATA_LENGTH_LEN) / 8;
 951                 pos += metadata->length;
 952                 pos += (FLAC__STREAM_METADATA_IS_LAST_LEN + FLAC__STREAM_METADATA_TYPE_LEN + FLAC__STREAM_METADATA_LENGTH_LEN) / 8;
 953                 fseek(f, pos, SEEK_SET);
 954                 for(i = 0; i < encoder_wrapper->seek_table.num_points; i++) {
 955                         if(!write_big_endian_uint64(f, encoder_wrapper->seek_table.points[i].sample_number)) goto end_;
 956                         if(!write_big_endian_uint64(f, encoder_wrapper->seek_table.points[i].stream_offset)) goto end_;
 957                         if(!write_big_endian_uint16(f, (FLAC__uint16)encoder_wrapper->seek_table.points[i].frame_samples)) goto end_;
 958                 }
 959         }
 960
 961 end_:
 962         fclose(f);
 963         return;
 964 }
 965 #endif