mirror of
https://github.com/archlinuxarm/PKGBUILDs.git
synced 2024-11-18 22:54:00 +00:00
474 lines
19 KiB
Diff
474 lines
19 KiB
Diff
diff -r -u scummvm-0.9.0/configure scummvm-0.9.0-b2/configure
|
|
--- scummvm-0.9.0/configure 2006-06-21 14:19:07.000000000 -0700
|
|
+++ scummvm-0.9.0-b2/configure 2006-10-25 00:10:35.000000000 -0700
|
|
@@ -1076,15 +1076,15 @@
|
|
if test "$_flac" = auto ; then
|
|
_flac=no
|
|
cat > $TMPC << EOF
|
|
-#include <FLAC/seekable_stream_decoder.h>
|
|
-int main(void) { FLAC__seekable_stream_decoder_init( 0 ); return 0; }
|
|
+#include <FLAC/format.h>
|
|
+int main(void) { return FLAC__STREAM_SYNC_LEN >> 30; /* guaranteed to be 0 */ }
|
|
EOF
|
|
- cc_check $LDFLAGS $CXXFLAGS $FLAC_CFLAGS $FLAC_LIBS \
|
|
- -lFLAC -lm && _flac=yes
|
|
+ cc_check $LDFLAGS $CXXFLAGS $FLAC_CFLAGS $FLAC_LIBS $OGG_CFLAGS $OGG_LIBS \
|
|
+ -lFLAC -logg -lm && _flac=yes
|
|
fi
|
|
if test "$_flac" = yes ; then
|
|
_def_flac='#define USE_FLAC'
|
|
- LIBS="$LIBS $FLAC_LIBS -lFLAC"
|
|
+ LIBS="$LIBS $FLAC_LIBS $OGG_LIBS -lFLAC -logg"
|
|
INCLUDES="$INCLUDES $FLAC_CFLAGS"
|
|
else
|
|
_def_flac='#undef USE_FLAC'
|
|
diff -r -u scummvm-0.9.0/sound/flac.cpp scummvm-0.9.0-b2/sound/flac.cpp
|
|
--- scummvm-0.9.0/sound/flac.cpp 2006-06-21 14:16:13.000000000 -0700
|
|
+++ scummvm-0.9.0-b2/sound/flac.cpp 2006-10-25 00:08:18.000000000 -0700
|
|
@@ -31,7 +31,18 @@
|
|
#include "sound/audiocd.h"
|
|
|
|
#define FLAC__NO_DLL // that MS-magic gave me headaches - just link the library you like
|
|
+#include <FLAC/export.h>
|
|
+// check if we have FLAC >= 1.1.3; LEGACY_FLAC code can be removed once FLAC-1.1.3 propagates everywhere
|
|
+#if !defined(FLAC_API_VERSION_CURRENT) || FLAC_API_VERSION_CURRENT < 8
|
|
+#define LEGACY_FLAC
|
|
+#else
|
|
+#undef LEGACY_FLAC
|
|
+#endif
|
|
+#ifdef LEGACY_FLAC
|
|
#include <FLAC/seekable_stream_decoder.h>
|
|
+#else
|
|
+#include <FLAC/stream_decoder.h>
|
|
+#endif
|
|
|
|
|
|
using Common::File;
|
|
@@ -67,7 +78,11 @@
|
|
|
|
const FLAC__StreamMetadata_StreamInfo& getStreamInfo() const {return _streaminfo;}
|
|
|
|
+#ifdef LEGACY_FLAC
|
|
inline FLAC__SeekableStreamDecoderState getState() const;
|
|
+#else
|
|
+ inline FLAC__StreamDecoderState getState() const;
|
|
+#endif
|
|
inline FLAC__StreamDecoderState getStreamDecoderState() const;
|
|
|
|
|
|
@@ -81,18 +96,30 @@
|
|
inline void setLastSample(FLAC__uint64 absoluteSample);
|
|
|
|
protected:
|
|
+#ifdef LEGACY_FLAC
|
|
inline ::FLAC__SeekableStreamDecoderReadStatus callbackRead(FLAC__byte buffer[], uint *bytes);
|
|
inline ::FLAC__SeekableStreamDecoderSeekStatus callbackSeek(FLAC__uint64 absoluteByteOffset);
|
|
inline ::FLAC__SeekableStreamDecoderTellStatus callbackTell(FLAC__uint64 *absoluteByteOffset);
|
|
inline ::FLAC__SeekableStreamDecoderLengthStatus callbackLength(FLAC__uint64 *streamLength);
|
|
+#else
|
|
+ inline ::FLAC__StreamDecoderReadStatus callbackRead(FLAC__byte buffer[], size_t *bytes);
|
|
+ inline ::FLAC__StreamDecoderSeekStatus callbackSeek(FLAC__uint64 absoluteByteOffset);
|
|
+ inline ::FLAC__StreamDecoderTellStatus callbackTell(FLAC__uint64 *absoluteByteOffset);
|
|
+ inline ::FLAC__StreamDecoderLengthStatus callbackLength(FLAC__uint64 *streamLength);
|
|
+#endif
|
|
inline bool callbackEOF();
|
|
inline ::FLAC__StreamDecoderWriteStatus callbackWrite(const ::FLAC__Frame *frame, const FLAC__int32 * const buffer[]);
|
|
inline void callbackMetadata(const ::FLAC__StreamMetadata *metadata);
|
|
inline void callbackError(::FLAC__StreamDecoderErrorStatus status);
|
|
|
|
+#ifdef LEGACY_FLAC
|
|
::FLAC__SeekableStreamDecoder *_decoder;
|
|
+#else
|
|
+ ::FLAC__StreamDecoder *_decoder;
|
|
+#endif
|
|
|
|
private:
|
|
+#ifdef LEGACY_FLAC
|
|
static ::FLAC__SeekableStreamDecoderReadStatus callWrapRead(const ::FLAC__SeekableStreamDecoder *decoder, FLAC__byte buffer[], uint *bytes, void *clientData);
|
|
static ::FLAC__SeekableStreamDecoderSeekStatus callWrapSeek(const ::FLAC__SeekableStreamDecoder *decoder, FLAC__uint64 absoluteByteOffset, void *clientData);
|
|
static ::FLAC__SeekableStreamDecoderTellStatus callWrapTell(const ::FLAC__SeekableStreamDecoder *decoder, FLAC__uint64 *absoluteByteOffset, void *clientData);
|
|
@@ -101,6 +128,16 @@
|
|
static ::FLAC__StreamDecoderWriteStatus callWrapWrite(const ::FLAC__SeekableStreamDecoder *decoder, const ::FLAC__Frame *frame, const FLAC__int32 * const buffer[], void *clientData);
|
|
static void callWrapMetadata(const ::FLAC__SeekableStreamDecoder *decoder, const ::FLAC__StreamMetadata *metadata, void *clientData);
|
|
static void callWrapError(const ::FLAC__SeekableStreamDecoder *decoder, ::FLAC__StreamDecoderErrorStatus status, void *clientData);
|
|
+#else
|
|
+ static ::FLAC__StreamDecoderReadStatus callWrapRead(const ::FLAC__StreamDecoder *decoder, FLAC__byte buffer[], size_t *bytes, void *clientData);
|
|
+ static ::FLAC__StreamDecoderSeekStatus callWrapSeek(const ::FLAC__StreamDecoder *decoder, FLAC__uint64 absoluteByteOffset, void *clientData);
|
|
+ static ::FLAC__StreamDecoderTellStatus callWrapTell(const ::FLAC__StreamDecoder *decoder, FLAC__uint64 *absoluteByteOffset, void *clientData);
|
|
+ static ::FLAC__StreamDecoderLengthStatus callWrapLength(const ::FLAC__StreamDecoder *decoder, FLAC__uint64 *streamLength, void *clientData);
|
|
+ static FLAC__bool callWrapEOF(const ::FLAC__StreamDecoder *decoder, void *clientData);
|
|
+ static ::FLAC__StreamDecoderWriteStatus callWrapWrite(const ::FLAC__StreamDecoder *decoder, const ::FLAC__Frame *frame, const FLAC__int32 * const buffer[], void *clientData);
|
|
+ static void callWrapMetadata(const ::FLAC__StreamDecoder *decoder, const ::FLAC__StreamMetadata *metadata, void *clientData);
|
|
+ static void callWrapError(const ::FLAC__StreamDecoder *decoder, ::FLAC__StreamDecoderErrorStatus status, void *clientData);
|
|
+#endif
|
|
// Private and undefined so you can't use them:
|
|
FlacInputStream(const FlacInputStream &);
|
|
void operator=(const FlacInputStream &);
|
|
@@ -157,7 +194,12 @@
|
|
};
|
|
|
|
FlacInputStream::FlacInputStream(File *sourceFile, const uint32 fileStart)
|
|
- : _decoder(::FLAC__seekable_stream_decoder_new()), _firstSample(0), _lastSample(0),
|
|
+#ifdef LEGACY_FLAC
|
|
+ : _decoder(::FLAC__seekable_stream_decoder_new()),
|
|
+#else
|
|
+ : _decoder(::FLAC__stream_decoder_new()),
|
|
+#endif
|
|
+ _firstSample(0), _lastSample(0),
|
|
_outBuffer(NULL), _requestedSamples(0), _lastSampleWritten(true),
|
|
_methodConvertBuffers(&FlacInputStream::convertBuffersGeneric)
|
|
{
|
|
@@ -178,7 +220,12 @@
|
|
}
|
|
|
|
FlacInputStream::FlacInputStream(File *sourceFile, const uint32 fileStart, const uint32 fileStop)
|
|
- : _decoder(::FLAC__seekable_stream_decoder_new()), _firstSample(0), _lastSample(0),
|
|
+#ifdef LEGACY_FLAC
|
|
+ : _decoder(::FLAC__seekable_stream_decoder_new()),
|
|
+#else
|
|
+ : _decoder(::FLAC__stream_decoder_new()),
|
|
+#endif
|
|
+ _firstSample(0), _lastSample(0),
|
|
_outBuffer(NULL), _requestedSamples(0), _lastSampleWritten(true),
|
|
_methodConvertBuffers(&FlacInputStream::convertBuffersGeneric)
|
|
{
|
|
@@ -201,8 +248,13 @@
|
|
|
|
FlacInputStream::~FlacInputStream() {
|
|
if (_decoder != NULL) {
|
|
+#ifdef LEGACY_FLAC
|
|
(void) ::FLAC__seekable_stream_decoder_finish(_decoder);
|
|
::FLAC__seekable_stream_decoder_delete(_decoder);
|
|
+#else
|
|
+ (void) ::FLAC__stream_decoder_finish(_decoder);
|
|
+ ::FLAC__stream_decoder_delete(_decoder);
|
|
+#endif
|
|
}
|
|
if (_preBuffer.bufData != NULL)
|
|
delete[] _preBuffer.bufData;
|
|
@@ -210,14 +262,27 @@
|
|
_fileInfo.fileHandle->decRef();
|
|
}
|
|
|
|
-inline FLAC__SeekableStreamDecoderState FlacInputStream::getState() const {
|
|
+#ifdef LEGACY_FLAC
|
|
+inline FLAC__SeekableStreamDecoderState FlacInputStream::getState() const
|
|
+#else
|
|
+inline FLAC__StreamDecoderState FlacInputStream::getState() const
|
|
+#endif
|
|
+{
|
|
assert(isValid());
|
|
+#ifdef LEGACY_FLAC
|
|
return ::FLAC__seekable_stream_decoder_get_state(_decoder);
|
|
+#else
|
|
+ return ::FLAC__stream_decoder_get_state(_decoder);
|
|
+#endif
|
|
}
|
|
|
|
inline FLAC__StreamDecoderState FlacInputStream::getStreamDecoderState() const {
|
|
assert(isValid());
|
|
+#ifdef LEGACY_FLAC
|
|
return ::FLAC__seekable_stream_decoder_get_stream_decoder_state(_decoder);
|
|
+#else
|
|
+ return ::FLAC__stream_decoder_get_state(_decoder);
|
|
+#endif
|
|
}
|
|
|
|
bool FlacInputStream::init() {
|
|
@@ -229,6 +294,7 @@
|
|
_lastSampleWritten = false;
|
|
_methodConvertBuffers = &FlacInputStream::convertBuffersGeneric;
|
|
|
|
+#ifdef LEGACY_FLAC
|
|
::FLAC__seekable_stream_decoder_set_read_callback(_decoder, &FlacInputStream::callWrapRead);
|
|
::FLAC__seekable_stream_decoder_set_seek_callback(_decoder, &FlacInputStream::callWrapSeek);
|
|
::FLAC__seekable_stream_decoder_set_tell_callback(_decoder, &FlacInputStream::callWrapTell);
|
|
@@ -247,6 +313,27 @@
|
|
}
|
|
}
|
|
}
|
|
+#else
|
|
+ if (::FLAC__stream_decoder_init_stream(
|
|
+ _decoder,
|
|
+ &FlacInputStream::callWrapRead,
|
|
+ &FlacInputStream::callWrapSeek,
|
|
+ &FlacInputStream::callWrapTell,
|
|
+ &FlacInputStream::callWrapLength,
|
|
+ &FlacInputStream::callWrapEOF,
|
|
+ &FlacInputStream::callWrapWrite,
|
|
+ &FlacInputStream::callWrapMetadata,
|
|
+ &FlacInputStream::callWrapError,
|
|
+ (void*)this
|
|
+ ) == FLAC__STREAM_DECODER_INIT_STATUS_OK) {
|
|
+ if (processUntilEndOfMetadata() && _streaminfo.channels > 0) {
|
|
+ if (_firstSample == 0 || 0 != ::FLAC__stream_decoder_seek_absolute(_decoder, _firstSample)) {
|
|
+ // FLAC__StreamDecoderState state = getStreamDecoderState();
|
|
+ return true; // no error occured
|
|
+ }
|
|
+ }
|
|
+ }
|
|
+#endif
|
|
|
|
warning("FlacInputStream: could not create an Audiostream from File %s", _fileInfo.fileHandle->name());
|
|
return false;
|
|
@@ -255,28 +342,48 @@
|
|
bool FlacInputStream::finish() {
|
|
assert(isValid());
|
|
deleteBuffer();
|
|
+#ifdef LEGACY_FLAC
|
|
return 0 != ::FLAC__seekable_stream_decoder_finish(_decoder);
|
|
+#else
|
|
+ return 0 != ::FLAC__stream_decoder_finish(_decoder);
|
|
+#endif
|
|
}
|
|
|
|
bool FlacInputStream::flush() {
|
|
assert(isValid());
|
|
flushBuffer();
|
|
+#ifdef LEGACY_FLAC
|
|
return 0 != ::FLAC__seekable_stream_decoder_flush(_decoder);
|
|
+#else
|
|
+ return 0 != ::FLAC__stream_decoder_flush(_decoder);
|
|
+#endif
|
|
}
|
|
|
|
inline bool FlacInputStream::processSingleBlock() {
|
|
assert(isValid());
|
|
+#ifdef LEGACY_FLAC
|
|
return 0 != ::FLAC__seekable_stream_decoder_process_single(_decoder);
|
|
+#else
|
|
+ return 0 != ::FLAC__stream_decoder_process_single(_decoder);
|
|
+#endif
|
|
}
|
|
|
|
inline bool FlacInputStream::processUntilEndOfMetadata() {
|
|
assert(isValid());
|
|
+#ifdef LEGACY_FLAC
|
|
return 0 != ::FLAC__seekable_stream_decoder_process_until_end_of_metadata(_decoder);
|
|
+#else
|
|
+ return 0 != ::FLAC__stream_decoder_process_until_end_of_metadata(_decoder);
|
|
+#endif
|
|
}
|
|
|
|
bool FlacInputStream::seekAbsolute(FLAC__uint64 sample) {
|
|
assert(isValid());
|
|
+#ifdef LEGACY_FLAC
|
|
const bool result = (0 != ::FLAC__seekable_stream_decoder_seek_absolute(_decoder, sample));
|
|
+#else
|
|
+ const bool result = (0 != ::FLAC__stream_decoder_seek_absolute(_decoder, sample));
|
|
+#endif
|
|
if (result) {
|
|
flushBuffer();
|
|
_lastSampleWritten = (_lastSample != 0 && sample >= _lastSample); // only set if we are SURE
|
|
@@ -349,11 +456,20 @@
|
|
return decoderOk ? samples : -1;
|
|
}
|
|
|
|
-inline ::FLAC__SeekableStreamDecoderReadStatus FlacInputStream::callbackRead(FLAC__byte buffer[], uint *bytes) {
|
|
+#ifdef LEGACY_FLAC
|
|
+inline ::FLAC__SeekableStreamDecoderReadStatus FlacInputStream::callbackRead(FLAC__byte buffer[], uint *bytes)
|
|
+#else
|
|
+inline ::FLAC__StreamDecoderReadStatus FlacInputStream::callbackRead(FLAC__byte buffer[], size_t *bytes)
|
|
+#endif
|
|
+{
|
|
assert(_fileInfo.fileHandle != NULL);
|
|
|
|
if (*bytes == 0)
|
|
+#ifdef LEGACY_FLAC
|
|
return FLAC__SEEKABLE_STREAM_DECODER_READ_STATUS_ERROR; /* abort to avoid a deadlock */
|
|
+#else
|
|
+ return FLAC__STREAM_DECODER_READ_STATUS_ABORT; /* abort to avoid a deadlock */
|
|
+#endif
|
|
|
|
const uint32 length = MIN(_fileInfo.fileEndPos - _fileInfo.filePos, static_cast<uint32>(*bytes));
|
|
|
|
@@ -361,11 +477,19 @@
|
|
const uint32 bytesRead = _fileInfo.fileHandle->read(buffer, length);
|
|
|
|
if (bytesRead == 0 && _fileInfo.fileHandle->ioFailed())
|
|
+#ifdef LEGACY_FLAC
|
|
return FLAC__SEEKABLE_STREAM_DECODER_READ_STATUS_ERROR;
|
|
+#else
|
|
+ return FLAC__STREAM_DECODER_READ_STATUS_ABORT;
|
|
+#endif
|
|
|
|
_fileInfo.filePos += bytesRead;
|
|
*bytes = static_cast<uint>(bytesRead);
|
|
+#ifdef LEGACY_FLAC
|
|
return FLAC__SEEKABLE_STREAM_DECODER_READ_STATUS_OK;
|
|
+#else
|
|
+ return FLAC__STREAM_DECODER_READ_STATUS_CONTINUE;
|
|
+#endif
|
|
}
|
|
|
|
inline void FlacInputStream::setLastSample(FLAC__uint64 absoluteSample) {
|
|
@@ -637,30 +761,60 @@
|
|
return FLAC__STREAM_DECODER_WRITE_STATUS_CONTINUE;
|
|
}
|
|
|
|
-inline ::FLAC__SeekableStreamDecoderSeekStatus FlacInputStream::callbackSeek(FLAC__uint64 absoluteByteOffset) {
|
|
+#ifdef LEGACY_FLAC
|
|
+inline ::FLAC__SeekableStreamDecoderSeekStatus FlacInputStream::callbackSeek(FLAC__uint64 absoluteByteOffset)
|
|
+#else
|
|
+inline ::FLAC__StreamDecoderSeekStatus FlacInputStream::callbackSeek(FLAC__uint64 absoluteByteOffset)
|
|
+#endif
|
|
+{
|
|
FLAC__uint64 newPos = absoluteByteOffset + _fileInfo.fileStartPos;
|
|
const bool result = (newPos < _fileInfo.fileEndPos);
|
|
|
|
if (result)
|
|
_fileInfo.filePos = static_cast<uint32>(newPos);
|
|
|
|
+#ifdef LEGACY_FLAC
|
|
return result ? FLAC__SEEKABLE_STREAM_DECODER_SEEK_STATUS_OK : FLAC__SEEKABLE_STREAM_DECODER_SEEK_STATUS_ERROR;
|
|
-
|
|
+#else
|
|
+ return result ? FLAC__STREAM_DECODER_SEEK_STATUS_OK : FLAC__STREAM_DECODER_SEEK_STATUS_ERROR;
|
|
+#endif
|
|
}
|
|
|
|
-inline ::FLAC__SeekableStreamDecoderTellStatus FlacInputStream::callbackTell(FLAC__uint64 *absoluteByteOffset) {
|
|
+#ifdef LEGACY_FLAC
|
|
+inline ::FLAC__SeekableStreamDecoderTellStatus FlacInputStream::callbackTell(FLAC__uint64 *absoluteByteOffset)
|
|
+#else
|
|
+inline ::FLAC__StreamDecoderTellStatus FlacInputStream::callbackTell(FLAC__uint64 *absoluteByteOffset)
|
|
+#endif
|
|
+{
|
|
/*if ()
|
|
return FLAC__SEEKABLE_STREAM_DECODER_TELL_STATUS_ERROR;*/
|
|
*absoluteByteOffset = static_cast<FLAC__uint64>(_fileInfo.filePos-_fileInfo.fileStartPos);
|
|
+#ifdef LEGACY_FLAC
|
|
return FLAC__SEEKABLE_STREAM_DECODER_TELL_STATUS_OK;
|
|
+#else
|
|
+ return FLAC__STREAM_DECODER_TELL_STATUS_OK;
|
|
+#endif
|
|
}
|
|
|
|
-inline ::FLAC__SeekableStreamDecoderLengthStatus FlacInputStream::callbackLength(FLAC__uint64 *streamLength) {
|
|
+#ifdef LEGACY_FLAC
|
|
+inline ::FLAC__SeekableStreamDecoderLengthStatus FlacInputStream::callbackLength(FLAC__uint64 *streamLength)
|
|
+#else
|
|
+inline ::FLAC__StreamDecoderLengthStatus FlacInputStream::callbackLength(FLAC__uint64 *streamLength)
|
|
+#endif
|
|
+{
|
|
if (_fileInfo.fileStartPos > _fileInfo.fileEndPos)
|
|
+#ifdef LEGACY_FLAC
|
|
return FLAC__SEEKABLE_STREAM_DECODER_LENGTH_STATUS_ERROR;
|
|
+#else
|
|
+ return FLAC__STREAM_DECODER_LENGTH_STATUS_ERROR;
|
|
+#endif
|
|
|
|
*streamLength = static_cast<FLAC__uint64>(_fileInfo.fileEndPos - _fileInfo.fileStartPos);
|
|
+#ifdef LEGACY_FLAC
|
|
return FLAC__SEEKABLE_STREAM_DECODER_LENGTH_STATUS_OK;
|
|
+#else
|
|
+ return FLAC__STREAM_DECODER_LENGTH_STATUS_OK;
|
|
+#endif
|
|
}
|
|
|
|
inline bool FlacInputStream::callbackEOF() {
|
|
@@ -682,56 +836,96 @@
|
|
}
|
|
|
|
/* Static Callback Wrappers */
|
|
-::FLAC__SeekableStreamDecoderReadStatus FlacInputStream::callWrapRead(const ::FLAC__SeekableStreamDecoder *decoder, FLAC__byte buffer[], uint *bytes, void *clientData) {
|
|
+#ifdef LEGACY_FLAC
|
|
+::FLAC__SeekableStreamDecoderReadStatus FlacInputStream::callWrapRead(const ::FLAC__SeekableStreamDecoder *decoder, FLAC__byte buffer[], uint *bytes, void *clientData)
|
|
+#else
|
|
+::FLAC__StreamDecoderReadStatus FlacInputStream::callWrapRead(const ::FLAC__StreamDecoder *decoder, FLAC__byte buffer[], size_t *bytes, void *clientData)
|
|
+#endif
|
|
+{
|
|
assert(0 != clientData);
|
|
FlacInputStream *instance = reinterpret_cast<FlacInputStream *>(clientData);
|
|
assert(0 != instance);
|
|
return instance->callbackRead(buffer, bytes);
|
|
}
|
|
|
|
-::FLAC__SeekableStreamDecoderSeekStatus FlacInputStream::callWrapSeek(const ::FLAC__SeekableStreamDecoder *decoder, FLAC__uint64 absoluteByteOffset, void *clientData) {
|
|
+#ifdef LEGACY_FLAC
|
|
+::FLAC__SeekableStreamDecoderSeekStatus FlacInputStream::callWrapSeek(const ::FLAC__SeekableStreamDecoder *decoder, FLAC__uint64 absoluteByteOffset, void *clientData)
|
|
+#else
|
|
+::FLAC__StreamDecoderSeekStatus FlacInputStream::callWrapSeek(const ::FLAC__StreamDecoder *decoder, FLAC__uint64 absoluteByteOffset, void *clientData)
|
|
+#endif
|
|
+{
|
|
assert(0 != clientData);
|
|
FlacInputStream *instance = reinterpret_cast<FlacInputStream *>(clientData);
|
|
assert(0 != instance);
|
|
return instance->callbackSeek(absoluteByteOffset);
|
|
}
|
|
|
|
-::FLAC__SeekableStreamDecoderTellStatus FlacInputStream::callWrapTell(const ::FLAC__SeekableStreamDecoder *decoder, FLAC__uint64 *absoluteByteOffset, void *clientData) {
|
|
+#ifdef LEGACY_FLAC
|
|
+::FLAC__SeekableStreamDecoderTellStatus FlacInputStream::callWrapTell(const ::FLAC__SeekableStreamDecoder *decoder, FLAC__uint64 *absoluteByteOffset, void *clientData)
|
|
+#else
|
|
+::FLAC__StreamDecoderTellStatus FlacInputStream::callWrapTell(const ::FLAC__StreamDecoder *decoder, FLAC__uint64 *absoluteByteOffset, void *clientData)
|
|
+#endif
|
|
+{
|
|
assert(0 != clientData);
|
|
FlacInputStream *instance = reinterpret_cast<FlacInputStream *>(clientData);
|
|
assert(0 != instance);
|
|
return instance->callbackTell(absoluteByteOffset);
|
|
}
|
|
|
|
-::FLAC__SeekableStreamDecoderLengthStatus FlacInputStream::callWrapLength(const ::FLAC__SeekableStreamDecoder *decoder, FLAC__uint64 *streamLength, void *clientData) {
|
|
+#ifdef LEGACY_FLAC
|
|
+::FLAC__SeekableStreamDecoderLengthStatus FlacInputStream::callWrapLength(const ::FLAC__SeekableStreamDecoder *decoder, FLAC__uint64 *streamLength, void *clientData)
|
|
+#else
|
|
+::FLAC__StreamDecoderLengthStatus FlacInputStream::callWrapLength(const ::FLAC__StreamDecoder *decoder, FLAC__uint64 *streamLength, void *clientData)
|
|
+#endif
|
|
+{
|
|
assert(0 != clientData);
|
|
FlacInputStream *instance = reinterpret_cast<FlacInputStream *>(clientData);
|
|
assert(0 != instance);
|
|
return instance->callbackLength(streamLength);
|
|
}
|
|
|
|
-FLAC__bool FlacInputStream::callWrapEOF(const ::FLAC__SeekableStreamDecoder *decoder, void *clientData) {
|
|
+#ifdef LEGACY_FLAC
|
|
+FLAC__bool FlacInputStream::callWrapEOF(const ::FLAC__SeekableStreamDecoder *decoder, void *clientData)
|
|
+#else
|
|
+FLAC__bool FlacInputStream::callWrapEOF(const ::FLAC__StreamDecoder *decoder, void *clientData)
|
|
+#endif
|
|
+{
|
|
assert(0 != clientData);
|
|
FlacInputStream *instance = reinterpret_cast<FlacInputStream *>(clientData);
|
|
assert(0 != instance);
|
|
return instance->callbackEOF();
|
|
}
|
|
|
|
-::FLAC__StreamDecoderWriteStatus FlacInputStream::callWrapWrite(const ::FLAC__SeekableStreamDecoder *decoder, const ::FLAC__Frame *frame, const FLAC__int32 * const buffer[], void *clientData) {
|
|
+#ifdef LEGACY_FLAC
|
|
+::FLAC__StreamDecoderWriteStatus FlacInputStream::callWrapWrite(const ::FLAC__SeekableStreamDecoder *decoder, const ::FLAC__Frame *frame, const FLAC__int32 * const buffer[], void *clientData)
|
|
+#else
|
|
+::FLAC__StreamDecoderWriteStatus FlacInputStream::callWrapWrite(const ::FLAC__StreamDecoder *decoder, const ::FLAC__Frame *frame, const FLAC__int32 * const buffer[], void *clientData)
|
|
+#endif
|
|
+{
|
|
assert(0 != clientData);
|
|
FlacInputStream *instance = reinterpret_cast<FlacInputStream *>(clientData);
|
|
assert(0 != instance);
|
|
return instance->callbackWrite(frame, buffer);
|
|
}
|
|
|
|
-void FlacInputStream::callWrapMetadata(const ::FLAC__SeekableStreamDecoder *decoder, const ::FLAC__StreamMetadata *metadata, void *clientData) {
|
|
+#ifdef LEGACY_FLAC
|
|
+void FlacInputStream::callWrapMetadata(const ::FLAC__SeekableStreamDecoder *decoder, const ::FLAC__StreamMetadata *metadata, void *clientData)
|
|
+#else
|
|
+void FlacInputStream::callWrapMetadata(const ::FLAC__StreamDecoder *decoder, const ::FLAC__StreamMetadata *metadata, void *clientData)
|
|
+#endif
|
|
+{
|
|
assert(0 != clientData);
|
|
FlacInputStream *instance = reinterpret_cast<FlacInputStream *>(clientData);
|
|
assert(0 != instance);
|
|
instance->callbackMetadata(metadata);
|
|
}
|
|
|
|
-void FlacInputStream::callWrapError(const ::FLAC__SeekableStreamDecoder *decoder, ::FLAC__StreamDecoderErrorStatus status, void *clientData) {
|
|
+#ifdef LEGACY_FLAC
|
|
+void FlacInputStream::callWrapError(const ::FLAC__SeekableStreamDecoder *decoder, ::FLAC__StreamDecoderErrorStatus status, void *clientData)
|
|
+#else
|
|
+void FlacInputStream::callWrapError(const ::FLAC__StreamDecoder *decoder, ::FLAC__StreamDecoderErrorStatus status, void *clientData)
|
|
+#endif
|
|
+{
|
|
assert(0 != clientData);
|
|
FlacInputStream *instance = reinterpret_cast<FlacInputStream *>(clientData);
|
|
assert(0 != instance);
|