[Scummvm-cvs-logs] SF.net SVN: scummvm:[47367] scummvm/trunk

fingolfin at users.sourceforge.net fingolfin at users.sourceforge.net
Tue Jan 19 01:52:42 CET 2010


Revision: 47367
          http://scummvm.svn.sourceforge.net/scummvm/?rev=47367&view=rev
Author:   fingolfin
Date:     2010-01-19 00:52:41 +0000 (Tue, 19 Jan 2010)

Log Message:
-----------
Rename 'Linear' audio streams to 'raw'

Modified Paths:
--------------
    scummvm/trunk/engines/kyra/sound_towns.cpp
    scummvm/trunk/engines/made/resource.cpp
    scummvm/trunk/engines/mohawk/sound.cpp
    scummvm/trunk/engines/mohawk/video/qt_player.cpp
    scummvm/trunk/engines/parallaction/sound_br.cpp
    scummvm/trunk/engines/parallaction/sound_ns.cpp
    scummvm/trunk/engines/saga/music.cpp
    scummvm/trunk/engines/sci/sound/audio.cpp
    scummvm/trunk/engines/sci/sound/iterator/iterator.cpp
    scummvm/trunk/engines/sci/sound/music.cpp
    scummvm/trunk/engines/scumm/he/cup_player_he.cpp
    scummvm/trunk/engines/scumm/he/sound_he.cpp
    scummvm/trunk/engines/scumm/player_mod.cpp
    scummvm/trunk/engines/tucker/sequences.cpp
    scummvm/trunk/sound/aiff.cpp
    scummvm/trunk/sound/audiostream.cpp
    scummvm/trunk/sound/audiostream.h
    scummvm/trunk/sound/iff_sound.cpp
    scummvm/trunk/sound/mixer.cpp
    scummvm/trunk/sound/mixer.h
    scummvm/trunk/sound/shorten.cpp
    scummvm/trunk/sound/voc.cpp
    scummvm/trunk/sound/wave.cpp

Modified: scummvm/trunk/engines/kyra/sound_towns.cpp
===================================================================
--- scummvm/trunk/engines/kyra/sound_towns.cpp	2010-01-19 00:41:37 UTC (rev 47366)
+++ scummvm/trunk/engines/kyra/sound_towns.cpp	2010-01-19 00:52:41 UTC (rev 47367)
@@ -3924,7 +3924,7 @@
 
 	uint32 outputRate = uint32(11025 * calculatePhaseStep(note, sfxRootNoteOffs, sfxRate, 11025, 0x2000));
 
-	_currentSFX = Audio::makeLinearInputStream(sfxPlaybackBuffer, playbackBufferSize,
+	_currentSFX = Audio::makeRawMemoryStream(sfxPlaybackBuffer, playbackBufferSize,
 		outputRate, Audio::Mixer::FLAG_UNSIGNED | Audio::Mixer::FLAG_LITTLE_ENDIAN | Audio::Mixer::FLAG_AUTOFREE, 0, 0);
 	_mixer->playInputStream(Audio::Mixer::kSFXSoundType, &_sfxHandle, _currentSFX);
 }
@@ -4296,7 +4296,7 @@
 
 	uint32 outputRate = uint32(11025 * SoundTowns::calculatePhaseStep(0x3c, 0x3c, sfxRate, 11025, 0x2000));
 
