AUDIO: Import the wave decoder from ScummVM.

This is needed for audio support in Myst 3.
2025-01-31 16:03:24 +00:00 · 2012-01-20 18:03:21 +01:00 · 2012-01-20 18:03:21 +01:00 · 377889ef0b
commit 377889ef0b
parent 315b0275c5
6 changed files with 1044 additions and 0 deletions
--- a/audio/decoders/adpcm.cpp
+++ b/audio/decoders/adpcm.cpp
@ -0,0 +1,447 @@
+/* ScummVM - Graphic Adventure Engine
+ *
+ * ScummVM is the legal property of its developers, whose names
+ * are too numerous to list here. Please refer to the COPYRIGHT
+ * file distributed with this source distribution.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ *
+ */
+
+#include "common/stream.h"
+#include "common/textconsole.h"
+#include "common/util.h"
+
+#include "audio/decoders/adpcm.h"
+#include "audio/decoders/adpcm_intern.h"
+
+
+namespace Audio {
+
+// Routines to convert 12 bit linear samples to the
+// Dialogic or Oki ADPCM coding format aka VOX.
+// See also <http://www.comptek.ru/telephony/tnotes/tt1-13.html>
+//
+// IMA ADPCM support is based on
+//   <http://wiki.multimedia.cx/index.php?title=IMA_ADPCM>
+//
+// In addition, also MS IMA ADPCM is supported. See
+//   <http://wiki.multimedia.cx/index.php?title=Microsoft_IMA_ADPCM>.
+
+ADPCMStream::ADPCMStream(Common::SeekableReadStream *stream, DisposeAfterUse::Flag disposeAfterUse, uint32 size, int rate, int channels, uint32 blockAlign)
+	: _stream(stream, disposeAfterUse),
+		_startpos(stream->pos()),
+		_endpos(_startpos + size),
+		_channels(channels),
+		_blockAlign(blockAlign),
+		_rate(rate) {
+
+	reset();
+}
+
+void ADPCMStream::reset() {
+	memset(&_status, 0, sizeof(_status));
+	_blockPos[0] = _blockPos[1] = _blockAlign; // To make sure first header is read
+}
+
+bool ADPCMStream::rewind() {
+	// TODO: Error checking.
+	reset();
+	_stream->seek(_startpos);
+	return true;
+}
+
+
+#pragma mark -
+
+
+int Oki_ADPCMStream::readBuffer(int16 *buffer, const int numSamples) {
+	int samples;
+	byte data;
+
+	assert(numSamples % 2 == 0);
+
+	for (samples = 0; samples < numSamples && !_stream->eos() && _stream->pos() < _endpos; samples += 2) {
+		data = _stream->readByte();
+		buffer[samples] = decodeOKI((data >> 4) & 0x0f);
+		buffer[samples + 1] = decodeOKI(data & 0x0f);
+	}
+	return samples;
+}
+
+static const int16 okiStepSize[49] = {
+	   16,   17,   19,   21,   23,   25,   28,   31,
+	   34,   37,   41,   45,   50,   55,   60,   66,
+	   73,   80,   88,   97,  107,  118,  130,  143,
+	  157,  173,  190,  209,  230,  253,  279,  307,
+	  337,  371,  408,  449,  494,  544,  598,  658,
+	  724,  796,  876,  963, 1060, 1166, 1282, 1411,
+	 1552
+};
+
+// Decode Linear to ADPCM
+int16 Oki_ADPCMStream::decodeOKI(byte code) {
+	int16 diff, E, samp;
+
+	E = (2 * (code & 0x7) + 1) * okiStepSize[_status.ima_ch[0].stepIndex] / 8;
+	diff = (code & 0x08) ? -E : E;
+	samp = _status.ima_ch[0].last + diff;
+	// Clip the values to +/- 2^11 (supposed to be 12 bits)
+	samp = CLIP<int16>(samp, -2048, 2047);
+
+	_status.ima_ch[0].last = samp;
+	_status.ima_ch[0].stepIndex += _stepAdjustTable[code];
+	_status.ima_ch[0].stepIndex = CLIP<int32>(_status.ima_ch[0].stepIndex, 0, ARRAYSIZE(okiStepSize) - 1);
+
+	// * 16 effectively converts 12-bit input to 16-bit output
+	return samp * 16;
+}
+
+
+#pragma mark -
+
+
+int DVI_ADPCMStream::readBuffer(int16 *buffer, const int numSamples) {
+	int samples;
+	byte data;
+
+	assert(numSamples % 2 == 0);
+
+	for (samples = 0; samples < numSamples && !_stream->eos() && _stream->pos() < _endpos; samples += 2) {
+		data = _stream->readByte();
+		buffer[samples] = decodeIMA((data >> 4) & 0x0f);
+		buffer[samples + 1] = decodeIMA(data & 0x0f, _channels == 2 ? 1 : 0);
+	}
+	return samples;
+}
+
+#pragma mark -
+
+
+int Apple_ADPCMStream::readBuffer(int16 *buffer, const int numSamples) {
+	// Need to write at least one samples per channel
+	assert((numSamples % _channels) == 0);
+
+	// Current sample positions
+	int samples[2] = { 0, 0};
+
+	// Number of samples per channel
+	int chanSamples = numSamples / _channels;
+
+	for (int i = 0; i < _channels; i++) {
+		_stream->seek(_streamPos[i]);
+
+		while ((samples[i] < chanSamples) &&
+		       // Last byte read and a new one needed
+		       !((_stream->eos() || (_stream->pos() >= _endpos)) && (_chunkPos[i] == 0))) {
+
+			if (_blockPos[i] == _blockAlign) {
+				// 2 byte header per block
+				uint16 temp = _stream->readUint16BE();
+
+				// First 9 bits are the upper bits of the predictor
+				_status.ima_ch[i].last      = (int16) (temp & 0xFF80);
+				// Lower 7 bits are the step index
+				_status.ima_ch[i].stepIndex =          temp & 0x007F;
+
+				// Clip the step index
+				_status.ima_ch[i].stepIndex = CLIP<int32>(_status.ima_ch[i].stepIndex, 0, 88);
+
+				_blockPos[i] = 2;
+			}
+
+			if (_chunkPos[i] == 0) {
+				// Decode data
+				byte data = _stream->readByte();
+				_buffer[i][0] = decodeIMA(data &  0x0F, i);
+				_buffer[i][1] = decodeIMA(data >>    4, i);
+			}
+
+			// The original is interleaved block-wise, we want it sample-wise
+			buffer[_channels * samples[i] + i] = _buffer[i][_chunkPos[i]];
+
+			if (++_chunkPos[i] > 1) {
+				// We're about to decode the next byte, so advance the block position
+				_chunkPos[i] = 0;
+				_blockPos[i]++;
+			}
+
+			samples[i]++;
+
+			if (_channels == 2)
+				if (_blockPos[i] == _blockAlign)
+					// We're at the end of the block.
+					// Since the channels are interleaved, skip the next block
+					_stream->skip(MIN<uint32>(_blockAlign, _endpos - _stream->pos()));
+
+			_streamPos[i] = _stream->pos();
+		}
+	}
+
+	return samples[0] + samples[1];
+}
+
+
+#pragma mark -
+
+
+int MSIma_ADPCMStream::readBuffer(int16 *buffer, const int numSamples) {
+	// Need to write at least one sample per channel
+	assert((numSamples % _channels) == 0);
+
+	int samples = 0;
+
+	while (samples < numSamples && !_stream->eos() && _stream->pos() < _endpos) {
+		if (_blockPos[0] == _blockAlign) {
+			for (int i = 0; i < _channels; i++) {
+				// read block header
+				_status.ima_ch[i].last = _stream->readSint16LE();
+				_status.ima_ch[i].stepIndex = _stream->readSint16LE();
+			}
+
+			_blockPos[0] = _channels * 4;
+		}
+
+		// Decode a set of samples
+		for (int i = 0; i < _channels; i++) {
+			// The stream encodes four bytes per channel at a time
+			for (int j = 0; j < 4; j++) {
+				byte data = _stream->readByte();
+				_blockPos[0]++;
+				_buffer[i][j * 2] = decodeIMA(data & 0x0f, i);
+				_buffer[i][j * 2 + 1] = decodeIMA((data >> 4) & 0x0f, i);
+				_samplesLeft[i] += 2;
+			}
+		}
+
+		while (samples < numSamples && _samplesLeft[0] != 0) {
+			for (int i = 0; i < _channels; i++) {
+				buffer[samples + i] = _buffer[i][8 - _samplesLeft[i]];
+				_samplesLeft[i]--;
+			}
+
+			samples += _channels;
+		}
+	}
+
+	return samples;
+}
+
+
+#pragma mark -
+
+
+static const int MSADPCMAdaptCoeff1[] = {
+	256, 512, 0, 192, 240, 460, 392
+};
+
+static const int MSADPCMAdaptCoeff2[] = {
+	0, -256, 0, 64, 0, -208, -232
+};
+
+static const int MSADPCMAdaptationTable[] = {
+	230, 230, 230, 230, 307, 409, 512, 614,
+	768, 614, 512, 409, 307, 230, 230, 230
+};
+
+
+int16 MS_ADPCMStream::decodeMS(ADPCMChannelStatus *c, byte code) {
+	int32 predictor;
+
+	predictor = (((c->sample1) * (c->coeff1)) + ((c->sample2) * (c->coeff2))) / 256;
+	predictor += (signed)((code & 0x08) ? (code - 0x10) : (code)) * c->delta;
+
+	predictor = CLIP<int32>(predictor, -32768, 32767);
+
+	c->sample2 = c->sample1;
+	c->sample1 = predictor;
+	c->delta = (MSADPCMAdaptationTable[(int)code] * c->delta) >> 8;
+
+	if (c->delta < 16)
+		c->delta = 16;
+
+	return (int16)predictor;
+}
+
+int MS_ADPCMStream::readBuffer(int16 *buffer, const int numSamples) {
+	int samples;
+	byte data;
+	int i = 0;
+
+	samples = 0;
+
+	while (samples < numSamples && !_stream->eos() && _stream->pos() < _endpos) {
+		if (_blockPos[0] == _blockAlign) {
+			// read block header
+			for (i = 0; i < _channels; i++) {
+				_status.ch[i].predictor = CLIP(_stream->readByte(), (byte)0, (byte)6);
+				_status.ch[i].coeff1 = MSADPCMAdaptCoeff1[_status.ch[i].predictor];
+				_status.ch[i].coeff2 = MSADPCMAdaptCoeff2[_status.ch[i].predictor];
+			}
+
+			for (i = 0; i < _channels; i++)
+				_status.ch[i].delta = _stream->readSint16LE();
+
+			for (i = 0; i < _channels; i++)
+				_status.ch[i].sample1 = _stream->readSint16LE();
+
+			for (i = 0; i < _channels; i++)
+				buffer[samples++] = _status.ch[i].sample2 = _stream->readSint16LE();
+
+			for (i = 0; i < _channels; i++)
+				buffer[samples++] = _status.ch[i].sample1;
+
+			_blockPos[0] = _channels * 7;
+		}
+
+		for (; samples < numSamples && _blockPos[0] < _blockAlign && !_stream->eos() && _stream->pos() < _endpos; samples += 2) {
+			data = _stream->readByte();
+			_blockPos[0]++;
+			buffer[samples] = decodeMS(&_status.ch[0], (data >> 4) & 0x0f);
+			buffer[samples + 1] = decodeMS(&_status.ch[_channels - 1], data & 0x0f);
+		}
+	}
+
+	return samples;
+}
+
+
+#pragma mark -
+
+
+#define DK3_READ_NIBBLE() \
+do { \
+	if (_topNibble) { \
+		_nibble = _lastByte >> 4; \
+		_topNibble = false; \
+	} else { \
+		if (_stream->pos() >= _endpos) \
+			break; \
+		if ((_stream->pos() % _blockAlign) == 0) \
+			continue; \
+		_lastByte = _stream->readByte(); \
+		_nibble = _lastByte & 0xf; \
+		_topNibble = true; \
+	} \
+} while (0)
+
+
+int DK3_ADPCMStream::readBuffer(int16 *buffer, const int numSamples) {
+	int samples = 0;
+
+	assert((numSamples % 4) == 0);
+
+	while (samples < numSamples && !_stream->eos() && _stream->pos() < _endpos) {
+		if ((_stream->pos() % _blockAlign) == 0) {
+			_stream->readUint16LE(); // Unknown
+			uint16 rate = _stream->readUint16LE(); // Copy of rate
+			_stream->skip(6); // Unknown
+			// Get predictor for both sum/diff channels
+			_status.ima_ch[0].last = _stream->readSint16LE();
+			_status.ima_ch[1].last = _stream->readSint16LE();
+			// Get index for both sum/diff channels
+			_status.ima_ch[0].stepIndex = _stream->readByte();
+			_status.ima_ch[1].stepIndex = _stream->readByte();
+
+			if (_stream->eos())
+				break;
+
+			// Sanity check
+			assert(rate == getRate());
+		}
+
+		DK3_READ_NIBBLE();
+		decodeIMA(_nibble, 0);
+
+		DK3_READ_NIBBLE();
+		decodeIMA(_nibble, 1);
+
+		buffer[samples++] = _status.ima_ch[0].last + _status.ima_ch[1].last;
+		buffer[samples++] = _status.ima_ch[0].last - _status.ima_ch[1].last;
+
+		DK3_READ_NIBBLE();
+		decodeIMA(_nibble, 0);
+
+		buffer[samples++] = _status.ima_ch[0].last + _status.ima_ch[1].last;
+		buffer[samples++] = _status.ima_ch[0].last - _status.ima_ch[1].last;
+	}
+
+	return samples;
+}
+
+
+#pragma mark -
+
+
+// This table is used to adjust the step for use on the next sample.
+// We could half the table, but since the lookup index used is always
+// a 4-bit nibble, it's more efficient to just keep it as it is.
+const int16 ADPCMStream::_stepAdjustTable[16] = {
+	-1, -1, -1, -1, 2, 4, 6, 8,
+	-1, -1, -1, -1, 2, 4, 6, 8
+};
+
+const int16 Ima_ADPCMStream::_imaTable[89] = {
+		7,    8,    9,   10,   11,   12,   13,   14,
+	   16,   17,   19,   21,   23,   25,   28,   31,
+	   34,   37,   41,   45,   50,   55,   60,   66,
+	   73,   80,   88,   97,  107,  118,  130,  143,
+	  157,  173,  190,  209,  230,  253,  279,  307,
+	  337,  371,  408,  449,  494,  544,  598,  658,
+	  724,  796,  876,  963, 1060, 1166, 1282, 1411,
+	 1552, 1707, 1878, 2066, 2272, 2499, 2749, 3024,
+	 3327, 3660, 4026, 4428, 4871, 5358, 5894, 6484,
+	 7132, 7845, 8630, 9493,10442,11487,12635,13899,
+	15289,16818,18500,20350,22385,24623,27086,29794,
+	32767
+};
+
+int16 Ima_ADPCMStream::decodeIMA(byte code, int channel) {
+	int32 E = (2 * (code & 0x7) + 1) * _imaTable[_status.ima_ch[channel].stepIndex] / 8;
+	int32 diff = (code & 0x08) ? -E : E;
+	int32 samp = CLIP<int32>(_status.ima_ch[channel].last + diff, -32768, 32767);
+
+	_status.ima_ch[channel].last = samp;
+	_status.ima_ch[channel].stepIndex += _stepAdjustTable[code];
+	_status.ima_ch[channel].stepIndex = CLIP<int32>(_status.ima_ch[channel].stepIndex, 0, ARRAYSIZE(_imaTable) - 1);
+
+	return samp;
+}
+
+RewindableAudioStream *makeADPCMStream(Common::SeekableReadStream *stream, DisposeAfterUse::Flag disposeAfterUse, uint32 size, typesADPCM type, int rate, int channels, uint32 blockAlign) {
+	// If size is 0, report the entire size of the stream
+	if (!size)
+		size = stream->size();
+
+	switch (type) {
+	case kADPCMOki:
+		return new Oki_ADPCMStream(stream, disposeAfterUse, size, rate, channels, blockAlign);
+	case kADPCMMSIma:
+		return new MSIma_ADPCMStream(stream, disposeAfterUse, size, rate, channels, blockAlign);
+	case kADPCMMS:
+		return new MS_ADPCMStream(stream, disposeAfterUse, size, rate, channels, blockAlign);
+	case kADPCMDVI:
+		return new DVI_ADPCMStream(stream, disposeAfterUse, size, rate, channels, blockAlign);
+	case kADPCMApple:
+		return new Apple_ADPCMStream(stream, disposeAfterUse, size, rate, channels, blockAlign);
+	case kADPCMDK3:
+		return new DK3_ADPCMStream(stream, disposeAfterUse, size, rate, channels, blockAlign);
+	default:
+		error("Unsupported ADPCM encoding");
+		break;
+	}
+}
+
+} // End of namespace Audio
--- a/audio/decoders/adpcm.h
+++ b/audio/decoders/adpcm.h
@ -0,0 +1,86 @@
+/* ScummVM - Graphic Adventure Engine
+ *
+ * ScummVM is the legal property of its developers, whose names
+ * are too numerous to list here. Please refer to the COPYRIGHT
+ * file distributed with this source distribution.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ *
+ */
+
+/**
+ * @file
+ * Sound decoder used in engines:
+ *  - agos
+ *  - lastexpress
+ *  - mohawk
+ *  - saga
+ *  - scumm
+ *  - tinsel
+ */
+
+#ifndef AUDIO_ADPCM_H
+#define AUDIO_ADPCM_H
+
+#include "common/scummsys.h"
+#include "common/types.h"
+
+namespace Common {
+class SeekableReadStream;
+}
+
+
+namespace Audio {
+
+class RewindableAudioStream;
+
+// There are several types of ADPCM encoding, only some are supported here
+// For all the different encodings, refer to:
+// http://wiki.multimedia.cx/index.php?title=Category:ADPCM_Audio_Codecs
+// Usually, if the audio stream we're trying to play has the FourCC header
+// string intact, it's easy to discern which encoding is used
+enum typesADPCM {
+	kADPCMOki,                 // Dialogic/Oki ADPCM (aka VOX)
+	kADPCMMSIma,               // Microsoft IMA ADPCM
+	kADPCMMS,                  // Microsoft ADPCM
+	kADPCMDVI,                 // Intel DVI IMA ADPCM
+	kADPCMApple,               // Apple QuickTime IMA ADPCM
+	kADPCMDK3                  // Duck DK3 IMA ADPCM
+};
+
+/**
+ * Takes an input stream containing ADPCM compressed sound data and creates
+ * an RewindableAudioStream from that.
+ *
+ * @param stream            the SeekableReadStream from which to read the ADPCM data
+ * @param disposeAfterUse   whether to delete the stream after use
+ * @param size              how many bytes to read from the stream (0 = all)
+ * @param type              the compression type used
+ * @param rate              the sampling rate
+ * @param channels          the number of channels
+ * @param blockAlign        block alignment ???
+ * @return   a new RewindableAudioStream, or NULL, if an error occurred
+ */
+RewindableAudioStream *makeADPCMStream(
+    Common::SeekableReadStream *stream,
+    DisposeAfterUse::Flag disposeAfterUse,
+    uint32 size, typesADPCM type,
+    int rate = 22050,
+    int channels = 2,
+    uint32 blockAlign = 0);
+
+} // End of namespace Audio
+
+#endif
--- a/audio/decoders/adpcm_intern.h
+++ b/audio/decoders/adpcm_intern.h
@ -0,0 +1,236 @@
+/* ScummVM - Graphic Adventure Engine
+ *
+ * ScummVM is the legal property of its developers, whose names
+ * are too numerous to list here. Please refer to the COPYRIGHT
+ * file distributed with this source distribution.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ *
+ */
+
+/**
+ * Internal interfaces to the ADPCM decoders.
+ *
+ * These can be used to make custom ADPCM decoder subclasses,
+ * or to at least share some common data tables between various
+ * ADPCM decoder implementations.
+ */
+
+#ifndef AUDIO_ADPCM_INTERN_H
+#define AUDIO_ADPCM_INTERN_H
+
+#include "audio/audiostream.h"
+#include "common/endian.h"
+#include "common/ptr.h"
+#include "common/stream.h"
+#include "common/textconsole.h"
+
+
+namespace Audio {
+
+class ADPCMStream : public RewindableAudioStream {
+protected:
+	Common::DisposablePtr<Common::SeekableReadStream> _stream;
+	int32 _startpos;
+	const int32 _endpos;
+	const int _channels;
+	const uint32 _blockAlign;
+	uint32 _blockPos[2];
+	const int _rate;
+
+	struct ADPCMStatus {
+		// OKI/IMA
+		struct {
+			int32 last;
+			int32 stepIndex;
+		} ima_ch[2];
+	} _status;
+
+	virtual void reset();
+
+public:
+	ADPCMStream(Common::SeekableReadStream *stream, DisposeAfterUse::Flag disposeAfterUse, uint32 size, int rate, int channels, uint32 blockAlign);
+
+	virtual bool endOfData() const { return (_stream->eos() || _stream->pos() >= _endpos); }
+	virtual bool isStereo() const	{ return _channels == 2; }
+	virtual int getRate() const	{ return _rate; }
+
+	virtual bool rewind();
+
+
+	/**
+	 * This table is used by some ADPCM variants (IMA and OKI) to adjust the
+	 * step for use on the next sample.
+	 * The first 8 entries are identical to the second 8 entries. Hence, we
+	 * could half the table in size. But since the lookup index is always a
+	 * 4-bit nibble, it is more efficient to just keep it as it is.
+	 */
+	static const int16 _stepAdjustTable[16];
+};
+
+class Oki_ADPCMStream : public ADPCMStream {
+public:
+	Oki_ADPCMStream(Common::SeekableReadStream *stream, DisposeAfterUse::Flag disposeAfterUse, uint32 size, int rate, int channels, uint32 blockAlign)
+		: ADPCMStream(stream, disposeAfterUse, size, rate, channels, blockAlign) {}
+
+	virtual int readBuffer(int16 *buffer, const int numSamples);
+
+protected:
+	int16 decodeOKI(byte);
+};
+
+class Ima_ADPCMStream : public ADPCMStream {
+protected:
+	int16 decodeIMA(byte code, int channel = 0); // Default to using the left channel/using one channel
+
+public:
+	Ima_ADPCMStream(Common::SeekableReadStream *stream, DisposeAfterUse::Flag disposeAfterUse, uint32 size, int rate, int channels, uint32 blockAlign)
+		: ADPCMStream(stream, disposeAfterUse, size, rate, channels, blockAlign) {}
+
+	/**
+	 * This table is used by decodeIMA.
+	 */
+	static const int16 _imaTable[89];
+};
+
+class DVI_ADPCMStream : public Ima_ADPCMStream {
+public:
+	DVI_ADPCMStream(Common::SeekableReadStream *stream, DisposeAfterUse::Flag disposeAfterUse, uint32 size, int rate, int channels, uint32 blockAlign)
+		: Ima_ADPCMStream(stream, disposeAfterUse, size, rate, channels, blockAlign) {}
+
+	virtual int readBuffer(int16 *buffer, const int numSamples);
+};
+
+class Apple_ADPCMStream : public Ima_ADPCMStream {
+protected:
+	// Apple QuickTime IMA ADPCM
+	int32 _streamPos[2];
+	int16 _buffer[2][2];
+	uint8 _chunkPos[2];
+
+	void reset() {
+		Ima_ADPCMStream::reset();
+		_chunkPos[0] = 0;
+		_chunkPos[1] = 0;
+		_streamPos[0] = 0;
+		_streamPos[1] = _blockAlign;
+	}
+
+public:
+	Apple_ADPCMStream(Common::SeekableReadStream *stream, DisposeAfterUse::Flag disposeAfterUse, uint32 size, int rate, int channels, uint32 blockAlign)
+		: Ima_ADPCMStream(stream, disposeAfterUse, size, rate, channels, blockAlign) {
+		_chunkPos[0] = 0;
+		_chunkPos[1] = 0;
+		_streamPos[0] = 0;
+		_streamPos[1] = _blockAlign;
+	}
+
+	virtual int readBuffer(int16 *buffer, const int numSamples);
+
+};
+
+class MSIma_ADPCMStream : public Ima_ADPCMStream {
+public:
+	MSIma_ADPCMStream(Common::SeekableReadStream *stream, DisposeAfterUse::Flag disposeAfterUse, uint32 size, int rate, int channels, uint32 blockAlign)
+		: Ima_ADPCMStream(stream, disposeAfterUse, size, rate, channels, blockAlign) {
+
+		if (blockAlign == 0)
+			error("MSIma_ADPCMStream(): blockAlign isn't specified");
+
+		if (blockAlign % (_channels * 4))
+			error("MSIma_ADPCMStream(): invalid blockAlign");
+
+		_samplesLeft[0] = 0;
+		_samplesLeft[1] = 0;
+	}
+
+	virtual int readBuffer(int16 *buffer, const int numSamples);
+
+	void reset() {
+		Ima_ADPCMStream::reset();
+		_samplesLeft[0] = 0;
+		_samplesLeft[1] = 0;
+	}
+
+private:
+	int16 _buffer[2][8];
+	int _samplesLeft[2];
+};
+
+class MS_ADPCMStream : public ADPCMStream {
+protected:
+	struct ADPCMChannelStatus {
+		byte predictor;
+		int16 delta;
+		int16 coeff1;
+		int16 coeff2;
+		int16 sample1;
+		int16 sample2;
+	};
+
+	struct {
+		// MS ADPCM
+		ADPCMChannelStatus ch[2];
+	} _status;
+
+	void reset() {
+		ADPCMStream::reset();
+		memset(&_status, 0, sizeof(_status));
+	}
+
+public:
+	MS_ADPCMStream(Common::SeekableReadStream *stream, DisposeAfterUse::Flag disposeAfterUse, uint32 size, int rate, int channels, uint32 blockAlign)
+		: ADPCMStream(stream, disposeAfterUse, size, rate, channels, blockAlign) {
+		if (blockAlign == 0)
+			error("MS_ADPCMStream(): blockAlign isn't specified for MS ADPCM");
+		memset(&_status, 0, sizeof(_status));
+	}
+
+	virtual int readBuffer(int16 *buffer, const int numSamples);
+
+protected:
+	int16 decodeMS(ADPCMChannelStatus *c, byte);
+};
+
+// Duck DK3 IMA ADPCM Decoder
+// Based on FFmpeg's decoder and http://wiki.multimedia.cx/index.php?title=Duck_DK3_IMA_ADPCM
+
+class DK3_ADPCMStream : public Ima_ADPCMStream {
+protected:
+
+	void reset() {
+		Ima_ADPCMStream::reset();
+		_topNibble = false;
+	}
+
+public:
+	DK3_ADPCMStream(Common::SeekableReadStream *stream, DisposeAfterUse::Flag disposeAfterUse, uint32 size, int rate, int channels, uint32 blockAlign)
+		: Ima_ADPCMStream(stream, disposeAfterUse, size, rate, channels, blockAlign) {
+
+		// DK3 only works as a stereo stream
+		assert(channels == 2);
+		_topNibble = false;
+	}
+
+	virtual int readBuffer(int16 *buffer, const int numSamples);
+
+private:
+	byte _nibble, _lastByte;
+	bool _topNibble;
+};
+
+} // End of namespace Audio
+
+#endif
--- a/audio/decoders/wave.cpp
+++ b/audio/decoders/wave.cpp
@ -0,0 +1,190 @@
+/* ScummVM - Graphic Adventure Engine
+ *
+ * ScummVM is the legal property of its developers, whose names
+ * are too numerous to list here. Please refer to the COPYRIGHT
+ * file distributed with this source distribution.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ *
+ */
+
+#include "common/debug.h"
+#include "common/textconsole.h"
+#include "common/stream.h"
+
+#include "audio/audiostream.h"
+#include "audio/decoders/wave.h"
+#include "audio/decoders/adpcm.h"
+#include "audio/decoders/raw.h"
+
+namespace Audio {
+
+bool loadWAVFromStream(Common::SeekableReadStream &stream, int &size, int &rate, byte &flags, uint16 *wavType, int *blockAlign_) {
+	const int32 initialPos = stream.pos();
+	byte buf[4+1];
+
+	buf[4] = 0;
+
+	stream.read(buf, 4);
+	if (memcmp(buf, "RIFF", 4) != 0) {
+		warning("getWavInfo: No 'RIFF' header");
+		return false;
+	}
+
+	int32 wavLength = stream.readUint32LE();
+
+	stream.read(buf, 4);
+	if (memcmp(buf, "WAVE", 4) != 0) {
+		warning("getWavInfo: No 'WAVE' header");
+		return false;
+	}
+
+	stream.read(buf, 4);
+	if (memcmp(buf, "fmt ", 4) != 0) {
+		warning("getWavInfo: No 'fmt' header");
+		return false;
+	}
+
+	uint32 fmtLength = stream.readUint32LE();
+	if (fmtLength < 16) {
+		// A valid fmt chunk always contains at least 16 bytes
+		warning("getWavInfo: 'fmt' header is too short");
+		return false;
+	}
+
+	// Next comes the "type" field of the fmt header. Some typical
+	// values for it:
+	// 1  -> uncompressed PCM
+	// 17 -> IMA ADPCM compressed WAVE
+	// See <http://www.saettler.com/RIFFNEW/RIFFNEW.htm> for a more complete
+	// list of common WAVE compression formats...
+	uint16 type = stream.readUint16LE();	// == 1 for PCM data
+	uint16 numChannels = stream.readUint16LE();	// 1 for mono, 2 for stereo
+	uint32 samplesPerSec = stream.readUint32LE();	// in Hz
+	uint32 avgBytesPerSec = stream.readUint32LE();	// == SampleRate * NumChannels * BitsPerSample/8
+
+	uint16 blockAlign = stream.readUint16LE();	// == NumChannels * BitsPerSample/8
+	uint16 bitsPerSample = stream.readUint16LE();	// 8, 16 ...
+	// 8 bit data is unsigned, 16 bit data signed
+
+
+	if (wavType != 0)
+		*wavType = type;
+
+	if (blockAlign_ != 0)
+		*blockAlign_ = blockAlign;
+#if 0
+	debug("WAVE information:");
+	debug("  total size: %d", wavLength);
+	debug("  fmt size: %d", fmtLength);
+	debug("  type: %d", type);
+	debug("  numChannels: %d", numChannels);
+	debug("  samplesPerSec: %d", samplesPerSec);
+	debug("  avgBytesPerSec: %d", avgBytesPerSec);
+	debug("  blockAlign: %d", blockAlign);
+	debug("  bitsPerSample: %d", bitsPerSample);
+#endif
+
+	if (type != 1 && type != 2 && type != 17) {
+		warning("getWavInfo: only PCM, MS ADPCM or IMA ADPCM data is supported (type %d)", type);
+		return false;
+	}
+
+	if (blockAlign != numChannels * bitsPerSample / 8 && type != 2) {
+		debug(0, "getWavInfo: blockAlign is invalid");
+	}
+
+	if (avgBytesPerSec != samplesPerSec * blockAlign && type != 2) {
+		debug(0, "getWavInfo: avgBytesPerSec is invalid");
+	}
+
+	// Prepare the return values.
+	rate = samplesPerSec;
+
+	flags = 0;
+	if (bitsPerSample == 8)		// 8 bit data is unsigned
+		flags |= Audio::FLAG_UNSIGNED;
+	else if (bitsPerSample == 16)	// 16 bit data is signed little endian
+		flags |= (Audio::FLAG_16BITS | Audio::FLAG_LITTLE_ENDIAN);
+	else if (bitsPerSample == 4 && (type == 2 || type == 17))
+		flags |= Audio::FLAG_16BITS;
+	else {
+		warning("getWavInfo: unsupported bitsPerSample %d", bitsPerSample);
+		return false;
+	}
+
+	if (numChannels == 2)
+		flags |= Audio::FLAG_STEREO;
+	else if (numChannels != 1) {
+		warning("getWavInfo: unsupported number of channels %d", numChannels);
+		return false;
+	}
+
+	// It's almost certainly a WAV file, but we still need to find its
+	// 'data' chunk.
+
+	// Skip over the rest of the fmt chunk.
+	int offset = fmtLength - 16;
+
+	do {
+		stream.seek(offset, SEEK_CUR);
+		if (stream.pos() >= initialPos + wavLength + 8) {
+			warning("getWavInfo: Can't find 'data' chunk");
+			return false;
+		}
+		stream.read(buf, 4);
+		offset = stream.readUint32LE();
+
+#if 0
+		debug("  found a '%s' tag of size %d", buf, offset);
+#endif
+	} while (memcmp(buf, "data", 4) != 0);
+
+	// Stream now points at 'offset' bytes of sample data...
+	size = offset;
+
+	return true;
+}
+
+RewindableAudioStream *makeWAVStream(Common::SeekableReadStream *stream, DisposeAfterUse::Flag disposeAfterUse) {
+	int size, rate;
+	byte flags;
+	uint16 type;
+	int blockAlign;
+
+	if (!loadWAVFromStream(*stream, size, rate, flags, &type, &blockAlign)) {
+		if (disposeAfterUse == DisposeAfterUse::YES)
+			delete stream;
+		return 0;
+	}
+
+	if (type == 17) // MS IMA ADPCM
+		return makeADPCMStream(stream, disposeAfterUse, size, Audio::kADPCMMSIma, rate, (flags & Audio::FLAG_STEREO) ? 2 : 1, blockAlign);
+	else if (type == 2) // MS ADPCM
+		return makeADPCMStream(stream, disposeAfterUse, size, Audio::kADPCMMS, rate, (flags & Audio::FLAG_STEREO) ? 2 : 1, blockAlign);
+
+	// Raw PCM. Just read everything at once.
+	// TODO: More elegant would be to wrap the stream.
+	byte *data = (byte *)malloc(size);
+	assert(data);
+	stream->read(data, size);
+
+	if (disposeAfterUse == DisposeAfterUse::YES)
+		delete stream;
+
+	return makeRawStream(data, size, rate, flags);
+}
+
+} // End of namespace Audio
--- a/audio/decoders/wave.h
+++ b/audio/decoders/wave.h
@ -0,0 +1,83 @@
+/* ScummVM - Graphic Adventure Engine
+ *
+ * ScummVM is the legal property of its developers, whose names
+ * are too numerous to list here. Please refer to the COPYRIGHT
+ * file distributed with this source distribution.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ *
+ */
+
+/**
+ * @file
+ * Sound decoder used in engines:
+ *  - agos
+ *  - gob
+ *  - mohawk
+ *  - saga
+ *  - sci
+ *  - scumm
+ *  - sword1
+ *  - sword2
+ *  - tucker
+ */
+
+#ifndef AUDIO_WAVE_H
+#define AUDIO_WAVE_H
+
+#include "common/scummsys.h"
+#include "common/types.h"
+
+namespace Common {
+class SeekableReadStream;
+}
+
+namespace Audio {
+
+class RewindableAudioStream;
+
+/**
+ * Try to load a WAVE from the given seekable stream. Returns true if
+ * successful. In that case, the stream's seek position will be set to the
+ * start of the audio data, and size, rate and flags contain information
+ * necessary for playback. Currently this function supports uncompressed
+ * raw PCM data, MS IMA ADPCM and MS ADPCM (uses makeADPCMStream internally).
+ */
+extern bool loadWAVFromStream(
+	Common::SeekableReadStream &stream,
+	int &size,
+	int &rate,
+	byte &flags,
+	uint16 *wavType = 0,
+	int *blockAlign = 0);
+
+/**
+ * Try to load a WAVE from the given seekable stream and create an AudioStream
+ * from that data. Currently this function supports uncompressed
+ * raw PCM data, MS IMA ADPCM and MS ADPCM (uses makeADPCMStream internally).
+ *
+ * This function uses loadWAVFromStream() internally.
+ *
+ * @param stream			the SeekableReadStream from which to read the WAVE data
+ * @param disposeAfterUse	whether to delete the stream after use
+ * @return	a new RewindableAudioStream, or NULL, if an error occurred
+ */
+RewindableAudioStream *makeWAVStream(
+	Common::SeekableReadStream *stream,
+	DisposeAfterUse::Flag disposeAfterUse);
+
+} // End of namespace Audio
+
+#endif
--- a/audio/module.mk
+++ b/audio/module.mk
@ -10,10 +10,12 @@ MODULE_OBJS := \
 	musicplugin.o \
 	null.o \
 	timestamp.o \
+	decoders/adpcm.o \
 	decoders/flac.o \
 	decoders/mp3.o \
 	decoders/raw.o \
 	decoders/vorbis.o \
+	decoders/wave.o \
 	decoders/xa.o \
 	softsynth/adlib.o \
 	softsynth/cms.o \