PKGBUILDs/extra/mythmusic/music_flac.patch

--- flacdecoder.cpp.old	2007-03-11 18:14:37.000000000 -0400
+++ flacdecoder.cpp	2007-03-11 18:15:34.000000000 -0400
@@ -17,7 +17,7 @@
 
 #include <qtimer.h>
 
-static FLAC__SeekableStreamDecoderReadStatus flacread(const FLAC__SeekableStreamDecoder *decoder, FLAC__byte bufferp[], unsigned *bytes, void *client_data)
+static FLAC__StreamDecoderReadStatus flacread(const FLAC__StreamDecoder *decoder, FLAC__byte bufferp[], unsigned *bytes, void *client_data)
 {
     decoder = decoder;
 
@@ -26,27 +26,27 @@
 
     if (len == -1)
     {
-        return FLAC__SEEKABLE_STREAM_DECODER_READ_STATUS_ERROR;
+        return FLAC__STREAM_DECODER_READ_STATUS_END_OF_STREAM;
     }
    
     *bytes = len;
-    return FLAC__SEEKABLE_STREAM_DECODER_READ_STATUS_OK;
+    return FLAC__STREAM_DECODER_READ_STATUS_CONTINUE;
 }
 
-static FLAC__SeekableStreamDecoderSeekStatus flacseek(const FLAC__SeekableStreamDecoder *decoder, FLAC__uint64 absolute_byte_offset, void *client_data) 
+static FLAC__StreamDecoderSeekStatus flacseek(const FLAC__StreamDecoder *decoder, FLAC__uint64 absolute_byte_offset, void *client_data) 
 {
     decoder = decoder;
     FlacDecoder *dflac = (FlacDecoder *)client_data;
 
     if (!dflac->input()->isDirectAccess())
-        return FLAC__SEEKABLE_STREAM_DECODER_SEEK_STATUS_ERROR;
+        return FLAC__STREAM_DECODER_SEEK_STATUS_ERROR;
 
     if (dflac->input()->at(absolute_byte_offset))
-        return FLAC__SEEKABLE_STREAM_DECODER_SEEK_STATUS_OK;
-    return FLAC__SEEKABLE_STREAM_DECODER_SEEK_STATUS_ERROR;
+        return FLAC__STREAM_DECODER_SEEK_STATUS_OK;
+    return FLAC__STREAM_DECODER_SEEK_STATUS_ERROR;
 }
 
-static FLAC__SeekableStreamDecoderTellStatus flactell(const FLAC__SeekableStreamDecoder *decoder, FLAC__uint64 *absolute_byte_offset, void *client_data)
+static FLAC__StreamDecoderTellStatus flactell(const FLAC__StreamDecoder *decoder, FLAC__uint64 *absolute_byte_offset, void *client_data)
 {
     decoder = decoder;
     FlacDecoder *dflac = (FlacDecoder *)client_data;
@@ -54,20 +54,20 @@
     long t = dflac->input()->at();
     *absolute_byte_offset = t;
 
-    return FLAC__SEEKABLE_STREAM_DECODER_TELL_STATUS_OK;
+    return FLAC__STREAM_DECODER_TELL_STATUS_OK;
 }
 
-static FLAC__SeekableStreamDecoderLengthStatus flaclength(const FLAC__SeekableStreamDecoder *decoder, FLAC__uint64 *stream_length, void *client_data)
+static FLAC__StreamDecoderLengthStatus flaclength(const FLAC__StreamDecoder *decoder, FLAC__uint64 *stream_length, void *client_data)
 {
     decoder = decoder;
 
     FlacDecoder *dflac = (FlacDecoder *)client_data;
 
     *stream_length = dflac->input()->size();
-    return FLAC__SEEKABLE_STREAM_DECODER_LENGTH_STATUS_OK;
+    return FLAC__STREAM_DECODER_LENGTH_STATUS_OK;
 }
 
-static FLAC__bool flaceof(const FLAC__SeekableStreamDecoder *decoder, void *client_data)
+static FLAC__bool flaceof(const FLAC__StreamDecoder *decoder, void *client_data)
 {
     decoder = decoder;
 
@@ -76,7 +76,7 @@
     return dflac->input()->atEnd();
 }
 
-static FLAC__StreamDecoderWriteStatus flacwrite(const FLAC__SeekableStreamDecoder *decoder, const FLAC__Frame *frame, const FLAC__int32 * const buffer[], void *client_data)
+static FLAC__StreamDecoderWriteStatus flacwrite(const FLAC__StreamDecoder *decoder, const FLAC__Frame *frame, const FLAC__int32 * const buffer[], void *client_data)
 {
     decoder = decoder;
 
@@ -132,7 +132,7 @@
     }
 }
 
-static void flacmetadata(const FLAC__SeekableStreamDecoder *decoder, const FLAC__StreamMetadata *metadata, void *client_data)
+static void flacmetadata(const FLAC__StreamDecoder *decoder, const FLAC__StreamMetadata *metadata, void *client_data)
 {
     decoder = decoder;
 
@@ -156,11 +156,11 @@
     }
 }
 