-	_currentSFX = Audio::makeLinearInputStream(sfx, outsize, outputRate,
+	_currentSFX = Audio::makeRawMemoryStream(sfx, outsize, outputRate,
 		Audio::Mixer::FLAG_UNSIGNED | Audio::Mixer::FLAG_LITTLE_ENDIAN | Audio::Mixer::FLAG_AUTOFREE, 0, 0);
 	_mixer->playInputStream(Audio::Mixer::kSFXSoundType, &_soundChannels[h], _currentSFX);
 	if (handle)

Modified: scummvm/trunk/engines/made/resource.cpp
===================================================================
--- scummvm/trunk/engines/made/resource.cpp	2010-01-19 00:41:37 UTC (rev 47366)
+++ scummvm/trunk/engines/made/resource.cpp	2010-01-19 00:52:41 UTC (rev 47367)
@@ -264,7 +264,7 @@
 	if (loop)
 		flags |= Audio::Mixer::FLAG_LOOP;
 
-	return Audio::makeLinearInputStream(_soundData, _soundSize, soundRate, flags, 0, 0);
+	return Audio::makeRawMemoryStream(_soundData, _soundSize, soundRate, flags, 0, 0);
 }
 
 void SoundResourceV1::load(byte *source, int size) {

Modified: scummvm/trunk/engines/mohawk/sound.cpp
===================================================================
--- scummvm/trunk/engines/mohawk/sound.cpp	2010-01-19 00:41:37 UTC (rev 47366)
+++ scummvm/trunk/engines/mohawk/sound.cpp	2010-01-19 00:52:41 UTC (rev 47367)
@@ -439,7 +439,7 @@
 			flags |= Audio::Mixer::FLAG_STEREO;
 		if (data_chunk.loop == 0xFFFF || loop)
 			flags |= Audio::Mixer::FLAG_LOOP;
-		return Audio::makeLinearInputStream(data_chunk.audio_data, data_chunk.size, data_chunk.sample_rate, flags, data_chunk.loopStart, data_chunk.loopEnd);
+		return Audio::makeRawMemoryStream(data_chunk.audio_data, data_chunk.size, data_chunk.sample_rate, flags, data_chunk.loopStart, data_chunk.loopEnd);
 	} else if (data_chunk.encoding == kCodecADPCM) {
 		Common::MemoryReadStream *dataStream = new Common::MemoryReadStream(data_chunk.audio_data, data_chunk.size, DisposeAfterUse::YES);
 		uint32 blockAlign = data_chunk.channels * data_chunk.bitsPerSample / 8;
@@ -485,7 +485,7 @@
 	if (loop)
 		flags |= Audio::Mixer::FLAG_LOOP;
 	
-	return Audio::makeLinearInputStream(data, size, rate, flags, 0, 0);
+	return Audio::makeRawMemoryStream(data, size, rate, flags, 0, 0);
 }
 
 SndHandle *Sound::getHandle() {

Modified: scummvm/trunk/engines/mohawk/video/qt_player.cpp
===================================================================
--- scummvm/trunk/engines/mohawk/video/qt_player.cpp	2010-01-19 00:41:37 UTC (rev 47366)
+++ scummvm/trunk/engines/mohawk/video/qt_player.cpp	2010-01-19 00:52:41 UTC (rev 47367)
@@ -1169,7 +1169,7 @@
 		byte *data = (byte *)malloc(dataSize);
 		stream->read(data, dataSize);
 		delete stream;
-		return Audio::makeLinearInputStream(data, dataSize, _streams[_audioStreamIndex]->sample_rate, flags, 0, 0);
+		return Audio::makeRawMemoryStream(data, dataSize, _streams[_audioStreamIndex]->sample_rate, flags, 0, 0);
 	} else if (_streams[_audioStreamIndex]->codec_tag == MKID_BE('ima4')) {
 		// Riven uses this codec (as do some Myst ME videos)
 		return Audio::makeADPCMStream(stream, true, stream->size(), Audio::kADPCMApple, _streams[_audioStreamIndex]->sample_rate, _streams[_audioStreamIndex]->channels, 34);

Modified: scummvm/trunk/engines/parallaction/sound_br.cpp
===================================================================
--- scummvm/trunk/engines/parallaction/sound_br.cpp	2010-01-19 00:41:37 UTC (rev 47366)
+++ scummvm/trunk/engines/parallaction/sound_br.cpp	2010-01-19 00:52:41 UTC (rev 47367)
@@ -422,7 +422,7 @@
 		flags |= Audio::Mixer::FLAG_LOOP;
 	}
 
-	ch->stream = Audio::makeLinearInputStream((byte *)data, dataSize, rate, flags, loopStart, loopEnd);
+	ch->stream = Audio::makeRawMemoryStream((byte *)data, dataSize, rate, flags, loopStart, loopEnd);
 	return ch->stream;
 }
 
@@ -482,7 +482,7 @@
 
 		// TODO: Confirm sound rate
 		int rate = 11025;
-		input = Audio::makeLinearInputStream((byte *)data, dataSize, rate, Audio::Mixer::FLAG_AUTOFREE, 0, 0);
+		input = Audio::makeRawMemoryStream((byte *)data, dataSize, rate, Audio::Mixer::FLAG_AUTOFREE, 0, 0);
 	} else {
 		input = Audio::make8SVXStream(*stream, looping);
 	}

