thirdparty/scummvm
2
0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

experimental imuse without timer thread usage, it might still have issue stoped audio while switching rooms

Browse source 
svn-id: r20270
This commit is contained in:
Paweł Kołodziejski 2006-01-28 16:30:39 +00:00
parent a0ac36c790
commit dd02251cb3
7 changed files with 211 additions and 212 deletions
Download patch file Download diff file Expand all files Collapse all files

266
scumm/imuse_digi/dimuse.cpp
View file

@ -38,23 +38,20 @@ IMuseDigital::Track::Track()
: soundId(-1), used(false), stream(NULL), stream2(NULL) { : soundId(-1), used(false), stream(NULL), stream2(NULL) {
} }
void IMuseDigital::timer_handler(void *refCon) {
IMuseDigital *imuseDigital = (IMuseDigital *)refCon;
imuseDigital->callback();
}
IMuseDigital::IMuseDigital(ScummEngine *scumm, int fps) IMuseDigital::IMuseDigital(ScummEngine *scumm, int fps)
: _vm(scumm) { : _vm(scumm) {
_pause = false; _pause = false;
_sound = new ImuseDigiSndMgr(_vm); _sound = new ImuseDigiSndMgr(_vm);
_callbackFps = fps; _callbackFps = fps;
_interval = 1000000 / fps;
_counter = _interval;
_firstCall = true;
resetState(); resetState();
for (int l = 0; l < MAX_DIGITAL_TRACKS + MAX_DIGITAL_FADETRACKS; l++) { for (int l = 0; l < MAX_DIGITAL_TRACKS + MAX_DIGITAL_FADETRACKS; l++) {
_track[l] = new Track; _track[l] = new Track;
_track[l]->trackId = l; _track[l]->trackId = l;
_track[l]->used = false; _track[l]->used = false;
} }
_vm->_timer->installTimerProc(timer_handler, 1000000 / _callbackFps, this);
_audioNames = NULL; _audioNames = NULL;
_numAudioNames = 0; _numAudioNames = 0;
@ -62,7 +59,6 @@ IMuseDigital::IMuseDigital(ScummEngine *scumm, int fps)
IMuseDigital::~IMuseDigital() { IMuseDigital::~IMuseDigital() {
stopAllSounds(); stopAllSounds();
_vm->_timer->removeTimerProc(timer_handler);
for (int l = 0; l < MAX_DIGITAL_TRACKS + MAX_DIGITAL_FADETRACKS; l++) { for (int l = 0; l < MAX_DIGITAL_TRACKS + MAX_DIGITAL_FADETRACKS; l++) {
delete _track[l]; delete _track[l];
} }
@ -79,8 +75,6 @@ void IMuseDigital::resetState() {
} }
void IMuseDigital::saveOrLoad(Serializer *ser) { void IMuseDigital::saveOrLoad(Serializer *ser) {
Common::StackLock lock(_mutex, "IMuseDigital::saveOrLoad()");
const SaveLoadEntry mainEntries[] = { const SaveLoadEntry mainEntries[] = {
MK_OBSOLETE(IMuseDigital, _volVoice, sleInt32, VER(31), VER(42)), MK_OBSOLETE(IMuseDigital, _volVoice, sleInt32, VER(31), VER(42)),
MK_OBSOLETE(IMuseDigital, _volSfx, sleInt32, VER(31), VER(42)), MK_OBSOLETE(IMuseDigital, _volSfx, sleInt32, VER(31), VER(42)),
@ -203,142 +197,154 @@ void IMuseDigital::saveOrLoad(Serializer *ser) {
} }
void IMuseDigital::callback() { void IMuseDigital::callback() {
Common::StackLock lock(_mutex, "IMuseDigital::callback()"); if (_firstCall) {
_thisTime = _vm->_system->getMillis();
_firstCall = false;
}
for (int l = 0; l < MAX_DIGITAL_TRACKS + MAX_DIGITAL_FADETRACKS; l++) { _lastTime = _thisTime;
Track *track = _track[l]; _thisTime = _vm->_system->getMillis();
if (track->used && !track->readyToRemove) { int32 interval = 1000 * (_thisTime - _lastTime);
if (track->toBeRemoved) { if (interval > 100000) {
track->readyToRemove = true; warning("IMuseDigital::callback: long interval: %d", interval);
continue; interval = _interval;
} }
if (_pause || !_vm) _counter -= interval;
return;
if (track->volFadeUsed) { while (_counter <= 0) {
if (track->volFadeStep < 0) { _counter += _interval;
if (track->vol > track->volFadeDest) {
track->vol += track->volFadeStep; if (_vm->_quit)
if (track->vol < track->volFadeDest) { return;
track->vol = track->volFadeDest;
track->volFadeUsed = false; for (int l = 0; l < MAX_DIGITAL_TRACKS + MAX_DIGITAL_FADETRACKS; l++) {
} Track *track = _track[l];
if (track->vol == 0) { if (track->used && !track->toBeRemoved) {
track->toBeRemoved = true; if (track->volFadeUsed) {
} if (track->volFadeStep < 0) {
}
} else if (track->volFadeStep > 0) {
if (track->vol < track->volFadeDest) {
track->vol += track->volFadeStep;
if (track->vol > track->volFadeDest) { if (track->vol > track->volFadeDest) {
track->vol = track->volFadeDest; track->vol += track->volFadeStep;
track->volFadeUsed = false; if (track->vol < track->volFadeDest) {
track->vol = track->volFadeDest;
track->volFadeUsed = false;
}
if (track->vol == 0) {
track->toBeRemoved = true;
}
}
} else if (track->volFadeStep > 0) {
if (track->vol < track->volFadeDest) {
track->vol += track->volFadeStep;
if (track->vol > track->volFadeDest) {
track->vol = track->volFadeDest;
track->volFadeUsed = false;
}
} }
} }
} debug(5, "Fade: sound(%d), Vol(%d)", track->soundId, track->vol / 1000);
debug(5, "Fade: sound(%d), Vol(%d)", track->soundId, track->vol / 1000);
}
const int pan = (track->pan != 64) ? 2 * track->pan - 127 : 0;
const int vol = track->vol / 1000;
Audio::Mixer::SoundType type = Audio::Mixer::kPlainSoundType;
if (track->volGroupId == 1)
type = Audio::Mixer::kSpeechSoundType;
if (track->volGroupId == 2)
type = Audio::Mixer::kSFXSoundType;
if (track->volGroupId == 3)
type = Audio::Mixer::kMusicSoundType;
if (track->stream) {
byte *data = NULL;
int32 result = 0;
if (track->curRegion == -1) {
switchToNextRegion(track);
if (track->toBeRemoved)
continue;
} }
int bits = _sound->getBits(track->soundHandle); const int pan = (track->pan != 64) ? 2 * track->pan - 127 : 0;
int channels = _sound->getChannels(track->soundHandle); const int vol = track->vol / 1000;
Audio::Mixer::SoundType type = Audio::Mixer::kPlainSoundType;
int32 mixer_size = track->iteration / _callbackFps; if (track->volGroupId == 1)
type = Audio::Mixer::kSpeechSoundType;
if (track->volGroupId == 2)
type = Audio::Mixer::kSFXSoundType;
if (track->volGroupId == 3)
type = Audio::Mixer::kMusicSoundType;
if (track->stream->endOfData()) { if (track->stream) {
mixer_size *= 2; byte *data = NULL;
} int32 result = 0;
if ((bits == 12) || (bits == 16)) { if (track->curRegion == -1) {
if (channels == 1)
mixer_size &= ~1;
if (channels == 2)
mixer_size &= ~3;
} else {
if (channels == 2)
mixer_size &= ~1;
}
if (mixer_size == 0)
continue;
do {
if (bits == 12) {
byte *ptr = NULL;
mixer_size += track->mod;
int mixer_size_12 = (mixer_size * 3) / 4;
int length = (mixer_size_12 / 3) * 4;
track->mod = mixer_size - length;
int32 offset = (track->regionOffset * 3) / 4;
int result2 = _sound->getDataFromRegion(track->soundHandle, track->curRegion, &ptr, offset, mixer_size_12);
result = BundleCodecs::decode12BitsSample(ptr, &data, result2);
free(ptr);
} else if (bits == 16) {
result = _sound->getDataFromRegion(track->soundHandle, track->curRegion, &data, track->regionOffset, mixer_size);
if (channels == 1) {
result &= ~1;
}
if (channels == 2) {
result &= ~3;
}
} else if (bits == 8) {
result = _sound->getDataFromRegion(track->soundHandle, track->curRegion, &data, track->regionOffset, mixer_size);
if (channels == 2) {
result &= ~1;
}
}
if (result > mixer_size)
result = mixer_size;
if (_vm->_mixer->isReady()) {
_vm->_mixer->setChannelVolume(track->handle, vol);
_vm->_mixer->setChannelBalance(track->handle, pan);
track->stream->append(data, result);
track->regionOffset += result;
}
free(data);
if (_sound->isEndOfRegion(track->soundHandle, track->curRegion)) {
switchToNextRegion(track); switchToNextRegion(track);
if (track->toBeRemoved) if (track->toBeRemoved)
break; continue;
} }
mixer_size -= result;
assert(mixer_size >= 0); int bits = _sound->getBits(track->soundHandle);
} while (mixer_size != 0); int channels = _sound->getChannels(track->soundHandle);
} else if (track->stream2) {
if (_vm->_mixer->isReady()) { int32 mixer_size = track->iteration / _callbackFps;
if (!track->started) {
track->started = true; if (track->stream->endOfData()) {
_vm->_mixer->playInputStream(type, &track->handle, track->stream2, -1, vol, pan, false); mixer_size *= 2;
}
if ((bits == 12) || (bits == 16)) {
if (channels == 1)
mixer_size &= ~1;
if (channels == 2)
mixer_size &= ~3;
} else { } else {
_vm->_mixer->setChannelVolume(track->handle, vol); if (channels == 2)
_vm->_mixer->setChannelBalance(track->handle, pan); mixer_size &= ~1;
}
if (mixer_size == 0)
continue;
do {
if (bits == 12) {
byte *ptr = NULL;
mixer_size += track->mod;
int mixer_size_12 = (mixer_size * 3) / 4;
int length = (mixer_size_12 / 3) * 4;
track->mod = mixer_size - length;
int32 offset = (track->regionOffset * 3) / 4;
int result2 = _sound->getDataFromRegion(track->soundHandle, track->curRegion, &ptr, offset, mixer_size_12);
result = BundleCodecs::decode12BitsSample(ptr, &data, result2);
free(ptr);
} else if (bits == 16) {
result = _sound->getDataFromRegion(track->soundHandle, track->curRegion, &data, track->regionOffset, mixer_size);
if (channels == 1) {
result &= ~1;
}
if (channels == 2) {
result &= ~3;
}
} else if (bits == 8) {
result = _sound->getDataFromRegion(track->soundHandle, track->curRegion, &data, track->regionOffset, mixer_size);
if (channels == 2) {
result &= ~1;
}
}
if (result > mixer_size)
result = mixer_size;
if (_vm->_mixer->isReady()) {
_vm->_mixer->setChannelVolume(track->handle, vol);
_vm->_mixer->setChannelBalance(track->handle, pan);
track->stream->append(data, result);
track->regionOffset += result;
}
free(data);
if (_sound->isEndOfRegion(track->soundHandle, track->curRegion)) {
switchToNextRegion(track);
if (track->toBeRemoved)
break;
}
mixer_size -= result;
assert(mixer_size >= 0);
} while (mixer_size != 0);
} else if (track->stream2) {
if (_vm->_mixer->isReady()) {
if (!track->started) {
track->started = true;
_vm->_mixer->playInputStream(type, &track->handle, track->stream2, -1, vol, pan, false);
} else {
_vm->_mixer->setChannelVolume(track->handle, vol);
_vm->_mixer->setChannelBalance(track->handle, pan);
}
} }
} }
} }

12
scumm/imuse_digi/dimuse.h
View file

@ -45,8 +45,6 @@ class Serializer;
class IMuseDigital : public MusicEngine { class IMuseDigital : public MusicEngine {
private: private:
int _callbackFps;
struct Track { struct Track {
int trackId; int trackId;
@ -86,7 +84,6 @@ private:
Track *_track[MAX_DIGITAL_TRACKS + MAX_DIGITAL_FADETRACKS]; Track *_track[MAX_DIGITAL_TRACKS + MAX_DIGITAL_FADETRACKS];
Common::Mutex _mutex;
ScummEngine *_vm; ScummEngine *_vm;
ImuseDigiSndMgr *_sound; ImuseDigiSndMgr *_sound;
@ -101,8 +98,10 @@ private:
int32 _curMusicSeq; int32 _curMusicSeq;
int32 _curMusicCue; int32 _curMusicCue;
static void timer_handler(void *refConf); int _callbackFps;
void callback(); int32 _lastTime, _thisTime, _interval, _counter, _diff;
bool _firstCall;
void switchToNextRegion(Track *track); void switchToNextRegion(Track *track);
int 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 startSound(int soundId, const char *soundName, int soundType, int volGroupId, AudioStream *input, int hookId, int volume, int priority);
@ -132,6 +131,9 @@ public:
IMuseDigital(ScummEngine *scumm, int fps); IMuseDigital(ScummEngine *scumm, int fps);
virtual ~IMuseDigital(); virtual ~IMuseDigital();
void callback();
void addDiff(int32 diff) { _diff += diff; }
void setAudioNames(int32 num, char *names); void setAudioNames(int32 num, char *names);
void startVoice(int soundId, AudioStream *input); void startVoice(int soundId, AudioStream *input);

29
scumm/imuse_digi/dimuse_script.cpp
View file

@ -163,15 +163,13 @@ void IMuseDigital::flushTracks() {
debug(5, "flushTracks()"); debug(5, "flushTracks()");
for (int l = 0; l < MAX_DIGITAL_TRACKS + MAX_DIGITAL_FADETRACKS; l++) { for (int l = 0; l < MAX_DIGITAL_TRACKS + MAX_DIGITAL_FADETRACKS; l++) {
Track *track = _track[l]; Track *track = _track[l];
if (track->used && (track->readyToRemove || if (track->used && track->toBeRemoved) {
(_vm->_insaneRunning && track->toBeRemoved))) { // INSANE hack for sync timer mode
if (track->stream) { if (track->stream) {
if (!track->stream->endOfStream()) { if (!track->stream->endOfStream()) {
track->stream->finish(); track->stream->finish();
} }
if (track->stream->endOfStream() if (track->stream->endOfStream()
|| _vm->_mixer->isPaused() // hack for paused Mixer || _vm->_mixer->isPaused()) { // hack for paused Mixer
|| _vm->_insaneRunning) { // INSANE hack for sync timer mode
_vm->_mixer->stopHandle(track->handle); _vm->_mixer->stopHandle(track->handle);
delete track->stream; delete track->stream;
track->stream = NULL; track->stream = NULL;
@ -194,7 +192,7 @@ void IMuseDigital::refreshScripts() {
bool found = false; bool found = false;
for (int l = 0; l < MAX_DIGITAL_TRACKS; l++) { for (int l = 0; l < MAX_DIGITAL_TRACKS; l++) {
Track *track = _track[l]; Track *track = _track[l];
if (track->used && !track->toBeRemoved && (track->volGroupId == IMUSE_VOLGRP_MUSIC)) { if (track->used && (track->volGroupId == IMUSE_VOLGRP_MUSIC)) {
found = true; found = true;
} }
} }
@ -238,7 +236,7 @@ void IMuseDigital::getLipSync(int soundId, int syncId, int32 msPos, int32 &width
if (msPos < 65536) { if (msPos < 65536) {
for (int l = 0; l < MAX_DIGITAL_TRACKS; l++) { for (int l = 0; l < MAX_DIGITAL_TRACKS; l++) {
Track *track = _track[l]; Track *track = _track[l];
if ((track->soundId == soundId) && track->used && !track->toBeRemoved) { if ((track->soundId == soundId) && track->used) {
_sound->getSyncSizeAndPtrById(track->soundHandle, syncId, sync_size, &sync_ptr); _sound->getSyncSizeAndPtrById(track->soundHandle, syncId, sync_size, &sync_ptr);
if ((sync_size != 0) && (sync_ptr != NULL)) { if ((sync_size != 0) && (sync_ptr != NULL)) {
sync_size /= 4; sync_size /= 4;
@ -265,7 +263,7 @@ void IMuseDigital::getLipSync(int soundId, int syncId, int32 msPos, int32 &width
int32 IMuseDigital::getPosInMs(int soundId) { int32 IMuseDigital::getPosInMs(int soundId) {
for (int l = 0; l < MAX_DIGITAL_TRACKS; l++) { for (int l = 0; l < MAX_DIGITAL_TRACKS; l++) {
Track *track = _track[l]; Track *track = _track[l];
if ((track->soundId == soundId) && track->used && !track->toBeRemoved) { if ((track->soundId == soundId) && track->used) {
int32 pos = (5 * (track->dataOffset + track->regionOffset)) / (track->iteration / 200); int32 pos = (5 * (track->dataOffset + track->regionOffset)) / (track->iteration / 200);
return pos; return pos;
} }
@ -280,7 +278,7 @@ int IMuseDigital::getSoundStatus(int sound) const {
Track *track = _track[l]; Track *track = _track[l];
if (track->soundId == sound) { if (track->soundId == sound) {
if ((track->stream2 && _vm->_mixer->isSoundHandleActive(track->handle)) || if ((track->stream2 && _vm->_mixer->isSoundHandleActive(track->handle)) ||
(track->stream && track->used && !track->readyToRemove)) { (track->stream && track->used)) {
return 1; return 1;
} }
} }
@ -293,7 +291,7 @@ void IMuseDigital::stopSound(int soundId) {
debug(5, "IMuseDigital::stopSound(%d)", soundId); debug(5, "IMuseDigital::stopSound(%d)", soundId);
for (int l = 0; l < MAX_DIGITAL_TRACKS; l++) { for (int l = 0; l < MAX_DIGITAL_TRACKS; l++) {
Track *track = _track[l]; Track *track = _track[l];
if ((track->soundId == soundId) && track->used && !track->toBeRemoved) { if ((track->soundId == soundId) && track->used) {
track->toBeRemoved = true; track->toBeRemoved = true;
} }
} }
@ -304,7 +302,7 @@ int32 IMuseDigital::getCurMusicPosInMs() {
for (int l = 0; l < MAX_DIGITAL_TRACKS; l++) { for (int l = 0; l < MAX_DIGITAL_TRACKS; l++) {
Track *track = _track[l]; Track *track = _track[l];
if (track->used && !track->toBeRemoved && (track->volGroupId == IMUSE_VOLGRP_MUSIC)) { if (track->used && (track->volGroupId == IMUSE_VOLGRP_MUSIC)) {
soundId = track->soundId; soundId = track->soundId;
} }
} }
@ -337,7 +335,7 @@ int32 IMuseDigital::getCurMusicLipSyncWidth(int syncId) {
for (int l = 0; l < MAX_DIGITAL_TRACKS; l++) { for (int l = 0; l < MAX_DIGITAL_TRACKS; l++) {
Track *track = _track[l]; Track *track = _track[l];
if (track->used && !track->toBeRemoved && (track->volGroupId == IMUSE_VOLGRP_MUSIC)) { if (track->used && (track->volGroupId == IMUSE_VOLGRP_MUSIC)) {
soundId = track->soundId; soundId = track->soundId;
} }
} }
@ -355,7 +353,7 @@ int32 IMuseDigital::getCurMusicLipSyncHeight(int syncId) {
for (int l = 0; l < MAX_DIGITAL_TRACKS; l++) { for (int l = 0; l < MAX_DIGITAL_TRACKS; l++) {
Track *track = _track[l]; Track *track = _track[l];
if (track->used && !track->toBeRemoved && (track->volGroupId == IMUSE_VOLGRP_MUSIC)) { if (track->used && (track->volGroupId == IMUSE_VOLGRP_MUSIC)) {
soundId = track->soundId; soundId = track->soundId;
} }
} }
@ -383,14 +381,13 @@ void IMuseDigital::stopAllSounds() {
if (!foundNotRemoved) if (!foundNotRemoved)
break; break;
flushTracks(); flushTracks();
_vm->_system->delayMillis(50);
#if defined(_WIN32_WCE) || defined (PALMOS_MODE) || defined(__SYMBIAN32__)
_vm->parseEvents(); // timers are events, we need to consume them
#endif
} }
} }
void IMuseDigital::pause(bool p) { void IMuseDigital::pause(bool p) {
if ((_pause) && (!p)) {
_thisTime = _vm->_system->getMillis();
}
_pause = p; _pause = p;
} }

96
scumm/imuse_digi/dimuse_track.cpp
View file

@ -47,8 +47,7 @@ int IMuseDigital::allocSlot(int priority) {
debug(5, "IMuseDigital::startSound(): All slots are full"); debug(5, "IMuseDigital::startSound(): All slots are full");
for (l = 0; l < MAX_DIGITAL_TRACKS; l++) { for (l = 0; l < MAX_DIGITAL_TRACKS; l++) {
Track *track = _track[l]; Track *track = _track[l];
if (track->used && !track->toBeRemoved && if (track->used && (lowest_priority > track->priority) && !track->stream2) {
(lowest_priority > track->priority) && !track->stream2) {
lowest_priority = track->priority; lowest_priority = track->priority;
trackId = l; trackId = l;
} }
@ -76,17 +75,8 @@ void IMuseDigital::startSound(int soundId, const char *soundName, int soundType,
} }
Track *track = _track[l]; Track *track = _track[l];
while (track->used) { flushTracks();
// The designated track is not yet available. So, we call flushTracks() assert(!track->used);
// to get it processed (and thus made ready for us). Since the actual
// processing is done by another thread, we also call parseEvents to
// give it some time (and to avoid busy waiting/looping).
flushTracks();
#ifndef __PLAYSTATION2__
_vm->parseEvents();
#endif
}
track->pan = 64; track->pan = 64;
track->vol = volume * 1000; track->vol = volume * 1000;
track->volFadeDest = 0; track->volFadeDest = 0;
@ -191,7 +181,7 @@ void IMuseDigital::setPriority(int soundId, int priority) {
for (int l = 0; l < MAX_DIGITAL_TRACKS; l++) { for (int l = 0; l < MAX_DIGITAL_TRACKS; l++) {
Track *track = _track[l]; Track *track = _track[l];
if ((track->soundId == soundId) && track->used && !track->toBeRemoved) { if ((track->soundId == soundId) && track->used) {
track->priority = priority; track->priority = priority;
} }
} }
@ -202,18 +192,16 @@ void IMuseDigital::setVolume(int soundId, int volume) {
for (int l = 0; l < MAX_DIGITAL_TRACKS; l++) { for (int l = 0; l < MAX_DIGITAL_TRACKS; l++) {
Track *track = _track[l]; Track *track = _track[l];
if ((track->soundId == soundId) && track->used && !track->toBeRemoved) { if ((track->soundId == soundId) && track->used) {
track->vol = volume * 1000; track->vol = volume * 1000;
} }
} }
} }
void IMuseDigital::setHookId(int soundId, int hookId) { void IMuseDigital::setHookId(int soundId, int hookId) {
Common::StackLock lock(_mutex, "IMuseDigital::setHookId()");
for (int l = 0; l < MAX_DIGITAL_TRACKS; l++) { for (int l = 0; l < MAX_DIGITAL_TRACKS; l++) {
Track *track = _track[l]; Track *track = _track[l];
if ((track->soundId == soundId) && track->used && !track->toBeRemoved) { if ((track->soundId == soundId) && track->used) {
track->curHookId = hookId; track->curHookId = hookId;
} }
} }
@ -224,7 +212,7 @@ int IMuseDigital::getCurMusicSoundId() {
for (int l = 0; l < MAX_DIGITAL_TRACKS; l++) { for (int l = 0; l < MAX_DIGITAL_TRACKS; l++) {
Track *track = _track[l]; Track *track = _track[l];
if (track->used && !track->toBeRemoved && (track->volGroupId == IMUSE_VOLGRP_MUSIC)) { if (track->used && (track->volGroupId == IMUSE_VOLGRP_MUSIC)) {
soundId = track->soundId; soundId = track->soundId;
} }
} }
@ -237,7 +225,7 @@ char *IMuseDigital::getCurMusicSoundName() {
for (int l = 0; l < MAX_DIGITAL_TRACKS; l++) { for (int l = 0; l < MAX_DIGITAL_TRACKS; l++) {
Track *track = _track[l]; Track *track = _track[l];
if (track->used && !track->toBeRemoved && (track->volGroupId == IMUSE_VOLGRP_MUSIC)) { if (track->used && (track->volGroupId == IMUSE_VOLGRP_MUSIC)) {
soundName = track->soundName; soundName = track->soundName;
} }
} }
@ -250,7 +238,7 @@ void IMuseDigital::setPan(int soundId, int pan) {
for (int l = 0; l < MAX_DIGITAL_TRACKS; l++) { for (int l = 0; l < MAX_DIGITAL_TRACKS; l++) {
Track *track = _track[l]; Track *track = _track[l];
if ((track->soundId == soundId) && track->used && !track->toBeRemoved) { if ((track->soundId == soundId) && track->used) {
track->pan = pan; track->pan = pan;
} }
} }
@ -265,19 +253,18 @@ void IMuseDigital::selectVolumeGroup(int soundId, int volGroupId) {
for (int l = 0; l < MAX_DIGITAL_TRACKS; l++) { for (int l = 0; l < MAX_DIGITAL_TRACKS; l++) {
Track *track = _track[l]; Track *track = _track[l];
if ((track->soundId == soundId) && track->used && !track->toBeRemoved) { if ((track->soundId == soundId) && track->used) {
track->volGroupId = volGroupId; track->volGroupId = volGroupId;
} }
} }
} }
void IMuseDigital::setFade(int soundId, int destVolume, int delay60HzTicks) { 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); debug(5, "IMuseDigital::setFade(%d, %d, %d)", soundId, destVolume, delay60HzTicks);
for (int l = 0; l < MAX_DIGITAL_TRACKS; l++) { for (int l = 0; l < MAX_DIGITAL_TRACKS; l++) {
Track *track = _track[l]; Track *track = _track[l];
if ((track->soundId == soundId) && track->used && !track->toBeRemoved) { if ((track->soundId == soundId) && track->used) {
track->volFadeDelay = delay60HzTicks; track->volFadeDelay = delay60HzTicks;
track->volFadeDest = destVolume * 1000; track->volFadeDest = destVolume * 1000;
track->volFadeStep = (track->volFadeDest - track->vol) * 60 * (1000 / _callbackFps) / (1000 * delay60HzTicks); track->volFadeStep = (track->volFadeDest - track->vol) * 60 * (1000 / _callbackFps) / (1000 * delay60HzTicks);
@ -290,7 +277,7 @@ void IMuseDigital::fadeOutMusic(int fadeDelay) {
debug(5, "IMuseDigital::fadeOutMusic"); debug(5, "IMuseDigital::fadeOutMusic");
for (int l = 0; l < MAX_DIGITAL_TRACKS; l++) { for (int l = 0; l < MAX_DIGITAL_TRACKS; l++) {
Track *track = _track[l]; Track *track = _track[l];
if (track->used && !track->toBeRemoved && (track->volGroupId == IMUSE_VOLGRP_MUSIC)) { if (track->used && (track->volGroupId == IMUSE_VOLGRP_MUSIC)) {
cloneToFadeOutTrack(track, fadeDelay); cloneToFadeOutTrack(track, fadeDelay);
track->toBeRemoved = true; track->toBeRemoved = true;
} }
@ -303,39 +290,36 @@ IMuseDigital::Track *IMuseDigital::cloneToFadeOutTrack(Track *track, int fadeDel
debug(5, "IMuseDigital::cloneToFadeOutTrack(%d, %d)", track->trackId, fadeDelay); debug(5, "IMuseDigital::cloneToFadeOutTrack(%d, %d)", track->trackId, fadeDelay);
{ for (int l = MAX_DIGITAL_TRACKS; l < MAX_DIGITAL_TRACKS + MAX_DIGITAL_FADETRACKS; l++) {
Common::StackLock lock(_mutex, "IMuseDigital::cloneToFadeOutTrack()"); if (!_track[l]->used) {
for (int l = MAX_DIGITAL_TRACKS; l < MAX_DIGITAL_TRACKS + MAX_DIGITAL_FADETRACKS; l++) { fadeTrack = _track[l];
if (!_track[l]->used) { break;
fadeTrack = _track[l];
break;
}
} }
if (fadeTrack == 0)
error("IMuseDigital::cloneToFadeOutTrack() Can't find free fade track");
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->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);
assert(fadeTrack->soundHandle);
} }
if (fadeTrack == 0)
error("IMuseDigital::cloneToFadeOutTrack() Can't find free fade track");
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->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);
assert(fadeTrack->soundHandle);
fadeTrack->volFadeDelay = fadeDelay; fadeTrack->volFadeDelay = fadeDelay;
fadeTrack->volFadeDest = 0; fadeTrack->volFadeDest = 0;

7
scumm/script.cpp
View file

@ -31,6 +31,7 @@
#include "scumm/util.h" #include "scumm/util.h"
#include "scumm/scumm.h" #include "scumm/scumm.h"
#include "scumm/verbs.h" #include "scumm/verbs.h"
#include "scumm/imuse_digi/dimuse.h"
namespace Scumm { namespace Scumm {
@ -463,7 +464,13 @@ void ScummEngine::executeScript() {
} }
printf("\n"); printf("\n");
} }
if (_imuseDigital) {
_imuseDigital->callback();
}
executeOpcode(_opcode); executeOpcode(_opcode);
} }
CHECK_HEAP; CHECK_HEAP;
} }

6
scumm/scumm.cpp
View file

@ -2341,9 +2341,11 @@ void ScummEngine::waitForTimer(int msec_delay) {
start_time = _system->getMillis(); start_time = _system->getMillis();
while (!_quit) { while (!_quit) {
parseEvents(); if (_imuseDigital) {
_imuseDigital->callback();
}
_sound->updateCD(); // Loop CD Audio if needed _sound->updateCD(); // Loop CD Audio if needed
parseEvents();
if (_system->getMillis() >= start_time + msec_delay) if (_system->getMillis() >= start_time + msec_delay)
break; break;
_system->delayMillis(10); _system->delayMillis(10);

7
scumm/smush/smush_player.cpp
View file

@ -1102,8 +1102,6 @@ void SmushPlayer::parseNextFrame() {
if (_insanity) if (_insanity)
_vm->_sound->processSound(); _vm->_sound->processSound();
_vm->_imuseDigital->flushTracks();
} }
void SmushPlayer::setPalette(const byte *palette) { void SmushPlayer::setPalette(const byte *palette) {
@ -1270,6 +1268,9 @@ void SmushPlayer::play(const char *filename, int32 offset, int32 startFrame) {
if (_vm->_smushVideoShouldFinish || _vm->_quit || _vm->_saveLoadFlag) if (_vm->_smushVideoShouldFinish || _vm->_quit || _vm->_saveLoadFlag)
break; break;
_vm->_imuseDigital->callback();
_vm->_imuseDigital->flushTracks();
lastTime = thisTime; lastTime = thisTime;
thisTime = _vm->_system->getMillis(); thisTime = _vm->_system->getMillis();
interval = 1000 * (thisTime - lastTime - diff); interval = 1000 * (thisTime - lastTime - diff);
@ -1284,7 +1285,7 @@ void SmushPlayer::play(const char *filename, int32 offset, int32 startFrame) {
_vm->_system->warpMouse(_warpX, _warpY); _vm->_system->warpMouse(_warpX, _warpY);
_warpNeeded = false; _warpNeeded = false;
} }
int32 before = _vm->_system->getMillis(); int32 before = _vm->_system->getMillis();
_vm->parseEvents(); _vm->parseEvents();
_vm->processKbd(true); _vm->processKbd(true);