-static void flacerror(const FLAC__SeekableStreamDecoder *decoder, FLAC__StreamDecoderErrorStatus status, void *client_data)
+static void flacerror(const FLAC__StreamDecoder *decoder, FLAC__StreamDecoderErrorStatus status, void *client_data)
 {
     decoder = decoder;
 
-    FLAC__FileDecoder *file_decoder = (FLAC__FileDecoder *)client_data;
+    FLAC__StreamDecoder *file_decoder = (FLAC__StreamDecoder *)client_data;
 
     file_decoder = file_decoder;
     status = status;
@@ -262,17 +262,8 @@
         }
     }
 
-    decoder = FLAC__seekable_stream_decoder_new();
-    FLAC__seekable_stream_decoder_set_md5_checking(decoder, false);
-    FLAC__seekable_stream_decoder_set_read_callback(decoder, flacread);
-    FLAC__seekable_stream_decoder_set_seek_callback(decoder, flacseek);
-    FLAC__seekable_stream_decoder_set_tell_callback(decoder, flactell);
-    FLAC__seekable_stream_decoder_set_length_callback(decoder, flaclength);
-    FLAC__seekable_stream_decoder_set_eof_callback(decoder, flaceof);
-    FLAC__seekable_stream_decoder_set_write_callback(decoder, flacwrite);
-    FLAC__seekable_stream_decoder_set_metadata_callback(decoder, flacmetadata);
-    FLAC__seekable_stream_decoder_set_error_callback(decoder, flacerror);
-    FLAC__seekable_stream_decoder_set_client_data(decoder, this);
+    decoder = FLAC__stream_decoder_new();
+    FLAC__stream_decoder_set_md5_checking(decoder, false);
 
     freq = 0;
     bitrate = 0;
@@ -281,8 +272,17 @@
     totalTime = 0; 
     totalTime = totalTime < 0 ? 0 : totalTime;
 
-    FLAC__seekable_stream_decoder_init(decoder);
-    FLAC__seekable_stream_decoder_process_until_end_of_metadata(decoder);
+    FLAC__stream_decoder_init_stream(decoder,
+                                     flacread,
+                                     flacseek,
+                                     flactell,
+                                     flaclength,
+                                     flaceof,
+                                     flacwrite,
+                                     flacmetadata,
+                                     flacerror,
+                                     this);
+    FLAC__stream_decoder_process_until_end_of_metadata(decoder);
 
     inited = TRUE;
     return TRUE;
@@ -295,8 +295,8 @@
 
 void FlacDecoder::deinit()
 {
-    FLAC__seekable_stream_decoder_finish(decoder);
-    FLAC__seekable_stream_decoder_delete(decoder);
+    FLAC__stream_decoder_finish(decoder);
+    FLAC__stream_decoder_delete(decoder);
 
     if (input()->isOpen())
         input()->close();
@@ -330,7 +330,7 @@
     }
 
     bool flacok = true;
-    FLAC__SeekableStreamDecoderState decoderstate;
+    FLAC__StreamDecoderState decoderstate;
 
     while (! done && ! finish) {
         lock();
@@ -340,12 +340,12 @@
             FLAC__uint64 sample = (FLAC__uint64)(seekTime * 44100.0);
             if (sample > totalsamples - 50)
                 sample = totalsamples - 50;
-            FLAC__seekable_stream_decoder_seek_absolute(decoder, sample);
+            FLAC__stream_decoder_seek_absolute(decoder, sample);
             seekTime = -1.0;
         }
 
