void Player_Mac::saveLoadWithSerializer(Serializer *ser) {
Common::StackLock lock(_mutex);
if (ser->getVersion() < VER(94)) {
if (_vm->_game.id == GID_MONKEY && ser->isLoading()) {
IMuse *dummyImuse = IMuse::create(_vm->_system, NULL, NULL);
dummyImuse->save_or_load(ser, _vm, false);
delete dummyImuse;
}
} else {
static const SaveLoadEntry musicEntries[] = {
MKLINE(Player_Mac, _sampleRate, sleUint32, VER(94)),
MKLINE(Player_Mac, _soundPlaying, sleInt16, VER(94)),
MKEND()
};
static const SaveLoadEntry channelEntries[] = {
MKLINE(Channel, _pos, sleUint16, VER(94)),
MKLINE(Channel, _pitchModifier, sleInt32, VER(94)),
MKLINE(Channel, _velocity, sleUint8, VER(94)),
MKLINE(Channel, _remaining, sleUint32, VER(94)),
MKLINE(Channel, _notesLeft, sleUint8, VER(94)),
MKEND()
};
static const SaveLoadEntry instrumentEntries[] = {
MKLINE(Instrument, _pos, sleUint32, VER(94)),
MKLINE(Instrument, _subPos, sleUint32, VER(94)),
MKEND()
};
uint32 mixerSampleRate = _sampleRate;
int i;
ser->saveLoadEntries(this, musicEntries);
if (ser->isLoading() && _soundPlaying != -1) {
const byte *ptr = _vm->getResourceAddress(rtSound, _soundPlaying);
assert(ptr);
loadMusic(ptr);
}
ser->saveLoadArrayOf(_channel, _numberOfChannels, sizeof(Channel), channelEntries);
for (i = 0; i < _numberOfChannels; i++) {
ser->saveLoadEntries(&_channel[i], instrumentEntries);
}
if (ser->isLoading()) {
// If necessary, adjust the channel data to fit the
// current sample rate.
if (_soundPlaying != -1 && _sampleRate != mixerSampleRate) {
double mult = (double)_sampleRate / (double)mixerSampleRate;
for (i = 0; i < _numberOfChannels; i++) {
_channel[i]._pitchModifier = (int)((double)_channel[i]._pitchModifier * mult);
_channel[i]._remaining = (int)((double)_channel[i]._remaining / mult);
}
}
_sampleRate = mixerSampleRate;
}
}
}
void Player_AD::saveLoadWithSerializer(Serializer *ser) {
Common::StackLock lock(_mutex);
if (ser->getVersion() < VER(95)) {
IMuse *dummyImuse = IMuse::create(_vm->_system, NULL, NULL);
dummyImuse->save_or_load(ser, _vm, false);
delete dummyImuse;
return;
}
if (ser->getVersion() >= VER(96)) {
int32 res[4] = {
_soundPlaying, _sfx[0].resource, _sfx[1].resource, _sfx[2].resource
};
// The first thing we save is a list of sound resources being played
// at the moment.
ser->saveLoadArrayOf(res, 4, sizeof(res[0]), sleInt32);
// If we are loading start the music again at this point.
if (ser->isLoading()) {
if (res[0] != -1) {
startSound(res[0]);
}
}
uint32 musicOffset = _curOffset;
static const SaveLoadEntry musicData[] = {
MKLINE(Player_AD, _engineMusicTimer, sleInt32, VER(96)),
MKLINE(Player_AD, _musicTimer, sleUint32, VER(96)),
MKLINE(Player_AD, _internalMusicTimer, sleUint32, VER(96)),
MKLINE(Player_AD, _curOffset, sleUint32, VER(96)),
MKLINE(Player_AD, _nextEventTimer, sleUint32, VER(96)),
MKEND()
};
ser->saveLoadEntries(this, musicData);
// We seek back to the old music position.
if (ser->isLoading()) {
SWAP(musicOffset, _curOffset);
musicSeekTo(musicOffset);
}
// Finally start up the SFX. This makes sure that they are not
// accidently stopped while seeking to the old music position.
if (ser->isLoading()) {
for (int i = 1; i < ARRAYSIZE(res); ++i) {
if (res[i] != -1) {
startSound(res[i]);
}
}
}
}
}
void CharsetRenderer::saveLoadWithSerializer(Serializer *ser) {
static const SaveLoadEntry charsetRendererEntries[] = {
MKLINE_OLD(CharsetRenderer, _curId, sleByte, VER(73), VER(73)),
MKLINE(CharsetRenderer, _curId, sleInt32, VER(74)),
MKLINE(CharsetRenderer, _color, sleByte, VER(73)),
MKEND()
};
ser->saveLoadEntries(this, charsetRendererEntries);
if (ser->isLoading()) {
setCurID(_curId);
setColor(_color);
}
}
void Part::saveLoadWithSerializer(Serializer *ser) {
const SaveLoadEntry partEntries[] = {
MKLINE(Part, _pitchbend, sleInt16, VER(8)),
MKLINE(Part, _pitchbend_factor, sleUint8, VER(8)),
MKLINE(Part, _transpose, sleInt8, VER(8)),
MKLINE(Part, _vol, sleUint8, VER(8)),
MKLINE(Part, _detune, sleInt8, VER(8)),
MKLINE(Part, _pan, sleInt8, VER(8)),
MKLINE(Part, _on, sleUint8, VER(8)),
MKLINE(Part, _modwheel, sleUint8, VER(8)),
MKLINE(Part, _pedal, sleUint8, VER(8)),
MK_OBSOLETE(Part, _program, sleUint8, VER(8), VER(16)),
MKLINE(Part, _pri, sleUint8, VER(8)),
MKLINE(Part, _chan, sleUint8, VER(8)),
MKLINE(Part, _effect_level, sleUint8, VER(8)),
MKLINE(Part, _chorus, sleUint8, VER(8)),
MKLINE(Part, _percussion, sleUint8, VER(8)),
MKLINE(Part, _bank, sleUint8, VER(8)),
MKEND()
};
int num;
if (ser->isSaving()) {
num = (_next ? (_next - _se->_parts + 1) : 0);
ser->saveUint16(num);
num = (_prev ? (_prev - _se->_parts + 1) : 0);
ser->saveUint16(num);
num = (_player ? (_player - _se->_players + 1) : 0);
ser->saveUint16(num);
} else {
num = ser->loadUint16();
_next = (num ? &_se->_parts[num - 1] : 0);
num = ser->loadUint16();
_prev = (num ? &_se->_parts[num - 1] : 0);
num = ser->loadUint16();
_player = (num ? &_se->_players[num - 1] : 0);
}
ser->saveLoadEntries(this, partEntries);
}
void IMuseDigital::saveOrLoad(Serializer *ser) {
Common::StackLock lock(_mutex, "IMuseDigital::saveOrLoad()");
const SaveLoadEntry mainEntries[] = {
MK_OBSOLETE(IMuseDigital, _volVoice, sleInt32, VER(31), VER(42)),
MK_OBSOLETE(IMuseDigital, _volSfx, sleInt32, VER(31), VER(42)),
MK_OBSOLETE(IMuseDigital, _volMusic, sleInt32, VER(31), VER(42)),
MKLINE(IMuseDigital, _curMusicState, sleInt32, VER(31)),
MKLINE(IMuseDigital, _curMusicSeq, sleInt32, VER(31)),
MKLINE(IMuseDigital, _curMusicCue, sleInt32, VER(31)),
MKLINE(IMuseDigital, _nextSeqToPlay, sleInt32, VER(31)),
MKLINE(IMuseDigital, _radioChatterSFX, sleByte, VER(76)),
MKARRAY(IMuseDigital, _attributes[0], sleInt32, 188, VER(31)),
MKEND()
};
const SaveLoadEntry trackEntries[] = {
MKLINE(Track, pan, sleInt8, VER(31)),
MKLINE(Track, vol, sleInt32, VER(31)),
MKLINE(Track, volFadeDest, sleInt32, VER(31)),
MKLINE(Track, volFadeStep, sleInt32, VER(31)),
MKLINE(Track, volFadeDelay, sleInt32, VER(31)),
MKLINE(Track, volFadeUsed, sleByte, VER(31)),
MKLINE(Track, soundId, sleInt32, VER(31)),
MKARRAY(Track, soundName[0], sleByte, 15, VER(31)),
MKLINE(Track, used, sleByte, VER(31)),
MKLINE(Track, toBeRemoved, sleByte, VER(31)),
MKLINE(Track, souStreamUsed, sleByte, VER(31)),
MK_OBSOLETE(Track, mixerStreamRunning, sleByte, VER(31), VER(76)),
MKLINE(Track, soundPriority, sleInt32, VER(31)),
MKLINE(Track, regionOffset, sleInt32, VER(31)),
MK_OBSOLETE(Track, trackOffset, sleInt32, VER(31), VER(31)),
MKLINE(Track, dataOffset, sleInt32, VER(31)),
MKLINE(Track, curRegion, sleInt32, VER(31)),
MKLINE(Track, curHookId, sleInt32, VER(31)),
MKLINE(Track, volGroupId, sleInt32, VER(31)),
MKLINE(Track, soundType, sleInt32, VER(31)),
MKLINE(Track, feedSize, sleInt32, VER(31)),
MKLINE(Track, dataMod12Bit, sleInt32, VER(31)),
MKLINE(Track, mixerFlags, sleInt32, VER(31)),
MK_OBSOLETE(Track, mixerVol, sleInt32, VER(31), VER(42)),
MK_OBSOLETE(Track, mixerPan, sleInt32, VER(31), VER(42)),
MKLINE(Track, sndDataExtComp, sleByte, VER(45)),
MKEND()
};
ser->saveLoadEntries(this, mainEntries);
for (int l = 0; l < MAX_DIGITAL_TRACKS + MAX_DIGITAL_FADETRACKS; l++) {
Track *track = _track[l];
if (ser->isLoading()) {
memset(track, 0, sizeof(Track));
}
ser->saveLoadEntries(track, trackEntries);
if (ser->isLoading()) {
_track[l]->trackId = l;
if (!track->used)
continue;
if ((track->toBeRemoved) || (track->souStreamUsed) || (track->curRegion == -1)) {
track->used = false;
continue;
}
// TODO: The code below has a lot in common with that in IMuseDigital::startSound.
// Try to refactor them to reduce the code duplication.
track->soundDesc = _sound->openSound(track->soundId, track->soundName, track->soundType, track->volGroupId, -1);
if (!track->soundDesc)
track->soundDesc = _sound->openSound(track->soundId, track->soundName, track->soundType, track->volGroupId, 1);
if (!track->soundDesc)
track->soundDesc = _sound->openSound(track->soundId, track->soundName, track->soundType, track->volGroupId, 2);
if (!track->soundDesc) {
warning("IMuseDigital::saveOrLoad: Can't open sound so will not be resumed");
track->used = false;
continue;
}
track->sndDataExtComp = _sound->isSndDataExtComp(track->soundDesc);
track->dataOffset = _sound->getRegionOffset(track->soundDesc, track->curRegion);
int bits = _sound->getBits(track->soundDesc);
int channels = _sound->getChannels(track->soundDesc);
int freq = _sound->getFreq(track->soundDesc);
track->feedSize = freq * channels;
track->mixerFlags = 0;
if (channels == 2)
track->mixerFlags = kFlagStereo;
if ((bits == 12) || (bits == 16)) {
track->mixerFlags |= kFlag16Bits;
track->feedSize *= 2;
} else if (bits == 8) {
track->mixerFlags |= kFlagUnsigned;
} else
error("IMuseDigital::saveOrLoad(): Can't handle %d bit samples", bits);
track->stream = Audio::makeQueuingAudioStream(freq, (track->mixerFlags & kFlagStereo) != 0);
_mixer->playStream(track->getType(), &track->mixChanHandle, track->stream, -1, track->getVol(), track->getPan(),
DisposeAfterUse::YES, false, (track->mixerFlags & kFlagStereo) != 0);
_mixer->pauseHandle(track->mixChanHandle, true);
}
}
}
