switch malloc+memset(0) to calloc()
[flac.git] / src / libFLAC / file_decoder.c
index dd9eff1..54d1bb4 100644 (file)
@@ -1,5 +1,5 @@
 /* libFLAC - Free Lossless Audio Codec library
- * Copyright (C) 2000,2001  Josh Coalson
+ * Copyright (C) 2000,2001,2002  Josh Coalson
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Library General Public
 #include <stdlib.h> /* for malloc() */
 #include <string.h> /* for strcmp() */
 #include <sys/stat.h> /* for stat() */
+#if defined _MSC_VER || defined __MINGW32__
+#include <io.h> /* for _setmode() */
+#include <fcntl.h> /* for _O_BINARY */
+#elif defined __CYGWIN__
+#include <io.h> /* for setmode(), O_BINARY */
+#include <fcntl.h> /* for _O_BINARY */
+#endif
 #include "FLAC/assert.h"
 #include "protected/file_decoder.h"
 #include "protected/seekable_stream_decoder.h"
  *
  ***********************************************************************/
 
+static void set_defaults_(FLAC__FileDecoder *decoder);
+static FILE *get_binary_stdin_();
 static FLAC__SeekableStreamDecoderReadStatus read_callback_(const FLAC__SeekableStreamDecoder *decoder, FLAC__byte buffer[], unsigned *bytes, void *client_data);
 static FLAC__SeekableStreamDecoderSeekStatus seek_callback_(const FLAC__SeekableStreamDecoder *decoder, FLAC__uint64 absolute_byte_offset, void *client_data);
 static FLAC__SeekableStreamDecoderTellStatus tell_callback_(const FLAC__SeekableStreamDecoder *decoder, FLAC__uint64 *absolute_byte_offset, void *client_data);
 static FLAC__SeekableStreamDecoderLengthStatus length_callback_(const FLAC__SeekableStreamDecoder *decoder, FLAC__uint64 *stream_length, void *client_data);
 static FLAC__bool eof_callback_(const FLAC__SeekableStreamDecoder *decoder, void *client_data);
-static FLAC__StreamDecoderWriteStatus write_callback_(const FLAC__SeekableStreamDecoder *decoder, const FLAC__Frame *frame, const FLAC__int32 *buffer[], void *client_data);
-static void metadata_callback_(const FLAC__SeekableStreamDecoder *decoder, const FLAC__StreamMetaData *metadata, void *client_data);
+static FLAC__StreamDecoderWriteStatus write_callback_(const FLAC__SeekableStreamDecoder *decoder, const FLAC__Frame *frame, const FLAC__int32 * const buffer[], void *client_data);
+static void metadata_callback_(const FLAC__SeekableStreamDecoder *decoder, const FLAC__StreamMetadata *metadata, void *client_data);
 static void error_callback_(const FLAC__SeekableStreamDecoder *decoder, FLAC__StreamDecoderErrorStatus status, void *client_data);
 
 /***********************************************************************
@@ -48,16 +57,13 @@ static void error_callback_(const FLAC__SeekableStreamDecoder *decoder, FLAC__St
  ***********************************************************************/
 
 typedef struct FLAC__FileDecoderPrivate {
-       FLAC__StreamDecoderWriteStatus (*write_callback)(const FLAC__FileDecoder *decoder, const FLAC__Frame *frame, const FLAC__int32 *buffer[], void *client_data);
-       void (*metadata_callback)(const FLAC__FileDecoder *decoder, const FLAC__StreamMetaData *metadata, void *client_data);
-       void (*error_callback)(const FLAC__FileDecoder *decoder, FLAC__StreamDecoderErrorStatus status, void *client_data);
+       FLAC__FileDecoderWriteCallback write_callback;
+       FLAC__FileDecoderMetadataCallback metadata_callback;
+       FLAC__FileDecoderErrorCallback error_callback;
        void *client_data;
        FILE *file;
        char *filename; /* == NULL if stdin */
        FLAC__SeekableStreamDecoder *seekable_stream_decoder;
-       struct {
-               FLAC__bool md5_checking;
-       } init_values_for_superclass;
 } FLAC__FileDecoderPrivate;
 
 /***********************************************************************
@@ -66,15 +72,13 @@ typedef struct FLAC__FileDecoderPrivate {
  *
  ***********************************************************************/
 