-        flacok = FLAC__seekable_stream_decoder_process_single(decoder);
-        decoderstate = FLAC__seekable_stream_decoder_get_state(decoder);
+        flacok = FLAC__stream_decoder_process_single(decoder);
+        decoderstate = FLAC__stream_decoder_get_state(decoder);
 
         if (decoderstate == 0 || decoderstate == 1)
         {
--- flacdecoder.h.old	2007-03-11 18:14:37.000000000 -0400
+++ flacdecoder.h	2007-03-11 18:14:12.000000000 -0400
@@ -35,7 +35,7 @@
     char *output_buf;
     ulong output_bytes, output_at;
 
-    FLAC__SeekableStreamDecoder *decoder;
+    FLAC__StreamDecoder *decoder;
 
     unsigned int bks;
     bool done, finish;
--- flacencoder.cpp.old	2007-03-11 18:14:37.000000000 -0400
+++ flacencoder.cpp	2007-03-11 18:14:12.000000000 -0400
@@ -9,7 +9,7 @@
 #include "flacencoder.h"
 #include "metaioflacvorbiscomment.h"
 
-#include <FLAC/file_encoder.h>
+#include <FLAC/stream_encoder.h>
 #include <FLAC/assert.h>
 #include <mythtv/mythcontext.h>
 
@@ -29,32 +29,32 @@
     int rice_parameter_search_dist = 0;
     int max_lpc_order = 8;
 
-    encoder = FLAC__file_encoder_new();
+    encoder = FLAC__stream_encoder_new();
 
-    FLAC__file_encoder_set_streamable_subset(encoder, true);
-    FLAC__file_encoder_set_do_mid_side_stereo(encoder, do_mid_side);
-    FLAC__file_encoder_set_loose_mid_side_stereo(encoder, loose_mid_side);
-    FLAC__file_encoder_set_channels(encoder, NUM_CHANNELS);
-    FLAC__file_encoder_set_bits_per_sample(encoder, 16);
-    FLAC__file_encoder_set_sample_rate(encoder, 44100);
-    FLAC__file_encoder_set_blocksize(encoder, blocksize);
-    FLAC__file_encoder_set_max_lpc_order(encoder, max_lpc_order);
-    FLAC__file_encoder_set_qlp_coeff_precision(encoder, qlp_coeff_precision);
-    FLAC__file_encoder_set_do_qlp_coeff_prec_search(encoder, false);
-    FLAC__file_encoder_set_do_escape_coding(encoder, do_escape_coding);
-    FLAC__file_encoder_set_do_exhaustive_model_search(encoder, 
+    FLAC__stream_encoder_set_streamable_subset(encoder, true);
+    FLAC__stream_encoder_set_do_mid_side_stereo(encoder, do_mid_side);
+    FLAC__stream_encoder_set_loose_mid_side_stereo(encoder, loose_mid_side);
+    FLAC__stream_encoder_set_channels(encoder, NUM_CHANNELS);
+    FLAC__stream_encoder_set_bits_per_sample(encoder, 16);
+    FLAC__stream_encoder_set_sample_rate(encoder, 44100);
+    FLAC__stream_encoder_set_blocksize(encoder, blocksize);
+    FLAC__stream_encoder_set_max_lpc_order(encoder, max_lpc_order);
+    FLAC__stream_encoder_set_qlp_coeff_precision(encoder, qlp_coeff_precision);
+    FLAC__stream_encoder_set_do_qlp_coeff_prec_search(encoder, false);
+    FLAC__stream_encoder_set_do_escape_coding(encoder, do_escape_coding);
+    FLAC__stream_encoder_set_do_exhaustive_model_search(encoder, 
                                                     do_exhaustive_model_search);
-    FLAC__file_encoder_set_min_residual_partition_order(encoder, 
+    FLAC__stream_encoder_set_min_residual_partition_order(encoder, 
                                                   min_residual_partition_order);
-    FLAC__file_encoder_set_max_residual_partition_order(encoder, 
+    FLAC__stream_encoder_set_max_residual_partition_order(encoder, 
                                                   max_residual_partition_order);
-    FLAC__file_encoder_set_rice_parameter_search_dist(encoder, 
+    FLAC__stream_encoder_set_rice_parameter_search_dist(encoder, 
                                                     rice_parameter_search_dist);
 
-    FLAC__file_encoder_set_filename(encoder, outfile.local8Bit());
+    
 
-    int ret = FLAC__file_encoder_init(encoder);
-    if (ret != FLAC__FILE_ENCODER_OK)
+    int ret = FLAC__stream_encoder_init_file(encoder, outfile.local8Bit(), NULL, NULL);
+    if (ret != FLAC__STREAM_ENCODER_OK)
     {
         VERBOSE(VB_GENERAL, QString("Error initializing FLAC encoder."
                                     " Got return code: %1").arg(ret));
@@ -70,8 +70,8 @@
 
     if (encoder)
     {
-        FLAC__file_encoder_finish(encoder);
-        FLAC__file_encoder_delete(encoder);
+        FLAC__stream_encoder_finish(encoder);
+        FLAC__stream_encoder_delete(encoder);
     }
 
     if (metadata)
@@ -102,7 +102,7 @@
 
         if(sampleindex == MAX_SAMPLES || (length == 0 && sampleindex > 0) ) 
         {
-            if (!FLAC__file_encoder_process(encoder,
+            if (!FLAC__stream_encoder_process(encoder,
                                             (const FLAC__int32 * const *) input,
                                             sampleindex))
             {
--- flacencoder.h.old	2007-03-11 18:14:37.000000000 -0400
+++ flacencoder.h	2007-03-11 18:14:12.000000000 -0400
@@ -4,7 +4,7 @@
 #include <qstring.h>
 
 #define HAVE_INTTYPES_H
-#include <FLAC/file_encoder.h>
+#include <FLAC/stream_encoder.h>
 
 #include "encoder.h"
 
@@ -21,7 +21,7 @@
     int addSamples(int16_t *bytes, unsigned int len);
 
   private:
-    FLAC__FileEncoder *encoder;
+    FLAC__StreamEncoder *encoder;
     unsigned int sampleindex;
     FLAC__int32 inputin[NUM_CHANNELS][MAX_SAMPLES];
     FLAC__int32 *input[NUM_CHANNELS];