Modified: scummvm/trunk/engines/parallaction/sound_ns.cpp
===================================================================
--- scummvm/trunk/engines/parallaction/sound_ns.cpp	2010-01-19 00:41:37 UTC (rev 47366)
+++ scummvm/trunk/engines/parallaction/sound_ns.cpp	2010-01-19 00:52:41 UTC (rev 47367)
@@ -376,7 +376,7 @@
 	if (!scumm_stricmp("beep", filename)) {
 		int rate = 11934;
 		ch->volume = 160;
-		input = Audio::makeLinearInputStream((byte *)beepSoundBuffer, beepSoundBufferSize, rate, 0, 0, 0);
+		input = Audio::makeRawMemoryStream((byte *)beepSoundBuffer, beepSoundBufferSize, rate, 0, 0, 0);
 	} else {
 		Common::SeekableReadStream *stream = _vm->_disk->loadSound(filename);
 		input = Audio::make8SVXStream(*stream, looping);

Modified: scummvm/trunk/engines/saga/music.cpp
===================================================================
--- scummvm/trunk/engines/saga/music.cpp	2010-01-19 00:41:37 UTC (rev 47366)
+++ scummvm/trunk/engines/saga/music.cpp	2010-01-19 00:52:41 UTC (rev 47367)
@@ -305,10 +305,10 @@
 				if (!_digitalMusicContext->isCompressed()) {
 					byte musicFlags = Audio::Mixer::FLAG_AUTOFREE | Audio::Mixer::FLAG_STEREO | 
 										Audio::Mixer::FLAG_16BITS | Audio::Mixer::FLAG_LITTLE_ENDIAN;
-					Audio::LinearDiskStreamAudioBlock audioBlocks[1];
+					Audio::RawDiskStreamAudioBlock audioBlocks[1];
 					audioBlocks[0].pos = 0;
 					audioBlocks[0].len = resData->size / 2;	// 16-bit sound
-					audioStream = Audio::makeLinearDiskStream(musicStream, audioBlocks, 1, 11025, musicFlags, DisposeAfterUse::YES);
+					audioStream = Audio::makeRawDiskStream(musicStream, audioBlocks, 1, 11025, musicFlags, DisposeAfterUse::YES);
 				} else {
 					// Read compressed header to determine compression type
 					musicFile->seek((uint32)resData->offset, SEEK_SET);

Modified: scummvm/trunk/engines/sci/sound/audio.cpp
===================================================================
--- scummvm/trunk/engines/sci/sound/audio.cpp	2010-01-19 00:41:37 UTC (rev 47366)
+++ scummvm/trunk/engines/sci/sound/audio.cpp	2010-01-19 00:52:41 UTC (rev 47367)
@@ -244,7 +244,7 @@
 	}
 
 	if (data)
-		audioStream = Audio::makeLinearInputStream(data, size, _audioRate, flags | Audio::Mixer::FLAG_AUTOFREE);
+		audioStream = Audio::makeRawMemoryStream(data, size, _audioRate, flags | Audio::Mixer::FLAG_AUTOFREE);
 
 	if (audioStream) {
 		*sampleLen = (flags & Audio::Mixer::FLAG_16BITS ? size >> 1 : size) * 60 / _audioRate;

Modified: scummvm/trunk/engines/sci/sound/iterator/iterator.cpp
===================================================================
--- scummvm/trunk/engines/sci/sound/iterator/iterator.cpp	2010-01-19 00:41:37 UTC (rev 47366)
+++ scummvm/trunk/engines/sci/sound/iterator/iterator.cpp	2010-01-19 00:52:41 UTC (rev 47367)
@@ -551,7 +551,7 @@
 
 	// Convert stream format flags
 	int flags = Audio::Mixer::FLAG_AUTOFREE | Audio::Mixer::FLAG_UNSIGNED;
-	return Audio::makeLinearInputStream(sound, size, rate, flags, 0, 0);
+	return Audio::makeRawMemoryStream(sound, size, rate, flags, 0, 0);
 }
 
 Audio::AudioStream *Sci0SongIterator::getAudioStream() {

Modified: scummvm/trunk/engines/sci/sound/music.cpp
===================================================================
--- scummvm/trunk/engines/sci/sound/music.cpp	2010-01-19 00:41:37 UTC (rev 47366)
+++ scummvm/trunk/engines/sci/sound/music.cpp	2010-01-19 00:52:41 UTC (rev 47367)
@@ -177,7 +177,7 @@
 		if (track->digitalChannelNr != -1) {
 			byte *channelData = track->channels[track->digitalChannelNr].data;
 			delete pSnd->pStreamAud;
-			pSnd->pStreamAud = Audio::makeLinearInputStream(channelData, track->digitalSampleSize, track->digitalSampleRate, Audio::Mixer::FLAG_UNSIGNED);
+			pSnd->pStreamAud = Audio::makeRawMemoryStream(channelData, track->digitalSampleSize, track->digitalSampleRate, Audio::Mixer::FLAG_UNSIGNED);
 			delete pSnd->pLoopStream;
 			pSnd->pLoopStream = 0;
 			pSnd->soundType = Audio::Mixer::kSFXSoundType;

Modified: scummvm/trunk/engines/scumm/he/cup_player_he.cpp
===================================================================
--- scummvm/trunk/engines/scumm/he/cup_player_he.cpp	2010-01-19 00:41:37 UTC (rev 47366)
+++ scummvm/trunk/engines/scumm/he/cup_player_he.cpp	2010-01-19 00:52:41 UTC (rev 47367)
@@ -175,7 +175,7 @@
 					loopEnd = soundSize - 8;
 				}
 				_mixer->playInputStream(Audio::Mixer::kSFXSoundType, &sfxChannel->handle,
-						Audio::makeLinearInputStream(soundData + 8, soundSize - 8, 11025, flags, 0, loopEnd));
+						Audio::makeRawMemoryStream(soundData + 8, soundSize - 8, 11025, flags, 0, loopEnd));
 			}
 		} else {
 			warning("Unable to find a free channel to play sound %d", sfx->num);

Modified: scummvm/trunk/engines/scumm/he/sound_he.cpp
===================================================================
--- scummvm/trunk/engines/scumm/he/sound_he.cpp	2010-01-19 00:41:37 UTC (rev 47366)
+++ scummvm/trunk/engines/scumm/he/sound_he.cpp	2010-01-19 00:52:41 UTC (rev 47367)
@@ -659,8 +659,8 @@
 
 			flags |= Audio::Mixer::FLAG_AUTOFREE;
 			
-			// makeADPCMStream returns a stream in native endianness, but LinearInputStream (and playRaw)
-			// is defaulted to Big Endian. If we're on a Little Endian system, set the LE flag.
+			// makeADPCMStream returns a stream in native endianness, but RawMemoryStream (and playRaw)
+			// defaults to big endian. If we're on a little endian system, set the LE flag.
 #ifdef SCUMM_LITTLE_ENDIAN
 			flags |= Audio::Mixer::FLAG_LITTLE_ENDIAN;
 #endif

Modified: scummvm/trunk/engines/scumm/player_mod.cpp
===================================================================
--- scummvm/trunk/engines/scumm/player_mod.cpp	2010-01-19 00:41:37 UTC (rev 47366)
+++ scummvm/trunk/engines/scumm/player_mod.cpp	2010-01-19 00:52:41 UTC (rev 47367)
@@ -94,7 +94,7 @@
 	_channels[i].pan = pan;
 	_channels[i].freq = rate;
 	_channels[i].ctr = 0;
-	_channels[i].input = Audio::makeLinearInputStream((const byte*)data, size, rate, Audio::Mixer::FLAG_AUTOFREE | (loopStart != loopEnd ? Audio::Mixer::FLAG_LOOP : 0), loopStart, loopEnd);
+	_channels[i].input = Audio::makeRawMemoryStream((const byte*)data, size, rate, Audio::Mixer::FLAG_AUTOFREE | (loopStart != loopEnd ? Audio::Mixer::FLAG_LOOP : 0), loopStart, loopEnd);
 	// read the first sample
 	_channels[i].input->readBuffer(&_channels[i].pos, 1);
 }

