projects / platform / upstream / flac.git / blobdiff
? search:
summary | shortlog | log | commit | commitdiff | tree
raw | inline | side by side
rework so that rice parameters and raw_bits from the entropy coding method struct...
[platform/upstream/flac.git] / src / libFLAC / seekable_stream_decoder.c
diff --git a/src/libFLAC/seekable_stream_decoder.c b/src/libFLAC/seekable_stream_decoder.c
index e617ab7..79bccfb 100644 (file)
--- a/src/libFLAC/seekable_stream_decoder.c
+++ b/src/libFLAC/seekable_stream_decoder.c
@@ -31,7 +31,7 @@
  *
  ***********************************************************************/
 
-static void seekable_stream_decoder_set_defaults_(FLAC__SeekableStreamDecoder *decoder);
+static void set_defaults_(FLAC__SeekableStreamDecoder *decoder);
 static FLAC__StreamDecoderReadStatus read_callback_(const FLAC__StreamDecoder *decoder, FLAC__byte buffer[], unsigned *bytes, void *client_data);
 static FLAC__StreamDecoderWriteStatus write_callback_(const FLAC__StreamDecoder *decoder, const FLAC__Frame *frame, const FLAC__int32 * const buffer[], void *client_data);
 static void metadata_callback_(const FLAC__StreamDecoder *decoder, const FLAC__StreamMetadata *metadata, void *client_data);
