Magellan Linux

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

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

    Parent Directory Parent Directory | Revision Log Revision Log

    Revision 487 - (hide 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 niro 487 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     } ;