Modified: scummvm/trunk/engines/tucker/sequences.cpp
===================================================================
--- scummvm/trunk/engines/tucker/sequences.cpp	2010-01-19 00:41:37 UTC (rev 47366)
+++ scummvm/trunk/engines/tucker/sequences.cpp	2010-01-19 00:52:41 UTC (rev 47367)
@@ -598,7 +598,7 @@
 				uint8 *sampleData = (uint8 *)malloc(size);
 				if (sampleData) {
 					f.read(sampleData, size);
-					stream = Audio::makeLinearInputStream(sampleData, size, rate, flags);
+					stream = Audio::makeRawMemoryStream(sampleData, size, rate, flags);
 				}
 			}
 			break;

Modified: scummvm/trunk/sound/aiff.cpp
===================================================================
--- scummvm/trunk/sound/aiff.cpp	2010-01-19 00:41:37 UTC (rev 47366)
+++ scummvm/trunk/sound/aiff.cpp	2010-01-19 00:52:41 UTC (rev 47367)
@@ -174,7 +174,7 @@
 	// Since we allocated our own buffer for the data, we must set the autofree flag.
 	flags |= Audio::Mixer::FLAG_AUTOFREE;
 
-	return makeLinearInputStream(data, size, rate, flags);
+	return makeRawMemoryStream(data, size, rate, flags);
 }
 
 } // End of namespace Audio

Modified: scummvm/trunk/sound/audiostream.cpp
===================================================================
--- scummvm/trunk/sound/audiostream.cpp	2010-01-19 00:41:37 UTC (rev 47366)
+++ scummvm/trunk/sound/audiostream.cpp	2010-01-19 00:52:41 UTC (rev 47367)
@@ -256,7 +256,7 @@
 }
 
 #pragma mark -
