smokephil/ardour
1
0
Fork 0
mirror of https://github.com/Ardour/ardour.git synced 2025-12-08 15:54:57 +01:00
Code Issues Projects Releases Wiki Activity

Patched libsndfile to work with FLAC >= 1.1.4

Browse source 
Patch derived from http://www.linuxfromscratch.org/patches/downloads/libsndfile/libsndfile-1.0.17-flac-1.patch


git-svn-id: svn://localhost/ardour2/branches/3.0@3706 d708f5d6-7413-0410-9779-e7cbd77b26cf
This commit is contained in:
Sakari Bergen 2008-08-21 11:48:28 +00:00
parent 23e205fdd1
commit e4372df05b
1 changed files with 204 additions and 15 deletions
Download patch file Download diff file Expand all files Collapse all files

219
libs/libsndfile/src/flac.c
View file

@ -46,6 +46,13 @@ flac_open (SF_PRIVATE *psf)
#include "sfendian.h" #include "sfendian.h"
#include "float_cast.h" #include "float_cast.h"
/* FLAC 1.1.3 has FLAC_API_VERSION_CURRENT == 8 */
#if !defined(FLAC_API_VERSION_CURRENT) || FLAC_API_VERSION_CURRENT < 8
#define LEGACY_FLAC
#else
#undef LEGACY_FLAC
#endif
/*------------------------------------------------------------------------------ /*------------------------------------------------------------------------------
** Private static functions. ** Private static functions.
*/ */
@ -60,8 +67,15 @@ typedef enum
} PFLAC_PCM ; } PFLAC_PCM ;
typedef struct typedef struct
{ FLAC__SeekableStreamDecoder *fsd ; {
#ifdef LEGACY_FLAC
FLAC__SeekableStreamDecoder *fsd ;
FLAC__SeekableStreamEncoder *fse ; FLAC__SeekableStreamEncoder *fse ;
#else
FLAC__StreamDecoder *fsd ;
FLAC__StreamEncoder *fse ;
#endif
PFLAC_PCM pcmtype ; PFLAC_PCM pcmtype ;
void* ptr ; void* ptr ;
unsigned pos, len, remain ; unsigned pos, len, remain ;
@ -108,6 +122,7 @@ static void d2flac24_clip_array (const double *src, FLAC__int32 *dest, int coun
static int flac_command (SF_PRIVATE *psf, int command, void *data, int datasize) ; static int flac_command (SF_PRIVATE *psf, int command, void *data, int datasize) ;
/* Decoder Callbacks */ /* Decoder Callbacks */
#ifdef LEGACY_FLAC
static FLAC__SeekableStreamDecoderReadStatus sf_flac_read_callback (const FLAC__SeekableStreamDecoder *decoder, FLAC__byte buffer [], unsigned *bytes, void *client_data) ; static FLAC__SeekableStreamDecoderReadStatus sf_flac_read_callback (const FLAC__SeekableStreamDecoder *decoder, FLAC__byte buffer [], unsigned *bytes, void *client_data) ;
static FLAC__SeekableStreamDecoderSeekStatus sf_flac_seek_callback (const FLAC__SeekableStreamDecoder *decoder, FLAC__uint64 absolute_byte_offset, void *client_data) ; static FLAC__SeekableStreamDecoderSeekStatus sf_flac_seek_callback (const FLAC__SeekableStreamDecoder *decoder, FLAC__uint64 absolute_byte_offset, void *client_data) ;
static FLAC__SeekableStreamDecoderTellStatus sf_flac_tell_callback (const FLAC__SeekableStreamDecoder *decoder, FLAC__uint64 *absolute_byte_offset, void *client_data) ; static FLAC__SeekableStreamDecoderTellStatus sf_flac_tell_callback (const FLAC__SeekableStreamDecoder *decoder, FLAC__uint64 *absolute_byte_offset, void *client_data) ;
@ -116,13 +131,29 @@ static FLAC__bool sf_flac_eof_callback (const FLAC__SeekableStreamDecoder *decod
static FLAC__StreamDecoderWriteStatus sf_flac_write_callback (const FLAC__SeekableStreamDecoder *decoder, const FLAC__Frame *frame, const FLAC__int32 * const buffer [], void *client_data) ; static FLAC__StreamDecoderWriteStatus sf_flac_write_callback (const FLAC__SeekableStreamDecoder *decoder, const FLAC__Frame *frame, const FLAC__int32 * const buffer [], void *client_data) ;
static void sf_flac_meta_callback (const FLAC__SeekableStreamDecoder *decoder, const FLAC__StreamMetadata *metadata, void *client_data) ; static void sf_flac_meta_callback (const FLAC__SeekableStreamDecoder *decoder, const FLAC__StreamMetadata *metadata, void *client_data) ;
static void sf_flac_error_callback (const FLAC__SeekableStreamDecoder *decoder, FLAC__StreamDecoderErrorStatus status, void *client_data) ; static void sf_flac_error_callback (const FLAC__SeekableStreamDecoder *decoder, FLAC__StreamDecoderErrorStatus status, void *client_data) ;
#else
static FLAC__StreamDecoderReadStatus sf_flac_read_callback (const FLAC__StreamDecoder *decoder, FLAC__byte buffer [], size_t *bytes, void *client_data) ;
static FLAC__StreamDecoderSeekStatus sf_flac_seek_callback (const FLAC__StreamDecoder *decoder, FLAC__uint64 absolute_byte_offset, void *client_data) ;
static FLAC__StreamDecoderTellStatus sf_flac_tell_callback (const FLAC__StreamDecoder *decoder, FLAC__uint64 *absolute_byte_offset, void *client_data) ;
static FLAC__StreamDecoderLengthStatus sf_flac_length_callback (const FLAC__StreamDecoder *decoder, FLAC__uint64 *stream_length, void *client_data) ;
static FLAC__bool sf_flac_eof_callback (const FLAC__StreamDecoder *decoder, void *client_data) ;
static FLAC__StreamDecoderWriteStatus sf_flac_write_callback (const FLAC__StreamDecoder *decoder, const FLAC__Frame *frame, const FLAC__int32 * const buffer [], void *client_data) ;
static void sf_flac_meta_callback (const FLAC__StreamDecoder *decoder, const FLAC__StreamMetadata *metadata, void *client_data) ;
static void sf_flac_error_callback (const FLAC__StreamDecoder *decoder, FLAC__StreamDecoderErrorStatus status, void *client_data) ;
#endif
/* Encoder Callbacks */ /* Encoder Callbacks */
#ifdef LEGACY_FLAC
static FLAC__SeekableStreamEncoderSeekStatus sf_flac_enc_seek_callback (const FLAC__SeekableStreamEncoder *encoder, FLAC__uint64 absolute_byte_offset, void *client_data) ; static FLAC__SeekableStreamEncoderSeekStatus sf_flac_enc_seek_callback (const FLAC__SeekableStreamEncoder *encoder, FLAC__uint64 absolute_byte_offset, void *client_data) ;
#ifdef HAVE_FLAC_1_1_1 #ifdef HAVE_FLAC_1_1_1
static FLAC__SeekableStreamEncoderTellStatus sf_flac_enc_tell_callback (const FLAC__SeekableStreamEncoder *encoder, FLAC__uint64 *absolute_byte_offset, void *client_data) ; static FLAC__SeekableStreamEncoderTellStatus sf_flac_enc_tell_callback (const FLAC__SeekableStreamEncoder *encoder, FLAC__uint64 *absolute_byte_offset, void *client_data) ;
#endif #endif
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) ; 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) ;
#else
static FLAC__StreamEncoderSeekStatus sf_flac_enc_seek_callback (const FLAC__StreamEncoder *encoder, FLAC__uint64 absolute_byte_offset, void *client_data) ;
static FLAC__StreamEncoderTellStatus sf_flac_enc_tell_callback (const FLAC__StreamEncoder *encoder, FLAC__uint64 *absolute_byte_offset, void *client_data) ;
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) ;
#endif
static const int legal_sample_rates [] = static const int legal_sample_rates [] =
{ 8000, 16000, 22050, 24000, 32000, 44100, 48000, 96000 { 8000, 16000, 22050, 24000, 32000, 44100, 48000, 96000
@ -283,51 +314,99 @@ flac_buffer_copy (SF_PRIVATE *psf)
} /* flac_buffer_copy */ } /* flac_buffer_copy */
#ifdef LEGACY_FLAC
static FLAC__SeekableStreamDecoderReadStatus static FLAC__SeekableStreamDecoderReadStatus
sf_flac_read_callback (const FLAC__SeekableStreamDecoder * UNUSED (decoder), FLAC__byte buffer [], unsigned *bytes, void *client_data) sf_flac_read_callback (const FLAC__SeekableStreamDecoder * UNUSED (decoder), FLAC__byte buffer [], unsigned *bytes, void *client_data)
#else
static FLAC__StreamDecoderReadStatus
sf_flac_read_callback (const FLAC__StreamDecoder * UNUSED (decoder), FLAC__byte buffer [], size_t *bytes, void *client_data)
#endif
{ SF_PRIVATE *psf = (SF_PRIVATE*) client_data ; { SF_PRIVATE *psf = (SF_PRIVATE*) client_data ;
*bytes = psf_fread (buffer, 1, *bytes, psf) ; *bytes = psf_fread (buffer, 1, *bytes, psf) ;
if (*bytes > 0 && psf->error == 0) if (*bytes > 0 && psf->error == 0)
#ifdef LEGACY_FLAC
return FLAC__SEEKABLE_STREAM_DECODER_READ_STATUS_OK ; return FLAC__SEEKABLE_STREAM_DECODER_READ_STATUS_OK ;
return FLAC__SEEKABLE_STREAM_DECODER_READ_STATUS_ERROR ; return FLAC__SEEKABLE_STREAM_DECODER_READ_STATUS_ERROR ;
#else
return FLAC__STREAM_DECODER_READ_STATUS_CONTINUE ;
return FLAC__STREAM_DECODER_READ_STATUS_ABORT ;
#endif
} /* sf_flac_read_callback */ } /* sf_flac_read_callback */
#ifdef LEGACY_FLAC
static FLAC__SeekableStreamDecoderSeekStatus static FLAC__SeekableStreamDecoderSeekStatus
sf_flac_seek_callback (const FLAC__SeekableStreamDecoder * UNUSED (decoder), FLAC__uint64 absolute_byte_offset, void *client_data) sf_flac_seek_callback (const FLAC__SeekableStreamDecoder * UNUSED (decoder), FLAC__uint64 absolute_byte_offset, void *client_data)
#else
static FLAC__StreamDecoderSeekStatus
sf_flac_seek_callback (const FLAC__StreamDecoder * UNUSED (decoder), FLAC__uint64 absolute_byte_offset, void *client_data)
#endif
{ SF_PRIVATE *psf = (SF_PRIVATE*) client_data ; { SF_PRIVATE *psf = (SF_PRIVATE*) client_data ;
psf_fseek (psf, absolute_byte_offset, SEEK_SET) ; psf_fseek (psf, absolute_byte_offset, SEEK_SET) ;
if (psf->error) if (psf->error)
#ifdef LEGACY_FLAC
return FLAC__SEEKABLE_STREAM_DECODER_SEEK_STATUS_ERROR ; return FLAC__SEEKABLE_STREAM_DECODER_SEEK_STATUS_ERROR ;
return FLAC__SEEKABLE_STREAM_DECODER_SEEK_STATUS_OK ; return FLAC__SEEKABLE_STREAM_DECODER_SEEK_STATUS_OK ;
#else
return FLAC__STREAM_DECODER_SEEK_STATUS_ERROR ;
return FLAC__STREAM_DECODER_SEEK_STATUS_OK ;
#endif
} /* sf_flac_seek_callback */ } /* sf_flac_seek_callback */
#ifdef LEGACY_FLAC
static FLAC__SeekableStreamDecoderTellStatus static FLAC__SeekableStreamDecoderTellStatus
sf_flac_tell_callback (const FLAC__SeekableStreamDecoder * UNUSED (decoder), FLAC__uint64 *absolute_byte_offset, void *client_data) sf_flac_tell_callback (const FLAC__SeekableStreamDecoder * UNUSED (decoder), FLAC__uint64 *absolute_byte_offset, void *client_data)
#else
static FLAC__StreamDecoderTellStatus
sf_flac_tell_callback (const FLAC__StreamDecoder * UNUSED (decoder), FLAC__uint64 *absolute_byte_offset, void *client_data)
#endif
{ SF_PRIVATE *psf = (SF_PRIVATE*) client_data ; { SF_PRIVATE *psf = (SF_PRIVATE*) client_data ;
*absolute_byte_offset = psf_ftell (psf) ; *absolute_byte_offset = psf_ftell (psf) ;
if (psf->error) if (psf->error)
#ifdef LEGACY_FLAC
return FLAC__SEEKABLE_STREAM_DECODER_TELL_STATUS_ERROR ; return FLAC__SEEKABLE_STREAM_DECODER_TELL_STATUS_ERROR ;
return FLAC__SEEKABLE_STREAM_DECODER_TELL_STATUS_OK ; return FLAC__SEEKABLE_STREAM_DECODER_TELL_STATUS_OK ;
#else
return FLAC__STREAM_DECODER_TELL_STATUS_ERROR ;
return FLAC__STREAM_DECODER_TELL_STATUS_OK ;
#endif
} /* sf_flac_tell_callback */ } /* sf_flac_tell_callback */
#ifdef LEGACY_FLAC
static FLAC__SeekableStreamDecoderLengthStatus static FLAC__SeekableStreamDecoderLengthStatus
sf_flac_length_callback (const FLAC__SeekableStreamDecoder * UNUSED (decoder), FLAC__uint64 *stream_length, void *client_data) sf_flac_length_callback (const FLAC__SeekableStreamDecoder * UNUSED (decoder), FLAC__uint64 *stream_length, void *client_data)
#else
static FLAC__StreamDecoderLengthStatus
sf_flac_length_callback (const FLAC__StreamDecoder * UNUSED (decoder), FLAC__uint64 *stream_length, void *client_data)
#endif
{ SF_PRIVATE *psf = (SF_PRIVATE*) client_data ; { SF_PRIVATE *psf = (SF_PRIVATE*) client_data ;
if ((*stream_length = psf->filelength) == 0) if ((*stream_length = psf->filelength) == 0)
#ifdef LEGACY_FLAC
return FLAC__SEEKABLE_STREAM_DECODER_LENGTH_STATUS_ERROR ; return FLAC__SEEKABLE_STREAM_DECODER_LENGTH_STATUS_ERROR ;
return FLAC__SEEKABLE_STREAM_DECODER_LENGTH_STATUS_OK ; return FLAC__SEEKABLE_STREAM_DECODER_LENGTH_STATUS_OK ;
#else
return FLAC__STREAM_DECODER_LENGTH_STATUS_ERROR ;
return FLAC__STREAM_DECODER_LENGTH_STATUS_OK ;
#endif
} /* sf_flac_length_callback */ } /* sf_flac_length_callback */
static FLAC__bool static FLAC__bool
#ifdef LEGACY_FLAC
sf_flac_eof_callback (const FLAC__SeekableStreamDecoder *UNUSED (decoder), void *client_data) sf_flac_eof_callback (const FLAC__SeekableStreamDecoder *UNUSED (decoder), void *client_data)
#else
sf_flac_eof_callback (const FLAC__StreamDecoder *UNUSED (decoder), void *client_data)
#endif
{ SF_PRIVATE *psf = (SF_PRIVATE*) client_data ; { SF_PRIVATE *psf = (SF_PRIVATE*) client_data ;
if (psf_ftell (psf) == psf->filelength) if (psf_ftell (psf) == psf->filelength)
@ -337,7 +416,11 @@ sf_flac_eof_callback (const FLAC__SeekableStreamDecoder *UNUSED (decoder), void
} /* sf_flac_eof_callback */ } /* sf_flac_eof_callback */
static FLAC__StreamDecoderWriteStatus static FLAC__StreamDecoderWriteStatus
#ifdef LEGACY_FLAC
sf_flac_write_callback (const FLAC__SeekableStreamDecoder * UNUSED (decoder), const FLAC__Frame *frame, const FLAC__int32 * const buffer [], void *client_data) sf_flac_write_callback (const FLAC__SeekableStreamDecoder * UNUSED (decoder), const FLAC__Frame *frame, const FLAC__int32 * const buffer [], void *client_data)
#else
sf_flac_write_callback (const FLAC__StreamDecoder * UNUSED (decoder), const FLAC__Frame *frame, const FLAC__int32 * const buffer [], void *client_data)
#endif
{ SF_PRIVATE *psf = (SF_PRIVATE*) client_data ; { SF_PRIVATE *psf = (SF_PRIVATE*) client_data ;
FLAC_PRIVATE* pflac = (FLAC_PRIVATE*) psf->fdata ; FLAC_PRIVATE* pflac = (FLAC_PRIVATE*) psf->fdata ;
@ -353,7 +436,11 @@ sf_flac_write_callback (const FLAC__SeekableStreamDecoder * UNUSED (decoder), co
} /* sf_flac_write_callback */ } /* sf_flac_write_callback */
static void static void
#ifdef LEGACY_FLAC
sf_flac_meta_callback (const FLAC__SeekableStreamDecoder * UNUSED (decoder), const FLAC__StreamMetadata *metadata, void *client_data) sf_flac_meta_callback (const FLAC__SeekableStreamDecoder * UNUSED (decoder), const FLAC__StreamMetadata *metadata, void *client_data)
#else
sf_flac_meta_callback (const FLAC__StreamDecoder * UNUSED (decoder), const FLAC__StreamMetadata *metadata, void *client_data)
#endif
{ SF_PRIVATE *psf = (SF_PRIVATE*) client_data ; { SF_PRIVATE *psf = (SF_PRIVATE*) client_data ;
switch (metadata->type) switch (metadata->type)
@ -387,7 +474,11 @@ sf_flac_meta_callback (const FLAC__SeekableStreamDecoder * UNUSED (decoder), con
} /* sf_flac_meta_callback */ } /* sf_flac_meta_callback */
static void static void
#ifdef LEGACY_FLAC
sf_flac_error_callback (const FLAC__SeekableStreamDecoder * UNUSED (decoder), FLAC__StreamDecoderErrorStatus status, void *client_data) sf_flac_error_callback (const FLAC__SeekableStreamDecoder * UNUSED (decoder), FLAC__StreamDecoderErrorStatus status, void *client_data)
#else
sf_flac_error_callback (const FLAC__StreamDecoder * UNUSED (decoder), FLAC__StreamDecoderErrorStatus status, void *client_data)
#endif
{ SF_PRIVATE *psf = (SF_PRIVATE*) client_data ; { SF_PRIVATE *psf = (SF_PRIVATE*) client_data ;
psf_log_printf (psf, "ERROR : %s\n", FLAC__StreamDecoderErrorStatusString [status]) ; psf_log_printf (psf, "ERROR : %s\n", FLAC__StreamDecoderErrorStatusString [status]) ;
@ -407,17 +498,29 @@ sf_flac_error_callback (const FLAC__SeekableStreamDecoder * UNUSED (decoder), FL
return ; return ;
} /* sf_flac_error_callback */ } /* sf_flac_error_callback */
#ifdef LEGACY_FLAC
static FLAC__SeekableStreamEncoderSeekStatus static FLAC__SeekableStreamEncoderSeekStatus
sf_flac_enc_seek_callback (const FLAC__SeekableStreamEncoder * UNUSED (encoder), FLAC__uint64 absolute_byte_offset, void *client_data) sf_flac_enc_seek_callback (const FLAC__SeekableStreamEncoder * UNUSED (encoder), FLAC__uint64 absolute_byte_offset, void *client_data)
#else
static FLAC__StreamEncoderSeekStatus
sf_flac_enc_seek_callback (const FLAC__StreamEncoder * UNUSED (encoder), FLAC__uint64 absolute_byte_offset, void *client_data)
#endif
{ SF_PRIVATE *psf = (SF_PRIVATE*) client_data ; { SF_PRIVATE *psf = (SF_PRIVATE*) client_data ;
psf_fseek (psf, absolute_byte_offset, SEEK_SET) ; psf_fseek (psf, absolute_byte_offset, SEEK_SET) ;
if (psf->error) if (psf->error)
#ifdef LEGACY_FLAC
return FLAC__SEEKABLE_STREAM_ENCODER_SEEK_STATUS_ERROR ; return FLAC__SEEKABLE_STREAM_ENCODER_SEEK_STATUS_ERROR ;
return FLAC__SEEKABLE_STREAM_ENCODER_SEEK_STATUS_OK ; return FLAC__SEEKABLE_STREAM_ENCODER_SEEK_STATUS_OK ;
#else
return FLAC__STREAM_ENCODER_SEEK_STATUS_ERROR ;
return FLAC__STREAM_ENCODER_SEEK_STATUS_OK ;
#endif
} /* sf_flac_enc_seek_callback */ } /* sf_flac_enc_seek_callback */
#ifdef LEGACY_FLAC
#ifdef HAVE_FLAC_1_1_1 #ifdef HAVE_FLAC_1_1_1
static FLAC__SeekableStreamEncoderTellStatus static FLAC__SeekableStreamEncoderTellStatus
sf_flac_enc_tell_callback (const FLAC__SeekableStreamEncoder *UNUSED (encoder), FLAC__uint64 *absolute_byte_offset, void *client_data) sf_flac_enc_tell_callback (const FLAC__SeekableStreamEncoder *UNUSED (encoder), FLAC__uint64 *absolute_byte_offset, void *client_data)
@ -430,9 +533,25 @@ sf_flac_enc_tell_callback (const FLAC__SeekableStreamEncoder *UNUSED (encoder),
return FLAC__SEEKABLE_STREAM_ENCODER_TELL_STATUS_OK ; return FLAC__SEEKABLE_STREAM_ENCODER_TELL_STATUS_OK ;
} /* sf_flac_enc_tell_callback */ } /* sf_flac_enc_tell_callback */
#endif #endif
#else
static FLAC__StreamEncoderTellStatus
sf_flac_enc_tell_callback (const FLAC__StreamEncoder *UNUSED (encoder), FLAC__uint64 *absolute_byte_offset, void *client_data)
{ SF_PRIVATE *psf = (SF_PRIVATE*) client_data ;
*absolute_byte_offset = psf_ftell (psf) ;
if (psf->error)
return FLAC__STREAM_ENCODER_TELL_STATUS_ERROR ;
return FLAC__STREAM_ENCODER_TELL_STATUS_OK ;
} /* sf_flac_enc_tell_callback */
#endif
static FLAC__StreamEncoderWriteStatus static FLAC__StreamEncoderWriteStatus
#ifdef LEGACY_FLAC
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) 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)
#else
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)
#endif
{ SF_PRIVATE *psf = (SF_PRIVATE*) client_data ; { SF_PRIVATE *psf = (SF_PRIVATE*) client_data ;
if (psf_fwrite (buffer, 1, bytes, psf) == bytes && psf->error == 0) if (psf_fwrite (buffer, 1, bytes, psf) == bytes && psf->error == 0)
@ -509,15 +628,27 @@ flac_close (SF_PRIVATE *psf)
return 0 ; return 0 ;
if (psf->mode == SFM_WRITE) if (psf->mode == SFM_WRITE)
{ FLAC__seekable_stream_encoder_finish (pflac->fse) ; {
#ifdef LEGACY_FLAC
FLAC__seekable_stream_encoder_finish (pflac->fse) ;
FLAC__seekable_stream_encoder_delete (pflac->fse) ; FLAC__seekable_stream_encoder_delete (pflac->fse) ;
#else
FLAC__stream_encoder_finish (pflac->fse) ;
FLAC__stream_encoder_delete (pflac->fse) ;
#endif
if (pflac->encbuffer) if (pflac->encbuffer)
free (pflac->encbuffer) ; free (pflac->encbuffer) ;
} ; } ;
if (psf->mode == SFM_READ) if (psf->mode == SFM_READ)
{ FLAC__seekable_stream_decoder_finish (pflac->fsd) ; {
#ifdef LEGACY_FLAC
FLAC__seekable_stream_decoder_finish (pflac->fsd) ;
FLAC__seekable_stream_decoder_delete (pflac->fsd) ; FLAC__seekable_stream_decoder_delete (pflac->fsd) ;
#else
FLAC__stream_decoder_finish (pflac->fsd) ;
FLAC__stream_decoder_delete (pflac->fsd) ;
#endif
} ; } ;
for (k = 0 ; k < ARRAY_LEN (pflac->rbuffer) ; k++) for (k = 0 ; k < ARRAY_LEN (pflac->rbuffer) ; k++)
@ -546,17 +677,6 @@ flac_enc_init (SF_PRIVATE *psf)
return SFE_FLAC_BAD_SAMPLE_RATE ; return SFE_FLAC_BAD_SAMPLE_RATE ;
psf_fseek (psf, 0, SEEK_SET) ; psf_fseek (psf, 0, SEEK_SET) ;
if ((pflac->fse = FLAC__seekable_stream_encoder_new ()) == NULL)
return SFE_FLAC_NEW_DECODER ;
FLAC__seekable_stream_encoder_set_write_callback (pflac->fse, sf_flac_enc_write_callback) ;
FLAC__seekable_stream_encoder_set_seek_callback (pflac->fse, sf_flac_enc_seek_callback) ;
#ifdef HAVE_FLAC_1_1_1
FLAC__seekable_stream_encoder_set_tell_callback (pflac->fse, sf_flac_enc_tell_callback) ;
#endif
FLAC__seekable_stream_encoder_set_client_data (pflac->fse, psf) ;
FLAC__seekable_stream_encoder_set_channels (pflac->fse, psf->sf.channels) ;
FLAC__seekable_stream_encoder_set_sample_rate (pflac->fse, psf->sf.samplerate) ;
switch (psf->sf.format & SF_FORMAT_SUBMASK) switch (psf->sf.format & SF_FORMAT_SUBMASK)
{ case SF_FORMAT_PCM_S8 : { case SF_FORMAT_PCM_S8 :
@ -574,12 +694,36 @@ flac_enc_init (SF_PRIVATE *psf)
break ; break ;
} ; } ;
#ifdef LEGACY_FLAC
if ((pflac->fse = FLAC__seekable_stream_encoder_new ()) == NULL)
return SFE_FLAC_NEW_DECODER ;
FLAC__seekable_stream_encoder_set_write_callback (pflac->fse, sf_flac_enc_write_callback) ;
FLAC__seekable_stream_encoder_set_seek_callback (pflac->fse, sf_flac_enc_seek_callback) ;
#ifdef HAVE_FLAC_1_1_1
FLAC__seekable_stream_encoder_set_tell_callback (pflac->fse, sf_flac_enc_tell_callback) ;
#endif
FLAC__seekable_stream_encoder_set_client_data (pflac->fse, psf) ;
FLAC__seekable_stream_encoder_set_channels (pflac->fse, psf->sf.channels) ;
FLAC__seekable_stream_encoder_set_sample_rate (pflac->fse, psf->sf.samplerate) ;
FLAC__seekable_stream_encoder_set_bits_per_sample (pflac->fse, bps) ; FLAC__seekable_stream_encoder_set_bits_per_sample (pflac->fse, bps) ;
if ((bps = FLAC__seekable_stream_encoder_init (pflac->fse)) != FLAC__SEEKABLE_STREAM_DECODER_OK) if ((bps = FLAC__seekable_stream_encoder_init (pflac->fse)) != FLAC__SEEKABLE_STREAM_DECODER_OK)
{ psf_log_printf (psf, "Error : FLAC encoder init returned error : %s\n", FLAC__seekable_stream_encoder_get_resolved_state_string (pflac->fse)) ; { psf_log_printf (psf, "Error : FLAC encoder init returned error : %s\n", FLAC__seekable_stream_encoder_get_resolved_state_string (pflac->fse)) ;
return SFE_FLAC_INIT_DECODER ; return SFE_FLAC_INIT_DECODER ;
} ; } ;
#else
if ((pflac->fse = FLAC__stream_encoder_new ()) == NULL)
return SFE_FLAC_NEW_DECODER ;
FLAC__stream_encoder_set_channels (pflac->fse, psf->sf.channels) ;
FLAC__stream_encoder_set_sample_rate (pflac->fse, psf->sf.samplerate) ;
FLAC__stream_encoder_set_bits_per_sample (pflac->fse, bps) ;
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)
{ psf_log_printf (psf, "Error : FLAC encoder init returned error : %s\n", FLAC__StreamEncoderInitStatusString[bps]) ;
return SFE_FLAC_INIT_DECODER ;
} ;
#endif
if (psf->error == 0) if (psf->error == 0)
psf->dataoffset = psf_ftell (psf) ; psf->dataoffset = psf_ftell (psf) ;
@ -593,6 +737,7 @@ flac_read_header (SF_PRIVATE *psf)
{ FLAC_PRIVATE* pflac = (FLAC_PRIVATE*) psf->fdata ; { FLAC_PRIVATE* pflac = (FLAC_PRIVATE*) psf->fdata ;
psf_fseek (psf, 0, SEEK_SET) ; psf_fseek (psf, 0, SEEK_SET) ;
#ifdef LEGACY_FLAC
if ((pflac->fsd = FLAC__seekable_stream_decoder_new ()) == NULL) if ((pflac->fsd = FLAC__seekable_stream_decoder_new ()) == NULL)
return SFE_FLAC_NEW_DECODER ; return SFE_FLAC_NEW_DECODER ;
@ -610,9 +755,22 @@ flac_read_header (SF_PRIVATE *psf)
return SFE_FLAC_INIT_DECODER ; return SFE_FLAC_INIT_DECODER ;
FLAC__seekable_stream_decoder_process_until_end_of_metadata (pflac->fsd) ; FLAC__seekable_stream_decoder_process_until_end_of_metadata (pflac->fsd) ;
#else
if ((pflac->fsd = FLAC__stream_decoder_new ()) == NULL)
return SFE_FLAC_NEW_DECODER ;
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)
return SFE_FLAC_INIT_DECODER ;
FLAC__stream_decoder_process_until_end_of_metadata (pflac->fsd) ;
#endif
if (psf->error == 0) if (psf->error == 0)
{ FLAC__uint64 position ; { FLAC__uint64 position ;
#ifdef LEGACY_FLAC
FLAC__seekable_stream_decoder_get_decode_position (pflac->fsd, &position) ; FLAC__seekable_stream_decoder_get_decode_position (pflac->fsd, &position) ;
#else
FLAC__stream_decoder_get_decode_position (pflac->fsd, &position) ;
#endif
psf->dataoffset = position ; psf->dataoffset = position ;
} ; } ;
@ -676,10 +834,18 @@ flac_read_loop (SF_PRIVATE *psf, unsigned len)
flac_buffer_copy (psf) ; flac_buffer_copy (psf) ;
while (pflac->pos < pflac->len) while (pflac->pos < pflac->len)
{ if (FLAC__seekable_stream_decoder_process_single (pflac->fsd) == 0) {
#ifdef LEGACY_FLAC
if (FLAC__seekable_stream_decoder_process_single (pflac->fsd) == 0)
break ; break ;
if (FLAC__seekable_stream_decoder_get_state (pflac->fsd) != FLAC__SEEKABLE_STREAM_DECODER_OK) if (FLAC__seekable_stream_decoder_get_state (pflac->fsd) != FLAC__SEEKABLE_STREAM_DECODER_OK)
break ; break ;
#else
if (FLAC__stream_decoder_process_single (pflac->fsd) == 0)
break ;
if (FLAC__stream_decoder_get_state (pflac->fsd) >= FLAC__STREAM_DECODER_END_OF_STREAM)
break ;
#endif
} ; } ;
pflac->ptr = NULL ; pflac->ptr = NULL ;
@ -795,7 +961,11 @@ flac_write_s2flac (SF_PRIVATE *psf, const short *ptr, sf_count_t len)
while (len > 0) while (len > 0)
{ writecount = (len >= bufferlen) ? bufferlen : (int) len ; { writecount = (len >= bufferlen) ? bufferlen : (int) len ;
convert (ptr + total, buffer, writecount) ; convert (ptr + total, buffer, writecount) ;
#ifdef LEGACY_FLAC
if (FLAC__seekable_stream_encoder_process_interleaved (pflac->fse, buffer, writecount/psf->sf.channels)) if (FLAC__seekable_stream_encoder_process_interleaved (pflac->fse, buffer, writecount/psf->sf.channels))
#else
if (FLAC__stream_encoder_process_interleaved (pflac->fse, buffer, writecount/psf->sf.channels))
#endif
thiswrite = writecount ; thiswrite = writecount ;
else else
break ; break ;
@ -837,7 +1007,11 @@ flac_write_i2flac (SF_PRIVATE *psf, const int *ptr, sf_count_t len)
while (len > 0) while (len > 0)
{ writecount = (len >= bufferlen) ? bufferlen : (int) len ; { writecount = (len >= bufferlen) ? bufferlen : (int) len ;
convert (ptr + total, buffer, writecount) ; convert (ptr + total, buffer, writecount) ;
#ifdef LEGACY_FLAC
if (FLAC__seekable_stream_encoder_process_interleaved (pflac->fse, buffer, writecount/psf->sf.channels)) if (FLAC__seekable_stream_encoder_process_interleaved (pflac->fse, buffer, writecount/psf->sf.channels))
#else
if (FLAC__stream_encoder_process_interleaved (pflac->fse, buffer, writecount/psf->sf.channels))
#endif
thiswrite = writecount ; thiswrite = writecount ;
else else
break ; break ;
@ -879,7 +1053,11 @@ flac_write_f2flac (SF_PRIVATE *psf, const float *ptr, sf_count_t len)
while (len > 0) while (len > 0)
{ writecount = (len >= bufferlen) ? bufferlen : (int) len ; { writecount = (len >= bufferlen) ? bufferlen : (int) len ;
convert (ptr + total, buffer, writecount, psf->norm_float) ; convert (ptr + total, buffer, writecount, psf->norm_float) ;
#ifdef LEGACY_FLAC
if (FLAC__seekable_stream_encoder_process_interleaved (pflac->fse, buffer, writecount/psf->sf.channels)) if (FLAC__seekable_stream_encoder_process_interleaved (pflac->fse, buffer, writecount/psf->sf.channels))
#else
if (FLAC__stream_encoder_process_interleaved (pflac->fse, buffer, writecount/psf->sf.channels))
#endif
thiswrite = writecount ; thiswrite = writecount ;
else else
break ; break ;
@ -1011,7 +1189,11 @@ flac_write_d2flac (SF_PRIVATE *psf, const double *ptr, sf_count_t len)
while (len > 0) while (len > 0)
{ writecount = (len >= bufferlen) ? bufferlen : (int) len ; { writecount = (len >= bufferlen) ? bufferlen : (int) len ;
convert (ptr + total, buffer, writecount, psf->norm_double) ; convert (ptr + total, buffer, writecount, psf->norm_double) ;
#ifdef LEGACY_FLAC
if (FLAC__seekable_stream_encoder_process_interleaved (pflac->fse, buffer, writecount/psf->sf.channels)) if (FLAC__seekable_stream_encoder_process_interleaved (pflac->fse, buffer, writecount/psf->sf.channels))
#else
if (FLAC__stream_encoder_process_interleaved (pflac->fse, buffer, writecount/psf->sf.channels))
#endif
thiswrite = writecount ; thiswrite = writecount ;
else else
break ; break ;
@ -1131,10 +1313,17 @@ flac_seek (SF_PRIVATE *psf, int UNUSED (mode), sf_count_t offset)
if (psf->mode == SFM_READ) if (psf->mode == SFM_READ)
{ FLAC__uint64 position ; { FLAC__uint64 position ;
#ifdef LEGACY_FLAC
if (FLAC__seekable_stream_decoder_seek_absolute (pflac->fsd, offset)) if (FLAC__seekable_stream_decoder_seek_absolute (pflac->fsd, offset))
{ FLAC__seekable_stream_decoder_get_decode_position (pflac->fsd, &position) ; { FLAC__seekable_stream_decoder_get_decode_position (pflac->fsd, &position) ;
return offset ; return offset ;
} ; } ;
#else
if (FLAC__stream_decoder_seek_absolute (pflac->fsd, offset))
{ FLAC__stream_decoder_get_decode_position (pflac->fsd, &position) ;
return offset ;
} ;
#endif
return ((sf_count_t) -1) ; return ((sf_count_t) -1) ;
} ; } ;