-const char *FLAC__FileDecoderStateString[] = {
+FLAC_API const char * const FLAC__FileDecoderStateString[] = {
        "FLAC__FILE_DECODER_OK",
-       "FLAC__FILE_DECODER_SEEKING",
        "FLAC__FILE_DECODER_END_OF_FILE",
        "FLAC__FILE_DECODER_ERROR_OPENING_FILE",
        "FLAC__FILE_DECODER_MEMORY_ALLOCATION_ERROR",
        "FLAC__FILE_DECODER_SEEK_ERROR",
-       "FLAC__FILE_DECODER_STREAM_ERROR",
-       "FLAC__FILE_DECODER_STREAM_DECODER_ERROR",
+       "FLAC__FILE_DECODER_SEEKABLE_STREAM_DECODER_ERROR",
        "FLAC__FILE_DECODER_ALREADY_INITIALIZED",
        "FLAC__FILE_DECODER_INVALID_CALLBACK",
        "FLAC__FILE_DECODER_UNINITIALIZED"
@@ -86,45 +90,57 @@ const char *FLAC__FileDecoderStateString[] = {
  *
  ***********************************************************************/
 
-FLAC__FileDecoder *FLAC__file_decoder_new()
+FLAC_API FLAC__FileDecoder *FLAC__file_decoder_new()
 {
        FLAC__FileDecoder *decoder;
 
        FLAC__ASSERT(sizeof(int) >= 4); /* we want to die right away if this is not true */
 
-       decoder = (FLAC__FileDecoder*)malloc(sizeof(FLAC__FileDecoder));
+       decoder = (FLAC__FileDecoder*)calloc(1, sizeof(FLAC__FileDecoder));
        if(decoder == 0) {
                return 0;
        }
-       decoder->protected_ = (FLAC__FileDecoderProtected*)malloc(sizeof(FLAC__FileDecoderProtected));
+
+       decoder->protected_ = (FLAC__FileDecoderProtected*)calloc(1, sizeof(FLAC__FileDecoderProtected));
        if(decoder->protected_ == 0) {
                free(decoder);
                return 0;
        }
-       decoder->private_ = (FLAC__FileDecoderPrivate*)malloc(sizeof(FLAC__FileDecoderPrivate));
+
+       decoder->private_ = (FLAC__FileDecoderPrivate*)calloc(1, sizeof(FLAC__FileDecoderPrivate));
        if(decoder->private_ == 0) {
                free(decoder->protected_);
                free(decoder);
                return 0;
        }
 
-       decoder->protected_->state = FLAC__FILE_DECODER_UNINITIALIZED;
+       decoder->private_->seekable_stream_decoder = FLAC__seekable_stream_decoder_new();
+       if(0 == decoder->private_->seekable_stream_decoder) {
+               free(decoder->private_);
+               free(decoder->protected_);
+               free(decoder);
+               return 0;
+       }
 
-       decoder->private_->filename = 0;
-       decoder->private_->write_callback = 0;
-       decoder->private_->metadata_callback = 0;
-       decoder->private_->error_callback = 0;
-       decoder->private_->client_data = 0;
-       decoder->private_->init_values_for_superclass.md5_checking = false;
+       decoder->private_->file = 0;
+
+       set_defaults_(decoder);
+
+       decoder->protected_->state = FLAC__FILE_DECODER_UNINITIALIZED;
 
        return decoder;
 }
 
-void FLAC__file_decoder_delete(FLAC__FileDecoder *decoder)
+FLAC_API void FLAC__file_decoder_delete(FLAC__FileDecoder *decoder)
 {
-       FLAC__ASSERT(decoder != 0);
-       FLAC__ASSERT(decoder->protected_ != 0);
-       FLAC__ASSERT(decoder->private_ != 0);
+       FLAC__ASSERT(0 != decoder);
+       FLAC__ASSERT(0 != decoder->protected_);
+       FLAC__ASSERT(0 != decoder->private_);
+       FLAC__ASSERT(0 != decoder->private_->seekable_stream_decoder);
+
+       (void)FLAC__file_decoder_finish(decoder);
+
+       FLAC__seekable_stream_decoder_delete(decoder->private_->seekable_stream_decoder);
 
        free(decoder->private_);
        free(decoder->protected_);
@@ -137,34 +153,24 @@ void FLAC__file_decoder_delete(FLAC__FileDecoder *decoder)
  *
  ***********************************************************************/
 
-FLAC__FileDecoderState FLAC__file_decoder_init(FLAC__FileDecoder *decoder)
+FLAC_API FLAC__FileDecoderState FLAC__file_decoder_init(FLAC__FileDecoder *decoder)
 {
-       FLAC__ASSERT(decoder != 0);
+       FLAC__ASSERT(0 != decoder);
 
        if(decoder->protected_->state != FLAC__FILE_DECODER_UNINITIALIZED)
                return decoder->protected_->state = FLAC__FILE_DECODER_ALREADY_INITIALIZED;
 
-       decoder->protected_->state = FLAC__FILE_DECODER_OK;
-
        if(0 == decoder->private_->write_callback || 0 == decoder->private_->metadata_callback || 0 == decoder->private_->error_callback)
                return decoder->protected_->state = FLAC__FILE_DECODER_INVALID_CALLBACK;
 
-       decoder->private_->file = 0;
-       decoder->private_->seekable_stream_decoder = 0;
-
        if(0 == decoder->private_->filename)
-               decoder->private_->file = stdin;
+               decoder->private_->file = get_binary_stdin_();
        else
                decoder->private_->file = fopen(decoder->private_->filename, "rb");
 
        if(decoder->private_->file == 0)
                return decoder->protected_->state = FLAC__FILE_DECODER_ERROR_OPENING_FILE;
 
-       decoder->private_->seekable_stream_decoder = FLAC__seekable_stream_decoder_new();
-
-       if(0 == decoder->private_->seekable_stream_decoder)
-               return decoder->protected_->state = FLAC__FILE_DECODER_MEMORY_ALLOCATION_ERROR;
-
        FLAC__seekable_stream_decoder_set_read_callback(decoder->private_->seekable_stream_decoder, read_callback_);
        FLAC__seekable_stream_decoder_set_seek_callback(decoder->private_->seekable_stream_decoder, seek_callback_);
        FLAC__seekable_stream_decoder_set_tell_callback(decoder->private_->seekable_stream_decoder, tell_callback_);
@@ -175,52 +181,55 @@ FLAC__FileDecoderState FLAC__file_decoder_init(FLAC__FileDecoder *decoder)
        FLAC__seekable_stream_decoder_set_error_callback(decoder->private_->seekable_stream_decoder, error_callback_);
        FLAC__seekable_stream_decoder_set_client_data(decoder->private_->seekable_stream_decoder, decoder);
 
-       /*
-        * Unfortunately, because of the "_new() ... _set_() ... _init()" order of
-        * decoder initialization, settings that are 'inherited' from the superclass
-        * have to be passed up this way, because the superclass has not even been
-        * created yet when the value is set in the subclass.
-        */
-       (void)FLAC__seekable_stream_decoder_set_md5_checking(decoder->private_->seekable_stream_decoder, decoder->private_->init_values_for_superclass.md5_checking);
-
        if(FLAC__seekable_stream_decoder_init(decoder->private_->seekable_stream_decoder) != FLAC__SEEKABLE_STREAM_DECODER_OK)
-               return decoder->protected_->state = FLAC__FILE_DECODER_STREAM_DECODER_ERROR; /*@@@ change this to FLAC__FILE_DECODER_SEEKABLE_STREAM_ERROR in next minor-revision */
+               return decoder->protected_->state = FLAC__FILE_DECODER_SEEKABLE_STREAM_DECODER_ERROR;
 
-       return decoder->protected_->state;
+       return decoder->protected_->state = FLAC__FILE_DECODER_OK;
 }
 
-FLAC__bool FLAC__file_decoder_finish(FLAC__FileDecoder *decoder)
+FLAC_API FLAC__bool FLAC__file_decoder_finish(FLAC__FileDecoder *decoder)
 {
-       FLAC__bool ok = true;
+       FLAC__ASSERT(0 != decoder);
 
-       FLAC__ASSERT(decoder != 0);
        if(decoder->protected_->state == FLAC__FILE_DECODER_UNINITIALIZED)
                return true;
-       if(decoder->private_->file != 0 && decoder->private_->file != stdin)
+
+       FLAC__ASSERT(0 != decoder->private_->seekable_stream_decoder);
+
+       if(0 != decoder->private_->file && decoder->private_->file != stdin) {
                fclose(decoder->private_->file);
+               decoder->private_->file = 0;
+       }
+
        if(0 != decoder->private_->filename) {
                free(decoder->private_->filename);
                decoder->private_->filename = 0;
        }
-       if(decoder->private_->seekable_stream_decoder != 0) {
-               ok = FLAC__seekable_stream_decoder_finish(decoder->private_->seekable_stream_decoder);
-               FLAC__seekable_stream_decoder_delete(decoder->private_->seekable_stream_decoder);
-       }
+
+       set_defaults_(decoder);
+
        decoder->protected_->state = FLAC__FILE_DECODER_UNINITIALIZED;
-       return ok;
+
+       return FLAC__seekable_stream_decoder_finish(decoder->private_->seekable_stream_decoder);
 }
 
-FLAC__bool FLAC__file_decoder_set_md5_checking(const FLAC__FileDecoder *decoder, FLAC__bool value)
+FLAC_API FLAC__bool FLAC__file_decoder_set_md5_checking(FLAC__FileDecoder *decoder, FLAC__bool value)
 {
+       FLAC__ASSERT(0 != decoder);
+       FLAC__ASSERT(0 != decoder->private_);
+       FLAC__ASSERT(0 != decoder->protected_);
+       FLAC__ASSERT(0 != decoder->private_->seekable_stream_decoder);
        if(decoder->protected_->state != FLAC__FILE_DECODER_UNINITIALIZED)
                return false;
-       decoder->private_->init_values_for_superclass.md5_checking = value;
-       return true;
+       return FLAC__seekable_stream_decoder_set_md5_checking(decoder->private_->seekable_stream_decoder, value);
 }
 
-FLAC__bool FLAC__file_decoder_set_filename(const FLAC__FileDecoder *decoder, const char *value)
+FLAC_API FLAC__bool FLAC__file_decoder_set_filename(FLAC__FileDecoder *decoder, const char *value)
 {
-       FLAC__ASSERT(value != 0);
+       FLAC__ASSERT(0 != decoder);
+       FLAC__ASSERT(0 != decoder->private_);
+       FLAC__ASSERT(0 != decoder->protected_);
+       FLAC__ASSERT(0 != value);
        if(decoder->protected_->state != FLAC__FILE_DECODER_UNINITIALIZED)
                return false;
        if(0 != decoder->private_->filename) {
@@ -237,72 +246,183 @@ FLAC__bool FLAC__file_decoder_set_filename(const FLAC__FileDecoder *decoder, con
        return true;
 }
 
-FLAC__bool FLAC__file_decoder_set_write_callback(const FLAC__FileDecoder *decoder, FLAC__StreamDecoderWriteStatus (*value)(const FLAC__FileDecoder *decoder, const FLAC__Frame *frame, const FLAC__int32 *buffer[], void *client_data))
+FLAC_API FLAC__bool FLAC__file_decoder_set_write_callback(FLAC__FileDecoder *decoder, FLAC__FileDecoderWriteCallback value)
 {
+       FLAC__ASSERT(0 != decoder);
+       FLAC__ASSERT(0 != decoder->private_);
+       FLAC__ASSERT(0 != decoder->protected_);
        if(decoder->protected_->state != FLAC__FILE_DECODER_UNINITIALIZED)
                return false;
        decoder->private_->write_callback = value;
        return true;
 }
 
-FLAC__bool FLAC__file_decoder_set_metadata_callback(const FLAC__FileDecoder *decoder, void (*value)(const FLAC__FileDecoder *decoder, const FLAC__StreamMetaData *metadata, void *client_data))
+FLAC_API FLAC__bool FLAC__file_decoder_set_metadata_callback(FLAC__FileDecoder *decoder, FLAC__FileDecoderMetadataCallback value)
 {
+       FLAC__ASSERT(0 != decoder);
+       FLAC__ASSERT(0 != decoder->private_);
+       FLAC__ASSERT(0 != decoder->protected_);
        if(decoder->protected_->state != FLAC__FILE_DECODER_UNINITIALIZED)
                return false;
        decoder->private_->metadata_callback = value;
        return true;
 }
 
-FLAC__bool FLAC__file_decoder_set_error_callback(const FLAC__FileDecoder *decoder, void (*value)(const FLAC__FileDecoder *decoder, FLAC__StreamDecoderErrorStatus status, void *client_data))
+FLAC_API FLAC__bool FLAC__file_decoder_set_error_callback(FLAC__FileDecoder *decoder, FLAC__FileDecoderErrorCallback value)
 {
+       FLAC__ASSERT(0 != decoder);
+       FLAC__ASSERT(0 != decoder->private_);
+       FLAC__ASSERT(0 != decoder->protected_);
        if(decoder->protected_->state != FLAC__FILE_DECODER_UNINITIALIZED)
                return false;
        decoder->private_->error_callback = value;
        return true;
 }
 
-FLAC__bool FLAC__file_decoder_set_client_data(const FLAC__FileDecoder *decoder, void *value)
+FLAC_API FLAC__bool FLAC__file_decoder_set_client_data(FLAC__FileDecoder *decoder, void *value)
 {
+       FLAC__ASSERT(0 != decoder);
+       FLAC__ASSERT(0 != decoder->private_);
+       FLAC__ASSERT(0 != decoder->protected_);
        if(decoder->protected_->state != FLAC__FILE_DECODER_UNINITIALIZED)
                return false;
        decoder->private_->client_data = value;
        return true;
 }
 
-FLAC__FileDecoderState FLAC__file_decoder_get_state(const FLAC__FileDecoder *decoder)
+FLAC_API FLAC__bool FLAC__file_decoder_set_metadata_respond(FLAC__FileDecoder *decoder, FLAC__MetadataType type)
+{
+       FLAC__ASSERT(0 != decoder);
+       FLAC__ASSERT(0 != decoder->private_);
+       FLAC__ASSERT(0 != decoder->protected_);
+       FLAC__ASSERT(0 != decoder->private_->seekable_stream_decoder);
+       if(decoder->protected_->state != FLAC__FILE_DECODER_UNINITIALIZED)
+               return false;
+       return FLAC__seekable_stream_decoder_set_metadata_respond(decoder->private_->seekable_stream_decoder, type);
+}
+
+FLAC_API FLAC__bool FLAC__file_decoder_set_metadata_respond_application(FLAC__FileDecoder *decoder, const FLAC__byte id[4])
+{
+       FLAC__ASSERT(0 != decoder);
+       FLAC__ASSERT(0 != decoder->private_);
+       FLAC__ASSERT(0 != decoder->protected_);
+       FLAC__ASSERT(0 != decoder->private_->seekable_stream_decoder);
+       if(decoder->protected_->state != FLAC__FILE_DECODER_UNINITIALIZED)
+               return false;
+       return FLAC__seekable_stream_decoder_set_metadata_respond_application(decoder->private_->seekable_stream_decoder, id);
+}
+
+FLAC_API FLAC__bool FLAC__file_decoder_set_metadata_respond_all(FLAC__FileDecoder *decoder)
+{
+       FLAC__ASSERT(0 != decoder);
+       FLAC__ASSERT(0 != decoder->private_);
+       FLAC__ASSERT(0 != decoder->protected_);
+       FLAC__ASSERT(0 != decoder->private_->seekable_stream_decoder);
+       if(decoder->protected_->state != FLAC__FILE_DECODER_UNINITIALIZED)
+               return false;
+       return FLAC__seekable_stream_decoder_set_metadata_respond_all(decoder->private_->seekable_stream_decoder);
+}
+
+FLAC_API FLAC__bool FLAC__file_decoder_set_metadata_ignore(FLAC__FileDecoder *decoder, FLAC__MetadataType type)
 {
+       FLAC__ASSERT(0 != decoder);
+       FLAC__ASSERT(0 != decoder->private_);
+       FLAC__ASSERT(0 != decoder->protected_);
+       FLAC__ASSERT(0 != decoder->private_->seekable_stream_decoder);
+       if(decoder->protected_->state != FLAC__FILE_DECODER_UNINITIALIZED)
+               return false;
+       return FLAC__seekable_stream_decoder_set_metadata_ignore(decoder->private_->seekable_stream_decoder, type);
+}
+
+FLAC_API FLAC__bool FLAC__file_decoder_set_metadata_ignore_application(FLAC__FileDecoder *decoder, const FLAC__byte id[4])
+{
+       FLAC__ASSERT(0 != decoder);
+       FLAC__ASSERT(0 != decoder->private_);
+       FLAC__ASSERT(0 != decoder->protected_);
+       FLAC__ASSERT(0 != decoder->private_->seekable_stream_decoder);
+       if(decoder->protected_->state != FLAC__FILE_DECODER_UNINITIALIZED)
+               return false;
+       return FLAC__seekable_stream_decoder_set_metadata_ignore_application(decoder->private_->seekable_stream_decoder, id);
+}
+
+FLAC_API FLAC__bool FLAC__file_decoder_set_metadata_ignore_all(FLAC__FileDecoder *decoder)
+{
+       FLAC__ASSERT(0 != decoder);
+       FLAC__ASSERT(0 != decoder->private_);
+       FLAC__ASSERT(0 != decoder->protected_);
+       FLAC__ASSERT(0 != decoder->private_->seekable_stream_decoder);
+       if(decoder->protected_->state != FLAC__FILE_DECODER_UNINITIALIZED)
+               return false;
+       return FLAC__seekable_stream_decoder_set_metadata_ignore_all(decoder->private_->seekable_stream_decoder);
+}
+
+FLAC_API FLAC__FileDecoderState FLAC__file_decoder_get_state(const FLAC__FileDecoder *decoder)
+{
+       FLAC__ASSERT(0 != decoder);
+       FLAC__ASSERT(0 != decoder->protected_);
        return decoder->protected_->state;
 }
 
-FLAC__bool FLAC__file_decoder_get_md5_checking(const FLAC__FileDecoder *decoder)
+FLAC_API FLAC__SeekableStreamDecoderState FLAC__file_decoder_get_seekable_stream_decoder_state(const FLAC__FileDecoder *decoder)
 {
-       return FLAC__seekable_stream_decoder_get_md5_checking(decoder->private_->seekable_stream_decoder);
+       FLAC__ASSERT(0 != decoder);
+       FLAC__ASSERT(0 != decoder->private_);
+       return FLAC__seekable_stream_decoder_get_state(decoder->private_->seekable_stream_decoder);
 }
 
-FLAC__bool FLAC__file_decoder_process_whole_file(FLAC__FileDecoder *decoder)
+FLAC_API FLAC__StreamDecoderState FLAC__file_decoder_get_stream_decoder_state(const FLAC__FileDecoder *decoder)
 {
-       FLAC__bool ret;
-       FLAC__ASSERT(decoder != 0);
+       FLAC__ASSERT(0 != decoder);
+       FLAC__ASSERT(0 != decoder->private_);
+       return FLAC__seekable_stream_decoder_get_stream_decoder_state(decoder->private_->seekable_stream_decoder);
+}
 
-       if(decoder->private_->seekable_stream_decoder->protected_->state == FLAC__SEEKABLE_STREAM_DECODER_END_OF_STREAM)
-               decoder->protected_->state = FLAC__FILE_DECODER_END_OF_FILE;
+FLAC_API FLAC__bool FLAC__file_decoder_get_md5_checking(const FLAC__FileDecoder *decoder)
+{
+       FLAC__ASSERT(0 != decoder);
+       FLAC__ASSERT(0 != decoder->private_);
+       return FLAC__seekable_stream_decoder_get_md5_checking(decoder->private_->seekable_stream_decoder);
+}
 
-       if(decoder->protected_->state == FLAC__FILE_DECODER_END_OF_FILE)
-               return true;
+FLAC_API unsigned FLAC__file_decoder_get_channels(const FLAC__FileDecoder *decoder)
+{
+       FLAC__ASSERT(0 != decoder);
+       FLAC__ASSERT(0 != decoder->private_);
+       return FLAC__seekable_stream_decoder_get_channels(decoder->private_->seekable_stream_decoder);
+}
 
-       FLAC__ASSERT(decoder->protected_->state == FLAC__FILE_DECODER_OK);
+FLAC_API FLAC__ChannelAssignment FLAC__file_decoder_get_channel_assignment(const FLAC__FileDecoder *decoder)
+{
+       FLAC__ASSERT(0 != decoder);
+       FLAC__ASSERT(0 != decoder->private_);
+       return FLAC__seekable_stream_decoder_get_channel_assignment(decoder->private_->seekable_stream_decoder);
+}
 
-       ret = FLAC__seekable_stream_decoder_process_whole_stream(decoder->private_->seekable_stream_decoder);
-       if(!ret)
-               decoder->protected_->state = FLAC__FILE_DECODER_SEEKABLE_STREAM_ERROR;
+FLAC_API unsigned FLAC__file_decoder_get_bits_per_sample(const FLAC__FileDecoder *decoder)
+{
+       FLAC__ASSERT(0 != decoder);
+       FLAC__ASSERT(0 != decoder->private_);
+       return FLAC__seekable_stream_decoder_get_bits_per_sample(decoder->private_->seekable_stream_decoder);
+}
 
-       return ret;
+FLAC_API unsigned FLAC__file_decoder_get_sample_rate(const FLAC__FileDecoder *decoder)
+{
+       FLAC__ASSERT(0 != decoder);
+       FLAC__ASSERT(0 != decoder->private_);
+       return FLAC__seekable_stream_decoder_get_sample_rate(decoder->private_->seekable_stream_decoder);
 }
 
-FLAC__bool FLAC__file_decoder_process_metadata(FLAC__FileDecoder *decoder)
+FLAC_API unsigned FLAC__file_decoder_get_blocksize(const FLAC__FileDecoder *decoder)
+{
+       FLAC__ASSERT(0 != decoder);
+       FLAC__ASSERT(0 != decoder->private_);
+       return FLAC__seekable_stream_decoder_get_blocksize(decoder->private_->seekable_stream_decoder);
+}
+
+FLAC_API FLAC__bool FLAC__file_decoder_process_single(FLAC__FileDecoder *decoder)
 {
        FLAC__bool ret;
-       FLAC__ASSERT(decoder != 0);
+       FLAC__ASSERT(0 != decoder);
 
        if(decoder->private_->seekable_stream_decoder->protected_->state == FLAC__SEEKABLE_STREAM_DECODER_END_OF_STREAM)
                decoder->protected_->state = FLAC__FILE_DECODER_END_OF_FILE;
@@ -312,17 +432,17 @@ FLAC__bool FLAC__file_decoder_process_metadata(FLAC__FileDecoder *decoder)
 
        FLAC__ASSERT(decoder->protected_->state == FLAC__FILE_DECODER_OK);
 
-       ret = FLAC__seekable_stream_decoder_process_metadata(decoder->private_->seekable_stream_decoder);
+       ret = FLAC__seekable_stream_decoder_process_single(decoder->private_->seekable_stream_decoder);
        if(!ret)
-               decoder->protected_->state = FLAC__FILE_DECODER_SEEKABLE_STREAM_ERROR;
+               decoder->protected_->state = FLAC__FILE_DECODER_SEEKABLE_STREAM_DECODER_ERROR;
 
        return ret;
 }
 
-FLAC__bool FLAC__file_decoder_process_one_frame(FLAC__FileDecoder *decoder)
+FLAC_API FLAC__bool FLAC__file_decoder_process_until_end_of_metadata(FLAC__FileDecoder *decoder)
 {
        FLAC__bool ret;
-       FLAC__ASSERT(decoder != 0);
+       FLAC__ASSERT(0 != decoder);
 
        if(decoder->private_->seekable_stream_decoder->protected_->state == FLAC__SEEKABLE_STREAM_DECODER_END_OF_STREAM)
                decoder->protected_->state = FLAC__FILE_DECODER_END_OF_FILE;
@@ -332,17 +452,17 @@ FLAC__bool FLAC__file_decoder_process_one_frame(FLAC__FileDecoder *decoder)
 
        FLAC__ASSERT(decoder->protected_->state == FLAC__FILE_DECODER_OK);
 
-       ret = FLAC__seekable_stream_decoder_process_one_frame(decoder->private_->seekable_stream_decoder);
+       ret = FLAC__seekable_stream_decoder_process_until_end_of_metadata(decoder->private_->seekable_stream_decoder);
        if(!ret)
-               decoder->protected_->state = FLAC__FILE_DECODER_SEEKABLE_STREAM_ERROR;
+               decoder->protected_->state = FLAC__FILE_DECODER_SEEKABLE_STREAM_DECODER_ERROR;
 
        return ret;
 }
 
-FLAC__bool FLAC__file_decoder_process_remaining_frames(FLAC__FileDecoder *decoder)
+FLAC_API FLAC__bool FLAC__file_decoder_process_until_end_of_file(FLAC__FileDecoder *decoder)
 {
        FLAC__bool ret;
-       FLAC__ASSERT(decoder != 0);
+       FLAC__ASSERT(0 != decoder);
 
        if(decoder->private_->seekable_stream_decoder->protected_->state == FLAC__SEEKABLE_STREAM_DECODER_END_OF_STREAM)
                decoder->protected_->state = FLAC__FILE_DECODER_END_OF_FILE;
@@ -352,23 +472,17 @@ FLAC__bool FLAC__file_decoder_process_remaining_frames(FLAC__FileDecoder *decode
 
        FLAC__ASSERT(decoder->protected_->state == FLAC__FILE_DECODER_OK);
 
-       ret = FLAC__seekable_stream_decoder_process_remaining_frames(decoder->private_->seekable_stream_decoder);
+       ret = FLAC__seekable_stream_decoder_process_until_end_of_stream(decoder->private_->seekable_stream_decoder);
        if(!ret)
-               decoder->protected_->state = FLAC__FILE_DECODER_SEEKABLE_STREAM_ERROR;
+               decoder->protected_->state = FLAC__FILE_DECODER_SEEKABLE_STREAM_DECODER_ERROR;
 
        return ret;
 }
 
-/***********************************************************************
- *
- * Private class methods
- *
- ***********************************************************************/
-
-FLAC__bool FLAC__file_decoder_seek_absolute(FLAC__FileDecoder *decoder, FLAC__uint64 sample)
+FLAC_API FLAC__bool FLAC__file_decoder_seek_absolute(FLAC__FileDecoder *decoder, FLAC__uint64 sample)
 {
-       FLAC__ASSERT(decoder != 0);
-       FLAC__ASSERT(decoder->protected_->state == FLAC__FILE_DECODER_OK);
+       FLAC__ASSERT(0 != decoder);
+       FLAC__ASSERT(decoder->protected_->state == FLAC__FILE_DECODER_OK || decoder->protected_->state == FLAC__FILE_DECODER_END_OF_FILE);
 
        if(decoder->private_->filename == 0) { /* means the file is stdin... */
                decoder->protected_->state = FLAC__FILE_DECODER_SEEK_ERROR;
@@ -379,8 +493,48 @@ FLAC__bool FLAC__file_decoder_seek_absolute(FLAC__FileDecoder *decoder, FLAC__ui
                decoder->protected_->state = FLAC__FILE_DECODER_SEEK_ERROR;
                return false;
        }
-       else
+       else {
+               decoder->protected_->state = FLAC__FILE_DECODER_OK;
                return true;
+       }
+}
+
+
+/***********************************************************************
+ *
+ * Private class methods
+ *
+ ***********************************************************************/
+
+void set_defaults_(FLAC__FileDecoder *decoder)
+{
+       FLAC__ASSERT(0 != decoder);
+       FLAC__ASSERT(0 != decoder->private_);
+
+       decoder->private_->filename = 0;
+       decoder->private_->write_callback = 0;
+       decoder->private_->metadata_callback = 0;
+       decoder->private_->error_callback = 0;
+       decoder->private_->client_data = 0;
+}
+
+/*
+ * This will forcibly set stdin to binary mode (for OSes that require it)
+ */
+FILE *get_binary_stdin_()
+{
+       /* if something breaks here it is probably due to the presence or
+        * absence of an underscore before the identifiers 'setmode',
+        * 'fileno', and/or 'O_BINARY'; check your system header files.
+        */
+#if defined _MSC_VER || defined __MINGW32__
+       _setmode(_fileno(stdin), _O_BINARY);
+#elif defined __CYGWIN__
+       /* almost certainly not needed for any modern Cygwin, but let's be safe... */
+       setmode(_fileno(stdin), _O_BINARY);
+#endif
+
+       return stdin;
 }
 
 FLAC__SeekableStreamDecoderReadStatus read_callback_(const FLAC__SeekableStreamDecoder *decoder, FLAC__byte buffer[], unsigned *bytes, void *client_data)
@@ -449,7 +603,7 @@ FLAC__bool eof_callback_(const FLAC__SeekableStreamDecoder *decoder, void *clien
        return feof(file_decoder->private_->file);
 }
 
-FLAC__StreamDecoderWriteStatus write_callback_(const FLAC__SeekableStreamDecoder *decoder, const FLAC__Frame *frame, const FLAC__int32 *buffer[], void *client_data)
+FLAC__StreamDecoderWriteStatus write_callback_(const FLAC__SeekableStreamDecoder *decoder, const FLAC__Frame *frame, const FLAC__int32 * const buffer[], void *client_data)
 {
        FLAC__FileDecoder *file_decoder = (FLAC__FileDecoder *)client_data;
        (void)decoder;
@@ -457,7 +611,7 @@ FLAC__StreamDecoderWriteStatus write_callback_(const FLAC__SeekableStreamDecoder
        return file_decoder->private_->write_callback(file_decoder, frame, buffer, file_decoder->private_->client_data);
 }
 
-void metadata_callback_(const FLAC__SeekableStreamDecoder *decoder, const FLAC__StreamMetaData *metadata, void *client_data)
+void metadata_callback_(const FLAC__SeekableStreamDecoder *decoder, const FLAC__StreamMetadata *metadata, void *client_data)
 {
        FLAC__FileDecoder *file_decoder = (FLAC__FileDecoder *)client_data;
        (void)decoder;