Magellan Linux

  • Back to homepage
    • /[pkg-src]/trunk/libsndfile/patches/libsndfile-1.0.17-flac-1.1.3.patch

    Contents of /trunk/libsndfile/patches/libsndfile-1.0.17-flac-1.1.3.patch

    Parent Directory Parent Directory | Revision Log Revision Log

    Revision 487 - (show annotations) (download)
    Wed Feb 13 20:35:23 2008 UTC (16 years, 3 months ago) by niro
    File size: 19742 byte(s) 
    -fix builds against newer flac versions
    1 diff -ru libsndfile-1.0.17/configure.ac libsndfile-1.0.17-b2/configure.ac
    2 --- libsndfile-1.0.17/configure.ac 2006-08-31 02:39:37.000000000 -0700
    3 +++ libsndfile-1.0.17-b2/configure.ac 2006-10-27 08:54:45.000000000 -0700
    4 @@ -339,7 +339,8 @@
    5 if test "x$HAVE_FLAC_1_1_1" = xyes ; then
    6 AC_DEFINE(HAVE_FLAC_1_1_1, [1], [Define to 1 if you have libflac 1.1.1])
    7 fi
    8 - FLAC_LIBS="-lFLAC"
    9 + # in FLAC 1.1.3 libOggFLAC was merged into libFLAC, hence we need -logg
    10 + FLAC_LIBS="-lFLAC -logg"
    11 fi
    12 fi
    13
    14 diff -ru libsndfile-1.0.17/src/flac.c libsndfile-1.0.17-b2/src/flac.c
    15 --- libsndfile-1.0.17/src/flac.c 2006-08-31 02:22:19.000000000 -0700
    16 +++ libsndfile-1.0.17-b2/src/flac.c 2006-10-27 08:47:36.000000000 -0700
    17 @@ -46,6 +46,13 @@
    18 #include "sfendian.h"
    19 #include "float_cast.h"
    20
    21 +/* FLAC 1.1.3 has FLAC_API_VERSION_CURRENT == 8 */
    22 +#if !defined(FLAC_API_VERSION_CURRENT) || FLAC_API_VERSION_CURRENT < 8
    23 +#define LEGACY_FLAC
    24 +#else
    25 +#undef LEGACY_FLAC
    26 +#endif
    27 +
    28 /*------------------------------------------------------------------------------
    29 ** Private static functions.
    30 */
    31 @@ -60,8 +67,14 @@
    32 } PFLAC_PCM ;
    33
    34 typedef struct
    35 -{ FLAC__SeekableStreamDecoder *fsd ;
    36 +{
    37 +#ifdef LEGACY_FLAC
    38 + FLAC__SeekableStreamDecoder *fsd ;
    39 FLAC__SeekableStreamEncoder *fse ;
    40 +#else
    41 + FLAC__StreamDecoder *fsd ;
    42 + FLAC__StreamEncoder *fse ;
    43 +#endif
    44 PFLAC_PCM pcmtype ;
    45 void* ptr ;
    46 unsigned pos, len, remain ;
    47 @@ -108,6 +121,7 @@
    48 static int flac_command (SF_PRIVATE *psf, int command, void *data, int datasize) ;
    49
    50 /* Decoder Callbacks */
    51 +#ifdef LEGACY_FLAC
    52 static FLAC__SeekableStreamDecoderReadStatus sf_flac_read_callback (const FLAC__SeekableStreamDecoder *decoder, FLAC__byte buffer [], unsigned *bytes, void *client_data) ;
    53 static FLAC__SeekableStreamDecoderSeekStatus sf_flac_seek_callback (const FLAC__SeekableStreamDecoder *decoder, FLAC__uint64 absolute_byte_offset, void *client_data) ;
    54 static FLAC__SeekableStreamDecoderTellStatus sf_flac_tell_callback (const FLAC__SeekableStreamDecoder *decoder, FLAC__uint64 *absolute_byte_offset, void *client_data) ;
    55 @@ -116,13 +130,29 @@
    56 static FLAC__StreamDecoderWriteStatus sf_flac_write_callback (const FLAC__SeekableStreamDecoder *decoder, const FLAC__Frame *frame, const FLAC__int32 * const buffer [], void *client_data) ;
    57 static void sf_flac_meta_callback (const FLAC__SeekableStreamDecoder *decoder, const FLAC__StreamMetadata *metadata, void *client_data) ;
    58 static void sf_flac_error_callback (const FLAC__SeekableStreamDecoder *decoder, FLAC__StreamDecoderErrorStatus status, void *client_data) ;
    59 +#else
    60 +static FLAC__StreamDecoderReadStatus sf_flac_read_callback (const FLAC__StreamDecoder *decoder, FLAC__byte buffer [], size_t *bytes, void *client_data) ;
    61 +static FLAC__StreamDecoderSeekStatus sf_flac_seek_callback (const FLAC__StreamDecoder *decoder, FLAC__uint64 absolute_byte_offset, void *client_data) ;
    62 +static FLAC__StreamDecoderTellStatus sf_flac_tell_callback (const FLAC__StreamDecoder *decoder, FLAC__uint64 *absolute_byte_offset, void *client_data) ;
    63 +static FLAC__StreamDecoderLengthStatus sf_flac_length_callback (const FLAC__StreamDecoder *decoder, FLAC__uint64 *stream_length, void *client_data) ;
    64 +static FLAC__bool sf_flac_eof_callback (const FLAC__StreamDecoder *decoder, void *client_data) ;
    65 +static FLAC__StreamDecoderWriteStatus sf_flac_write_callback (const FLAC__StreamDecoder *decoder, const FLAC__Frame *frame, const FLAC__int32 * const buffer [], void *client_data) ;
    66 +static void sf_flac_meta_callback (const FLAC__StreamDecoder *decoder, const FLAC__StreamMetadata *metadata, void *client_data) ;
    67 +static void sf_flac_error_callback (const FLAC__StreamDecoder *decoder, FLAC__StreamDecoderErrorStatus status, void *client_data) ;
    68 +#endif
    69
    70 /* Encoder Callbacks */
    71 +#ifdef LEGACY_FLAC
    72 static FLAC__SeekableStreamEncoderSeekStatus sf_flac_enc_seek_callback (const FLAC__SeekableStreamEncoder *encoder, FLAC__uint64 absolute_byte_offset, void *client_data) ;
    73 #ifdef HAVE_FLAC_1_1_1
    74 static FLAC__SeekableStreamEncoderTellStatus sf_flac_enc_tell_callback (const FLAC__SeekableStreamEncoder *encoder, FLAC__uint64 *absolute_byte_offset, void *client_data) ;
    75 #endif
    76 static FLAC__StreamEncoderWriteStatus sf_flac_enc_write_callback (const FLAC__SeekableStreamEncoder *encoder, const FLAC__byte buffer [], unsigned bytes, unsigned samples, unsigned current_frame, void *client_data) ;
    77 +#else
    78 +static FLAC__StreamEncoderSeekStatus sf_flac_enc_seek_callback (const FLAC__StreamEncoder *encoder, FLAC__uint64 absolute_byte_offset, void *client_data) ;
    79 +static FLAC__StreamEncoderTellStatus sf_flac_enc_tell_callback (const FLAC__StreamEncoder *encoder, FLAC__uint64 *absolute_byte_offset, void *client_data) ;
    80 +static FLAC__StreamEncoderWriteStatus sf_flac_enc_write_callback (const FLAC__StreamEncoder *encoder, const FLAC__byte buffer [], size_t bytes, unsigned samples, unsigned current_frame, void *client_data) ;
    81 +#endif
    82
    83 static const int legal_sample_rates [] =
    84 { 8000, 16000, 22050, 24000, 32000, 44100, 48000, 96000
    85 @@ -283,51 +313,99 @@
    86 } /* flac_buffer_copy */
    87
    88
    89 +#ifdef LEGACY_FLAC
    90 static FLAC__SeekableStreamDecoderReadStatus
    91 sf_flac_read_callback (const FLAC__SeekableStreamDecoder * UNUSED (decoder), FLAC__byte buffer [], unsigned *bytes, void *client_data)
    92 +#else
    93 +static FLAC__StreamDecoderReadStatus
    94 +sf_flac_read_callback (const FLAC__StreamDecoder * UNUSED (decoder), FLAC__byte buffer [], size_t *bytes, void *client_data)
    95 +#endif
    96 { SF_PRIVATE *psf = (SF_PRIVATE*) client_data ;
    97
    98 *bytes = psf_fread (buffer, 1, *bytes, psf) ;
    99 if (*bytes > 0 && psf->error == 0)
    100 +#ifdef LEGACY_FLAC
    101 return FLAC__SEEKABLE_STREAM_DECODER_READ_STATUS_OK ;
    102
    103 return FLAC__SEEKABLE_STREAM_DECODER_READ_STATUS_ERROR ;
    104 +#else
    105 + return FLAC__STREAM_DECODER_READ_STATUS_CONTINUE ;
    106 +
    107 + return FLAC__STREAM_DECODER_READ_STATUS_ABORT ;
    108 +#endif
    109 } /* sf_flac_read_callback */
    110
    111 +#ifdef LEGACY_FLAC
    112 static FLAC__SeekableStreamDecoderSeekStatus
    113 sf_flac_seek_callback (const FLAC__SeekableStreamDecoder * UNUSED (decoder), FLAC__uint64 absolute_byte_offset, void *client_data)
    114 +#else
    115 +static FLAC__StreamDecoderSeekStatus
    116 +sf_flac_seek_callback (const FLAC__StreamDecoder * UNUSED (decoder), FLAC__uint64 absolute_byte_offset, void *client_data)
    117 +#endif
    118 { SF_PRIVATE *psf = (SF_PRIVATE*) client_data ;
    119
    120 psf_fseek (psf, absolute_byte_offset, SEEK_SET) ;
    121 if (psf->error)
    122 +#ifdef LEGACY_FLAC
    123 return FLAC__SEEKABLE_STREAM_DECODER_SEEK_STATUS_ERROR ;
    124
    125 return FLAC__SEEKABLE_STREAM_DECODER_SEEK_STATUS_OK ;
    126 +#else
    127 + return FLAC__STREAM_DECODER_SEEK_STATUS_ERROR ;
    128 +
    129 + return FLAC__STREAM_DECODER_SEEK_STATUS_OK ;
    130 +#endif
    131 } /* sf_flac_seek_callback */
    132
    133 +#ifdef LEGACY_FLAC
    134 static FLAC__SeekableStreamDecoderTellStatus
    135 sf_flac_tell_callback (const FLAC__SeekableStreamDecoder * UNUSED (decoder), FLAC__uint64 *absolute_byte_offset, void *client_data)
    136 +#else
    137 +static FLAC__StreamDecoderTellStatus
    138 +sf_flac_tell_callback (const FLAC__StreamDecoder * UNUSED (decoder), FLAC__uint64 *absolute_byte_offset, void *client_data)
    139 +#endif
    140 { SF_PRIVATE *psf = (SF_PRIVATE*) client_data ;
    141
    142 *absolute_byte_offset = psf_ftell (psf) ;
    143 if (psf->error)
    144 +#ifdef LEGACY_FLAC
    145 return FLAC__SEEKABLE_STREAM_DECODER_TELL_STATUS_ERROR ;
    146
    147 return FLAC__SEEKABLE_STREAM_DECODER_TELL_STATUS_OK ;
    148 +#else
    149 + return FLAC__STREAM_DECODER_TELL_STATUS_ERROR ;
    150 +
    151 + return FLAC__STREAM_DECODER_TELL_STATUS_OK ;
    152 +#endif
    153 } /* sf_flac_tell_callback */
    154
    155 +#ifdef LEGACY_FLAC
    156 static FLAC__SeekableStreamDecoderLengthStatus
    157 sf_flac_length_callback (const FLAC__SeekableStreamDecoder * UNUSED (decoder), FLAC__uint64 *stream_length, void *client_data)
    158 +#else
    159 +static FLAC__StreamDecoderLengthStatus
    160 +sf_flac_length_callback (const FLAC__StreamDecoder * UNUSED (decoder), FLAC__uint64 *stream_length, void *client_data)
    161 +#endif
    162 { SF_PRIVATE *psf = (SF_PRIVATE*) client_data ;
    163
    164 if ((*stream_length = psf->filelength) == 0)
    165 +#ifdef LEGACY_FLAC
    166 return FLAC__SEEKABLE_STREAM_DECODER_LENGTH_STATUS_ERROR ;
    167
    168 return FLAC__SEEKABLE_STREAM_DECODER_LENGTH_STATUS_OK ;
    169 +#else
    170 + return FLAC__STREAM_DECODER_LENGTH_STATUS_ERROR ;
    171 +
    172 + return FLAC__STREAM_DECODER_LENGTH_STATUS_OK ;
    173 +#endif
    174 } /* sf_flac_length_callback */
    175
    176 static FLAC__bool
    177 +#ifdef LEGACY_FLAC
    178 sf_flac_eof_callback (const FLAC__SeekableStreamDecoder *UNUSED (decoder), void *client_data)
    179 +#else
    180 +sf_flac_eof_callback (const FLAC__StreamDecoder *UNUSED (decoder), void *client_data)
    181 +#endif
    182 { SF_PRIVATE *psf = (SF_PRIVATE*) client_data ;
    183
    184 if (psf_ftell (psf) == psf->filelength)
    185 @@ -337,7 +415,11 @@
    186 } /* sf_flac_eof_callback */
    187
    188 static FLAC__StreamDecoderWriteStatus
    189 +#ifdef LEGACY_FLAC
    190 sf_flac_write_callback (const FLAC__SeekableStreamDecoder * UNUSED (decoder), const FLAC__Frame *frame, const FLAC__int32 * const buffer [], void *client_data)
    191 +#else
    192 +sf_flac_write_callback (const FLAC__StreamDecoder * UNUSED (decoder), const FLAC__Frame *frame, const FLAC__int32 * const buffer [], void *client_data)
    193 +#endif
    194 { SF_PRIVATE *psf = (SF_PRIVATE*) client_data ;
    195 FLAC_PRIVATE* pflac = (FLAC_PRIVATE*) psf->codec_data ;
    196
    197 @@ -353,7 +435,11 @@
    198 } /* sf_flac_write_callback */
    199
    200 static void
    201 +#ifdef LEGACY_FLAC
    202 sf_flac_meta_callback (const FLAC__SeekableStreamDecoder * UNUSED (decoder), const FLAC__StreamMetadata *metadata, void *client_data)
    203 +#else
    204 +sf_flac_meta_callback (const FLAC__StreamDecoder * UNUSED (decoder), const FLAC__StreamMetadata *metadata, void *client_data)
    205 +#endif
    206 { SF_PRIVATE *psf = (SF_PRIVATE*) client_data ;
    207
    208 switch (metadata->type)
    209 @@ -387,7 +473,11 @@
    210 } /* sf_flac_meta_callback */
    211
    212 static void
    213 +#ifdef LEGACY_FLAC
    214 sf_flac_error_callback (const FLAC__SeekableStreamDecoder * UNUSED (decoder), FLAC__StreamDecoderErrorStatus status, void *client_data)
    215 +#else
    216 +sf_flac_error_callback (const FLAC__StreamDecoder * UNUSED (decoder), FLAC__StreamDecoderErrorStatus status, void *client_data)
    217 +#endif
    218 { SF_PRIVATE *psf = (SF_PRIVATE*) client_data ;
    219
    220 psf_log_printf (psf, "ERROR : %s\n", FLAC__StreamDecoderErrorStatusString [status]) ;
    221 @@ -407,17 +497,29 @@
    222 return ;
    223 } /* sf_flac_error_callback */
    224
    225 +#ifdef LEGACY_FLAC
    226 static FLAC__SeekableStreamEncoderSeekStatus
    227 sf_flac_enc_seek_callback (const FLAC__SeekableStreamEncoder * UNUSED (encoder), FLAC__uint64 absolute_byte_offset, void *client_data)
    228 +#else
    229 +static FLAC__StreamEncoderSeekStatus
    230 +sf_flac_enc_seek_callback (const FLAC__StreamEncoder * UNUSED (encoder), FLAC__uint64 absolute_byte_offset, void *client_data)
    231 +#endif
    232 { SF_PRIVATE *psf = (SF_PRIVATE*) client_data ;
    233
    234 psf_fseek (psf, absolute_byte_offset, SEEK_SET) ;
    235 if (psf->error)
    236 +#ifdef LEGACY_FLAC
    237 return FLAC__SEEKABLE_STREAM_ENCODER_SEEK_STATUS_ERROR ;
    238
    239 return FLAC__SEEKABLE_STREAM_ENCODER_SEEK_STATUS_OK ;
    240 +#else
    241 + return FLAC__STREAM_ENCODER_SEEK_STATUS_ERROR ;
    242 +
    243 + return FLAC__STREAM_ENCODER_SEEK_STATUS_OK ;
    244 +#endif
    245 } /* sf_flac_enc_seek_callback */
    246
    247 +#ifdef LEGACY_FLAC
    248 #ifdef HAVE_FLAC_1_1_1
    249 static FLAC__SeekableStreamEncoderTellStatus
    250 sf_flac_enc_tell_callback (const FLAC__SeekableStreamEncoder *UNUSED (encoder), FLAC__uint64 *absolute_byte_offset, void *client_data)
    251 @@ -430,9 +532,25 @@
    252 return FLAC__SEEKABLE_STREAM_ENCODER_TELL_STATUS_OK ;
    253 } /* sf_flac_enc_tell_callback */
    254 #endif
    255 +#else
    256 +static FLAC__StreamEncoderTellStatus
    257 +sf_flac_enc_tell_callback (const FLAC__StreamEncoder *UNUSED (encoder), FLAC__uint64 *absolute_byte_offset, void *client_data)
    258 +{ SF_PRIVATE *psf = (SF_PRIVATE*) client_data ;
    259 +
    260 + *absolute_byte_offset = psf_ftell (psf) ;
    261 + if (psf->error)
    262 + return FLAC__STREAM_ENCODER_TELL_STATUS_ERROR ;
    263 +
    264 + return FLAC__STREAM_ENCODER_TELL_STATUS_OK ;
    265 +} /* sf_flac_enc_tell_callback */
    266 +#endif
    267
    268 static FLAC__StreamEncoderWriteStatus
    269 +#ifdef LEGACY_FLAC
    270 sf_flac_enc_write_callback (const FLAC__SeekableStreamEncoder * UNUSED (encoder), const FLAC__byte buffer [], unsigned bytes, unsigned UNUSED (samples), unsigned UNUSED (current_frame), void *client_data)
    271 +#else
    272 +sf_flac_enc_write_callback (const FLAC__StreamEncoder * UNUSED (encoder), const FLAC__byte buffer [], size_t bytes, unsigned UNUSED (samples), unsigned UNUSED (current_frame), void *client_data)
    273 +#endif
    274 { SF_PRIVATE *psf = (SF_PRIVATE*) client_data ;
    275
    276 if (psf_fwrite (buffer, 1, bytes, psf) == bytes && psf->error == 0)
    277 @@ -509,15 +627,27 @@
    278 return 0 ;
    279
    280 if (psf->mode == SFM_WRITE)
    281 - { FLAC__seekable_stream_encoder_finish (pflac->fse) ;
    282 + {
    283 +#ifdef LEGACY_FLAC
    284 + FLAC__seekable_stream_encoder_finish (pflac->fse) ;
    285 FLAC__seekable_stream_encoder_delete (pflac->fse) ;
    286 +#else
    287 + FLAC__stream_encoder_finish (pflac->fse) ;
    288 + FLAC__stream_encoder_delete (pflac->fse) ;
    289 +#endif
    290 if (pflac->encbuffer)
    291 free (pflac->encbuffer) ;
    292 } ;
    293
    294 if (psf->mode == SFM_READ)
    295 - { FLAC__seekable_stream_decoder_finish (pflac->fsd) ;
    296 + {
    297 +#ifdef LEGACY_FLAC
    298 + FLAC__seekable_stream_decoder_finish (pflac->fsd) ;
    299 FLAC__seekable_stream_decoder_delete (pflac->fsd) ;
    300 +#else
    301 + FLAC__stream_decoder_finish (pflac->fsd) ;
    302 + FLAC__stream_decoder_delete (pflac->fsd) ;
    303 +#endif
    304 } ;
    305
    306 for (k = 0 ; k < ARRAY_LEN (pflac->rbuffer) ; k++)
    307 @@ -546,17 +676,6 @@
    308 return SFE_FLAC_BAD_SAMPLE_RATE ;
    309
    310 psf_fseek (psf, 0, SEEK_SET) ;
    311 - if ((pflac->fse = FLAC__seekable_stream_encoder_new ()) == NULL)
    312 - return SFE_FLAC_NEW_DECODER ;
    313 - FLAC__seekable_stream_encoder_set_write_callback (pflac->fse, sf_flac_enc_write_callback) ;
    314 - FLAC__seekable_stream_encoder_set_seek_callback (pflac->fse, sf_flac_enc_seek_callback) ;
    315 -
    316 -#ifdef HAVE_FLAC_1_1_1
    317 - FLAC__seekable_stream_encoder_set_tell_callback (pflac->fse, sf_flac_enc_tell_callback) ;
    318 -#endif
    319 - FLAC__seekable_stream_encoder_set_client_data (pflac->fse, psf) ;
    320 - FLAC__seekable_stream_encoder_set_channels (pflac->fse, psf->sf.channels) ;
    321 - FLAC__seekable_stream_encoder_set_sample_rate (pflac->fse, psf->sf.samplerate) ;
    322
    323 switch (psf->sf.format & SF_FORMAT_SUBMASK)
    324 { case SF_FORMAT_PCM_S8 :
    325 @@ -574,12 +693,36 @@
    326 break ;
    327 } ;
    328
    329 +#ifdef LEGACY_FLAC
    330 + if ((pflac->fse = FLAC__seekable_stream_encoder_new ()) == NULL)
    331 + return SFE_FLAC_NEW_DECODER ;
    332 + FLAC__seekable_stream_encoder_set_write_callback (pflac->fse, sf_flac_enc_write_callback) ;
    333 + FLAC__seekable_stream_encoder_set_seek_callback (pflac->fse, sf_flac_enc_seek_callback) ;
    334 +
    335 +#ifdef HAVE_FLAC_1_1_1
    336 + FLAC__seekable_stream_encoder_set_tell_callback (pflac->fse, sf_flac_enc_tell_callback) ;
    337 +#endif
    338 + FLAC__seekable_stream_encoder_set_client_data (pflac->fse, psf) ;
    339 + FLAC__seekable_stream_encoder_set_channels (pflac->fse, psf->sf.channels) ;
    340 + FLAC__seekable_stream_encoder_set_sample_rate (pflac->fse, psf->sf.samplerate) ;
    341 FLAC__seekable_stream_encoder_set_bits_per_sample (pflac->fse, bps) ;
    342
    343 if ((bps = FLAC__seekable_stream_encoder_init (pflac->fse)) != FLAC__SEEKABLE_STREAM_DECODER_OK)
    344 { psf_log_printf (psf, "Error : FLAC encoder init returned error : %s\n", FLAC__seekable_stream_encoder_get_resolved_state_string (pflac->fse)) ;
    345 return SFE_FLAC_INIT_DECODER ;
    346 } ;
    347 +#else
    348 + if ((pflac->fse = FLAC__stream_encoder_new ()) == NULL)
    349 + return SFE_FLAC_NEW_DECODER ;
    350 + FLAC__stream_encoder_set_channels (pflac->fse, psf->sf.channels) ;
    351 + FLAC__stream_encoder_set_sample_rate (pflac->fse, psf->sf.samplerate) ;
    352 + FLAC__stream_encoder_set_bits_per_sample (pflac->fse, bps) ;
    353 +
    354 + if ((bps = FLAC__stream_encoder_init_stream (pflac->fse, sf_flac_enc_write_callback, sf_flac_enc_seek_callback, sf_flac_enc_tell_callback, NULL, psf)) != FLAC__STREAM_DECODER_INIT_STATUS_OK)
    355 + { psf_log_printf (psf, "Error : FLAC encoder init returned error : %s\n", FLAC__StreamEncoderInitStatusString[bps]) ;
    356 + return SFE_FLAC_INIT_DECODER ;
    357 + } ;
    358 +#endif
    359
    360 if (psf->error == 0)
    361 psf->dataoffset = psf_ftell (psf) ;
    362 @@ -593,6 +736,7 @@
    363 { FLAC_PRIVATE* pflac = (FLAC_PRIVATE*) psf->codec_data ;
    364
    365 psf_fseek (psf, 0, SEEK_SET) ;
    366 +#ifdef LEGACY_FLAC
    367 if ((pflac->fsd = FLAC__seekable_stream_decoder_new ()) == NULL)
    368 return SFE_FLAC_NEW_DECODER ;
    369
    370 @@ -610,9 +754,22 @@
    371 return SFE_FLAC_INIT_DECODER ;
    372
    373 FLAC__seekable_stream_decoder_process_until_end_of_metadata (pflac->fsd) ;
    374 +#else
    375 + if ((pflac->fsd = FLAC__stream_decoder_new ()) == NULL)
    376 + return SFE_FLAC_NEW_DECODER ;
    377 +
    378 + if (FLAC__stream_decoder_init_stream (pflac->fsd, sf_flac_read_callback, sf_flac_seek_callback, sf_flac_tell_callback, sf_flac_length_callback, sf_flac_eof_callback, sf_flac_write_callback, sf_flac_meta_callback, sf_flac_error_callback, psf) != FLAC__STREAM_DECODER_INIT_STATUS_OK)
    379 + return SFE_FLAC_INIT_DECODER ;
    380 +
    381 + FLAC__stream_decoder_process_until_end_of_metadata (pflac->fsd) ;
    382 +#endif
    383 if (psf->error == 0)
    384 { FLAC__uint64 position ;
    385 +#ifdef LEGACY_FLAC
    386 FLAC__seekable_stream_decoder_get_decode_position (pflac->fsd, &position) ;
    387 +#else
    388 + FLAC__stream_decoder_get_decode_position (pflac->fsd, &position) ;
    389 +#endif
    390 psf->dataoffset = position ;
    391 } ;
    392
    393 @@ -676,10 +833,18 @@
    394 flac_buffer_copy (psf) ;
    395
    396 while (pflac->pos < pflac->len)
    397 - { if (FLAC__seekable_stream_decoder_process_single (pflac->fsd) == 0)
    398 + {
    399 +#ifdef LEGACY_FLAC
    400 + if (FLAC__seekable_stream_decoder_process_single (pflac->fsd) == 0)
    401 break ;
    402 if (FLAC__seekable_stream_decoder_get_state (pflac->fsd) != FLAC__SEEKABLE_STREAM_DECODER_OK)
    403 break ;
    404 +#else
    405 + if (FLAC__stream_decoder_process_single (pflac->fsd) == 0)
    406 + break ;
    407 + if (FLAC__stream_decoder_get_state (pflac->fsd) >= FLAC__STREAM_DECODER_END_OF_STREAM)
    408 + break ;
    409 +#endif
    410 } ;
    411
    412 pflac->ptr = NULL ;
    413 @@ -795,7 +960,11 @@
    414 while (len > 0)
    415 { writecount = (len >= bufferlen) ? bufferlen : (int) len ;
    416 convert (ptr + total, buffer, writecount) ;
    417 +#ifdef LEGACY_FLAC
    418 if (FLAC__seekable_stream_encoder_process_interleaved (pflac->fse, buffer, writecount/psf->sf.channels))
    419 +#else
    420 + if (FLAC__stream_encoder_process_interleaved (pflac->fse, buffer, writecount/psf->sf.channels))
    421 +#endif
    422 thiswrite = writecount ;
    423 else
    424 break ;
    425 @@ -837,7 +1006,11 @@
    426 while (len > 0)
    427 { writecount = (len >= bufferlen) ? bufferlen : (int) len ;
    428 convert (ptr + total, buffer, writecount) ;
    429 +#ifdef LEGACY_FLAC
    430 if (FLAC__seekable_stream_encoder_process_interleaved (pflac->fse, buffer, writecount/psf->sf.channels))
    431 +#else
    432 + if (FLAC__stream_encoder_process_interleaved (pflac->fse, buffer, writecount/psf->sf.channels))
    433 +#endif
    434 thiswrite = writecount ;
    435 else
    436 break ;
    437 @@ -879,7 +1052,11 @@
    438 while (len > 0)
    439 { writecount = (len >= bufferlen) ? bufferlen : (int) len ;
    440 convert (ptr + total, buffer, writecount, psf->norm_float) ;
    441 +#ifdef LEGACY_FLAC
    442 if (FLAC__seekable_stream_encoder_process_interleaved (pflac->fse, buffer, writecount/psf->sf.channels))
    443 +#else
    444 + if (FLAC__stream_encoder_process_interleaved (pflac->fse, buffer, writecount/psf->sf.channels))
    445 +#endif
    446 thiswrite = writecount ;
    447 else
    448 break ;
    449 @@ -1011,7 +1188,11 @@
    450 while (len > 0)
    451 { writecount = (len >= bufferlen) ? bufferlen : (int) len ;
    452 convert (ptr + total, buffer, writecount, psf->norm_double) ;
    453 +#ifdef LEGACY_FLAC
    454 if (FLAC__seekable_stream_encoder_process_interleaved (pflac->fse, buffer, writecount/psf->sf.channels))
    455 +#else
    456 + if (FLAC__stream_encoder_process_interleaved (pflac->fse, buffer, writecount/psf->sf.channels))
    457 +#endif
    458 thiswrite = writecount ;
    459 else
    460 break ;
    461 @@ -1131,10 +1312,17 @@
    462
    463 if (psf->mode == SFM_READ)
    464 { FLAC__uint64 position ;
    465 +#ifdef LEGACY_FLAC
    466 if (FLAC__seekable_stream_decoder_seek_absolute (pflac->fsd, offset))
    467 { FLAC__seekable_stream_decoder_get_decode_position (pflac->fsd, &position) ;
    468 return offset ;
    469 } ;
    470 +#else
    471 + if (FLAC__stream_decoder_seek_absolute (pflac->fsd, offset))
    472 + { FLAC__stream_decoder_get_decode_position (pflac->fsd, &position) ;
    473 + return offset ;
    474 + } ;
    475 +#endif
    476
    477 return ((sf_count_t) -1) ;
    478 } ;