Added patch from Josh Coalson (from FLAC) and closing bug #157582.

Package-Manager: portage-2.1.2_rc2-r2

4 files changed, 496 insertions, 13 deletions

diff --git a/games-engines/scummvm/ChangeLog b/games-engines/scummvm/ChangeLog
index 5f2219954d60..943c7fc124fa 100644
--- a/games-engines/scummvm/ChangeLog
+++ b/games-engines/scummvm/ChangeLog
@@ -1,6 +1,10 @@
 # ChangeLog for games-engines/scummvm
 # Copyright 1999-2006 Gentoo Foundation; Distributed under the GPL v2
-# $Header: /var/cvsroot/gentoo-x86/games-engines/scummvm/ChangeLog,v 1.41 2006/11/28 19:19:34 nyhm Exp $
+# $Header: /var/cvsroot/gentoo-x86/games-engines/scummvm/ChangeLog,v 1.42 2006/12/12 22:41:29 wolf31o2 Exp $
+
+  12 Dec 2006; Chris Gianelloni <wolf31o2@gentoo.org>
+  +files/flac-1.1.3.patch, scummvm-0.9.1.ebuild:
+  Added patch from Josh Coalson (from FLAC) and closing bug #157582.
 
   28 Nov 2006; Tristan Heaven <nyhm@gentoo.org> scummvm-0.9.1.ebuild:
   List in the AdventureGame menu category, bug #155852
diff --git a/games-engines/scummvm/Manifest b/games-engines/scummvm/Manifest
index 59d31f239fee..65e709b3d73b 100644
--- a/games-engines/scummvm/Manifest
+++ b/games-engines/scummvm/Manifest
@@ -1,15 +1,19 @@
 -----BEGIN PGP SIGNED MESSAGE-----
 Hash: SHA1
 
+AUX flac-1.1.3.patch 19758 RMD160 453ccfacfe7ce9bc9a917ff5a81564fe78b4f213 SHA1 a6b06fbb13c1864ce7d21906e7ff7c0d9e00853a SHA256 b48da44ec6e37bc1a220e3f8dc88805c45aaab7ddc5e5d9d5c02ae90dca4dbc4
+MD5 6df789e547b467ce3ad5c7e2ab05ca48 files/flac-1.1.3.patch 19758
+RMD160 453ccfacfe7ce9bc9a917ff5a81564fe78b4f213 files/flac-1.1.3.patch 19758
+SHA256 b48da44ec6e37bc1a220e3f8dc88805c45aaab7ddc5e5d9d5c02ae90dca4dbc4 files/flac-1.1.3.patch 19758
 DIST scummvm-0.9.1.tar.bz2 4514100 RMD160 c77a7fa4251b6f6ee303dc35049671547dffed7a SHA1 6fcd00903f13fbafab65b432458e097f0e0d5d83 SHA256 5cd5d9c06281a4f81d85d9a9f9b0410045d4a764a855f06f574183b528c15d1a