@@ -45,14 +45,14 @@ static FLAC__bool seek_to_absolute_sample_(FLAC__SeekableStreamDecoder *decoder,
  ***********************************************************************/
 
 typedef struct FLAC__SeekableStreamDecoderPrivate {
-       FLAC__SeekableStreamDecoderReadStatus (*read_callback)(const FLAC__SeekableStreamDecoder *decoder, FLAC__byte buffer[], unsigned *bytes, void *client_data);
-       FLAC__SeekableStreamDecoderSeekStatus (*seek_callback)(const FLAC__SeekableStreamDecoder *decoder, FLAC__uint64 absolute_byte_offset, void *client_data);
-       FLAC__SeekableStreamDecoderTellStatus (*tell_callback)(const FLAC__SeekableStreamDecoder *decoder, FLAC__uint64 *absolute_byte_offset, void *client_data);
-       FLAC__SeekableStreamDecoderLengthStatus (*length_callback)(const FLAC__SeekableStreamDecoder *decoder, FLAC__uint64 *stream_length, void *client_data);
-       FLAC__bool (*eof_callback)(const FLAC__SeekableStreamDecoder *decoder, void *client_data);
-       FLAC__StreamDecoderWriteStatus (*write_callback)(const FLAC__SeekableStreamDecoder *decoder, const FLAC__Frame *frame, const FLAC__int32 * const buffer[], void *client_data);
-       void (*metadata_callback)(const FLAC__SeekableStreamDecoder *decoder, const FLAC__StreamMetadata *metadata, void *client_data);
-       void (*error_callback)(const FLAC__SeekableStreamDecoder *decoder, FLAC__StreamDecoderErrorStatus status, void *client_data);
+       FLAC__SeekableStreamDecoderReadCallback read_callback;
+       FLAC__SeekableStreamDecoderSeekCallback seek_callback;
+       FLAC__SeekableStreamDecoderTellCallback tell_callback;
+       FLAC__SeekableStreamDecoderLengthCallback length_callback;
+       FLAC__SeekableStreamDecoderEofCallback eof_callback;
+       FLAC__SeekableStreamDecoderWriteCallback write_callback;
+       FLAC__SeekableStreamDecoderMetadataCallback metadata_callback;
+       FLAC__SeekableStreamDecoderErrorCallback error_callback;
        void *client_data;
        FLAC__StreamDecoder *stream_decoder;
        FLAC__bool do_md5_checking; /* initially gets protected_->md5_checking but is turned off after a seek */
@@ -83,9 +83,9 @@ const char * const FLAC__SeekableStreamDecoderStateString[] = {
        "FLAC__SEEKABLE_STREAM_DECODER_STREAM_DECODER_ERROR",
        "FLAC__SEEKABLE_STREAM_DECODER_READ_ERROR",
        "FLAC__SEEKABLE_STREAM_DECODER_SEEK_ERROR",
-    "FLAC__SEEKABLE_STREAM_DECODER_ALREADY_INITIALIZED",
-    "FLAC__SEEKABLE_STREAM_DECODER_INVALID_CALLBACK",
-    "FLAC__SEEKABLE_STREAM_DECODER_UNINITIALIZED"
+       "FLAC__SEEKABLE_STREAM_DECODER_ALREADY_INITIALIZED",
+       "FLAC__SEEKABLE_STREAM_DECODER_INVALID_CALLBACK",
+       "FLAC__SEEKABLE_STREAM_DECODER_UNINITIALIZED"
 };
 
 const char * const FLAC__SeekableStreamDecoderReadStatusString[] = {
@@ -108,6 +108,7 @@ const char * const FLAC__SeekableStreamDecoderLengthStatusString[] = {
        "FLAC__SEEKABLE_STREAM_DECODER_LENGTH_STATUS_ERROR"
 };
 
+
 /***********************************************************************
  *
  * Class constructor/destructor
@@ -124,20 +125,24 @@ FLAC__SeekableStreamDecoder *FLAC__seekable_stream_decoder_new()
        if(decoder == 0) {
                return 0;
        }
+       memset(decoder, 0, sizeof(FLAC__SeekableStreamDecoder));
+
        decoder->protected_ = (FLAC__SeekableStreamDecoderProtected*)malloc(sizeof(FLAC__SeekableStreamDecoderProtected));
        if(decoder->protected_ == 0) {
                free(decoder);
                return 0;
        }
+       memset(decoder->protected_, 0, sizeof(FLAC__SeekableStreamDecoderProtected));
+
        decoder->private_ = (FLAC__SeekableStreamDecoderPrivate*)malloc(sizeof(FLAC__SeekableStreamDecoderPrivate));
        if(decoder->private_ == 0) {
                free(decoder->protected_);
                free(decoder);
                return 0;
        }
+       memset(decoder->private_, 0, sizeof(FLAC__SeekableStreamDecoderPrivate));
 
        decoder->private_->stream_decoder = FLAC__stream_decoder_new();
-
        if(0 == decoder->private_->stream_decoder) {
                free(decoder->private_);
                free(decoder->protected_);
@@ -145,7 +150,7 @@ FLAC__SeekableStreamDecoder *FLAC__seekable_stream_decoder_new()
                return 0;
        }
 
-       seekable_stream_decoder_set_defaults_(decoder);
+       set_defaults_(decoder);
 
        decoder->protected_->state = FLAC__SEEKABLE_STREAM_DECODER_UNINITIALIZED;
 
@@ -154,10 +159,10 @@ FLAC__SeekableStreamDecoder *FLAC__seekable_stream_decoder_new()
 
 void FLAC__seekable_stream_decoder_delete(FLAC__SeekableStreamDecoder *decoder)
 {
-       FLAC__ASSERT(decoder != 0);
-       FLAC__ASSERT(decoder->protected_ != 0);
-       FLAC__ASSERT(decoder->private_ != 0);
-       FLAC__ASSERT(decoder->private_->stream_decoder != 0);
+       FLAC__ASSERT(0 != decoder);
+       FLAC__ASSERT(0 != decoder->protected_);
+       FLAC__ASSERT(0 != decoder->private_);
+       FLAC__ASSERT(0 != decoder->private_->stream_decoder);
 
        (void)FLAC__seekable_stream_decoder_finish(decoder);
 
@@ -176,7 +181,7 @@ void FLAC__seekable_stream_decoder_delete(FLAC__SeekableStreamDecoder *decoder)
 
 FLAC__SeekableStreamDecoderState FLAC__seekable_stream_decoder_init(FLAC__SeekableStreamDecoder *decoder)
 {
-       FLAC__ASSERT(decoder != 0);
+       FLAC__ASSERT(0 != decoder);
 
        if(decoder->protected_->state != FLAC__SEEKABLE_STREAM_DECODER_UNINITIALIZED)
                return decoder->protected_->state = FLAC__SEEKABLE_STREAM_DECODER_ALREADY_INITIALIZED;
@@ -222,14 +227,14 @@ FLAC__bool FLAC__seekable_stream_decoder_finish(FLAC__SeekableStreamDecoder *dec
 {
        FLAC__bool md5_failed = false;
 
-       FLAC__ASSERT(decoder != 0);
-       FLAC__ASSERT(decoder->private_ != 0);
-       FLAC__ASSERT(decoder->protected_ != 0);
+       FLAC__ASSERT(0 != decoder);
+       FLAC__ASSERT(0 != decoder->private_);
+       FLAC__ASSERT(0 != decoder->protected_);
 
        if(decoder->protected_->state == FLAC__SEEKABLE_STREAM_DECODER_UNINITIALIZED)
                return true;
 
-       FLAC__ASSERT(decoder->private_->stream_decoder != 0);
+       FLAC__ASSERT(0 != decoder->private_->stream_decoder);
 
        /* see the comment in FLAC__seekable_stream_decoder_init() as to why we
         * always call MD5Final()
@@ -243,7 +248,7 @@ FLAC__bool FLAC__seekable_stream_decoder_finish(FLAC__SeekableStreamDecoder *dec
                        md5_failed = true;
        }
 
-       seekable_stream_decoder_set_defaults_(decoder);
+       set_defaults_(decoder);
 
        decoder->protected_->state = FLAC__SEEKABLE_STREAM_DECODER_UNINITIALIZED;
 
@@ -252,96 +257,96 @@ FLAC__bool FLAC__seekable_stream_decoder_finish(FLAC__SeekableStreamDecoder *dec
 
 FLAC__bool FLAC__seekable_stream_decoder_set_md5_checking(FLAC__SeekableStreamDecoder *decoder, FLAC__bool value)
 {
-       FLAC__ASSERT(decoder != 0);
-       FLAC__ASSERT(decoder->protected_ != 0);
+       FLAC__ASSERT(0 != decoder);
+       FLAC__ASSERT(0 != decoder->protected_);
        if(decoder->protected_->state != FLAC__SEEKABLE_STREAM_DECODER_UNINITIALIZED)
                return false;
        decoder->protected_->md5_checking = value;
        return true;
 }
 
-FLAC__bool FLAC__seekable_stream_decoder_set_read_callback(FLAC__SeekableStreamDecoder *decoder, FLAC__SeekableStreamDecoderReadStatus (*value)(const FLAC__SeekableStreamDecoder *decoder, FLAC__byte buffer[], unsigned *bytes, void *client_data))
+FLAC__bool FLAC__seekable_stream_decoder_set_read_callback(FLAC__SeekableStreamDecoder *decoder, FLAC__SeekableStreamDecoderReadCallback value)
 {
-       FLAC__ASSERT(decoder != 0);
-       FLAC__ASSERT(decoder->private_ != 0);
-       FLAC__ASSERT(decoder->protected_ != 0);
+       FLAC__ASSERT(0 != decoder);
+       FLAC__ASSERT(0 != decoder->private_);
+       FLAC__ASSERT(0 != decoder->protected_);
        if(decoder->protected_->state != FLAC__SEEKABLE_STREAM_DECODER_UNINITIALIZED)
                return false;
        decoder->private_->read_callback = value;
        return true;
 }
 
-FLAC__bool FLAC__seekable_stream_decoder_set_seek_callback(FLAC__SeekableStreamDecoder *decoder, FLAC__SeekableStreamDecoderSeekStatus (*value)(const FLAC__SeekableStreamDecoder *decoder, FLAC__uint64 absolute_byte_offset, void *client_data))
+FLAC__bool FLAC__seekable_stream_decoder_set_seek_callback(FLAC__SeekableStreamDecoder *decoder, FLAC__SeekableStreamDecoderSeekCallback value)
 {
-       FLAC__ASSERT(decoder != 0);
-       FLAC__ASSERT(decoder->private_ != 0);
-       FLAC__ASSERT(decoder->protected_ != 0);
+       FLAC__ASSERT(0 != decoder);
+       FLAC__ASSERT(0 != decoder->private_);
+       FLAC__ASSERT(0 != decoder->protected_);
        if(decoder->protected_->state != FLAC__SEEKABLE_STREAM_DECODER_UNINITIALIZED)
                return false;
        decoder->private_->seek_callback = value;
        return true;
 }
 
-FLAC__bool FLAC__seekable_stream_decoder_set_tell_callback(FLAC__SeekableStreamDecoder *decoder, FLAC__SeekableStreamDecoderTellStatus (*value)(const FLAC__SeekableStreamDecoder *decoder, FLAC__uint64 *absolute_byte_offset, void *client_data))
+FLAC__bool FLAC__seekable_stream_decoder_set_tell_callback(FLAC__SeekableStreamDecoder *decoder, FLAC__SeekableStreamDecoderTellCallback value)
 {
-       FLAC__ASSERT(decoder != 0);
-       FLAC__ASSERT(decoder->private_ != 0);
-       FLAC__ASSERT(decoder->protected_ != 0);
+       FLAC__ASSERT(0 != decoder);
+       FLAC__ASSERT(0 != decoder->private_);
+       FLAC__ASSERT(0 != decoder->protected_);
        if(decoder->protected_->state != FLAC__SEEKABLE_STREAM_DECODER_UNINITIALIZED)
                return false;
        decoder->private_->tell_callback = value;
        return true;
 }
 
-FLAC__bool FLAC__seekable_stream_decoder_set_length_callback(FLAC__SeekableStreamDecoder *decoder, FLAC__SeekableStreamDecoderLengthStatus (*value)(const FLAC__SeekableStreamDecoder *decoder, FLAC__uint64 *stream_length, void *client_data))
+FLAC__bool FLAC__seekable_stream_decoder_set_length_callback(FLAC__SeekableStreamDecoder *decoder, FLAC__SeekableStreamDecoderLengthCallback value)
 {
-       FLAC__ASSERT(decoder != 0);
-       FLAC__ASSERT(decoder->private_ != 0);
-       FLAC__ASSERT(decoder->protected_ != 0);
+       FLAC__ASSERT(0 != decoder);
+       FLAC__ASSERT(0 != decoder->private_);
+       FLAC__ASSERT(0 != decoder->protected_);
        if(decoder->protected_->state != FLAC__SEEKABLE_STREAM_DECODER_UNINITIALIZED)
                return false;
        decoder->private_->length_callback = value;
        return true;
 }
 
-FLAC__bool FLAC__seekable_stream_decoder_set_eof_callback(FLAC__SeekableStreamDecoder *decoder, FLAC__bool (*value)(const FLAC__SeekableStreamDecoder *decoder, void *client_data))
+FLAC__bool FLAC__seekable_stream_decoder_set_eof_callback(FLAC__SeekableStreamDecoder *decoder, FLAC__SeekableStreamDecoderEofCallback value)
 {
-       FLAC__ASSERT(decoder != 0);
-       FLAC__ASSERT(decoder->private_ != 0);
-       FLAC__ASSERT(decoder->protected_ != 0);
+       FLAC__ASSERT(0 != decoder);
+       FLAC__ASSERT(0 != decoder->private_);
+       FLAC__ASSERT(0 != decoder->protected_);
        if(decoder->protected_->state != FLAC__SEEKABLE_STREAM_DECODER_UNINITIALIZED)
                return false;
        decoder->private_->eof_callback = value;
        return true;
 }
 
-FLAC__bool FLAC__seekable_stream_decoder_set_write_callback(FLAC__SeekableStreamDecoder *decoder, FLAC__StreamDecoderWriteStatus (*value)(const FLAC__SeekableStreamDecoder *decoder, const FLAC__Frame *frame, const FLAC__int32 * const buffer[], void *client_data))
+FLAC__bool FLAC__seekable_stream_decoder_set_write_callback(FLAC__SeekableStreamDecoder *decoder, FLAC__SeekableStreamDecoderWriteCallback value)
 {
-       FLAC__ASSERT(decoder != 0);
-       FLAC__ASSERT(decoder->private_ != 0);
-       FLAC__ASSERT(decoder->protected_ != 0);
+       FLAC__ASSERT(0 != decoder);
+       FLAC__ASSERT(0 != decoder->private_);
+       FLAC__ASSERT(0 != decoder->protected_);
        if(decoder->protected_->state != FLAC__SEEKABLE_STREAM_DECODER_UNINITIALIZED)
                return false;
        decoder->private_->write_callback = value;
        return true;
 }
 
-FLAC__bool FLAC__seekable_stream_decoder_set_metadata_callback(FLAC__SeekableStreamDecoder *decoder, void (*value)(const FLAC__SeekableStreamDecoder *decoder, const FLAC__StreamMetadata *metadata, void *client_data))
+FLAC__bool FLAC__seekable_stream_decoder_set_metadata_callback(FLAC__SeekableStreamDecoder *decoder, FLAC__SeekableStreamDecoderMetadataCallback value)
 {
-       FLAC__ASSERT(decoder != 0);
-       FLAC__ASSERT(decoder->private_ != 0);
-       FLAC__ASSERT(decoder->protected_ != 0);
+       FLAC__ASSERT(0 != decoder);
+       FLAC__ASSERT(0 != decoder->private_);
+       FLAC__ASSERT(0 != decoder->protected_);
        if(decoder->protected_->state != FLAC__SEEKABLE_STREAM_DECODER_UNINITIALIZED)
                return false;
        decoder->private_->metadata_callback = value;
        return true;
 }
 
-FLAC__bool FLAC__seekable_stream_decoder_set_error_callback(FLAC__SeekableStreamDecoder *decoder, void (*value)(const FLAC__SeekableStreamDecoder *decoder, FLAC__StreamDecoderErrorStatus status, void *client_data))
+FLAC__bool FLAC__seekable_stream_decoder_set_error_callback(FLAC__SeekableStreamDecoder *decoder, FLAC__SeekableStreamDecoderErrorCallback value)
 {
-       FLAC__ASSERT(decoder != 0);
-       FLAC__ASSERT(decoder->private_ != 0);
-       FLAC__ASSERT(decoder->protected_ != 0);
+       FLAC__ASSERT(0 != decoder);
+       FLAC__ASSERT(0 != decoder->private_);
+       FLAC__ASSERT(0 != decoder->protected_);
        if(decoder->protected_->state != FLAC__SEEKABLE_STREAM_DECODER_UNINITIALIZED)
                return false;
        decoder->private_->error_callback = value;
@@ -350,9 +355,9 @@ FLAC__bool FLAC__seekable_stream_decoder_set_error_callback(FLAC__SeekableStream
 
 FLAC__bool FLAC__seekable_stream_decoder_set_client_data(FLAC__SeekableStreamDecoder *decoder, void *value)
 {
-       FLAC__ASSERT(decoder != 0);
-       FLAC__ASSERT(decoder->private_ != 0);
-       FLAC__ASSERT(decoder->protected_ != 0);
+       FLAC__ASSERT(0 != decoder);
+       FLAC__ASSERT(0 != decoder->private_);
+       FLAC__ASSERT(0 != decoder->protected_);
        if(decoder->protected_->state != FLAC__SEEKABLE_STREAM_DECODER_UNINITIALIZED)
                return false;
        decoder->private_->client_data = value;
@@ -361,10 +366,10 @@ FLAC__bool FLAC__seekable_stream_decoder_set_client_data(FLAC__SeekableStreamDec
 
 FLAC__bool FLAC__seekable_stream_decoder_set_metadata_respond(FLAC__SeekableStreamDecoder *decoder, FLAC__MetadataType type)
 {
-       FLAC__ASSERT(decoder != 0);
-       FLAC__ASSERT(decoder->private_ != 0);
-       FLAC__ASSERT(decoder->protected_ != 0);
-       FLAC__ASSERT(decoder->private_->stream_decoder != 0);
+       FLAC__ASSERT(0 != decoder);
+       FLAC__ASSERT(0 != decoder->private_);
+       FLAC__ASSERT(0 != decoder->protected_);
+       FLAC__ASSERT(0 != decoder->private_->stream_decoder);
        if(decoder->protected_->state != FLAC__SEEKABLE_STREAM_DECODER_UNINITIALIZED)
                return false;
        if(type == FLAC__METADATA_TYPE_STREAMINFO)
@@ -376,10 +381,10 @@ FLAC__bool FLAC__seekable_stream_decoder_set_metadata_respond(FLAC__SeekableStre
 
 FLAC__bool FLAC__seekable_stream_decoder_set_metadata_respond_application(FLAC__SeekableStreamDecoder *decoder, const FLAC__byte id[4])
 {
-       FLAC__ASSERT(decoder != 0);
-       FLAC__ASSERT(decoder->private_ != 0);
-       FLAC__ASSERT(decoder->protected_ != 0);
-       FLAC__ASSERT(decoder->private_->stream_decoder != 0);
+       FLAC__ASSERT(0 != decoder);
+       FLAC__ASSERT(0 != decoder->private_);
+       FLAC__ASSERT(0 != decoder->protected_);
+       FLAC__ASSERT(0 != decoder->private_->stream_decoder);
        if(decoder->protected_->state != FLAC__SEEKABLE_STREAM_DECODER_UNINITIALIZED)
                return false;
        return FLAC__stream_decoder_set_metadata_respond_application(decoder->private_->stream_decoder, id);
@@ -387,10 +392,10 @@ FLAC__bool FLAC__seekable_stream_decoder_set_metadata_respond_application(FLAC__
 
 FLAC__bool FLAC__seekable_stream_decoder_set_metadata_respond_all(FLAC__SeekableStreamDecoder *decoder)
 {
-       FLAC__ASSERT(decoder != 0);
-       FLAC__ASSERT(decoder->private_ != 0);
-       FLAC__ASSERT(decoder->protected_ != 0);
-       FLAC__ASSERT(decoder->private_->stream_decoder != 0);
+       FLAC__ASSERT(0 != decoder);
+       FLAC__ASSERT(0 != decoder->private_);
+       FLAC__ASSERT(0 != decoder->protected_);
+       FLAC__ASSERT(0 != decoder->private_->stream_decoder);
        if(decoder->protected_->state != FLAC__SEEKABLE_STREAM_DECODER_UNINITIALIZED)
                return false;
        decoder->private_->ignore_stream_info_block = false;
@@ -400,10 +405,10 @@ FLAC__bool FLAC__seekable_stream_decoder_set_metadata_respond_all(FLAC__Seekable
 
 FLAC__bool FLAC__seekable_stream_decoder_set_metadata_ignore(FLAC__SeekableStreamDecoder *decoder, FLAC__MetadataType type)
 {
-       FLAC__ASSERT(decoder != 0);
-       FLAC__ASSERT(decoder->private_ != 0);
-       FLAC__ASSERT(decoder->protected_ != 0);
-       FLAC__ASSERT(decoder->private_->stream_decoder != 0);
+       FLAC__ASSERT(0 != decoder);
+       FLAC__ASSERT(0 != decoder->private_);
+       FLAC__ASSERT(0 != decoder->protected_);
+       FLAC__ASSERT(0 != decoder->private_->stream_decoder);
        if(decoder->protected_->state != FLAC__SEEKABLE_STREAM_DECODER_UNINITIALIZED)
                return false;
        if(type == FLAC__METADATA_TYPE_STREAMINFO)
@@ -415,10 +420,10 @@ FLAC__bool FLAC__seekable_stream_decoder_set_metadata_ignore(FLAC__SeekableStrea
 
 FLAC__bool FLAC__seekable_stream_decoder_set_metadata_ignore_application(FLAC__SeekableStreamDecoder *decoder, const FLAC__byte id[4])
 {
-       FLAC__ASSERT(decoder != 0);
-       FLAC__ASSERT(decoder->private_ != 0);
-       FLAC__ASSERT(decoder->protected_ != 0);
-       FLAC__ASSERT(decoder->private_->stream_decoder != 0);
+       FLAC__ASSERT(0 != decoder);
+       FLAC__ASSERT(0 != decoder->private_);
+       FLAC__ASSERT(0 != decoder->protected_);
+       FLAC__ASSERT(0 != decoder->private_->stream_decoder);
        if(decoder->protected_->state != FLAC__SEEKABLE_STREAM_DECODER_UNINITIALIZED)
                return false;
        return FLAC__stream_decoder_set_metadata_ignore_application(decoder->private_->stream_decoder, id);
@@ -426,10 +431,10 @@ FLAC__bool FLAC__seekable_stream_decoder_set_metadata_ignore_application(FLAC__S
 
 FLAC__bool FLAC__seekable_stream_decoder_set_metadata_ignore_all(FLAC__SeekableStreamDecoder *decoder)
 {
-       FLAC__ASSERT(decoder != 0);
-       FLAC__ASSERT(decoder->private_ != 0);
-       FLAC__ASSERT(decoder->protected_ != 0);
-       FLAC__ASSERT(decoder->private_->stream_decoder != 0);
+       FLAC__ASSERT(0 != decoder);
+       FLAC__ASSERT(0 != decoder->private_);
+       FLAC__ASSERT(0 != decoder->protected_);
+       FLAC__ASSERT(0 != decoder->private_->stream_decoder);
        if(decoder->protected_->state != FLAC__SEEKABLE_STREAM_DECODER_UNINITIALIZED)
                return false;
        decoder->private_->ignore_stream_info_block = true;
@@ -439,58 +444,65 @@ FLAC__bool FLAC__seekable_stream_decoder_set_metadata_ignore_all(FLAC__SeekableS
 
 FLAC__SeekableStreamDecoderState FLAC__seekable_stream_decoder_get_state(const FLAC__SeekableStreamDecoder *decoder)
 {
-       FLAC__ASSERT(decoder != 0);
-       FLAC__ASSERT(decoder->protected_ != 0);
+       FLAC__ASSERT(0 != decoder);
+       FLAC__ASSERT(0 != decoder->protected_);
        return decoder->protected_->state;
 }
 
+FLAC__SeekableStreamDecoderState FLAC__seekable_stream_decoder_get_stream_decoder_state(const FLAC__SeekableStreamDecoder *decoder)
+{
+       FLAC__ASSERT(0 != decoder);
+       FLAC__ASSERT(0 != decoder->private_);
+       return FLAC__stream_decoder_get_state(decoder->private_->stream_decoder);
+}
+
 FLAC__bool FLAC__seekable_stream_decoder_get_md5_checking(const FLAC__SeekableStreamDecoder *decoder)
 {
-       FLAC__ASSERT(decoder != 0);
-       FLAC__ASSERT(decoder->protected_ != 0);
+       FLAC__ASSERT(0 != decoder);
+       FLAC__ASSERT(0 != decoder->protected_);
        return decoder->protected_->md5_checking;
 }
 
 unsigned FLAC__seekable_stream_decoder_get_channels(const FLAC__SeekableStreamDecoder *decoder)
 {
-    FLAC__ASSERT(decoder != 0);
-    FLAC__ASSERT(decoder->private_ != 0);
-    return FLAC__stream_decoder_get_channels(decoder->private_->stream_decoder);
+       FLAC__ASSERT(0 != decoder);
+       FLAC__ASSERT(0 != decoder->private_);
+       return FLAC__stream_decoder_get_channels(decoder->private_->stream_decoder);
 }
 
 FLAC__ChannelAssignment FLAC__seekable_stream_decoder_get_channel_assignment(const FLAC__SeekableStreamDecoder *decoder)
 {
-    FLAC__ASSERT(decoder != 0);
-    FLAC__ASSERT(decoder->private_ != 0);
-    return FLAC__stream_decoder_get_channel_assignment(decoder->private_->stream_decoder);
+       FLAC__ASSERT(0 != decoder);
+       FLAC__ASSERT(0 != decoder->private_);
+       return FLAC__stream_decoder_get_channel_assignment(decoder->private_->stream_decoder);
 }
 
 unsigned FLAC__seekable_stream_decoder_get_bits_per_sample(const FLAC__SeekableStreamDecoder *decoder)
 {
-    FLAC__ASSERT(decoder != 0);
-    FLAC__ASSERT(decoder->private_ != 0);
-    return FLAC__stream_decoder_get_bits_per_sample(decoder->private_->stream_decoder);
+       FLAC__ASSERT(0 != decoder);
+       FLAC__ASSERT(0 != decoder->private_);
+       return FLAC__stream_decoder_get_bits_per_sample(decoder->private_->stream_decoder);
 }
 
 unsigned FLAC__seekable_stream_decoder_get_sample_rate(const FLAC__SeekableStreamDecoder *decoder)
 {
-    FLAC__ASSERT(decoder != 0);
-    FLAC__ASSERT(decoder->private_ != 0);
-    return FLAC__stream_decoder_get_sample_rate(decoder->private_->stream_decoder);
+       FLAC__ASSERT(0 != decoder);
+       FLAC__ASSERT(0 != decoder->private_);
+       return FLAC__stream_decoder_get_sample_rate(decoder->private_->stream_decoder);
 }
 
 unsigned FLAC__seekable_stream_decoder_get_blocksize(const FLAC__SeekableStreamDecoder *decoder)
 {
-    FLAC__ASSERT(decoder != 0);
-    FLAC__ASSERT(decoder->private_ != 0);
-    return FLAC__stream_decoder_get_blocksize(decoder->private_->stream_decoder);
+       FLAC__ASSERT(0 != decoder);
+       FLAC__ASSERT(0 != decoder->private_);
+       return FLAC__stream_decoder_get_blocksize(decoder->private_->stream_decoder);
 }
 
 FLAC__bool FLAC__seekable_stream_decoder_flush(FLAC__SeekableStreamDecoder *decoder)
 {
-       FLAC__ASSERT(decoder != 0);
-       FLAC__ASSERT(decoder->private_ != 0);
-       FLAC__ASSERT(decoder->protected_ != 0);
+       FLAC__ASSERT(0 != decoder);
+       FLAC__ASSERT(0 != decoder->private_);
+       FLAC__ASSERT(0 != decoder->protected_);
 
        decoder->private_->do_md5_checking = false;
 
@@ -499,14 +511,16 @@ FLAC__bool FLAC__seekable_stream_decoder_flush(FLAC__SeekableStreamDecoder *deco
                return false;
        }
 
+       decoder->protected_->state = FLAC__SEEKABLE_STREAM_DECODER_OK;
+
        return true;
 }
 
 FLAC__bool FLAC__seekable_stream_decoder_reset(FLAC__SeekableStreamDecoder *decoder)
 {
-       FLAC__ASSERT(decoder != 0);
-       FLAC__ASSERT(decoder->private_ != 0);
-       FLAC__ASSERT(decoder->protected_ != 0);
+       FLAC__ASSERT(0 != decoder);
+       FLAC__ASSERT(0 != decoder->private_);
+       FLAC__ASSERT(0 != decoder->protected_);
 
        if(!FLAC__seekable_stream_decoder_flush(decoder)) {
                decoder->protected_->state = FLAC__SEEKABLE_STREAM_DECODER_STREAM_DECODER_ERROR;
@@ -535,30 +549,10 @@ FLAC__bool FLAC__seekable_stream_decoder_reset(FLAC__SeekableStreamDecoder *deco
        return true;
 }
 
-FLAC__bool FLAC__seekable_stream_decoder_process_whole_stream(FLAC__SeekableStreamDecoder *decoder)
-{
-       FLAC__bool ret;
-       FLAC__ASSERT(decoder != 0);
-
-       if(decoder->private_->stream_decoder->protected_->state == FLAC__STREAM_DECODER_END_OF_STREAM)
-               decoder->protected_->state = FLAC__SEEKABLE_STREAM_DECODER_END_OF_STREAM;
-
-       if(decoder->protected_->state == FLAC__SEEKABLE_STREAM_DECODER_END_OF_STREAM)
-               return true;
-
-       FLAC__ASSERT(decoder->protected_->state == FLAC__SEEKABLE_STREAM_DECODER_OK);
-
-       ret = FLAC__stream_decoder_process_whole_stream(decoder->private_->stream_decoder);
-       if(!ret)
-               decoder->protected_->state = FLAC__SEEKABLE_STREAM_DECODER_STREAM_DECODER_ERROR;
-
-       return ret;
-}
-
-FLAC__bool FLAC__seekable_stream_decoder_process_metadata(FLAC__SeekableStreamDecoder *decoder)
+FLAC__bool FLAC__seekable_stream_decoder_process_single(FLAC__SeekableStreamDecoder *decoder)
 {
        FLAC__bool ret;
-       FLAC__ASSERT(decoder != 0);
+       FLAC__ASSERT(0 != decoder);
 
        if(decoder->private_->stream_decoder->protected_->state == FLAC__STREAM_DECODER_END_OF_STREAM)
                decoder->protected_->state = FLAC__SEEKABLE_STREAM_DECODER_END_OF_STREAM;
@@ -568,17 +562,17 @@ FLAC__bool FLAC__seekable_stream_decoder_process_metadata(FLAC__SeekableStreamDe
 
        FLAC__ASSERT(decoder->protected_->state == FLAC__SEEKABLE_STREAM_DECODER_OK);
 
-       ret = FLAC__stream_decoder_process_metadata(decoder->private_->stream_decoder);
+       ret = FLAC__stream_decoder_process_single(decoder->private_->stream_decoder);
        if(!ret)
                decoder->protected_->state = FLAC__SEEKABLE_STREAM_DECODER_STREAM_DECODER_ERROR;
 
        return ret;
 }
 
-FLAC__bool FLAC__seekable_stream_decoder_process_one_frame(FLAC__SeekableStreamDecoder *decoder)
+FLAC__bool FLAC__seekable_stream_decoder_process_until_end_of_metadata(FLAC__SeekableStreamDecoder *decoder)
 {
        FLAC__bool ret;
-       FLAC__ASSERT(decoder != 0);
+       FLAC__ASSERT(0 != decoder);
 
        if(decoder->private_->stream_decoder->protected_->state == FLAC__STREAM_DECODER_END_OF_STREAM)
                decoder->protected_->state = FLAC__SEEKABLE_STREAM_DECODER_END_OF_STREAM;
@@ -588,17 +582,17 @@ FLAC__bool FLAC__seekable_stream_decoder_process_one_frame(FLAC__SeekableStreamD
 
        FLAC__ASSERT(decoder->protected_->state == FLAC__SEEKABLE_STREAM_DECODER_OK);
 
-       ret = FLAC__stream_decoder_process_one_frame(decoder->private_->stream_decoder);
+       ret = FLAC__stream_decoder_process_until_end_of_metadata(decoder->private_->stream_decoder);
        if(!ret)
                decoder->protected_->state = FLAC__SEEKABLE_STREAM_DECODER_STREAM_DECODER_ERROR;
 
        return ret;
 }
 
-FLAC__bool FLAC__seekable_stream_decoder_process_remaining_frames(FLAC__SeekableStreamDecoder *decoder)
+FLAC__bool FLAC__seekable_stream_decoder_process_until_end_of_stream(FLAC__SeekableStreamDecoder *decoder)
 {
        FLAC__bool ret;
-       FLAC__ASSERT(decoder != 0);
+       FLAC__ASSERT(0 != decoder);
 
        if(decoder->private_->stream_decoder->protected_->state == FLAC__STREAM_DECODER_END_OF_STREAM)
                decoder->protected_->state = FLAC__SEEKABLE_STREAM_DECODER_END_OF_STREAM;
@@ -608,7 +602,7 @@ FLAC__bool FLAC__seekable_stream_decoder_process_remaining_frames(FLAC__Seekable
 
        FLAC__ASSERT(decoder->protected_->state == FLAC__SEEKABLE_STREAM_DECODER_OK);
 
-       ret = FLAC__stream_decoder_process_remaining_frames(decoder->private_->stream_decoder);
+       ret = FLAC__stream_decoder_process_until_end_of_stream(decoder->private_->stream_decoder);
        if(!ret)
                decoder->protected_->state = FLAC__SEEKABLE_STREAM_DECODER_STREAM_DECODER_ERROR;
 
@@ -619,7 +613,7 @@ FLAC__bool FLAC__seekable_stream_decoder_seek_absolute(FLAC__SeekableStreamDecod
 {
        FLAC__uint64 length;
 
-       FLAC__ASSERT(decoder != 0);
+       FLAC__ASSERT(0 != decoder);
        FLAC__ASSERT(decoder->protected_->state == FLAC__SEEKABLE_STREAM_DECODER_OK || decoder->protected_->state == FLAC__SEEKABLE_STREAM_DECODER_END_OF_STREAM);
 
        decoder->protected_->state = FLAC__SEEKABLE_STREAM_DECODER_SEEKING;
@@ -641,7 +635,7 @@ FLAC__bool FLAC__seekable_stream_decoder_seek_absolute(FLAC__SeekableStreamDecod
                decoder->protected_->state = FLAC__SEEKABLE_STREAM_DECODER_SEEK_ERROR;
                return false;
        }
-       if(!FLAC__stream_decoder_process_metadata(decoder->private_->stream_decoder)) {
+       if(!FLAC__stream_decoder_process_until_end_of_metadata(decoder->private_->stream_decoder)) {
                decoder->protected_->state = FLAC__SEEKABLE_STREAM_DECODER_STREAM_DECODER_ERROR;
                return false;
        }
@@ -659,7 +653,7 @@ FLAC__bool FLAC__seekable_stream_decoder_seek_absolute(FLAC__SeekableStreamDecod
  *
  ***********************************************************************/
 
-void seekable_stream_decoder_set_defaults_(FLAC__SeekableStreamDecoder *decoder)
+void set_defaults_(FLAC__SeekableStreamDecoder *decoder)
 {
        decoder->private_->read_callback = 0;
        decoder->private_->seek_callback = 0;
@@ -951,7 +945,7 @@ FLAC__bool seek_to_absolute_sample_(FLAC__SeekableStreamDecoder *decoder, FLAC__
                                return false;
                        }
                }
-               if(!FLAC__stream_decoder_process_one_frame(decoder->private_->stream_decoder)) {
+               if(!FLAC__stream_decoder_process_single(decoder->private_->stream_decoder)) {
                        decoder->protected_->state = FLAC__SEEKABLE_STREAM_DECODER_SEEK_ERROR;
                        return false;
                }
Domain: Multimedia / Audio FW;