some optimisations in imuse digi

svn-id: r13851

1 files changed, 138 insertions, 127 deletions

diff --git a/scumm/imuse_digi/dimuse_track.cpp b/scumm/imuse_digi/dimuse_track.cpp
index 3c1359db8d..0ceaa901f9 100644
--- a/scumm/imuse_digi/dimuse_track.cpp
+++ b/scumm/imuse_digi/dimuse_track.cpp
@@ -15,7 +15,6 @@
  * along with this program; if not, write to the Free Software
  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
  *
- * $Header$
  */
 
 #include "stdafx.h"
@@ -45,27 +44,30 @@ bool IMuseDigital::allocSlot(int priority) {
 	if (!found_free) {
 		debug(5, "IMuseDigital::startSound(): All slots are full");
 		for (l = 0; l < MAX_DIGITAL_TRACKS; l++) {
-			if (_track[l]->used && _track[l]->handle.isActive() &&
-					(lower_priority > _track[l]->priority) && (!_track[l]->stream2))
-				lower_priority = _track[l]->priority;
+			Track *track = _track[l];
+				if (track->used && track->handle.isActive() &&
+					(lower_priority > track->priority) && (!track->stream2))
+				lower_priority = track->priority;
 		}
 		if (lower_priority <= priority) {
-			int track_id = -1;
+			int trackId = -1;
 			for (l = 0; l < MAX_DIGITAL_TRACKS; l++) {
-				if (_track[l]->used && _track[l]->handle.isActive() &&
-						(lower_priority == _track[l]->priority) && (!_track[l]->stream2)) {
-					track_id = l;
+				Track *track = _track[l];
+				if (track->used && track->handle.isActive() &&
+						(lower_priority == track->priority) && (!track->stream2)) {
+					trackId = l;
 				}
 			}
-			assert(track_id != -1);
-			_track[track_id]->stream->finish();
-			_track[track_id]->stream = NULL;
-			_vm->_mixer->stopHandle(_track[track_id]->handle);
-			_sound->closeSound(_track[track_id]->soundHandle);
-			_track[track_id]->soundHandle = NULL;
-			_track[track_id]->used = false;
-			assert(!_track[track_id]->handle.isActive());
-			debug(5, "IMuseDigital::startSound(): Removed sound %d from track %d", _track[track_id]->soundId, track_id);
+			assert(trackId != -1);
+			Track *track = _track[trackId];
+			track->stream->finish();
+			track->stream = NULL;
+			_vm->_mixer->stopHandle(track->handle);
+			_sound->closeSound(track->soundHandle);
+			track->soundHandle = NULL;
+			track->used = false;
+			assert(!track->handle.isActive());
+			debug(5, "IMuseDigital::startSound(): Removed sound %d from track %d", track->soundId, trackId);
 		} else {
 			debug(5, "IMuseDigital::startSound(): Priority sound too low");
 			return false;
@@ -86,52 +88,53 @@ void IMuseDigital::startSound(int soundId, const char *soundName, int soundType,
 	}
 
 	for (l = 0; l < MAX_DIGITAL_TRACKS; l++) {
-		if (!_track[l]->used && !_track[l]->handle.isActive()) {
-			_track[l]->pan = 64;
-			_track[l]->vol = volume * 1000;
-			_track[l]->volFadeDest = 0;
-			_track[l]->volFadeStep = 0;
-			_track[l]->volFadeDelay = 0;
-			_track[l]->volFadeUsed = false;
-			_track[l]->soundId = soundId;
-			_track[l]->started = false;
-			_track[l]->volGroupId = volGroupId;
-			_track[l]->curHookId = hookId;
-			_track[l]->priority = priority;
-			_track[l]->curRegion = -1;
-			_track[l]->dataOffset = 0;
-			_track[l]->regionOffset = 0;
-			_track[l]->mod = 0;
-			_track[l]->mixerFlags = 0;
-			_track[l]->mixerPan = 0;
-			_track[l]->mixerVol = volume;
-			_track[l]->toBeRemoved = false;
-			_track[l]->soundType = soundType;
+		Track *track = _track[l];
+		if (!track->used && !track->handle.isActive()) {
+			track->pan = 64;
+			track->vol = volume * 1000;
+			track->volFadeDest = 0;
+			track->volFadeStep = 0;
+			track->volFadeDelay = 0;
+			track->volFadeUsed = false;
+			track->soundId = soundId;
+			track->started = false;
+			track->volGroupId = volGroupId;
+			track->curHookId = hookId;
+			track->priority = priority;
+			track->curRegion = -1;
+			track->dataOffset = 0;
+			track->regionOffset = 0;
+			track->mod = 0;
+			track->mixerFlags = 0;
+			track->mixerPan = 0;
+			track->mixerVol = volume;
+			track->toBeRemoved = false;
+			track->soundType = soundType;
 
 			int bits = 0, freq = 0, channels = 0;
 
 			if (input) {
-				_track[l]->iteration = 0;
-				_track[l]->souStream = true;
-				_track[l]->soundName[0] = 0;
+				track->iteration = 0;
+				track->souStream = true;
+				track->soundName[0] = 0;
 			} else {
-				_track[l]->souStream = false;
-				strcpy(_track[l]->soundName, soundName);
-				_track[l]->soundHandle = _sound->openSound(soundId, soundName, soundType, volGroupId);
+				track->souStream = false;
+				strcpy(track->soundName, soundName);
+				track->soundHandle = _sound->openSound(soundId, soundName, soundType, volGroupId);
 
-				if (_track[l]->soundHandle == NULL)
+				if (track->soundHandle == NULL)
 					return;
 
-				bits = _sound->getBits(_track[l]->soundHandle);
-				channels = _sound->getChannels(_track[l]->soundHandle);
-				freq = _sound->getFreq(_track[l]->soundHandle);
+				bits = _sound->getBits(track->soundHandle);
+				channels = _sound->getChannels(track->soundHandle);
+				freq = _sound->getFreq(track->soundHandle);
 
 				if ((soundId == kTalkSoundID) && (soundType == IMUSE_BUNDLE)) {
 					if (_vm->_actorToPrintStrFor != 0xFF && _vm->_actorToPrintStrFor != 0) {
 						Actor *a = _vm->derefActor(_vm->_actorToPrintStrFor, "IMuseDigital::startSound");
 						freq = (freq * a->talkFrequency) / 256;
-						_track[l]->pan = a->talkPan;
-						_track[l]->vol = a->talkVolume * 1000;
+						track->pan = a->talkPan;
+						track->vol = a->talkVolume * 1000;
 					}
 				}
 
@@ -139,33 +142,33 @@ void IMuseDigital::startSound(int soundId, const char *soundName, int soundType,
 				assert(channels == 1 || channels == 2);
 				assert(0 < freq && freq <= 65535);
 
-				_track[l]->iteration = freq * channels;
+				track->iteration = freq * channels;
 				if (channels == 2)
-					_track[l]->mixerFlags = SoundMixer::FLAG_STEREO | SoundMixer::FLAG_REVERSE_STEREO;
+					track->mixerFlags = SoundMixer::FLAG_STEREO | SoundMixer::FLAG_REVERSE_STEREO;
 
 				if ((bits == 12) || (bits == 16)) {
-					_track[l]->mixerFlags |= SoundMixer::FLAG_16BITS;
-					_track[l]->iteration *= 2;
+					track->mixerFlags |= SoundMixer::FLAG_16BITS;
+					track->iteration *= 2;
 				} else if (bits == 8) {
-					_track[l]->mixerFlags |= SoundMixer::FLAG_UNSIGNED;
+					track->mixerFlags |= SoundMixer::FLAG_UNSIGNED;
 				} else
 					error("IMuseDigital::startSound(): Can't handle %d bit samples", bits);
 			}
 
 			if (input) {
-				_track[l]->stream2 = input;
-				_track[l]->stream = NULL;
-				_track[l]->started = false;
+				track->stream2 = input;
+				track->stream = NULL;
+				track->started = false;
 			} else {
 				// setup 1 second stream wrapped buffer
-				int32 streamBufferSize = _track[l]->iteration;
-				_track[l]->stream2 = NULL;
-				_track[l]->stream = makeAppendableAudioStream(freq, _track[l]->mixerFlags, streamBufferSize);
-				_vm->_mixer->playInputStream(&_track[l]->handle, _track[l]->stream, false, _track[l]->vol / 1000, _track[l]->pan, -1);
-				_track[l]->started = true;
+				int32 streamBufferSize = track->iteration;
+				track->stream2 = NULL;
+				track->stream = makeAppendableAudioStream(freq, track->mixerFlags, streamBufferSize);
+				_vm->_mixer->playInputStream(&track->handle, track->stream, false, track->vol / 1000, track->pan, -1);
+				track->started = true;
 			}
 
-			_track[l]->used = true;
+			track->used = true;
 			return;
 		}
 	}
@@ -180,8 +183,9 @@ void IMuseDigital::setPriority(int soundId, int priority) {
 	assert ((priority >= 0) && (priority <= 127));
 
 	for (int l = 0; l < MAX_DIGITAL_TRACKS; l++) {
-		if ((_track[l]->soundId == soundId) && _track[l]->used) {
-			_track[l]->priority = priority;
+		Track *track = _track[l];
+		if ((track->soundId == soundId) && track->used) {
+			track->priority = priority;
 		}
 	}
 }
@@ -190,8 +194,9 @@ void IMuseDigital::setVolume(int soundId, int volume) {
 	Common::StackLock lock(_mutex, "IMuseDigital::setVolume()");
 	debug(5, "IMuseDigital::setVolume(%d, %d)", soundId, volume);
 	for (int l = 0; l < MAX_DIGITAL_TRACKS; l++) {
-		if ((_track[l]->soundId == soundId) && _track[l]->used) {
-			_track[l]->vol = volume * 1000;
+		Track *track = _track[l];
+		if ((track->soundId == soundId) && track->used) {
+			track->vol = volume * 1000;
 		}
 	}
 }
@@ -200,8 +205,9 @@ void IMuseDigital::setPan(int soundId, int pan) {
 	Common::StackLock lock(_mutex, "IMuseDigital::setPan()");
 	debug(5, "IMuseDigital::setPan(%d, %d)", soundId, pan);
 	for (int l = 0; l < MAX_DIGITAL_TRACKS; l++) {
-		if ((_track[l]->soundId == soundId) && _track[l]->used) {
-			_track[l]->pan = pan;
+		Track *track = _track[l];
+		if ((track->soundId == soundId) && track->used) {
+			track->pan = pan;
 		}
 	}
 }
@@ -215,8 +221,9 @@ void IMuseDigital::selectVolumeGroup(int soundId, int volGroupId) {
 		volGroupId = 3;
 
 	for (int l = 0; l < MAX_DIGITAL_TRACKS; l++) {
-		if ((_track[l]->soundId == soundId) && _track[l]->used) {
-			_track[l]->volGroupId = volGroupId;
+		Track *track = _track[l];
+		if ((track->soundId == soundId) && track->used) {
+			track->volGroupId = volGroupId;
 		}
 	}
 }
@@ -225,11 +232,12 @@ void IMuseDigital::setFade(int soundId, int destVolume, int delay60HzTicks) {
 	Common::StackLock lock(_mutex, "IMuseDigital::setFade()");
 	debug(5, "IMuseDigital::setFade(%d, %d, %d)", soundId, destVolume, delay60HzTicks);
 	for (int l = 0; l < MAX_DIGITAL_TRACKS; l++) {
-		if ((_track[l]->soundId == soundId) && _track[l]->used) {
-			_track[l]->volFadeDelay = delay60HzTicks;
-			_track[l]->volFadeDest = destVolume * 1000;
-			_track[l]->volFadeStep = (_track[l]->volFadeDest - _track[l]->vol) * 60 * 40 / (1000 * delay60HzTicks);
-			_track[l]->volFadeUsed = true;
+		Track *track = _track[l];
+		if ((track->soundId == soundId) && track->used) {
+			track->volFadeDelay = delay60HzTicks;
+			track->volFadeDest = destVolume * 1000;
+			track->volFadeStep = (track->volFadeDest - track->vol) * 60 * 40 / (1000 * delay60HzTicks);
+			track->volFadeUsed = true;
 		}
 	}
 }
@@ -238,78 +246,81 @@ void IMuseDigital::fadeOutMusic(int fadeDelay) {
 	Common::StackLock lock(_mutex, "IMuseDigital::fadeOutMusic()");
 	debug(5, "IMuseDigital::fadeOutMusic");
 	for (int l = 0; l < MAX_DIGITAL_TRACKS; l++) {
-		if ((_track[l]->used) && (_track[l]->volGroupId == IMUSE_VOLGRP_MUSIC)) {
+		Track *track = _track[l];
+		if ((track->used) && (track->volGroupId == IMUSE_VOLGRP_MUSIC)) {
 			cloneToFadeOutTrack(l, fadeDelay, true);
 		}
 	}
 }
 
-int IMuseDigital::cloneToFadeOutTrack(int track, int fadeDelay, int killNormalTrack) {
+int IMuseDigital::cloneToFadeOutTrack(int trackId, int fadeDelay, int killNormalTrack) {
 	Common::StackLock lock(_mutex, "IMuseDigital::cloneToFadeOutTrack()");
-	debug(5, "IMuseDigital::cloneToFadeOutTrack(%d, %d)", track, fadeDelay);
-	int fadeTrack = -1;
+	debug(5, "IMuseDigital::cloneToFadeOutTrack(%d, %d)", trackId, fadeDelay);
+	int fadeTrackId = -1;
 
 	for (int l = MAX_DIGITAL_TRACKS; l < MAX_DIGITAL_TRACKS + MAX_DIGITAL_FADETRACKS; l++) {
 		if (!_track[l]->used) {
-			fadeTrack = l;
+			fadeTrackId = l;
 			break;
 		}
 	}
-	if (fadeTrack == -1)
-		error("IMuseDigital::cloneToFadeTrack() Can't find free fade track");
+	if (fadeTrackId == -1)
+		error("IMuseDigital::cloneTofadeTrackId() Can't find free fade track");
 
 	// swap track to fade track
-	Track *tmpTrack = _track[track];
-	_track[track] = _track[fadeTrack];
-	_track[fadeTrack] = tmpTrack;
+	Track *tmpTrack = _track[trackId];
+	_track[trackId] = _track[fadeTrackId];
+	_track[fadeTrackId] = tmpTrack;
 
 	// copy track params from swaped fade track to new track
-	_track[track]->pan = _track[fadeTrack]->pan;
-	_track[track]->vol = _track[fadeTrack]->vol;
-	_track[track]->volGroupId = _track[fadeTrack]->volGroupId;
-	_track[track]->volFadeDelay = _track[fadeTrack]->volFadeDelay;
-	_track[track]->volFadeDest = _track[fadeTrack]->volFadeDest;
-	_track[track]->volFadeStep = _track[fadeTrack]->volFadeStep;
-	_track[track]->volFadeUsed = _track[fadeTrack]->volFadeUsed;
-	_track[track]->priority = _track[fadeTrack]->priority;
-	_track[track]->soundId = _track[fadeTrack]->soundId;
-	_track[track]->dataOffset = _track[fadeTrack]->dataOffset;
-	_track[track]->regionOffset = _track[fadeTrack]->regionOffset;
-	_track[track]->curRegion = _track[fadeTrack]->curRegion;
-	_track[track]->curHookId = _track[fadeTrack]->curHookId;
-	_track[track]->iteration = _track[fadeTrack]->iteration;
-	_track[track]->mixerFlags = _track[fadeTrack]->mixerFlags;
-	_track[track]->mixerVol = _track[fadeTrack]->mixerVol;
-	_track[track]->mixerPan = _track[fadeTrack]->mixerPan;
-	_track[track]->mod = _track[fadeTrack]->mod;
-	_track[track]->used = _track[fadeTrack]->used;
-	_track[track]->toBeRemoved = _track[fadeTrack]->toBeRemoved;
-	_track[track]->souStream = _track[fadeTrack]->souStream;
-	_track[track]->started = _track[fadeTrack]->started;
-	_track[track]->stream2 = _track[fadeTrack]->stream2;
-	strcpy(_track[track]->soundName, _track[fadeTrack]->soundName);
-	_track[track]->soundType = _track[fadeTrack]->soundType;
-
-	_track[track]->soundHandle = NULL;
-	_track[track]->stream = NULL;
-
-	_track[fadeTrack]->volFadeDelay = fadeDelay;
-	_track[fadeTrack]->volFadeDest = 0;
-	_track[fadeTrack]->volFadeStep = (_track[fadeTrack]->volFadeDest - _track[fadeTrack]->vol) * 60 * 40 / (1000 * fadeDelay);
-	_track[fadeTrack]->volFadeUsed = true;
+	Track *track = _track[trackId];
+	Track *fadeTrack = _track[fadeTrackId];
+	track->pan = fadeTrack->pan;
+	track->vol = fadeTrack->vol;
+	track->volGroupId = fadeTrack->volGroupId;
+	track->volFadeDelay = fadeTrack->volFadeDelay;
+	track->volFadeDest = fadeTrack->volFadeDest;
+	track->volFadeStep = fadeTrack->volFadeStep;
+	track->volFadeUsed = fadeTrack->volFadeUsed;
+	track->priority = fadeTrack->priority;
+	track->soundId = fadeTrack->soundId;
+	track->dataOffset = fadeTrack->dataOffset;
+	track->regionOffset = fadeTrack->regionOffset;
+	track->curRegion = fadeTrack->curRegion;
+	track->curHookId = fadeTrack->curHookId;
+	track->iteration = fadeTrack->iteration;
+	track->mixerFlags = fadeTrack->mixerFlags;
+	track->mixerVol = fadeTrack->mixerVol;
+	track->mixerPan = fadeTrack->mixerPan;
+	track->mod = fadeTrack->mod;
+	track->used = fadeTrack->used;
+	track->toBeRemoved = fadeTrack->toBeRemoved;
+	track->souStream = fadeTrack->souStream;
+	track->started = fadeTrack->started;
+	track->stream2 = fadeTrack->stream2;
+	strcpy(track->soundName, fadeTrack->soundName);
+	track->soundType = fadeTrack->soundType;
+
+	track->soundHandle = NULL;
+	track->stream = NULL;
+
+	fadeTrack->volFadeDelay = fadeDelay;
+	fadeTrack->volFadeDest = 0;
+	fadeTrack->volFadeStep = (fadeTrack->volFadeDest - fadeTrack->vol) * 60 * 40 / (1000 * fadeDelay);
+	fadeTrack->volFadeUsed = true;
 
 	if (killNormalTrack) {
-		_track[track]->used = false;
+		track->used = false;
 	} else {
-		_track[track]->soundHandle = _sound->cloneSound(_track[fadeTrack]->soundHandle);
+		track->soundHandle = _sound->cloneSound(fadeTrack->soundHandle);
 		// setup 1 second stream wrapped buffer
-		int32 streamBufferSize = _track[track]->iteration;
-		_track[track]->stream = makeAppendableAudioStream(_sound->getFreq(_track[track]->soundHandle), _track[track]->mixerFlags, streamBufferSize);
-		_vm->_mixer->playInputStream(&_track[track]->handle, _track[track]->stream, false, _track[track]->vol / 1000, _track[track]->pan, -1);
-		_track[track]->started = true;
+		int32 streamBufferSize = track->iteration;
+		track->stream = makeAppendableAudioStream(_sound->getFreq(track->soundHandle), track->mixerFlags, streamBufferSize);
+		_vm->_mixer->playInputStream(&track->handle, track->stream, false, track->vol / 1000, track->pan, -1);
+		track->started = true;
 	}
 
-	return fadeTrack;
+	return fadeTrackId;
 }
 
 } // End of namespace Scumm