-EBUILD scummvm-0.9.1.ebuild 2467 RMD160 9e399c693ea19ab44b89fc258a55a7f2e260414a SHA1 fbeb9d158e0d87f27941ba49993c4bc78c06726a SHA256 5a0ee189367870a4fdbc3ddaba66d9527b896ff75a33247d0a1627f5a338908c
-MD5 514d431b9b940b38fa97c99194c2a8db scummvm-0.9.1.ebuild 2467
-RMD160 9e399c693ea19ab44b89fc258a55a7f2e260414a scummvm-0.9.1.ebuild 2467
-SHA256 5a0ee189367870a4fdbc3ddaba66d9527b896ff75a33247d0a1627f5a338908c scummvm-0.9.1.ebuild 2467
-MISC ChangeLog 7798 RMD160 9e6f1ec8f3711041f8e2349297225a025afe0179 SHA1 40e5e48461ce18d7e72b7bd16b891178739ed739 SHA256 e9e61b68b612df084ad2dff407e15656effbf555b732047c6ad5899129b9aa3c
-MD5 42b43d5e05e799ded25c39c7f33b8d71 ChangeLog 7798
-RMD160 9e6f1ec8f3711041f8e2349297225a025afe0179 ChangeLog 7798
-SHA256 e9e61b68b612df084ad2dff407e15656effbf555b732047c6ad5899129b9aa3c ChangeLog 7798
+EBUILD scummvm-0.9.1.ebuild 2510 RMD160 4ca18faa6efc02e33b26d1ecc4bc9b9356a0e009 SHA1 7188feb7aa2c67f30b051b76ff48a8edbcfac6f9 SHA256 34f553de1b0c347b0ef759cb62c72a9f6f4e8d43520be8a11aa61fafefc36fed
+MD5 2e83c3550882e1f8d66788dfd3e52b1f scummvm-0.9.1.ebuild 2510
+RMD160 4ca18faa6efc02e33b26d1ecc4bc9b9356a0e009 scummvm-0.9.1.ebuild 2510
+SHA256 34f553de1b0c347b0ef759cb62c72a9f6f4e8d43520be8a11aa61fafefc36fed scummvm-0.9.1.ebuild 2510
+MISC ChangeLog 7975 RMD160 98921d5575454040cb2fbd304c33c8611d4fed8f SHA1 60157489924d2ebaf8a228e269386a79cfc0b342 SHA256 82c9bee7bbf36d8346e530b45e759e6520d7cb038751a24992ac28b047e1f71a
+MD5 062902dee973a4611b26f3a11d00f365 ChangeLog 7975
+RMD160 98921d5575454040cb2fbd304c33c8611d4fed8f ChangeLog 7975
+SHA256 82c9bee7bbf36d8346e530b45e759e6520d7cb038751a24992ac28b047e1f71a ChangeLog 7975
 MISC metadata.xml 158 RMD160 cbd9984bb6b426c8c9cee5022fe0a26261612fea SHA1 be5251fa1dacef5c41b74761bb1c8c54fb633b9e SHA256 1423a4fdd4a79b1728a2056d9e300f7e1074253095d82726218d9e9b953888a3
 MD5 f17b9b8fa07a38914fe1c03268f51678 metadata.xml 158
 RMD160 cbd9984bb6b426c8c9cee5022fe0a26261612fea metadata.xml 158
@@ -20,7 +24,7 @@ SHA256 2e16d33743687dd58e4cf7760d1e525db223323ac32dab47808221c9f5446e0a files/di
 -----BEGIN PGP SIGNATURE-----
 Version: GnuPG v1.4.5 (GNU/Linux)
 
-iD8DBQFFbIvMdz7hIScOURERAuvlAJ4g06Bzy3to5reuCgI/lQ+9XWQlngCgyr6X
-S7JzRXLM5sPmnLOkCU1Yx9I=
-=4edX
+iD8DBQFFfzAfkT4lNIS36YERAkurAJ0eENKaeD9d6Ye6adexDJ+CY/LNywCZAVPn
+YY7vIzFkn+qLxzn96+HsdoM=
+=Hy20
 -----END PGP SIGNATURE-----
diff --git a/games-engines/scummvm/files/flac-1.1.3.patch b/games-engines/scummvm/files/flac-1.1.3.patch
new file mode 100644
index 000000000000..9c9ca8def367
--- /dev/null
+++ b/games-engines/scummvm/files/flac-1.1.3.patch
@@ -0,0 +1,474 @@
+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);
diff --git a/games-engines/scummvm/scummvm-0.9.1.ebuild b/games-engines/scummvm/scummvm-0.9.1.ebuild
index 2447af6136c5..ae809bf2dd2a 100644
--- a/games-engines/scummvm/scummvm-0.9.1.ebuild
+++ b/games-engines/scummvm/scummvm-0.9.1.ebuild
@@ -1,6 +1,6 @@
 # Copyright 1999-2006 Gentoo Foundation
 # Distributed under the terms of the GNU General Public License v2
-# $Header: /var/cvsroot/gentoo-x86/games-engines/scummvm/scummvm-0.9.1.ebuild,v 1.3 2006/11/28 19:19:34 nyhm Exp $
+# $Header: /var/cvsroot/gentoo-x86/games-engines/scummvm/scummvm-0.9.1.ebuild,v 1.4 2006/12/12 22:41:29 wolf31o2 Exp $
 
 inherit eutils games
 
@@ -29,6 +29,7 @@ DEPEND="${RDEPEND}
 src_unpack() {
 	unpack ${A}
 	cd "${S}"
+	epatch "${FILESDIR}"/flac-1.1.3.patch
 	if use x86 ; then
 		local f
 		for f in graphics/scaler/{hq3x_i386.asm,hq2x_i386.asm}