From a135a7f9385b59b91d5a7f23fd8792ff36afb353 Mon Sep 17 00:00:00 2001 From: Neil Millstone Date: Thu, 13 Aug 2009 21:46:41 +0000 Subject: Allow VOCs to stream from disk. Disabled by default, use symbol STREAM_AUDIO_FROM_DISK to enable. See patch #2834001. svn-id: r43357 --- sound/audiostream.cpp | 196 +++++++++++++++++++++++++++++++++++++++++++++++++- sound/audiostream.h | 20 +++++- sound/voc.cpp | 143 +++++++++++++++++++++++++++++++++++- sound/voc.h | 5 +- 4 files changed, 359 insertions(+), 5 deletions(-) (limited to 'sound') diff --git a/sound/audiostream.cpp b/sound/audiostream.cpp index 61a2e778ab..8ea72851e2 100644 --- a/sound/audiostream.cpp +++ b/sound/audiostream.cpp @@ -173,6 +173,162 @@ int LinearMemoryStream::readBuffer(int16 *buf } + +#pragma mark - +#pragma mark --- LinearDiskStream --- +#pragma mark - + + + +/** + * LinearDiskStream. This can stream linear (PCM) audio from disk. The + * function takes an pointer to an array of LinearDiskStreamAudioBlock which defines the + * start position and length of each block of uncompressed audio in the stream. + */ +template +class LinearDiskStream : public AudioStream { + +// Allow backends to override buffer size +#ifdef CUSTOM_AUDIO_BUFFER_SIZE + static const int32 BUFFER_SIZE = CUSTOM_AUDIO_BUFFER_SIZE; +#else + static const int32 BUFFER_SIZE = 16384; +#endif + +protected: + byte* _buffer; ///< Streaming buffer + const byte *_ptr; ///< Pointer to current position in stream buffer + const int _rate; ///< Sample rate of stream + + int32 _playtime; ///< Calculated total play time + Common::SeekableReadStream *_stream; ///< Stream to read data from + int32 _filePos; ///< Current position in stream + int32 _diskLeft; ///< Samples left in stream in current block not yet read to buffer + int32 _bufferLeft; ///< Samples left in buffer in current block + bool _disposeAfterUse; ///< If true, delete stream object when LinearDiskStream is destructed + + LinearDiskStreamAudioBlock *_audioBlock; ///< Audio block list + int _audioBlockCount; ///< Number of blocks in _audioBlock + int _currentBlock; ///< Current audio block number + + int _beginLoop; ///< Loop parameter, currently not implemented + int _endLoop; ///< Loop parameter, currently not implemented + + +public: + LinearDiskStream(int rate, uint beginLoop, uint endLoop, bool disposeStream, Common::SeekableReadStream *stream, LinearDiskStreamAudioBlock *block, uint numBlocks) + : _rate(rate), _stream(stream), _beginLoop(beginLoop), _endLoop(endLoop), _disposeAfterUse(disposeStream), + _audioBlockCount(numBlocks) { + + // Allocate streaming buffer + if (is16Bit) { + _buffer = (byte *)malloc(BUFFER_SIZE * sizeof(int16)); + } else { + _buffer = (byte *)malloc(BUFFER_SIZE * sizeof(byte)); + } + + _ptr = _buffer; + _bufferLeft = 0; + + // Copy audio block data to our buffer + // TODO: Replace this with a Common::Array or Common::List to + // make it a little friendlier. + _audioBlock = new LinearDiskStreamAudioBlock[numBlocks]; + memcpy(_audioBlock, block, numBlocks * sizeof(LinearDiskStreamAudioBlock)); + + // Set current buffer state, playing first block + _currentBlock = 0; + _filePos = _audioBlock[_currentBlock].pos; + _diskLeft = _audioBlock[_currentBlock].len; + + // Add up length of all blocks in order to caluclate total play time + int len = 0; + for (int r = 0; r < _audioBlockCount; r++) { + len += _audioBlock[r].len; + } + _playtime = calculatePlayTime(rate, len / (is16Bit ? 2 : 1) / (stereo ? 2 : 1)); + } + + + virtual ~LinearDiskStream() { + if (_disposeAfterUse) { + delete _stream; + } + + delete[] _audioBlock; + free(_buffer); + } + int readBuffer(int16 *buffer, const int numSamples); + + bool isStereo() const { return stereo; } + bool endOfData() const { return (_currentBlock == _audioBlockCount - 1) && (_diskLeft == 0) && (_bufferLeft == 0); } + + int getRate() const { return _rate; } + int32 getTotalPlayTime() const { return _playtime; } +}; + +template +int LinearDiskStream::readBuffer(int16 *buffer, const int numSamples) { + int oldPos = _stream->pos(); + bool restoreFilePosition = false; + + int samples = numSamples; + + while (samples > 0 && ((_diskLeft > 0 || _bufferLeft > 0) || (_currentBlock != _audioBlockCount - 1)) ) { + + // Output samples in the buffer to the output + int len = MIN(samples, _bufferLeft); + samples -= len; + _bufferLeft -= len; + + while (len > 0) { + *buffer++ = READ_ENDIAN_SAMPLE(is16Bit, isUnsigned, _ptr, isLE); + _ptr += (is16Bit ? 2 : 1); + len--; + } + + // Have we now finished this block? If so, read the next block + if ((_bufferLeft == 0) && (_diskLeft == 0) && (_currentBlock != _audioBlockCount - 1)) { + // Next block + _currentBlock++; + + _filePos = _audioBlock[_currentBlock].pos; + _diskLeft = _audioBlock[_currentBlock].len; + } + + + // Now read more data from disk if there is more to be read + if ((_bufferLeft == 0) && (_diskLeft > 0)) { + int32 readAmount = MIN(_diskLeft, BUFFER_SIZE); + + _stream->seek(_filePos, SEEK_SET); + _stream->read(_buffer, readAmount * (is16Bit? 2: 1)); + + // Amount of data in buffer is now the amount read in, and + // the amount left to read on disk is decreased by the same amount + _bufferLeft = readAmount; + _diskLeft -= readAmount; + _ptr = (byte *)_buffer; + _filePos += readAmount * (is16Bit? 2: 1); + + // Set this flag now we've used the file, it restores it's + // original position. + restoreFilePosition = true; + } + } + + // In case calling code relies on the position of this stream staying + // constant, I restore the location if I've changed it. This is probably + // not necessary. + if (restoreFilePosition) { + _stream->seek(oldPos, SEEK_SET); + } + + return numSamples-samples; +} + + + #pragma mark - #pragma mark --- Input stream factory --- #pragma mark - @@ -202,6 +358,7 @@ AudioStream *makeLinearInputStream(const byte *ptr, uint32 len, int rate, byte f const bool isLE = (flags & Audio::Mixer::FLAG_LITTLE_ENDIAN) != 0; const bool autoFree = (flags & Audio::Mixer::FLAG_AUTOFREE) != 0; + uint loopOffset = 0, loopLen = 0; if (flags & Audio::Mixer::FLAG_LOOP) { if (loopEnd == 0) @@ -236,6 +393,44 @@ AudioStream *makeLinearInputStream(const byte *ptr, uint32 len, int rate, byte f } + + + +#define MAKE_LINEAR_DISK(STEREO, UNSIGNED) \ + if (is16Bit) { \ + if (isLE) \ + return new LinearDiskStream(rate, loopStart, loopEnd, takeOwnership, &stream, block, numBlocks); \ + else \ + return new LinearDiskStream(rate, loopStart, loopEnd, takeOwnership, &stream, block, numBlocks); \ + } else \ + return new LinearDiskStream(rate, loopStart, loopEnd, takeOwnership, &stream, block, numBlocks) + + +AudioStream *makeLinearDiskStream(Common::SeekableReadStream& stream, LinearDiskStreamAudioBlock* block, int numBlocks, int rate, byte flags, bool takeOwnership, uint loopStart, uint loopEnd) { + const bool isStereo = (flags & Audio::Mixer::FLAG_STEREO) != 0; + const bool is16Bit = (flags & Audio::Mixer::FLAG_16BITS) != 0; + const bool isUnsigned = (flags & Audio::Mixer::FLAG_UNSIGNED) != 0; + const bool isLE = (flags & Audio::Mixer::FLAG_LITTLE_ENDIAN) != 0; + + + if (isStereo) { + if (isUnsigned) { + MAKE_LINEAR_DISK(true, true); + } else { + MAKE_LINEAR_DISK(true, false); + } + } else { + if (isUnsigned) { + MAKE_LINEAR_DISK(false, true); + } else { + MAKE_LINEAR_DISK(false, false); + } + } +} + + + + #pragma mark - #pragma mark --- Appendable audio stream --- #pragma mark - @@ -306,7 +501,6 @@ BaseAppendableMemoryStream::~BaseAppendableMemoryStream() { template int AppendableMemoryStream::readBuffer(int16 *buffer, const int numSamples) { Common::StackLock lock(_mutex); - int samples = numSamples; while (samples > 0 && !eosIntern()) { Buffer buf = *_bufferQueue.begin(); diff --git a/sound/audiostream.h b/sound/audiostream.h index a917957a77..99e140608d 100644 --- a/sound/audiostream.h +++ b/sound/audiostream.h @@ -28,7 +28,7 @@ #include "common/util.h" #include "common/scummsys.h" - +#include "common/stream.h" namespace Audio { @@ -109,6 +109,7 @@ public: virtual int32 getTotalPlayTime() const { return kUnknownPlayTime; } }; + /** * Factory function for a raw linear AudioStream, which will simply treat all data * in the buffer described by ptr and len as raw sample data in the specified @@ -118,6 +119,23 @@ public: */ AudioStream *makeLinearInputStream(const byte *ptr, uint32 len, int rate, byte flags, uint loopStart, uint loopEnd); + +/** Struct used to define the audio data to be played by a LinearDiskStream */ + +struct LinearDiskStreamAudioBlock { + int32 pos; ///< Position in stream of the block + int32 len; ///< Length of the block (in samples) +}; + + +/** Factory function for a Linear Disk Stream. This can stream linear (PCM) audio from disk. The + * function takes an pointer to an array of LinearDiskStreamAudioBlock which defines the + * start position and length of each block of uncompressed audio in the stream. + */ + +AudioStream *makeLinearDiskStream(Common::SeekableReadStream& stream, LinearDiskStreamAudioBlock* block, int + numBlocks, int rate, byte flags, bool disposeStream, uint loopStart, uint loopEnd); + /** * An audio stream to which additional data can be appended on-the-fly. * Used by SMUSH, iMuseDigital, the Kyrandia 3 VQA player, etc. diff --git a/sound/voc.cpp b/sound/voc.cpp index 3e8d8c2ed3..a332477f3c 100644 --- a/sound/voc.cpp +++ b/sound/voc.cpp @@ -166,14 +166,155 @@ byte *loadVOCFromStream(Common::ReadStream &stream, int &size, int &rate) { return loadVOCFromStream(stream, size, rate, loops, begin_loop, end_loop); } -AudioStream *makeVOCStream(Common::ReadStream &stream, byte flags, uint loopStart, uint loopEnd) { + +#ifdef STREAM_AUDIO_FROM_DISK + +int parseVOCFormat(Common::SeekableReadStream& stream, LinearDiskStreamAudioBlock* block, int &rate, int &loops, int &begin_loop, int &end_loop) { + VocFileHeader fileHeader; + int currentBlock = 0; + int size = 0; + + if (stream.read(&fileHeader, 8) != 8) + goto invalid; + + if (!memcmp(&fileHeader, "VTLK", 4)) { + if (stream.read(&fileHeader, sizeof(VocFileHeader)) != sizeof(VocFileHeader)) + goto invalid; + } else if (!memcmp(&fileHeader, "Creative", 8)) { + if (stream.read(((byte *)&fileHeader) + 8, sizeof(VocFileHeader) - 8) != sizeof(VocFileHeader) - 8) + goto invalid; + } else { + invalid:; + warning("loadVOCFromStream: Invalid header"); + return 0; + } + + if (memcmp(fileHeader.desc, "Creative Voice File", 19) != 0) + error("loadVOCFromStream: Invalid header"); + if (fileHeader.desc[19] != 0x1A) + debug(3, "loadVOCFromStream: Partially invalid header"); + + int32 offset = FROM_LE_16(fileHeader.datablock_offset); + int16 version = FROM_LE_16(fileHeader.version); + int16 code = FROM_LE_16(fileHeader.id); + assert(offset == sizeof(VocFileHeader)); + // 0x100 is an invalid VOC version used by German version of DOTT (Disk) and + // French version of Simon the Sorcerer 2 (CD) + assert(version == 0x010A || version == 0x0114 || version == 0x0100); + assert(code == ~version + 0x1234); + + int len; + size = 0; + begin_loop = 0; + end_loop = 0; + + while ((code = stream.readByte())) { + len = stream.readByte(); + len |= stream.readByte() << 8; + len |= stream.readByte() << 16; + + switch (code) { + case 1: + case 9: { + int packing; + if (code == 1) { + int time_constant = stream.readByte(); + packing = stream.readByte(); + len -= 2; + rate = getSampleRateFromVOCRate(time_constant); + } else { + rate = stream.readUint32LE(); + int bits = stream.readByte(); + int channels = stream.readByte(); + if (bits != 8 || channels != 1) { + warning("Unsupported VOC file format (%d bits per sample, %d channels)", bits, channels); + break; + } + packing = stream.readUint16LE(); + stream.readUint32LE(); + len -= 12; + } + debug(9, "VOC Data Block: %d, %d, %d", rate, packing, len); + if (packing == 0) { + + // Found a data block - so add it to the block list + block[currentBlock].pos = stream.pos(); + block[currentBlock].len = len; + currentBlock++; + + stream.seek(len, SEEK_CUR); + + size += len; + begin_loop = size; + end_loop = size; + } else { + warning("VOC file packing %d unsupported", packing); + } + } break; + case 3: // silence + // occur with a few Igor sounds, voc file starts with a silence block with a + // frequency different from the data block. Just ignore fow now (implementing + // it wouldn't make a big difference anyway...) + assert(len == 3); + stream.readUint16LE(); + stream.readByte(); + break; + case 6: // begin of loop + assert(len == 2); + loops = stream.readUint16LE(); + break; + case 7: // end of loop + assert(len == 0); + break; + case 8: // "Extended" + // This occures in the LoL Intro demo. This block can usually be used to create stereo + // sound, but the LoL intro has only an empty block, thus this dummy implementation will + // work. + assert(len == 4); + stream.readUint16LE(); + stream.readByte(); + stream.readByte(); + break; + default: + warning("Unhandled code in VOC file : %d", code); + return 0; + } + } + debug(4, "VOC Data Size : %d", size); + return currentBlock; +} + +AudioStream *makeVOCDiskStream(Common::SeekableReadStream &stream, byte flags, bool takeOwnership) { + const int MAX_AUDIO_BLOCKS = 256; + + LinearDiskStreamAudioBlock *block = new LinearDiskStreamAudioBlock[MAX_AUDIO_BLOCKS]; + int rate, loops, begin_loop, end_loop; + + int numBlocks = parseVOCFormat(stream, block, rate, loops, begin_loop, end_loop); + + AudioStream* audioStream = makeLinearDiskStream(stream, block, numBlocks, rate, flags, takeOwnership, begin_loop, end_loop); + + delete[] block; + + return audioStream; +} + +#endif + + +AudioStream *makeVOCStream(Common::SeekableReadStream &stream, byte flags, uint loopStart, uint loopEnd, bool takeOwnershipOfStream) { +#ifdef STREAM_AUDIO_FROM_DISK + return makeVOCDiskStream(stream, flags, takeOwnershipOfStream); +#else int size, rate; byte *data = loadVOCFromStream(stream, size, rate); + if (!data) return 0; return makeLinearInputStream(data, size, rate, flags | Audio::Mixer::FLAG_AUTOFREE, loopStart, loopEnd); +#endif } diff --git a/sound/voc.h b/sound/voc.h index 2b4796e048..c696afb0c8 100644 --- a/sound/voc.h +++ b/sound/voc.h @@ -41,6 +41,7 @@ #include "common/scummsys.h" namespace Common { class ReadStream; } +namespace Common { class SeekableReadStream; } namespace Audio { @@ -78,7 +79,7 @@ struct VocBlockHeader { extern int getSampleRateFromVOCRate(int vocSR); /** - * Try to load a VOC from the given seekable stream. Returns a pointer to memory + * Try to load a VOC from the given stream. Returns a pointer to memory * containing the PCM sample data (allocated with malloc). It is the callers * responsibility to dellocate that data again later on! Currently this * function only supports uncompressed raw PCM data. @@ -92,7 +93,7 @@ extern byte *loadVOCFromStream(Common::ReadStream &stream, int &size, int &rate) * * This function uses loadVOCFromStream() internally. */ -AudioStream *makeVOCStream(Common::ReadStream &stream, byte flags = 0, uint loopStart = 0, uint loopEnd = 0); +AudioStream *makeVOCStream(Common::SeekableReadStream &stream, byte flags = 0, uint loopStart = 0, uint loopEnd = 0, bool takeOwnershipOfStream = false); } // End of namespace Audio -- cgit v1.2.3