use angle brackets for including ogg.h
[flac.git] / src / libOggFLAC / stream_decoder.c
index aedaa03..2a2c0aa 100644 (file)
@@ -17,9 +17,9 @@
  * Boston, MA  02111-1307, USA.
  */
 
-#include <stdlib.h>
+#include <stdlib.h> /* for calloc() */
 #include <string.h> /* for memset() */
-#include "ogg/ogg.h"
+#include <ogg/ogg.h>
 #include "FLAC/assert.h"
 #include "protected/stream_decoder.h"
 
@@ -57,6 +57,7 @@ typedef struct OggFLAC__StreamDecoderPrivate {
        struct {
                ogg_stream_state stream_state;
                ogg_sync_state sync_state;
+               FLAC__bool need_serial_number;
        } ogg;
 } OggFLAC__StreamDecoderPrivate;
 
@@ -66,7 +67,7 @@ typedef struct OggFLAC__StreamDecoderPrivate {
  *
  ***********************************************************************/
 
-const char * const OggFLAC__StreamDecoderStateString[] = {
+const OggFLAC_API char * const OggFLAC__StreamDecoderStateString[] = {
        "OggFLAC__STREAM_DECODER_OK",
        "OggFLAC__STREAM_DECODER_OGG_ERROR",
        "OggFLAC__STREAM_DECODER_READ_ERROR",
@@ -83,30 +84,27 @@ const char * const OggFLAC__StreamDecoderStateString[] = {
  * Class constructor/destructor
  *
  ***********************************************************************/
-OggFLAC__StreamDecoder *OggFLAC__stream_decoder_new()
+OggFLAC_API OggFLAC__StreamDecoder *OggFLAC__stream_decoder_new()
 {
        OggFLAC__StreamDecoder *decoder;
 
-       decoder = (OggFLAC__StreamDecoder*)malloc(sizeof(OggFLAC__StreamDecoder));
+       decoder = (OggFLAC__StreamDecoder*)calloc(1, sizeof(OggFLAC__StreamDecoder));
        if(decoder == 0) {
                return 0;
        }
-       memset(decoder, 0, sizeof(OggFLAC__StreamDecoder));
 
-       decoder->protected_ = (OggFLAC__StreamDecoderProtected*)malloc(sizeof(OggFLAC__StreamDecoderProtected));
+       decoder->protected_ = (OggFLAC__StreamDecoderProtected*)calloc(1, sizeof(OggFLAC__StreamDecoderProtected));
        if(decoder->protected_ == 0) {
                free(decoder);
                return 0;
        }
-       memset(decoder->protected_, 0, sizeof(OggFLAC__StreamDecoderProtected));
 
-       decoder->private_ = (OggFLAC__StreamDecoderPrivate*)malloc(sizeof(OggFLAC__StreamDecoderPrivate));
+       decoder->private_ = (OggFLAC__StreamDecoderPrivate*)calloc(1, sizeof(OggFLAC__StreamDecoderPrivate));
        if(decoder->private_ == 0) {
                free(decoder->protected_);
                free(decoder);
                return 0;
        }
-       memset(decoder->private_, 0, sizeof(OggFLAC__StreamDecoderPrivate));
 
        decoder->private_->FLAC_stream_decoder = FLAC__stream_decoder_new();
        if(0 == decoder->private_->FLAC_stream_decoder) {
@@ -123,7 +121,7 @@ OggFLAC__StreamDecoder *OggFLAC__stream_decoder_new()
        return decoder;
 }
 
-void OggFLAC__stream_decoder_delete(OggFLAC__StreamDecoder *decoder)
+OggFLAC_API void OggFLAC__stream_decoder_delete(OggFLAC__StreamDecoder *decoder)
 {
        FLAC__ASSERT(0 != decoder);
        FLAC__ASSERT(0 != decoder->protected_);
@@ -132,7 +130,7 @@ void OggFLAC__stream_decoder_delete(OggFLAC__StreamDecoder *decoder)
 
        OggFLAC__stream_decoder_finish(decoder);
 
-    FLAC__stream_decoder_delete(decoder->private_->FLAC_stream_decoder);
+       FLAC__stream_decoder_delete(decoder->private_->FLAC_stream_decoder);
 
        free(decoder->private_);
        free(decoder->protected_);
@@ -145,7 +143,7 @@ void OggFLAC__stream_decoder_delete(OggFLAC__StreamDecoder *decoder)
  *
  ***********************************************************************/
 
-OggFLAC__StreamDecoderState OggFLAC__stream_decoder_init(OggFLAC__StreamDecoder *decoder)
+OggFLAC_API OggFLAC__StreamDecoderState OggFLAC__stream_decoder_init(OggFLAC__StreamDecoder *decoder)
 {
        FLAC__ASSERT(0 != decoder);
 
@@ -155,25 +153,27 @@ OggFLAC__StreamDecoderState OggFLAC__stream_decoder_init(OggFLAC__StreamDecoder
        if(0 == decoder->private_->read_callback || 0 == decoder->private_->write_callback || 0 == decoder->private_->metadata_callback || 0 == decoder->private_->error_callback)
                return decoder->protected_->state = OggFLAC__STREAM_DECODER_INVALID_CALLBACK;
 
-       if(ogg_stream_init(&decoder->private_->ogg.stream_state, 0) != 0)
+       decoder->private_->ogg.need_serial_number = decoder->protected_->use_first_serial_number;
+       /* we will determine the serial number later if necessary */
+       if(ogg_stream_init(&decoder->private_->ogg.stream_state, decoder->protected_->serial_number) != 0)
                return decoder->protected_->state = OggFLAC__STREAM_DECODER_OGG_ERROR;
 
        if(ogg_sync_init(&decoder->private_->ogg.sync_state) != 0)
                return decoder->protected_->state = OggFLAC__STREAM_DECODER_OGG_ERROR;
 
-    FLAC__stream_decoder_set_read_callback(decoder->private_->FLAC_stream_decoder, read_callback_);
-    FLAC__stream_decoder_set_write_callback(decoder->private_->FLAC_stream_decoder, write_callback_);
-    FLAC__stream_decoder_set_metadata_callback(decoder->private_->FLAC_stream_decoder, metadata_callback_);
-    FLAC__stream_decoder_set_error_callback(decoder->private_->FLAC_stream_decoder, error_callback_);
-    FLAC__stream_decoder_set_client_data(decoder->private_->FLAC_stream_decoder, decoder);
+       FLAC__stream_decoder_set_read_callback(decoder->private_->FLAC_stream_decoder, read_callback_);
+       FLAC__stream_decoder_set_write_callback(decoder->private_->FLAC_stream_decoder, write_callback_);
+       FLAC__stream_decoder_set_metadata_callback(decoder->private_->FLAC_stream_decoder, metadata_callback_);
+       FLAC__stream_decoder_set_error_callback(decoder->private_->FLAC_stream_decoder, error_callback_);
+       FLAC__stream_decoder_set_client_data(decoder->private_->FLAC_stream_decoder, decoder);
 
-    if(FLAC__stream_decoder_init(decoder->private_->FLAC_stream_decoder) != FLAC__STREAM_DECODER_SEARCH_FOR_METADATA)
-        return decoder->protected_->state = OggFLAC__STREAM_DECODER_FLAC_STREAM_DECODER_ERROR;
+       if(FLAC__stream_decoder_init(decoder->private_->FLAC_stream_decoder) != FLAC__STREAM_DECODER_SEARCH_FOR_METADATA)
+               return decoder->protected_->state = OggFLAC__STREAM_DECODER_FLAC_STREAM_DECODER_ERROR;
 
        return decoder->protected_->state = OggFLAC__STREAM_DECODER_OK;
 }
 
-void OggFLAC__stream_decoder_finish(OggFLAC__StreamDecoder *decoder)
+OggFLAC_API void OggFLAC__stream_decoder_finish(OggFLAC__StreamDecoder *decoder)
 {
        FLAC__ASSERT(0 != decoder);
        FLAC__ASSERT(0 != decoder->private_);
@@ -194,7 +194,7 @@ void OggFLAC__stream_decoder_finish(OggFLAC__StreamDecoder *decoder)
        decoder->protected_->state = OggFLAC__STREAM_DECODER_UNINITIALIZED;
 }
 
-FLAC__bool OggFLAC__stream_decoder_set_read_callback(OggFLAC__StreamDecoder *decoder, OggFLAC__StreamDecoderReadCallback value)
+OggFLAC_API FLAC__bool OggFLAC__stream_decoder_set_read_callback(OggFLAC__StreamDecoder *decoder, OggFLAC__StreamDecoderReadCallback value)
 {
        FLAC__ASSERT(0 != decoder);
        FLAC__ASSERT(0 != decoder->private_);
@@ -205,7 +205,7 @@ FLAC__bool OggFLAC__stream_decoder_set_read_callback(OggFLAC__StreamDecoder *dec
        return true;
 }
 
-FLAC__bool OggFLAC__stream_decoder_set_write_callback(OggFLAC__StreamDecoder *decoder, OggFLAC__StreamDecoderWriteCallback value)
+OggFLAC_API FLAC__bool OggFLAC__stream_decoder_set_write_callback(OggFLAC__StreamDecoder *decoder, OggFLAC__StreamDecoderWriteCallback value)
 {
        FLAC__ASSERT(0 != decoder);
        FLAC__ASSERT(0 != decoder->private_);
@@ -216,7 +216,7 @@ FLAC__bool OggFLAC__stream_decoder_set_write_callback(OggFLAC__StreamDecoder *de
        return true;
 }
 
-FLAC__bool OggFLAC__stream_decoder_set_metadata_callback(OggFLAC__StreamDecoder *decoder, OggFLAC__StreamDecoderMetadataCallback value)
+OggFLAC_API FLAC__bool OggFLAC__stream_decoder_set_metadata_callback(OggFLAC__StreamDecoder *decoder, OggFLAC__StreamDecoderMetadataCallback value)
 {
        FLAC__ASSERT(0 != decoder);
        FLAC__ASSERT(0 != decoder->private_);
@@ -227,7 +227,7 @@ FLAC__bool OggFLAC__stream_decoder_set_metadata_callback(OggFLAC__StreamDecoder
        return true;
 }
 
-FLAC__bool OggFLAC__stream_decoder_set_error_callback(OggFLAC__StreamDecoder *decoder, OggFLAC__StreamDecoderErrorCallback value)
+OggFLAC_API FLAC__bool OggFLAC__stream_decoder_set_error_callback(OggFLAC__StreamDecoder *decoder, OggFLAC__StreamDecoderErrorCallback value)
 {
        FLAC__ASSERT(0 != decoder);
        FLAC__ASSERT(0 != decoder->private_);
@@ -238,7 +238,7 @@ FLAC__bool OggFLAC__stream_decoder_set_error_callback(OggFLAC__StreamDecoder *de
        return true;
 }
 
-FLAC__bool OggFLAC__stream_decoder_set_client_data(OggFLAC__StreamDecoder *decoder, void *value)
+OggFLAC_API FLAC__bool OggFLAC__stream_decoder_set_client_data(OggFLAC__StreamDecoder *decoder, void *value)
 {
        FLAC__ASSERT(0 != decoder);
        FLAC__ASSERT(0 != decoder->private_);
@@ -249,7 +249,19 @@ FLAC__bool OggFLAC__stream_decoder_set_client_data(OggFLAC__StreamDecoder *decod
        return true;
 }
 
-FLAC__bool OggFLAC__stream_decoder_set_metadata_respond(OggFLAC__StreamDecoder *decoder, FLAC__MetadataType type)
+OggFLAC_API FLAC__bool OggFLAC__stream_decoder_set_serial_number(OggFLAC__StreamDecoder *decoder, long value)
+{
+       FLAC__ASSERT(0 != decoder);
+       FLAC__ASSERT(0 != decoder->private_);
+       FLAC__ASSERT(0 != decoder->protected_);
+       if(decoder->protected_->state != OggFLAC__STREAM_DECODER_UNINITIALIZED)
+               return false;
+       decoder->protected_->use_first_serial_number = false;
+       decoder->protected_->serial_number = value;
+       return true;
+}
+
+OggFLAC_API FLAC__bool OggFLAC__stream_decoder_set_metadata_respond(OggFLAC__StreamDecoder *decoder, FLAC__MetadataType type)
 {
        FLAC__ASSERT(0 != decoder);
        FLAC__ASSERT(0 != decoder->private_);
@@ -259,7 +271,7 @@ FLAC__bool OggFLAC__stream_decoder_set_metadata_respond(OggFLAC__StreamDecoder *
        return FLAC__stream_decoder_set_metadata_respond(decoder->private_->FLAC_stream_decoder, type);
 }
 
-FLAC__bool OggFLAC__stream_decoder_set_metadata_respond_application(OggFLAC__StreamDecoder *decoder, const FLAC__byte id[4])
+OggFLAC_API FLAC__bool OggFLAC__stream_decoder_set_metadata_respond_application(OggFLAC__StreamDecoder *decoder, const FLAC__byte id[4])
 {
        FLAC__ASSERT(0 != decoder);
        FLAC__ASSERT(0 != decoder->private_);
@@ -269,7 +281,7 @@ FLAC__bool OggFLAC__stream_decoder_set_metadata_respond_application(OggFLAC__Str
        return FLAC__stream_decoder_set_metadata_respond_application(decoder->private_->FLAC_stream_decoder, id);
 }
 
-FLAC__bool OggFLAC__stream_decoder_set_metadata_respond_all(OggFLAC__StreamDecoder *decoder)
+OggFLAC_API FLAC__bool OggFLAC__stream_decoder_set_metadata_respond_all(OggFLAC__StreamDecoder *decoder)
 {
        FLAC__ASSERT(0 != decoder);
        FLAC__ASSERT(0 != decoder->private_);
@@ -279,7 +291,7 @@ FLAC__bool OggFLAC__stream_decoder_set_metadata_respond_all(OggFLAC__StreamDecod
        return FLAC__stream_decoder_set_metadata_respond_all(decoder->private_->FLAC_stream_decoder);
 }
 
-FLAC__bool OggFLAC__stream_decoder_set_metadata_ignore(OggFLAC__StreamDecoder *decoder, FLAC__MetadataType type)
+OggFLAC_API FLAC__bool OggFLAC__stream_decoder_set_metadata_ignore(OggFLAC__StreamDecoder *decoder, FLAC__MetadataType type)
 {
        FLAC__ASSERT(0 != decoder);
        FLAC__ASSERT(0 != decoder->private_);
@@ -289,7 +301,7 @@ FLAC__bool OggFLAC__stream_decoder_set_metadata_ignore(OggFLAC__StreamDecoder *d
        return FLAC__stream_decoder_set_metadata_ignore(decoder->private_->FLAC_stream_decoder, type);
 }
 
-FLAC__bool OggFLAC__stream_decoder_set_metadata_ignore_application(OggFLAC__StreamDecoder *decoder, const FLAC__byte id[4])
+OggFLAC_API FLAC__bool OggFLAC__stream_decoder_set_metadata_ignore_application(OggFLAC__StreamDecoder *decoder, const FLAC__byte id[4])
 {
        FLAC__ASSERT(0 != decoder);
        FLAC__ASSERT(0 != decoder->private_);
@@ -299,7 +311,7 @@ FLAC__bool OggFLAC__stream_decoder_set_metadata_ignore_application(OggFLAC__Stre
        return FLAC__stream_decoder_set_metadata_ignore_application(decoder->private_->FLAC_stream_decoder, id);
 }
 
-FLAC__bool OggFLAC__stream_decoder_set_metadata_ignore_all(OggFLAC__StreamDecoder *decoder)
+OggFLAC_API FLAC__bool OggFLAC__stream_decoder_set_metadata_ignore_all(OggFLAC__StreamDecoder *decoder)
 {
        FLAC__ASSERT(0 != decoder);
        FLAC__ASSERT(0 != decoder->private_);
@@ -309,56 +321,56 @@ FLAC__bool OggFLAC__stream_decoder_set_metadata_ignore_all(OggFLAC__StreamDecode
        return FLAC__stream_decoder_set_metadata_ignore_all(decoder->private_->FLAC_stream_decoder);
 }
 
-OggFLAC__StreamDecoderState OggFLAC__stream_decoder_get_state(const OggFLAC__StreamDecoder *decoder)
+OggFLAC_API OggFLAC__StreamDecoderState OggFLAC__stream_decoder_get_state(const OggFLAC__StreamDecoder *decoder)
 {
        FLAC__ASSERT(0 != decoder);
        FLAC__ASSERT(0 != decoder->protected_);
        return decoder->protected_->state;
 }
 
-FLAC__StreamDecoderState OggFLAC__stream_decoder_get_FLAC_stream_decoder_state(const OggFLAC__StreamDecoder *decoder)
+OggFLAC_API FLAC__StreamDecoderState OggFLAC__stream_decoder_get_FLAC_stream_decoder_state(const OggFLAC__StreamDecoder *decoder)
 {
        FLAC__ASSERT(0 != decoder);
        FLAC__ASSERT(0 != decoder->private_);
        return FLAC__stream_decoder_get_state(decoder->private_->FLAC_stream_decoder);
 }
 
-unsigned OggFLAC__stream_decoder_get_channels(const OggFLAC__StreamDecoder *decoder)
+OggFLAC_API unsigned OggFLAC__stream_decoder_get_channels(const OggFLAC__StreamDecoder *decoder)
 {
        FLAC__ASSERT(0 != decoder);
        FLAC__ASSERT(0 != decoder->private_);
        return FLAC__stream_decoder_get_channels(decoder->private_->FLAC_stream_decoder);
 }
 
-FLAC__ChannelAssignment OggFLAC__stream_decoder_get_channel_assignment(const OggFLAC__StreamDecoder *decoder)
+OggFLAC_API FLAC__ChannelAssignment OggFLAC__stream_decoder_get_channel_assignment(const OggFLAC__StreamDecoder *decoder)
 {
        FLAC__ASSERT(0 != decoder);
        FLAC__ASSERT(0 != decoder->private_);
        return FLAC__stream_decoder_get_channel_assignment(decoder->private_->FLAC_stream_decoder);
 }
 
-unsigned OggFLAC__stream_decoder_get_bits_per_sample(const OggFLAC__StreamDecoder *decoder)
+OggFLAC_API unsigned OggFLAC__stream_decoder_get_bits_per_sample(const OggFLAC__StreamDecoder *decoder)
 {
        FLAC__ASSERT(0 != decoder);
        FLAC__ASSERT(0 != decoder->private_);
        return FLAC__stream_decoder_get_bits_per_sample(decoder->private_->FLAC_stream_decoder);
 }
 
-unsigned OggFLAC__stream_decoder_get_sample_rate(const OggFLAC__StreamDecoder *decoder)
+OggFLAC_API unsigned OggFLAC__stream_decoder_get_sample_rate(const OggFLAC__StreamDecoder *decoder)
 {
        FLAC__ASSERT(0 != decoder);
        FLAC__ASSERT(0 != decoder->private_);
        return FLAC__stream_decoder_get_sample_rate(decoder->private_->FLAC_stream_decoder);
 }
 
-unsigned OggFLAC__stream_decoder_get_blocksize(const OggFLAC__StreamDecoder *decoder)
+OggFLAC_API unsigned OggFLAC__stream_decoder_get_blocksize(const OggFLAC__StreamDecoder *decoder)
 {
        FLAC__ASSERT(0 != decoder);
        FLAC__ASSERT(0 != decoder->private_);
        return FLAC__stream_decoder_get_blocksize(decoder->private_->FLAC_stream_decoder);
 }
 
-FLAC__bool OggFLAC__stream_decoder_flush(OggFLAC__StreamDecoder *decoder)
+OggFLAC_API FLAC__bool OggFLAC__stream_decoder_flush(OggFLAC__StreamDecoder *decoder)
 {
        FLAC__ASSERT(0 != decoder);
        FLAC__ASSERT(0 != decoder->private_);
@@ -376,7 +388,7 @@ FLAC__bool OggFLAC__stream_decoder_flush(OggFLAC__StreamDecoder *decoder)
        return true;
 }
 
-FLAC__bool OggFLAC__stream_decoder_reset(OggFLAC__StreamDecoder *decoder)
+OggFLAC_API FLAC__bool OggFLAC__stream_decoder_reset(OggFLAC__StreamDecoder *decoder)
 {
        FLAC__ASSERT(0 != decoder);
        FLAC__ASSERT(0 != decoder->private_);
@@ -397,21 +409,21 @@ FLAC__bool OggFLAC__stream_decoder_reset(OggFLAC__StreamDecoder *decoder)
        return true;
 }
 
-FLAC__bool OggFLAC__stream_decoder_process_single(OggFLAC__StreamDecoder *decoder)
+OggFLAC_API FLAC__bool OggFLAC__stream_decoder_process_single(OggFLAC__StreamDecoder *decoder)
 {
        FLAC__ASSERT(0 != decoder);
        FLAC__ASSERT(0 != decoder->private_);
        return FLAC__stream_decoder_process_single(decoder->private_->FLAC_stream_decoder);
 }
 
-FLAC__bool OggFLAC__stream_decoder_process_until_end_of_metadata(OggFLAC__StreamDecoder *decoder)
+OggFLAC_API FLAC__bool OggFLAC__stream_decoder_process_until_end_of_metadata(OggFLAC__StreamDecoder *decoder)
 {
        FLAC__ASSERT(0 != decoder);
        FLAC__ASSERT(0 != decoder->private_);
        return FLAC__stream_decoder_process_until_end_of_metadata(decoder->private_->FLAC_stream_decoder);
 }
 
-FLAC__bool OggFLAC__stream_decoder_process_until_end_of_stream(OggFLAC__StreamDecoder *decoder)
+OggFLAC_API FLAC__bool OggFLAC__stream_decoder_process_until_end_of_stream(OggFLAC__StreamDecoder *decoder)
 {
        FLAC__ASSERT(0 != decoder);
        FLAC__ASSERT(0 != decoder->private_);
@@ -432,6 +444,7 @@ void set_defaults_(OggFLAC__StreamDecoder *decoder)
        decoder->private_->metadata_callback = 0;
        decoder->private_->error_callback = 0;
        decoder->private_->client_data = 0;
+       decoder->protected_->use_first_serial_number = true;
 }
 
 FLAC__StreamDecoderReadStatus read_callback_(const FLAC__StreamDecoder *unused, FLAC__byte buffer[], unsigned *bytes, void *client_data)
@@ -448,7 +461,7 @@ FLAC__StreamDecoderReadStatus read_callback_(const FLAC__StreamDecoder *unused,
         * We have to be careful not to read in more than the
         * FLAC__StreamDecoder says it has room for.  We know
         * that the size of the decoded data must be no more
-        * than the encoded data we will read.  
+        * than the encoded data we will read.
         */
        ogg_bytes_to_read = min(*bytes, OGG_BYTES_CHUNK);
        oggbuf = ogg_sync_buffer(&decoder->private_->ogg.sync_state, ogg_bytes_to_read);
@@ -456,7 +469,7 @@ FLAC__StreamDecoderReadStatus read_callback_(const FLAC__StreamDecoder *unused,
        if(decoder->private_->read_callback(decoder, oggbuf, &ogg_bytes_to_read, decoder->private_->client_data) != FLAC__STREAM_DECODER_READ_STATUS_CONTINUE) {
                decoder->protected_->state = OggFLAC__STREAM_DECODER_READ_ERROR;
                return FLAC__STREAM_DECODER_READ_STATUS_ABORT;
-       }   
+       }
        ogg_bytes_read = ogg_bytes_to_read;
 
        if(ogg_sync_wrote(&decoder->private_->ogg.sync_state, ogg_bytes_read) < 0) {
@@ -466,6 +479,11 @@ FLAC__StreamDecoderReadStatus read_callback_(const FLAC__StreamDecoder *unused,
 
        *bytes = 0;
        while(ogg_sync_pageout(&decoder->private_->ogg.sync_state, &page) == 1) {
+               /* grab the serial number if necessary */
+               if(decoder->private_->ogg.need_serial_number) {
+                       decoder->private_->ogg.stream_state.serialno = decoder->protected_->serial_number = ogg_page_serialno(&page);
+                       decoder->private_->ogg.need_serial_number = false;
+               }
                if(ogg_stream_pagein(&decoder->private_->ogg.stream_state, &page) == 0) {
                        ogg_packet packet;
 
@@ -485,21 +503,21 @@ FLAC__StreamDecoderReadStatus read_callback_(const FLAC__StreamDecoder *unused,
 
 FLAC__StreamDecoderWriteStatus write_callback_(const FLAC__StreamDecoder *unused, const FLAC__Frame *frame, const FLAC__int32 * const buffer[], void *client_data)
 {
-    OggFLAC__StreamDecoder *decoder = (OggFLAC__StreamDecoder*)client_data;
+       OggFLAC__StreamDecoder *decoder = (OggFLAC__StreamDecoder*)client_data;
        (void)unused;
        return decoder->private_->write_callback(decoder, frame, buffer, decoder->private_->client_data);
 }
 
 void metadata_callback_(const FLAC__StreamDecoder *unused, const FLAC__StreamMetadata *metadata, void *client_data)
 {
-    OggFLAC__StreamDecoder *decoder = (OggFLAC__StreamDecoder*)client_data;
+       OggFLAC__StreamDecoder *decoder = (OggFLAC__StreamDecoder*)client_data;
        (void)unused;
-       return decoder->private_->metadata_callback(decoder, metadata, decoder->private_->client_data);
+       decoder->private_->metadata_callback(decoder, metadata, decoder->private_->client_data);
 }
 
 void error_callback_(const FLAC__StreamDecoder *unused, FLAC__StreamDecoderErrorStatus status, void *client_data)
 {
-    OggFLAC__StreamDecoder *decoder = (OggFLAC__StreamDecoder*)client_data;
+       OggFLAC__StreamDecoder *decoder = (OggFLAC__StreamDecoder*)client_data;
        (void)unused;
-       return decoder->private_->error_callback(decoder, status, decoder->private_->client_data);
+       decoder->private_->error_callback(decoder, status, decoder->private_->client_data);
 }