decreased usage of stack mutex locks for imuse digital

svn-id: r13893

4 files changed, 147 insertions, 187 deletions

diff --git a/scumm/imuse_digi/dimuse.cpp b/scumm/imuse_digi/dimuse.cpp
index 8902083173..8c9ea7a8f2 100644
--- a/scumm/imuse_digi/dimuse.cpp
+++ b/scumm/imuse_digi/dimuse.cpp
@@ -58,7 +58,6 @@ IMuseDigital::IMuseDigital(ScummEngine *scumm)
 }
 
 IMuseDigital::~IMuseDigital() {
-	Common::StackLock lock(_mutex, "IMuseDigital::~IMuseDigital()");
 	stopAllSounds();
 	_vm->_timer->removeTimerProc(timer_handler);
 	for (int l = 0; l < MAX_DIGITAL_TRACKS + MAX_DIGITAL_FADETRACKS; l++) {
@@ -125,26 +124,28 @@ void IMuseDigital::saveOrLoad(Serializer *ser) {
 	ser->_load_ref = NULL;
 
 	ser->saveLoadEntries(this, mainEntries);
-	for (int i = 0; i < MAX_DIGITAL_TRACKS + MAX_DIGITAL_FADETRACKS; i++) {
-		Track *track = _track[i];
+	for (int l = 0; l < MAX_DIGITAL_TRACKS + MAX_DIGITAL_FADETRACKS; l++) {
+		Track *track = _track[l];
 		ser->saveLoadEntries(track, trackEntries);
 		if (!ser->isSaving()) {
 			if (!track->used)
 				continue;
-			if (track->souStream) {
+			track->readyToRemove = false;
+			if ((track->toBeRemoved) || (track->souStream)) {
 				track->stream2 = NULL;
 				track->stream = NULL;
 				track->used = false;
-			} else {
-				track->soundHandle = _sound->openSound(track->soundId,
-										track->soundName, track->soundType,
-										track->volGroupId);
-				int32 streamBufferSize = track->iteration;
-				int	freq = _sound->getFreq(track->soundHandle);
-				track->stream2 = NULL;
-				track->stream = makeAppendableAudioStream(freq, track->mixerFlags, streamBufferSize);
-				_vm->_mixer->playInputStream(&track->handle, track->stream, false, track->vol / 1000, track->pan, -1);
+				continue;
 			}
+
+			track->soundHandle = _sound->openSound(track->soundId,
+									track->soundName, track->soundType,
+									track->volGroupId);
+			int32 streamBufferSize = track->iteration;
+			int	freq = _sound->getFreq(track->soundHandle);
+			track->stream2 = NULL;
+			track->stream = makeAppendableAudioStream(freq, track->mixerFlags, streamBufferSize);
+			_vm->_mixer->playInputStream(&track->handle, track->stream, false, track->vol / 1000, track->pan, -1);
 		}
 	}
 }
@@ -157,25 +158,10 @@ void IMuseDigital::callback() {
 
 	for (int l = 0; l < MAX_DIGITAL_TRACKS + MAX_DIGITAL_FADETRACKS; l++) {
 		Track *track = _track[l];
-		if (track->used) {
-			if (track->stream2) {
-				if (!track->handle.isActive() && track->started) {
-					debug(5, "IMuseDigital::callback() A: stopped sound: %d", track->soundId);
-					delete _track[l]->stream2;
-					track->stream2 = NULL;
-					track->used = false;
-					continue;
-				}
-			} else if (track->stream) {
-				if (track->toBeRemoved) {
-					debug(5, "IMuseDigital::callback() B: stopped sound: %d", track->soundId);
-					track->stream->finish();
-					track->stream = NULL;
-					_sound->closeSound(track->soundHandle);
-					track->soundHandle = NULL;
-					track->used = false;
-					continue;
-				}
+		if (track->used && !track->readyToRemove) {
+			if (track->toBeRemoved) {
+				track->readyToRemove = true;
+				continue;
 			}
 
 			if (track->volFadeUsed) {
@@ -238,12 +224,11 @@ void IMuseDigital::callback() {
 				int bits = _sound->getBits(track->soundHandle);
 				int channels = _sound->getChannels(track->soundHandle);
 
-//				int32 bufferUsage = track->iteration - track->stream->getFreeSpace();
-				int32 bufferMin = track->iteration / 25;
-//				if (bufferMin < bufferUsage)
-//					continue;
+				int32 mixer_size = track->iteration / 25;
 
-				int32 mixer_size = bufferMin;
+				if (track->stream->endOfData()) {
+					mixer_size *= 2;
+				}
 
 				if ((bits == 12) || (bits == 16)) {
 					if (channels == 1)
@@ -315,7 +300,6 @@ void IMuseDigital::switchToNextRegion(int trackId) {
 	debug(5, "switchToNextRegion(track:%d)", trackId);
 
 	Track *track = _track[trackId];
-
 	if (trackId >= MAX_DIGITAL_TRACKS) {
 		track->toBeRemoved = true;
 		debug(5, "exit (fadetrack can't go next region) switchToNextRegion(trackId:%d)", trackId);
@@ -343,7 +327,7 @@ void IMuseDigital::switchToNextRegion(int trackId) {
 		if (sampleHookId != 0) {
 			if (track->curHookId == sampleHookId) {
 				if (fadeDelay != 0) {
-					int fadeTrackId = cloneToFadeOutTrack(trackId, fadeDelay, false);
+					int fadeTrackId = cloneToFadeOutTrack(trackId, fadeDelay);
 					Track *fadeTrack = _track[fadeTrackId];
 					fadeTrack->dataOffset = _sound->getRegionOffset(fadeTrack->soundHandle, fadeTrack->curRegion);
 					fadeTrack->regionOffset = 0;
@@ -356,7 +340,7 @@ void IMuseDigital::switchToNextRegion(int trackId) {
 			}
 		} else {
 			if (fadeDelay != 0) {
-				int fadeTrackId = cloneToFadeOutTrack(trackId, fadeDelay, false);
+				int fadeTrackId = cloneToFadeOutTrack(trackId, fadeDelay);
 				Track *fadeTrack = _track[fadeTrackId];
 				fadeTrack->dataOffset = _sound->getRegionOffset(fadeTrack->soundHandle, fadeTrack->curRegion);
 				fadeTrack->regionOffset = 0;
diff --git a/scumm/imuse_digi/dimuse.h b/scumm/imuse_digi/dimuse.h
index 5aaa47efc4..88e274879f 100644
--- a/scumm/imuse_digi/dimuse.h
+++ b/scumm/imuse_digi/dimuse.h
@@ -55,6 +55,7 @@ private:
 		char soundName[15];
 		bool used;
 		bool toBeRemoved;
+		bool readyToRemove;
 		bool started;
 		bool souStream;
 		int32 priority;
@@ -100,7 +101,7 @@ private:
 	static void timer_handler(void *refConf);
 	void callback();
 	void switchToNextRegion(int trackId);
-	bool allocSlot(int priority);
+	int allocSlot(int priority);
 	void startSound(int soundId, const char *soundName, int soundType, int volGroupId, AudioStream *input, int hookId, int volume, int priority);
 	void selectVolumeGroup(int soundId, int volGroupId);
 
@@ -109,7 +110,7 @@ private:
 
 	int getSoundIdByName(const char *soundName);
 	void fadeOutMusic(int fadeDelay);
-	int cloneToFadeOutTrack(int trackId, int fadeDelay, int killNormalTrack);
+	int cloneToFadeOutTrack(int trackId, int fadeDelay);
 
 	void setFtMusicState(int stateId);
 	void setFtMusicSequence(int seqId);
@@ -156,6 +157,7 @@ public:
 	void pause(bool pause);
 	void parseScriptCmds(int a, int b, int c, int d, int e, int f, int g, int h);
 	void refreshScripts();
+	void flushTracks();
 	int getSoundStatus(int sound) const;
 	int32 getCurMusicPosInMs();
 	int32 getCurVoiceLipSyncWidth();
diff --git a/scumm/imuse_digi/dimuse_script.cpp b/scumm/imuse_digi/dimuse_script.cpp
index 7812cf8fa9..72e77d655c 100644
--- a/scumm/imuse_digi/dimuse_script.cpp
+++ b/scumm/imuse_digi/dimuse_script.cpp
@@ -159,16 +159,36 @@ void IMuseDigital::parseScriptCmds(int a, int b, int c, int d, int e, int f, int
 	}
 }
 
+void IMuseDigital::flushTracks() {
+	for (int l = 0; l < MAX_DIGITAL_TRACKS + MAX_DIGITAL_FADETRACKS; l++) {
+		Track *track = _track[l];
+		if (track->used && track->readyToRemove) {
+			if (track->stream) {
+	 			track->stream->finish();
+				track->stream = NULL;
+				_vm->_mixer->stopHandle(track->handle);
+				_sound->closeSound(track->soundHandle);
+				track->soundHandle = NULL;
+			} else if (track->stream2) {
+				_vm->_mixer->stopHandle(track->handle);
+				delete track->stream2;
+				track->stream2 = NULL;
+			}
+			track->used = false;
+		}
+	}
+}
+
 void IMuseDigital::refreshScripts() {
-	Common::StackLock lock(_mutex, "IMuseDigital::refreshScripts()");
 	bool found = false;
 	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->toBeRemoved && (track->volGroupId == IMUSE_VOLGRP_MUSIC)) {
 			found = true;
 		}
 	}
 
-	if ((!found) && (_curMusicSeq != 0)) {
+	if (!found && (_curMusicSeq != 0)) {
 		parseScriptCmds(0x1001, 0, 0, 0, 0, 0, 0, 0);
 	}
 }
@@ -206,7 +226,7 @@ void IMuseDigital::getLipSync(int soundId, int syncId, int32 msPos, int32 &width
 	if (msPos < 65536) {
 		for (int l = 0; l < MAX_DIGITAL_TRACKS; l++) {
 			Track *track = _track[l];
-			if ((track->soundId == soundId) && track->used) {
+			if ((track->soundId == soundId) && track->used && !track->toBeRemoved) {
 				_sound->getSyncSizeAndPtrById(track->soundHandle, syncId, sync_size, &sync_ptr);
 				if ((sync_size != 0) && (sync_ptr != NULL)) {
 					sync_size /= 4;
@@ -233,7 +253,7 @@ void IMuseDigital::getLipSync(int soundId, int syncId, int32 msPos, int32 &width
 int32 IMuseDigital::getPosInMs(int soundId) {
 	for (int l = 0; l < MAX_DIGITAL_TRACKS; l++) {
 		Track *track = _track[l];
-		if ((track->soundId == soundId) && (track->used)) {
+		if ((track->soundId == soundId) && track->used && !track->toBeRemoved) {
 			int32 pos = (5 * (track->dataOffset + track->regionOffset)) / (track->iteration / 200);
 			return pos;
 		}
@@ -243,7 +263,6 @@ int32 IMuseDigital::getPosInMs(int soundId) {
 }
 
 int IMuseDigital::getSoundStatus(int sound) const {
-	Common::StackLock lock(_mutex, "IMuseDigital::getSoundStatus()");
 	debug(5, "IMuseDigital::getSoundStatus(%d)", sound);
 	for (int l = 0; l < MAX_DIGITAL_TRACKS; l++) {
 		Track *track = _track[l];
@@ -256,34 +275,21 @@ int IMuseDigital::getSoundStatus(int sound) const {
 }
 
 void IMuseDigital::stopSound(int soundId) {
-	Common::StackLock lock(_mutex, "IMuseDigital::stopSound()");
 	debug(5, "IMuseDigital::stopSound(%d)", soundId);
 	for (int l = 0; l < MAX_DIGITAL_TRACKS; l++) {
 		Track *track = _track[l];
-		if ((track->soundId == soundId) && (track->used)) {
-			if (track->stream) {
-				track->stream->finish();
-				track->stream = NULL;
-				_vm->_mixer->stopHandle(track->handle);
-				_sound->closeSound(track->soundHandle);
-				track->soundHandle = NULL;
-			} else if (track->stream2) {
-				_vm->_mixer->stopHandle(track->handle);
-				delete track->stream2;
-				track->stream2 = NULL;
-			}
-			track->used = false;
+		if ((track->soundId == soundId) && track->used && !track->toBeRemoved) {
+			track->toBeRemoved = true;
 		}
 	}
 }
 
 int32 IMuseDigital::getCurMusicPosInMs() {
-	Common::StackLock lock(_mutex, "IMuseDigital::getCurMusicPosInMs()");
 	int soundId = -1;
 
 	for (int l = 0; l < MAX_DIGITAL_TRACKS; l++) {
 		Track *track = _track[l];
-		if ((track->used) && (track->volGroupId == IMUSE_VOLGRP_MUSIC)) {
+		if (track->used && !track->toBeRemoved && (track->volGroupId == IMUSE_VOLGRP_MUSIC)) {
 			soundId = track->soundId;
 		}
 	}
@@ -294,7 +300,6 @@ int32 IMuseDigital::getCurMusicPosInMs() {
 }
 
 int32 IMuseDigital::getCurVoiceLipSyncWidth() {
-	Common::StackLock lock(_mutex, "IMuseDigital::getCutVoiceLipSyncWidth()");
 	int32 msPos = getPosInMs(kTalkSoundID) + 50;
 	int32 width = 0, height = 0;
 
@@ -304,7 +309,6 @@ int32 IMuseDigital::getCurVoiceLipSyncWidth() {
 }
 
 int32 IMuseDigital::getCurVoiceLipSyncHeight() {
-	Common::StackLock lock(_mutex, "IMuseDigital::getCurVoiceLipSyncHeight()");
 	int32 msPos = getPosInMs(kTalkSoundID) + 50;
 	int32 width = 0, height = 0;
 
@@ -314,12 +318,11 @@ int32 IMuseDigital::getCurVoiceLipSyncHeight() {
 }
 
 int32 IMuseDigital::getCurMusicLipSyncWidth(int syncId) {
-	Common::StackLock lock(_mutex, "IMuseDigital::getCurMusicLipSyncWidth()");
 	int soundId = -1;
 
 	for (int l = 0; l < MAX_DIGITAL_TRACKS; l++) {
 		Track *track = _track[l];
-		if ((track->used) && (track->volGroupId == IMUSE_VOLGRP_MUSIC)) {
+		if (track->used && !track->toBeRemoved && (track->volGroupId == IMUSE_VOLGRP_MUSIC)) {
 			soundId = track->soundId;
 		}
 	}
@@ -333,12 +336,11 @@ int32 IMuseDigital::getCurMusicLipSyncWidth(int syncId) {
 }
 
 int32 IMuseDigital::getCurMusicLipSyncHeight(int syncId) {
-	Common::StackLock lock(_mutex, "IMuseDigital::getCurMusicLipSyncHeight()");
 	int soundId = -1;
 
 	for (int l = 0; l < MAX_DIGITAL_TRACKS; l++) {
 		Track *track = _track[l];
-		if ((track->used) && (track->volGroupId == IMUSE_VOLGRP_MUSIC)) {
+		if (track->used && !track->toBeRemoved && (track->volGroupId == IMUSE_VOLGRP_MUSIC)) {
 			soundId = track->soundId;
 		}
 	}
@@ -352,33 +354,28 @@ int32 IMuseDigital::getCurMusicLipSyncHeight(int syncId) {
 }
 
 void IMuseDigital::stopAllSounds() {
-	Common::StackLock lock(_mutex, "IMuseDigital::stopAllSounds()");
 	debug(5, "IMuseDigital::stopAllSounds");
 
-	for (int l = 0; l < MAX_DIGITAL_TRACKS + MAX_DIGITAL_FADETRACKS; l++) {
-		Track *track = _track[l];
-		if (track->used) {
-			if (track->stream) {
-				track->stream->finish();
-				track->stream = NULL;
-				_vm->_mixer->stopHandle(track->handle);
-				_sound->closeSound(track->soundHandle);
-				track->soundHandle = NULL;
-			} else if (track->stream2) {
-				_vm->_mixer->stopHandle(track->handle);
-				delete track->stream2;
-				track->stream2 = NULL;
+	for(;;) {
+		bool foundNotRemoved = false;
+		for (int l = 0; l < MAX_DIGITAL_TRACKS + MAX_DIGITAL_FADETRACKS; l++) {
+			Track *track = _track[l];
+			if (track->used) {
+				track->toBeRemoved = true;
+				foundNotRemoved = true;
 			}
-			track->used = false;
 		}
+		if (!foundNotRemoved)
+			break;
+		flushTracks();
 	}
 }
 
 void IMuseDigital::pause(bool p) {
-	Common::StackLock lock(_mutex, "IMuseDigital::pause()");
 	for (int l = 0; l < MAX_DIGITAL_TRACKS + MAX_DIGITAL_FADETRACKS; l++) {
-		if (_track[l]->used) {
-			_vm->_mixer->pauseHandle(_track[l]->handle, p);
+		Track *track = _track[l];
+		if (track->used) {
+			_vm->_mixer->pauseHandle(track->handle, p);
 		}
 	}
 	_pause = p;
diff --git a/scumm/imuse_digi/dimuse_track.cpp b/scumm/imuse_digi/dimuse_track.cpp
index 705d6d3c21..c9dfad79bb 100644
--- a/scumm/imuse_digi/dimuse_track.cpp
+++ b/scumm/imuse_digi/dimuse_track.cpp
@@ -32,64 +32,57 @@
 
 namespace Scumm {
 
-bool IMuseDigital::allocSlot(int priority) {
-	Common::StackLock lock(_mutex, "IMuseDigital::allocSlot()");
-	int l;
-	int lower_priority = 127;
-	bool found_free = false;
+int IMuseDigital::allocSlot(int priority) {
+	int l, lower_priority = 127;
+	int trackId = -1;
 
 	for (l = 0; l < MAX_DIGITAL_TRACKS; l++) {
-		if (!_track[l]->used && !_track[l]->handle.isActive())
-			found_free = true;
+		if (!_track[l]->used) {
+			trackId = l;
+			break;
+		}
 	}
 
-	if (!found_free) {
+	if (trackId == -1) {
 		debug(5, "IMuseDigital::startSound(): All slots are full");
 		for (l = 0; l < MAX_DIGITAL_TRACKS; l++) {
 			Track *track = _track[l];
-				if (track->used && track->handle.isActive() &&
-					(lower_priority > track->priority) && (!track->stream2))
+			if (track->used && !track->toBeRemoved &&
+					(lower_priority > track->priority) && !track->stream2)
 				lower_priority = track->priority;
 		}
 		if (lower_priority <= priority) {
-			int trackId = -1;
 			for (l = 0; l < MAX_DIGITAL_TRACKS; l++) {
 				Track *track = _track[l];
-				if (track->used && track->handle.isActive() &&
-						(lower_priority == track->priority) && (!track->stream2)) {
+				if (track->used && !track->toBeRemoved &&
+						(lower_priority == track->priority) && !track->stream2) {
 					trackId = l;
 				}
 			}
 			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);
+			_track[trackId]->toBeRemoved = true;
+			debug(5, "IMuseDigital::startSound(): Removed sound %d from track %d", _track[trackId]->soundId, trackId);
 		} else {
 			debug(5, "IMuseDigital::startSound(): Priority sound too low");
-			return false;
+			return -1;
 		}
 	}
 
-	return true;
+	return trackId;
 }
 
 void IMuseDigital::startSound(int soundId, const char *soundName, int soundType, int volGroupId, AudioStream *input, int hookId, int volume, int priority) {
 	debug(5, "IMuseDigital::startSound(%d)", soundId);
-	int l;
 
-	if (!allocSlot(priority)) {
+	int l = allocSlot(priority);
+	if (l == -1) {
 		warning("IMuseDigital::startSound() Can't start sound - no free slots");
 		return;
 	}
 
-	for (l = 0; l < MAX_DIGITAL_TRACKS; l++) {
-		Track *track = _track[l];
+	Track *track = _track[l];
+	for (;;) {
+		flushTracks();
 		if (!track->used && !track->handle.isActive()) {
 			track->pan = 64;
 			track->vol = volume * 1000;
@@ -110,6 +103,7 @@ void IMuseDigital::startSound(int soundId, const char *soundName, int soundType,
 			track->mixerPan = 0;
 			track->mixerVol = volume;
 			track->toBeRemoved = false;
+			track->readyToRemove = false;
 			track->soundType = soundType;
 
 			int bits = 0, freq = 0, channels = 0;
@@ -173,48 +167,41 @@ void IMuseDigital::startSound(int soundId, const char *soundName, int soundType,
 			return;
 		}
 	}
-
-	error("IMuseDigital::startSound(): We should never get here");
 }
 
 void IMuseDigital::setPriority(int soundId, int priority) {
-	Common::StackLock lock(_mutex, "IMuseDigital::setPriority()");
 	debug(5, "IMuseDigital::setPriority(%d, %d)", soundId, priority);
-
 	assert ((priority >= 0) && (priority <= 127));
 
 	for (int l = 0; l < MAX_DIGITAL_TRACKS; l++) {
 		Track *track = _track[l];
-		if ((track->soundId == soundId) && track->used) {
+		if ((track->soundId == soundId) && track->used && !track->toBeRemoved) {
 			track->priority = priority;
 		}
 	}
 }
 
 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++) {
 		Track *track = _track[l];
-		if ((track->soundId == soundId) && track->used) {
+		if ((track->soundId == soundId) && track->used && !track->toBeRemoved) {
 			track->vol = volume * 1000;
 		}
 	}
 }
 
 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++) {
 		Track *track = _track[l];
-		if ((track->soundId == soundId) && track->used) {
+		if ((track->soundId == soundId) && track->used && !track->toBeRemoved) {
 			track->pan = pan;
 		}
 	}
 }
 
 void IMuseDigital::selectVolumeGroup(int soundId, int volGroupId) {
-	Common::StackLock lock(_mutex, "IMuseDigital::setGroupVolume()");
 	debug(5, "IMuseDigital::setGroupVolume(%d, %d)", soundId, volGroupId);
 	assert((volGroupId >= 1) && (volGroupId <= 4));
 
@@ -223,7 +210,7 @@ void IMuseDigital::selectVolumeGroup(int soundId, int volGroupId) {
 
 	for (int l = 0; l < MAX_DIGITAL_TRACKS; l++) {
 		Track *track = _track[l];
-		if ((track->soundId == soundId) && track->used) {
+		if ((track->soundId == soundId) && track->used && !track->toBeRemoved) {
 			track->volGroupId = volGroupId;
 		}
 	}
@@ -231,10 +218,11 @@ void IMuseDigital::selectVolumeGroup(int soundId, int volGroupId) {
 
 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++) {
 		Track *track = _track[l];
-		if ((track->soundId == soundId) && track->used) {
+		if ((track->soundId == soundId) && track->used && !track->toBeRemoved) {
 			track->volFadeDelay = delay60HzTicks;
 			track->volFadeDest = destVolume * 1000;
 			track->volFadeStep = (track->volFadeDest - track->vol) * 60 * 40 / (1000 * delay60HzTicks);
@@ -244,82 +232,71 @@ void IMuseDigital::setFade(int soundId, int destVolume, int delay60HzTicks) {
 }
 
 void IMuseDigital::fadeOutMusic(int fadeDelay) {
-	Common::StackLock lock(_mutex, "IMuseDigital::fadeOutMusic()");
 	debug(5, "IMuseDigital::fadeOutMusic");
 	for (int l = 0; l < MAX_DIGITAL_TRACKS; l++) {
 		Track *track = _track[l];
-		if ((track->used) && (track->volGroupId == IMUSE_VOLGRP_MUSIC)) {
-			cloneToFadeOutTrack(l, fadeDelay, true);
+		if (track->used && !track->toBeRemoved && (track->volGroupId == IMUSE_VOLGRP_MUSIC)) {
+			cloneToFadeOutTrack(l, fadeDelay);
+			track->toBeRemoved = true;
 		}
 	}
 }
 
-int IMuseDigital::cloneToFadeOutTrack(int trackId, int fadeDelay, int killNormalTrack) {
-	Common::StackLock lock(_mutex, "IMuseDigital::cloneToFadeOutTrack()");
-	debug(5, "IMuseDigital::cloneToFadeOutTrack(%d, %d)", trackId, fadeDelay);
+int IMuseDigital::cloneToFadeOutTrack(int trackId, int fadeDelay) {
 	int fadeTrackId = -1;
+	Track *track;
+	Track *fadeTrack;
 
-	for (int l = MAX_DIGITAL_TRACKS; l < MAX_DIGITAL_TRACKS + MAX_DIGITAL_FADETRACKS; l++) {
-		if (!_track[l]->used) {
-			fadeTrackId = l;
-			break;
+	debug(5, "IMuseDigital::cloneToFadeOutTrack(%d, %d)", trackId, fadeDelay);
+
+	{
+		Common::StackLock lock(_mutex, "IMuseDigital::cloneToFadeOutTrack()");
+		for (int l = MAX_DIGITAL_TRACKS; l < MAX_DIGITAL_TRACKS + MAX_DIGITAL_FADETRACKS; l++) {
+			if (!_track[l]->used) {
+				fadeTrackId = l;
+				break;
+			}
 		}
+		if (fadeTrackId == -1)
+			error("IMuseDigital::cloneTofadeTrackId() Can't find free fade track");
+
+		track = _track[trackId];
+		fadeTrack = _track[fadeTrackId];
+		fadeTrack->pan = track->pan;
+		fadeTrack->vol = track->vol;
+		fadeTrack->volGroupId = track->volGroupId;
+		fadeTrack->priority = track->priority;
+		fadeTrack->soundId = track->soundId;
+		fadeTrack->dataOffset = track->dataOffset;
+		fadeTrack->regionOffset = track->regionOffset;
+		fadeTrack->curRegion = track->curRegion;
+		fadeTrack->curHookId = track->curHookId;
+		fadeTrack->iteration = track->iteration;
+		fadeTrack->mixerFlags = track->mixerFlags;
+		fadeTrack->mixerVol = track->mixerVol;
+		fadeTrack->mixerPan = track->mixerPan;
+		fadeTrack->mod = track->mod;
+		fadeTrack->toBeRemoved = track->toBeRemoved;
+		fadeTrack->readyToRemove = track->readyToRemove;
+		fadeTrack->souStream = track->souStream;
+		fadeTrack->started = track->started;
+		fadeTrack->stream2 = track->stream2;
+		strcpy(fadeTrack->soundName, track->soundName);
+		fadeTrack->soundType = track->soundType;
+		fadeTrack->soundHandle = _sound->cloneSound(track->soundHandle);
 	}
-	if (fadeTrackId == -1)
-		error("IMuseDigital::cloneTofadeTrackId() Can't find free fade track");
-
-	// swap track to fade track
-	Track *tmpTrack = _track[trackId];
-	_track[trackId] = _track[fadeTrackId];
-	_track[fadeTrackId] = tmpTrack;
-
-	// copy track params from swaped fade track to new track
-	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->used = false;
-	} else {
-		track->soundHandle = _sound->cloneSound(fadeTrack->soundHandle);
-		// setup 1 second stream wrapped buffer
-		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;
-	}
+	// setup 1 second stream wrapped buffer
+	int32 streamBufferSize = fadeTrack->iteration;
+	fadeTrack->stream = makeAppendableAudioStream(_sound->getFreq(fadeTrack->soundHandle), fadeTrack->mixerFlags, streamBufferSize);
+	_vm->_mixer->playInputStream(&fadeTrack->handle, fadeTrack->stream, false, fadeTrack->vol / 1000, fadeTrack->pan, -1);
+	fadeTrack->started = true;
+	fadeTrack->used = true;
 
 	return fadeTrackId;
 }