-#pragma mark --- LinearMemoryStream ---
+#pragma mark --- RawMemoryStream ---
 #pragma mark -
 
 uint32 calculateSampleOffset(const Timestamp &where, int rate) {
@@ -274,7 +274,7 @@
  * case. This results in a total of 12 versions of the code being generated.
  */
 template<bool stereo, bool is16Bit, bool isUnsigned, bool isLE>
-class LinearMemoryStream : public SeekableAudioStream {
+class RawMemoryStream : public SeekableAudioStream {
 protected:
 	const byte *_ptr;
 	const byte *_end;
@@ -284,13 +284,13 @@
 	const Timestamp _playtime;
 
 public:
-	LinearMemoryStream(int rate, const byte *ptr, uint len, DisposeAfterUse::Flag autoFreeMemory)
+	RawMemoryStream(int rate, const byte *ptr, uint len, DisposeAfterUse::Flag autoFreeMemory)
 	    : _ptr(ptr), _end(ptr+len), _rate(rate), _origPtr(ptr),
 	      _disposeAfterUse(autoFreeMemory),
 	      _playtime(0, len / (is16Bit ? 2 : 1) / (stereo ? 2 : 1), rate) {
 	}
 
-	virtual ~LinearMemoryStream() {
+	virtual ~RawMemoryStream() {
 		if (_disposeAfterUse == DisposeAfterUse::YES)
 			free(const_cast<byte *>(_origPtr));
 	}
@@ -306,7 +306,7 @@
 };
 
 template<bool stereo, bool is16Bit, bool isUnsigned, bool isLE>
-int LinearMemoryStream<stereo, is16Bit, isUnsigned, isLE>::readBuffer(int16 *buffer, const int numSamples) {
+int RawMemoryStream<stereo, is16Bit, isUnsigned, isLE>::readBuffer(int16 *buffer, const int numSamples) {
 	int samples = numSamples;
 	while (samples > 0 && _ptr < _end) {
 		int len = MIN(samples, (int)(_end - _ptr) / (is16Bit ? 2 : 1));
@@ -320,7 +320,7 @@
 }
 
 template<bool stereo, bool is16Bit, bool isUnsigned, bool isLE>
-bool LinearMemoryStream<stereo, is16Bit, isUnsigned, isLE>::seek(const Timestamp &where) {
+bool RawMemoryStream<stereo, is16Bit, isUnsigned, isLE>::seek(const Timestamp &where) {
 	const uint8 *ptr = _origPtr + calculateSampleOffset(where, getRate()) * (is16Bit ? 2 : 1) * (stereo ? 2 : 1);
 	if (ptr > _end) {
 		_ptr = _end;
@@ -335,18 +335,18 @@
 }
 
 #pragma mark -
-#pragma mark --- LinearDiskStream ---
+#pragma mark --- RawDiskStream ---
 #pragma mark -
 
 
 
 /**
- *  LinearDiskStream.  This can stream linear (PCM) audio from disk.  The
- *  function takes an pointer to an array of LinearDiskStreamAudioBlock which defines the
+ *  RawDiskStream.  This can stream raw PCM audio data from disk.  The
+ *  function takes an pointer to an array of RawDiskStreamAudioBlock which defines the
  *  start position and length of each block of uncompressed audio in the stream.
  */
 template<bool stereo, bool is16Bit, bool isUnsigned, bool isLE>
-class LinearDiskStream : public SeekableAudioStream {
+class RawDiskStream : public SeekableAudioStream {
 
 // Allow backends to override buffer size
 #ifdef CUSTOM_AUDIO_BUFFER_SIZE
@@ -365,13 +365,13 @@
 	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
-	const DisposeAfterUse::Flag _disposeAfterUse;		///< Indicates whether the stream object should be deleted when this LinearDiskStream is destructed
+	const DisposeAfterUse::Flag _disposeAfterUse;		///< Indicates whether the stream object should be deleted when this RawDiskStream is destructed
 
-	LinearDiskStreamAudioBlock *_audioBlock;	///< Audio block list
+	RawDiskStreamAudioBlock *_audioBlock;	///< Audio block list
 	const int _audioBlockCount;		///< Number of blocks in _audioBlock
 	int _currentBlock;		///< Current audio block number
 public:
-	LinearDiskStream(int rate, DisposeAfterUse::Flag disposeStream, Common::SeekableReadStream *stream, LinearDiskStreamAudioBlock *block, uint numBlocks)
+	RawDiskStream(int rate, DisposeAfterUse::Flag disposeStream, Common::SeekableReadStream *stream, RawDiskStreamAudioBlock *block, uint numBlocks)
 		: _rate(rate), _playtime(0, rate), _stream(stream), _disposeAfterUse(disposeStream),
 		  _audioBlockCount(numBlocks) {
 
@@ -390,8 +390,8 @@
 		// 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));
+		_audioBlock = new RawDiskStreamAudioBlock[numBlocks];
+		memcpy(_audioBlock, block, numBlocks * sizeof(RawDiskStreamAudioBlock));
 
 		// Set current buffer state, playing first block
 		_currentBlock = 0;
@@ -407,7 +407,7 @@
 	}
 
 
-	virtual ~LinearDiskStream() {
+	virtual ~RawDiskStream() {
 		if (_disposeAfterUse == DisposeAfterUse::YES) {
 			delete _stream;
 		}
@@ -427,7 +427,7 @@
 };
 
 template<bool stereo, bool is16Bit, bool isUnsigned, bool isLE>
-int LinearDiskStream<stereo, is16Bit, isUnsigned, isLE>::readBuffer(int16 *buffer, const int numSamples) {
+int RawDiskStream<stereo, is16Bit, isUnsigned, isLE>::readBuffer(int16 *buffer, const int numSamples) {
 	int oldPos = _stream->pos();
 	bool restoreFilePosition = false;
 
@@ -485,7 +485,7 @@
 }
 
 template<bool stereo, bool is16Bit, bool isUnsigned, bool isLE>
-bool LinearDiskStream<stereo, is16Bit, isUnsigned, isLE>::seek(const Timestamp &where) {
+bool RawDiskStream<stereo, is16Bit, isUnsigned, isLE>::seek(const Timestamp &where) {
 	const uint32 seekSample = calculateSampleOffset(where, getRate()) * (stereo ? 2 : 1);
 	uint32 curSample = 0;
 
@@ -533,13 +533,13 @@
 #define MAKE_LINEAR(STEREO, UNSIGNED) \
 		if (is16Bit) { \
 			if (isLE) \
-				return new LinearMemoryStream<STEREO, true, UNSIGNED, true>(rate, ptr, len, autoFree); \
+				return new RawMemoryStream<STEREO, true, UNSIGNED, true>(rate, ptr, len, autoFree); \
 			else  \
-				return new LinearMemoryStream<STEREO, true, UNSIGNED, false>(rate, ptr, len, autoFree); \
+				return new RawMemoryStream<STEREO, true, UNSIGNED, false>(rate, ptr, len, autoFree); \
 		} else \
-			return new LinearMemoryStream<STEREO, false, UNSIGNED, false>(rate, ptr, len, autoFree)
+			return new RawMemoryStream<STEREO, false, UNSIGNED, false>(rate, ptr, len, autoFree)
 
-SeekableAudioStream *makeLinearInputStream(const byte *ptr, uint32 len, int rate, byte flags) {
+SeekableAudioStream *makeRawMemoryStream(const byte *ptr, uint32 len, int rate, byte flags) {
 	const bool isStereo   = (flags & Mixer::FLAG_STEREO) != 0;
 	const bool is16Bit    = (flags & Mixer::FLAG_16BITS) != 0;
 	const bool isUnsigned = (flags & Mixer::FLAG_UNSIGNED) != 0;
@@ -569,9 +569,9 @@
 }
 
 
-AudioStream *makeLinearInputStream(const byte *ptr, uint32 len, int rate,
+AudioStream *makeRawMemoryStream(const byte *ptr, uint32 len, int rate,
                                    byte flags, uint loopStart, uint loopEnd) {
-	SeekableAudioStream *stream = makeLinearInputStream(ptr, len, rate, flags);
+	SeekableAudioStream *stream = makeRawMemoryStream(ptr, len, rate, flags);
 
 	const bool isStereo   = (flags & Mixer::FLAG_STEREO) != 0;
 	const bool is16Bit    = (flags & Mixer::FLAG_16BITS) != 0;
@@ -606,14 +606,14 @@
 #define MAKE_LINEAR_DISK(STEREO, UNSIGNED) \
 		if (is16Bit) { \
 			if (isLE) \
-				return new LinearDiskStream<STEREO, true, UNSIGNED, true>(rate, disposeStream, stream, block, numBlocks); \
+				return new RawDiskStream<STEREO, true, UNSIGNED, true>(rate, disposeStream, stream, block, numBlocks); \
 			else  \
-				return new LinearDiskStream<STEREO, true, UNSIGNED, false>(rate, disposeStream, stream, block, numBlocks); \
+				return new RawDiskStream<STEREO, true, UNSIGNED, false>(rate, disposeStream, stream, block, numBlocks); \
 		} else \
-			return new LinearDiskStream<STEREO, false, UNSIGNED, false>(rate, disposeStream, stream, block, numBlocks)
+			return new RawDiskStream<STEREO, false, UNSIGNED, false>(rate, disposeStream, stream, block, numBlocks)
 
 
-SeekableAudioStream *makeLinearDiskStream(Common::SeekableReadStream *stream, LinearDiskStreamAudioBlock *block, int numBlocks,
+SeekableAudioStream *makeRawDiskStream(Common::SeekableReadStream *stream, RawDiskStreamAudioBlock *block, int numBlocks,
 					int rate, byte flags, DisposeAfterUse::Flag disposeStream) {
 	const bool isStereo   = (flags & Mixer::FLAG_STEREO) != 0;
 	const bool is16Bit    = (flags & Mixer::FLAG_16BITS) != 0;
@@ -635,9 +635,9 @@
 	}
 }
 
-AudioStream *makeLinearDiskStream(Common::SeekableReadStream *stream, LinearDiskStreamAudioBlock *block,
+AudioStream *makeRawDiskStream(Common::SeekableReadStream *stream, RawDiskStreamAudioBlock *block,
 		int numBlocks, int rate, byte flags, DisposeAfterUse::Flag disposeStream, uint loopStart, uint loopEnd) {
-	SeekableAudioStream *s = makeLinearDiskStream(stream, block, numBlocks, rate, flags, disposeStream);
+	SeekableAudioStream *s = makeRawDiskStream(stream, block, numBlocks, rate, flags, disposeStream);
 
 	const bool isStereo   = (flags & Mixer::FLAG_STEREO) != 0;
 	const bool is16Bit    = (flags & Mixer::FLAG_16BITS) != 0;

Modified: scummvm/trunk/sound/audiostream.h
===================================================================
--- scummvm/trunk/sound/audiostream.h	2010-01-19 00:41:37 UTC (rev 47366)
+++ scummvm/trunk/sound/audiostream.h	2010-01-19 00:52:41 UTC (rev 47367)
@@ -307,27 +307,27 @@
  * @see Mixer::RawFlags
  * @return The new SeekableAudioStream (or 0 on failure).
  */
-SeekableAudioStream *makeLinearInputStream(const byte *ptr, uint32 len, int rate, byte flags);
+SeekableAudioStream *makeRawMemoryStream(const byte *ptr, uint32 len, int rate, byte flags);
 
 /**
  * NOTE:
  * This API is considered deprecated.
  *
- * Factory function for a raw linear AudioStream, which will simply treat all
+ * Factory function for a raw PCM AudioStream, which will simply treat all
  * data in the buffer described by ptr and len as raw sample data in the
  * specified format. It will then simply pass this data directly to the mixer,
  * after converting it to the sample format used by the mixer (i.e. 16 bit
  * signed native endian). Optionally supports (infinite) looping of a portion
  * of the data.
  */
-AudioStream *makeLinearInputStream(const byte *ptr, uint32 len, int rate,
+AudioStream *makeRawMemoryStream(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 used to define the audio data to be played by a RawDiskStream.
  */
-struct LinearDiskStreamAudioBlock {
+struct RawDiskStreamAudioBlock {
 	int32 pos;		///< Position in stream of the block
 	int32 len;		///< Length of the block (in samples)
 };
@@ -336,8 +336,8 @@
  * Creates a audio stream, which plays from given stream.
  *
  * @param stream Stream to play from
- * @param block Pointer to an LinearDiskStreamAudioBlock array
- * @see LinearDiskStreamAudioBlock
+ * @param block Pointer to an RawDiskStreamAudioBlock array
+ * @see RawDiskStreamAudioBlock
  * @param numBlocks Number of blocks.
  * @param rate The rate 
  * @param len Length of the data (in bytes!)
@@ -346,19 +346,19 @@
  * @param disposeStream Whether the "stream" object should be destroyed after playback.
  * @return The new SeekableAudioStream (or 0 on failure).
  */
-SeekableAudioStream *makeLinearDiskStream(Common::SeekableReadStream *stream, LinearDiskStreamAudioBlock *block,
+SeekableAudioStream *makeRawDiskStream(Common::SeekableReadStream *stream, RawDiskStreamAudioBlock *block,
 		int numBlocks, int rate, byte flags, DisposeAfterUse::Flag disposeStream);
 
 /**
  * NOTE:
  * This API is considered deprecated.
  *
- * 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
+ * Factory function for a Raw Disk Stream.  This can stream raw PCM
+ * audio data from disk. The function takes an pointer to an array of
+ * RawDiskStreamAudioBlock which defines the start position and length of
  * each block of uncompressed audio in the stream.
  */
-AudioStream *makeLinearDiskStream(Common::SeekableReadStream *stream, LinearDiskStreamAudioBlock *block,
+AudioStream *makeRawDiskStream(Common::SeekableReadStream *stream, RawDiskStreamAudioBlock *block,
 		int numBlocks, int rate, byte flags, DisposeAfterUse::Flag disposeStream, uint loopStart, uint loopEnd);
 
 class QueuingAudioStream : public Audio::AudioStream {
@@ -381,7 +381,7 @@
 	 * with new[], not with malloc).
 	 */
 	void queueBuffer(byte *data, uint32 size, byte flags) {
-		AudioStream *stream = makeLinearInputStream(data, size, getRate(), flags, 0, 0);
+		AudioStream *stream = makeRawMemoryStream(data, size, getRate(), flags, 0, 0);
 		queueAudioStream(stream, DisposeAfterUse::YES);
 	}
 

Modified: scummvm/trunk/sound/iff_sound.cpp
===================================================================
--- scummvm/trunk/sound/iff_sound.cpp	2010-01-19 00:41:37 UTC (rev 47366)
+++ scummvm/trunk/sound/iff_sound.cpp	2010-01-19 00:52:41 UTC (rev 47367)
@@ -100,7 +100,7 @@
 
 	flags |= Audio::Mixer::FLAG_AUTOFREE;
 
-	return Audio::makeLinearInputStream((byte *)loader._data, loader._dataSize, loader._header.samplesPerSec, flags, loopStart, loopEnd);
+	return Audio::makeRawMemoryStream((byte *)loader._data, loader._dataSize, loader._header.samplesPerSec, flags, loopStart, loopEnd);
 }
 
 }

Modified: scummvm/trunk/sound/mixer.cpp
===================================================================
--- scummvm/trunk/sound/mixer.cpp	2010-01-19 00:41:37 UTC (rev 47366)
+++ scummvm/trunk/sound/mixer.cpp	2010-01-19 00:52:41 UTC (rev 47367)
@@ -225,7 +225,7 @@
 			uint32 loopStart, uint32 loopEnd) {
 
 	// Create the input stream
-	AudioStream *input = makeLinearInputStream((byte *)sound, size, rate, flags, loopStart, loopEnd);
+	AudioStream *input = makeRawMemoryStream((byte *)sound, size, rate, flags, loopStart, loopEnd);
 
 	// Play it
 	playInputStream(type, handle, input, id, volume, balance, DisposeAfterUse::YES, false, ((flags & Mixer::FLAG_REVERSE_STEREO) != 0));

Modified: scummvm/trunk/sound/mixer.h
===================================================================
--- scummvm/trunk/sound/mixer.h	2010-01-19 00:41:37 UTC (rev 47366)
+++ scummvm/trunk/sound/mixer.h	2010-01-19 00:52:41 UTC (rev 47367)
@@ -65,7 +65,7 @@
 public:
 	/**
 	 * Various flags which can be bit-ORed and then passed to
-	 * Mixer::playRaw resp. makeLinearInputStream to control their
+	 * Mixer::playRaw resp. makeRawMemoryStream to control their
 	 * behavior.
 	 *
 	 * Engine authors are advised not to rely on a certain value or
@@ -131,7 +131,7 @@
 	/**
 	 * Start playing the given raw sound data.
 	 * Internally, this simply creates an audio input stream wrapping the data
-	 * (using the makeLinearInputStream factory function), which is then
+	 * (using the makeRawMemoryStream factory function), which is then
 	 * passed on to playInputStream.
 	 */
 	virtual void playRaw(

Modified: scummvm/trunk/sound/shorten.cpp
===================================================================
--- scummvm/trunk/sound/shorten.cpp	2010-01-19 00:41:37 UTC (rev 47366)
+++ scummvm/trunk/sound/shorten.cpp	2010-01-19 00:52:41 UTC (rev 47367)
@@ -525,7 +525,7 @@
 	// Since we allocated our own buffer for the data, we must set the autofree flag.
 	flags |= Audio::Mixer::FLAG_AUTOFREE;
 
-	return makeLinearInputStream(data, size, rate, flags, 0, 0);
+	return makeRawMemoryStream(data, size, rate, flags, 0, 0);
 }
 
 } // End of namespace Audio

Modified: scummvm/trunk/sound/voc.cpp
===================================================================
--- scummvm/trunk/sound/voc.cpp	2010-01-19 00:41:37 UTC (rev 47366)
+++ scummvm/trunk/sound/voc.cpp	2010-01-19 00:52:41 UTC (rev 47367)
@@ -179,7 +179,7 @@
 
 #ifdef STREAM_AUDIO_FROM_DISK
 
-int parseVOCFormat(Common::SeekableReadStream& stream, LinearDiskStreamAudioBlock* block, int &rate, int &loops, int &begin_loop, int &end_loop) {
+int parseVOCFormat(Common::SeekableReadStream& stream, RawDiskStreamAudioBlock* block, int &rate, int &loops, int &begin_loop, int &end_loop) {
 	VocFileHeader fileHeader;
 	int currentBlock = 0;
 	int size = 0;
@@ -301,7 +301,7 @@
 AudioStream *makeVOCDiskStream(Common::SeekableReadStream &stream, byte flags, DisposeAfterUse::Flag takeOwnership) {
 	const int MAX_AUDIO_BLOCKS = 256;
 
-	LinearDiskStreamAudioBlock *block = new LinearDiskStreamAudioBlock[MAX_AUDIO_BLOCKS];
+	RawDiskStreamAudioBlock *block = new RawDiskStreamAudioBlock[MAX_AUDIO_BLOCKS];
 	int rate, loops, begin_loop, end_loop;
 
 	int numBlocks = parseVOCFormat(stream, block, rate, loops, begin_loop, end_loop);
@@ -311,7 +311,7 @@
 	// Create an audiostream from the data. Note the numBlocks may be 0,
 	// e.g. when invalid data is encountered. See bug #2890038.
 	if (numBlocks)
-		audioStream = makeLinearDiskStream(&stream, block, numBlocks, rate, flags, takeOwnership, begin_loop, end_loop);
+		audioStream = makeRawDiskStream(&stream, block, numBlocks, rate, flags, takeOwnership, begin_loop, end_loop);
 
 	delete[] block;
 
@@ -321,7 +321,7 @@
 SeekableAudioStream *makeVOCDiskStreamNoLoop(Common::SeekableReadStream &stream, byte flags, DisposeAfterUse::Flag takeOwnership) {
 	const int MAX_AUDIO_BLOCKS = 256;
 
-	LinearDiskStreamAudioBlock *block = new LinearDiskStreamAudioBlock[MAX_AUDIO_BLOCKS];
+	RawDiskStreamAudioBlock *block = new RawDiskStreamAudioBlock[MAX_AUDIO_BLOCKS];
 	int rate, loops, begin_loop, end_loop;
 
 	int numBlocks = parseVOCFormat(stream, block, rate, loops, begin_loop, end_loop);
@@ -331,7 +331,7 @@
 	// Create an audiostream from the data. Note the numBlocks may be 0,
 	// e.g. when invalid data is encountered. See bug #2890038.
 	if (numBlocks)
-		audioStream = makeLinearDiskStream(&stream, block, numBlocks, rate, flags, takeOwnership);
+		audioStream = makeRawDiskStream(&stream, block, numBlocks, rate, flags, takeOwnership);
 
 	delete[] block;
 
@@ -352,7 +352,7 @@
 	if (!data)
 		return 0;
 
-	return makeLinearInputStream(data, size, rate, flags | Audio::Mixer::FLAG_AUTOFREE, loopStart, loopEnd);
+	return makeRawMemoryStream(data, size, rate, flags | Audio::Mixer::FLAG_AUTOFREE, loopStart, loopEnd);
 #endif
 }
 
@@ -367,7 +367,7 @@
 	if (!data)
 		return 0;
 
-	return makeLinearInputStream(data, size, rate, flags | Audio::Mixer::FLAG_AUTOFREE);
+	return makeRawMemoryStream(data, size, rate, flags | Audio::Mixer::FLAG_AUTOFREE);
 #endif
 }
 

Modified: scummvm/trunk/sound/wave.cpp
===================================================================
--- scummvm/trunk/sound/wave.cpp	2010-01-19 00:41:37 UTC (rev 47366)
+++ scummvm/trunk/sound/wave.cpp	2010-01-19 00:52:41 UTC (rev 47367)
@@ -190,7 +190,7 @@
 	// Since we allocated our own buffer for the data, we must set the autofree flag.
 	flags |= Audio::Mixer::FLAG_AUTOFREE;
 
-	return makeLinearInputStream(data, size, rate, flags);
+	return makeRawMemoryStream(data, size, rate, flags);
 }
 
 } // End of namespace Audio


This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site.




More information about the Scummvm-git-logs mailing list