Attachment 1822 Details for Bug 10875 – scummvm-0.9.0+flac-1.1.3.patch

[patch] scummvm-0.9.0+flac-1.1.3.patch

scummvm-0.9.0+flac-1.1.3.patch (text/plain), 19.29 KB, created by led on 2007-02-19 18:55:32 MSK

(hide)

Description:

Filename:

MIME Type:

Creator: led

Created: 2007-02-19 18:55:32 MSK

Size: 19.29 KB

patch

obsolete

>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);

Actions: View | Diff

Attachments on bug 10875: 1822