From 544daa5c315f2d598ebeefe43de675fdad1be18a Mon Sep 17 00:00:00 2001 From: Filippos Karapetis Date: Sun, 15 Nov 2009 14:14:49 +0000 Subject: - Started importing the music code from Greg's SCI engine - Simplified some sound version checks svn-id: r45923 --- engines/sci/sfx/music.cpp | 705 +++++++++++++++++++++++++++++++++++++++++++ engines/sci/sfx/music.h | 207 +++++++++++++ engines/sci/sfx/soundcmd.cpp | 50 ++- engines/sci/sfx/soundcmd.h | 6 + 4 files changed, 960 insertions(+), 8 deletions(-) create mode 100644 engines/sci/sfx/music.cpp create mode 100644 engines/sci/sfx/music.h (limited to 'engines/sci/sfx') diff --git a/engines/sci/sfx/music.cpp b/engines/sci/sfx/music.cpp new file mode 100644 index 0000000000..ad0fe25b00 --- /dev/null +++ b/engines/sci/sfx/music.cpp @@ -0,0 +1,705 @@ +/* ScummVM - Graphic Adventure Engine + * + * ScummVM is the legal property of its developers, whose names + * are too numerous to list here. Please refer to the COPYRIGHT + * file distributed with this source distribution. + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + * + * $URL$ + * $Id$ + * + */ + +#include "sci/sci.h" +#include "sci/resource.h" +#include "sci/sfx/music.h" +#include "sound/audiostream.h" +#include "common/config-manager.h" + +namespace Sci { + +static const int nMidiParams[] = { 2, 2, 2, 2, 1, 1, 2, 0 }; + +static int f_compare(const void *arg1, const void *arg2) { + return ((sciSound *)arg2)->prio - ((sciSound *)arg1)->prio; +} + +SciMusic::SciMusic() { +} + +SciMusic::~SciMusic() { + if (_pMidiDrv) { + _pMidiDrv->close(); + delete _pMidiDrv; + } +} +//---------------------------------------- +void SciMusic::init() { + // system init + _pMixer = g_system->getMixer(); + _pMixer->setVolumeForSoundType(Audio::Mixer::kSFXSoundType, ConfMan.getInt( + "sfx_volume")); + _pMixer->setVolumeForSoundType(Audio::Mixer::kSpeechSoundType, + ConfMan.getInt("speech_volume")); + _pMixer->setVolumeForSoundType(Audio::Mixer::kMusicSoundType, + ConfMan.getInt("music_volume")); + // SCI sound init + _dwTempo = 0; + _midiType = MidiDriver::detectMusicDriver(MDT_MIDI | MDT_ADLIB | MDT_PCSPK + | MDT_PREFER_MIDI); + _pMidiDrv = MidiDriver::createMidi(_midiType); + if (_pMidiDrv) { + _pMidiDrv->open(); + _pMidiDrv->setTimerCallback(this, &miditimerCallback); + _dwTempo = _pMidiDrv->getBaseTempo(); + } else + warning("Can't initialise music driver"); + _bMultiMidi = ConfMan.getBool("multi_midi"); +} +//---------------------------------------- +bool SciMusic::saveState(Common::OutSaveFile *pFile) { + // TODO +#if 0 + pFile->writeString("AUDIO\n"); + // palylist + int sz = _playList.size(); + pFile->writeUint16LE(sz); + for(int i = 0; i < sz; i++) { + pFile->writeUint16LE(ptr2heap((byte*)_playList[i])); + // member variable + pFile->writeUint16LE(_audVolNum); + pFile->writeByte(_langID); + pFile->writeUint16LE(_audioType); + pFile->writeUint16LE(_audioRate); + // TODO: current playing stream (hCurrentAud) info + } +#endif + return true; +} + +//---------------------------------------- +bool SciMusic::restoreState(Common::InSaveFile *pFile){ + // TODO +#if 0 + if (pFile->readLine() != "AUDIO") + return false; +#endif + return true; +} +//---------------------------------------- +void SciMusic::stopAll() { + _pMixer->stopAll(); + //audioStop(); + for(uint i = 0; i < _playList.size(); i++){ + soundStop(_playList[i]); + soundKill(_playList[i]); + } +} +//---------------------------------------- +void SciMusic::miditimerCallback(void *p) { + SciMusic* aud = (SciMusic *)p; + aud->onTimer(); +} +//---------------------------------------- +uint16 SciMusic::soundGetVoices() { + uint16 res; + switch (_midiType) { + case MD_PCSPK: + res = 1; + break; + case MD_PCJR: + res = 3; + break; + case MD_ADLIB: + res = 8; + break; + case MD_MT32: + res = 16; + break; + default: + res = 1; + break; + } + return res; +} +//---------------------------------------- +void SciMusic::sortPlayList() { + sciSound ** pData = _playList.begin(); + qsort(pData, _playList.size(), sizeof(sciSound *), &f_compare); +} + +void SciMusic::patchSysEx(byte * addr, byte *pdata, int len) { + byte *buff = new byte[7 + len + 1]; + uint16 chk = 0; + int i; + + buff[0] = 0x41; + buff[1] = 0x10; + buff[2] = 0x16; + buff[3] = 0x12; + buff[4] = addr[0]; + buff[5] = addr[1]; + buff[6] = addr[2]; + for (i = 0; i < len; i++) { + buff[7 + i] = pdata[i]; + chk += pdata[i]; + } + chk += addr[0] + addr[1] + addr[2]; + buff[7 + i] = 128 - chk % 128; + _pMidiDrv->sysEx(buff, len + 8); + delete[] buff; +} + +void SciMusic::patchUpdateAddr(byte *addr, int len) { + addr[2] += len; + if (addr[2] >= 0x7F) { + addr[1]++; + addr[2] -= 0x80; + } +} +void SciMusic::loadPatch() { + if (_midiType == MD_MT32) + loadPatchMT32(); +} + +// currently loads patch 1.pat for Roland/MT-32 device +void SciMusic::loadPatchMT32() { + //byte sysText[] = { 0x20, 0, 0 }; + byte sysMem[] = { 0x5, 0, 0 }; // patch memory + byte sysRhytm[] = { 0x3, 0x1, 0x10 }; // rhytm + byte sysMsg3[15] = { 0x41, 0x10, 0x16, 0x12, 0x52, 0, 0xA, 0x16, 0x16, + 0x16, 0x16, 0x16, 0x16, 0x20, 0x80 }; + byte sysTimbre[] = { 0x8, 0, 0 }; // timbre memory + byte sysSystem[] = { 0x10, 0, 4 }; // partial reserve & midi channel + byte arr[3][11]; + + Resource *res = ((SciEngine *)g_engine)->getResourceManager()->findResource(ResourceId(kResourceTypePatch, 1), 0); + + if (res) { + byte *pData = res->data, *p; + // welcome message + //patchSysEx(sysText, pData + 20, 20); + // reading reverb mode, time and level + p = pData + 74; + for (int i = 0; i < 11; i++) { + arr[0][i] = *p++; + arr[1][i] = *p++; + arr[2][i] = *p++; + } + // sub_657 - patch memory + for (int i = 0; i < 48; i++) { + patchSysEx(sysMem, p, 8); + patchUpdateAddr(sysMem, 8); + p += 8; + } + // sub_696 - timbre + byte dl = *p++, cl = 0; + while (dl--) { + patchSysEx(sysTimbre, p, 14); // common area + patchUpdateAddr(sysTimbre, 14); + patchSysEx(sysTimbre, p + 14, 58);// partial 1 + patchUpdateAddr(sysTimbre, 58); + patchSysEx(sysTimbre, p + 72, 58);// partial 2 + patchUpdateAddr(sysTimbre, 58); + patchSysEx(sysTimbre, p + 130, 58);// partial 3 + patchUpdateAddr(sysTimbre, 58); + patchSysEx(sysTimbre, p + 188, 58);// partial 4 + patchUpdateAddr(sysTimbre, 58); + p += 246; + cl += 2; + sysTimbre[1] = cl; + sysTimbre[2] = 0; + } + // patch memory or rhytm + uint16 flag = READ_BE_UINT16(p); + p += 2; + if (flag == 0xABCD) { + // sub_657 + for (int i = 0; i < 48; i++) { + patchSysEx(sysMem, p, 8); + patchUpdateAddr(sysMem, 8); + p += 8; + } + } else if (flag == 0xDCBA) { + // sub_756 + for (int i = 0; i < 64; i++) { + patchSysEx(sysRhytm, p, 4); + patchUpdateAddr(sysRhytm, 4); + p += 4; + } + patchSysEx(sysSystem, p, 18); + } + // after-init text message + //patchSysEx(sysText, pData, 20); + // some final sysex + _pMidiDrv->sysEx(sysMsg3, 15); + // releasing patch resource + //g_sci->ResMgr.ResUnload(SCI_RES_PATCH, 1); + debug("MT-32 patch loaded"); + } +} +//---------------------------------------- +void SciMusic::soundInitSnd(SoundRes*res, sciSound *pSnd) { + //_mutex.lock(); + SoundRes::tagTrack *pTrack = NULL; + switch (_midiType) { + case MD_PCSPK: + pTrack = res->getTrackByType(SoundRes::kTrackSpeaker); + break; + case MD_PCJR: + pTrack = res->getTrackByType(SoundRes::kTrackTandy); + break; + case MD_ADLIB: + pTrack = res->getTrackByType(SoundRes::kTrackAdlib); + break; + case MD_MT32: + pTrack = res->getTrackByType(SoundRes::kTrackMT32); + break; + } + // attempting to select default MT-32/Roland track + if (!pTrack) + pTrack = res->getTrackByType(SoundRes::kTrackMT32); + if (pTrack) { + // if MIDI device is selected but there is no digital track in sound resource + // try to use adlib's digital sample if possible + if (_midiType <= MD_MT32 && pTrack->nDigital == 0xFF && _bMultiMidi) { + if (res->getTrackByType(SoundRes::kTrackAdlib)->nDigital != 0xFF) + pTrack = res->getTrackByType(SoundRes::kTrackAdlib); + } + // play digital sample + if (pTrack->nDigital != 0xFF) { + byte *pdata = pTrack->aChannels[pTrack->nDigital].ptr; + int rate = READ_LE_UINT16(pdata); + uint32 size = READ_LE_UINT16(pdata + 2); + assert(READ_LE_UINT16(pdata + 4) == 0); // Possibly a compression flag + //assert(READ_LE_UINT16(pdata + 6) == size); + if (pSnd->pStreamAud) + delete pSnd->pStreamAud; + pSnd->pStreamAud = Audio::makeLinearInputStream(pdata + 8, size, rate, + Audio::Mixer::FLAG_UNSIGNED, 0, 0); + pSnd->hCurrentAud = Audio::SoundHandle(); + } else {// play MIDI track + if (pSnd->pMidiParser == NULL) { + pSnd->pMidiParser = new MidiParser_SCI(); + pSnd->pMidiParser->setMidiDriver(_pMidiDrv); + pSnd->pMidiParser->setTimerRate(_dwTempo); + } + pSnd->pMidiParser->loadMusic(pTrack, pSnd); + } + } + //_mutex.unlock(); +} +//---------------------------------------- +void SciMusic::onTimer() { + _mutex.lock(); + uint sz = _playList.size(); + for (uint i = 0; i < sz; i++) { + if (_playList[i]->sndStatus != kPlaying) + continue; + if (_playList[i]->pMidiParser) { + if (_playList[i]->FadeStep) + doFade(_playList[i]); + _playList[i]->pMidiParser->onTimer(); + _playList[i]->ticker = (uint16)_playList[i]->pMidiParser->getTick(); + } else if (_playList[i]->pStreamAud) { + if (_pMixer->isSoundHandleActive(_playList[i]->hCurrentAud) + == false) { + _playList[i]->ticker = 0xFFFF; + _playList[i]->signal = 0xFFFF; + _playList[i]->sndStatus = kStopped; + } else + _playList[i]->ticker = (uint16)(_pMixer->getSoundElapsedTime( + _playList[i]->hCurrentAud) * 0.06); + } + }//for() + _mutex.unlock(); +} +//--------------------------------------------- +void SciMusic::doFade(sciSound *pSnd) { + if (pSnd->FadeTicker) + pSnd->FadeTicker--; + else { + pSnd->FadeTicker = pSnd->FadeTickerStep; + if (pSnd->volume + pSnd->FadeStep > pSnd->FadeTo) { + pSnd->volume = pSnd->FadeTo; + pSnd->FadeStep = 0; + } else + pSnd->volume += pSnd->FadeStep; + pSnd->pMidiParser->setVolume(pSnd->volume); + } +} + +//--------------------------------------------- +void SciMusic::soundPlay(sciSound *pSnd) { + //_mutex.lock(); + uint sz = _playList.size(), i; + // searching if sound is already in _playList + for (i = 0; i < sz && _playList[i] != pSnd; i++) + ; + if (i == sz) {// not found + _playList.push_back(pSnd); + sortPlayList(); + } + + if (pSnd->pStreamAud && _pMixer->isSoundHandleActive(pSnd->hCurrentAud) + == false) + _pMixer->playInputStream(Audio::Mixer::kSFXSoundType, &pSnd->hCurrentAud, + pSnd->pStreamAud, -1, pSnd->volume, 0, false); + else if (pSnd->pMidiParser) { + pSnd->pMidiParser->setVolume(pSnd->volume); + if (pSnd->sndStatus == kStopped) + pSnd->pMidiParser->jumpToTick(0); + } + pSnd->sndStatus = kPlaying; + //_mutex.unlock(); +} +//--------------------------------------------- +void SciMusic::soundStop(sciSound *pSnd) { + //_mutex.lock(); + pSnd->sndStatus = kStopped; + if (pSnd->pStreamAud) + _pMixer->stopHandle(pSnd->hCurrentAud); + if (pSnd->pMidiParser) + pSnd->pMidiParser->stop(); + //_mutex.unlock(); +} +//--------------------------------------------- +void SciMusic::soundSetVolume(sciSound *pSnd, byte volume) { + if (pSnd->pStreamAud) + _pMixer->setChannelVolume(pSnd->hCurrentAud, volume); + else if (pSnd->pMidiParser) + pSnd->pMidiParser->setVolume(volume); +} +//--------------------------------------------- +void SciMusic::soundSetPriority(sciSound *pSnd, byte prio) { + pSnd->prio = prio; + sortPlayList(); +} +//--------------------------------------------- +void SciMusic::soundKill(sciSound *pSnd) { + //_mutex.lock(); + pSnd->sndStatus = kStopped; + if (pSnd->pMidiParser) { + pSnd->pMidiParser->unloadMusic(); + delete pSnd->pMidiParser; + pSnd->pMidiParser = NULL; + } + if (pSnd->pStreamAud) { + _pMixer->stopHandle(pSnd->hCurrentAud); + pSnd->pStreamAud = NULL; + } + + uint sz = _playList.size(), i; + // searching if sound is already in _playList + for (i = 0; i < sz; i++) { + if (_playList[i] == pSnd) { + _playList.remove_at(i); + break; + } + } + //_mutex.unlock(); +} +//--------------------------------------------- +void SciMusic::soundPause(sciSound *pSnd) { + pSnd->sndStatus = kPaused; + if (pSnd->pStreamAud) + _pMixer->pauseHandle(pSnd->hCurrentAud, true); + else if (pSnd->pMidiParser) + pSnd->pMidiParser->pause(); +} + +//--------------------------------------------- +uint16 SciMusic::soundGetMasterVolume() { + return _pMixer->getVolumeForSoundType(Audio::Mixer::kMusicSoundType) * 0xF + / Audio::Mixer::kMaxMixerVolume; +} +//--------------------------------------------- +void SciMusic::soundSetMasterVolume(uint16 vol) { + vol = vol & 0xF; // 0..15 + vol = vol * Audio::Mixer::kMaxMixerVolume / 0xF; + // TODO:balance volume to prevent music to be too loud + _pMixer->setVolumeForSoundType(Audio::Mixer::kMusicSoundType, vol); + _pMixer->setVolumeForSoundType(Audio::Mixer::kSFXSoundType, vol); + _pMixer->setVolumeForSoundType(Audio::Mixer::kSpeechSoundType, vol); + _pMixer->setVolumeForSoundType(Audio::Mixer::kPlainSoundType, vol); +} + +//--------------------------------------------- +// MidiParser_SCI +// +MidiParser_SCI::MidiParser_SCI() : + MidiParser() { + _pMidiData = NULL; + // mididata contains delta in 1/60th second + // values of ppqn and tempo are found experimentally and may be wrong + _ppqn = 1; + setTempo(16667); +} +//--------------------------------------------- +MidiParser_SCI::~MidiParser_SCI() { + unloadMusic(); +} +//--------------------------------------------- +bool MidiParser_SCI::loadMusic(SoundRes::tagTrack *ptrack, sciSound *psnd) { + unloadMusic(); + _pTrack = ptrack; + _pSnd = psnd; + setVolume(psnd->volume); + midiMixChannels(); + + _num_tracks = 1; + _tracks[0] = _pMidiData; + setTrack(0); + _loopTick = 0; + return true; +} + +void MidiParser_SCI::unloadMusic() { + allNotesOff(); + resetTracking(); + _num_tracks = 0; + if (_pMidiData) { + delete[] _pMidiData; + _pMidiData = NULL; + } +} + +void MidiParser_SCI::parseNextEvent(EventInfo &info) { + info.start = _position._play_pos; + info.delta = *(_position._play_pos++); + + // Process the next info. + if ((_position._play_pos[0] & 0xF0) >= 0x80) + info.event = *(_position._play_pos++); + else + info.event = _position._running_status; + if (info.event < 0x80) + return; + + _position._running_status = info.event; + switch (info.command()) { + case 0xC: + info.basic.param1 = *(_position._play_pos++); + info.basic.param2 = 0; + if (info.channel() == 0xF) {// SCI special case + if (info.basic.param1 != 0x7F) + _pSnd->signal = info.basic.param1; + else + _loopTick = _position._play_tick; + } + break; + case 0xD: + info.basic.param1 = *(_position._play_pos++); + info.basic.param2 = 0; + break; + + case 0xB: + info.basic.param1 = *(_position._play_pos++); + info.basic.param2 = *(_position._play_pos++); + if (info.channel() == 0xF) {// SCI special + if (info.basic.param1 == 0x60) + _pSnd->dataInc++; + // BF 50 x - set reverb to x + // BF 60 x - dataInc++ + // BF 52 x - bHold=x + } + if (info.basic.param1 == 7) // channel volume change -scale it + info.basic.param2 = info.basic.param2 * _volume / 0x7F; + info.length = 0; + break; + + case 0x8: + case 0x9: + case 0xA: + case 0xE: + info.basic.param1 = *(_position._play_pos++); + info.basic.param2 = *(_position._play_pos++); + if (info.command() == 0x9 && info.basic.param2 == 0) + info.event = info.channel() | 0x80; + info.length = 0; + break; + + case 0xF: // System Common, Meta or SysEx event + switch (info.event & 0x0F) { + case 0x2: // Song Position Pointer + info.basic.param1 = *(_position._play_pos++); + info.basic.param2 = *(_position._play_pos++); + break; + + case 0x3: // Song Select + info.basic.param1 = *(_position._play_pos++); + info.basic.param2 = 0; + break; + + case 0x6: + case 0x8: + case 0xA: + case 0xB: + case 0xC: + case 0xE: + info.basic.param1 = info.basic.param2 = 0; + break; + + case 0x0: // SysEx + info.length = readVLQ(_position._play_pos); + info.ext.data = _position._play_pos; + _position._play_pos += info.length; + break; + + case 0xF: // META event + info.ext.type = *(_position._play_pos++); + info.length = readVLQ(_position._play_pos); + info.ext.data = _position._play_pos; + _position._play_pos += info.length; + if (info.ext.type == 0x2F) {// end of track reached + if (_pSnd->loop) { + jumpToTick(_loopTick); + _pSnd->loop--; + } else { + _pSnd->sndStatus = kStopped; + _pSnd->signal = 0xFFFF; + } + } + break; + default: + warning( + "MidiParser_SCI::parseNextEvent: Unsupported event code %x", + info.event); + } // // System Common, Meta or SysEx event + }// switch (info.command()) +} + +//---------------------------------------- +byte MidiParser_SCI::midiGetNextChannel(long ticker) { + byte curr = 0xFF; + long closest = ticker + 1000000, next = 0; + for (int i = 0; i < _pTrack->nChannels; i++) { + if (_pTrack->aChannels[i].time == -1) // channel ended + continue; + next = *_pTrack->aChannels[i].ptr; // when the next event shoudl occur + if (next == 0xF8) // 0xF8 means 240 ticks delay + next = 240; + next += _pTrack->aChannels[i].time; + if (next < closest) { + curr = i; + closest = next; + } + } + return curr; +} +//---------------------------------------- +byte *MidiParser_SCI::midiMixChannels() { + int lSize = 0; + byte **pDataPtr = new byte *[_pTrack->nChannels]; + for (int i = 0; i < _pTrack->nChannels; i++) { + pDataPtr[i] = _pTrack->aChannels[i].ptr; + _pTrack->aChannels[i].time = 0; + _pTrack->aChannels[i].prev = 0; + lSize += _pTrack->aChannels[i].size; + } + byte *pOutData = new byte[lSize * 2]; // FIXME: creates overhead and still may be not enough to hold all data + _pMidiData = pOutData; + long ticker = 0; + byte curr, delta; + byte cmd, par1, global_prev = 0; + long new_delta; + SoundRes::tagChannel *pCh; + while ((curr = midiGetNextChannel(ticker)) != 0xFF) { // there is still active channel + pCh = &_pTrack->aChannels[curr]; + delta = *pCh->ptr++; + pCh->time += (delta == 0xF8 ? 240 : delta); // when the comamnd is supposed to occur + if (delta == 0xF8) + continue; + new_delta = pCh->time - ticker; + ticker += new_delta; + + cmd = *pCh->ptr++; + if (cmd != 0xFC) { + // output new delta + while (new_delta > 240) { + *pOutData++ = 0xF8; + new_delta -= 240; + } + *pOutData++ = (byte)new_delta; + } + switch (cmd) { + case 0xF0: // sysEx + *pOutData++ = cmd; + do { + par1 = *pCh->ptr++; + *pOutData++ = par1; // out + } while (par1 != 0xF7); + break; + case 0xFC: // end channel + pCh->time = -1; // FIXME + break; + default: // MIDI command + if (cmd & 0x80) + par1 = *pCh->ptr++; + else {// running status + par1 = cmd; + cmd = pCh->prev; + } + if (cmd != global_prev) + *pOutData++ = cmd; // out cmd + *pOutData++ = par1;// pout par1 + if (nMidiParams[(cmd >> 4) - 8] == 2) + *pOutData++ = *pCh->ptr++; // out par2 + pCh->prev = cmd; + global_prev = cmd; + }// switch(cmd) + }// while (curr) + // mixing finished. inserting stop event + *pOutData++ = 0; + *pOutData++ = 0xFF; + *pOutData++ = 0x2F; + *pOutData++ = 0x00; + *pOutData++ = 0x00; + + for (int i = 0; i < _pTrack->nChannels; i++) + _pTrack->aChannels[i].ptr = pDataPtr[i]; + delete[] pDataPtr; + return _pMidiData; +} + +void MidiParser_SCI::setVolume(byte bVolume) { + if (bVolume > 0x7F) + bVolume = 0x7F; + if (_volume != bVolume) { + _volume = bVolume; + // sending volume change to all active channels + for (int i = 0; i < _pTrack->nChannels; i++) + if (_pTrack->aChannels[i].number <= 0xF) + _driver->send(0xB0 + _pTrack->aChannels[i].number, 7, _volume); + } +} + +//--------------------------- + +SoundRes::tagTrack* SoundRes::getTrackByNumber(uint16 number) { + if (/*number >= 0 &&*/number < nTracks) + return &aTracks[number]; + return NULL; +} + +SoundRes::tagTrack* SoundRes::getTrackByType(kTrackType type) { + for (int i = 0; i < nTracks; i++) + if (aTracks[i].type == type) + return &aTracks[i]; + return NULL; +} + +} // end of namespace SCI diff --git a/engines/sci/sfx/music.h b/engines/sci/sfx/music.h new file mode 100644 index 0000000000..0e78418f32 --- /dev/null +++ b/engines/sci/sfx/music.h @@ -0,0 +1,207 @@ +/* ScummVM - Graphic Adventure Engine + * + * ScummVM is the legal property of its developers, whose names + * are too numerous to list here. Please refer to the COPYRIGHT + * file distributed with this source distribution. + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + * + * $URL$ + * $Id$ + * + */ + +#ifndef SCI_MUSIC_H +#define SCI_MUSIC_H + +#include "sound/mixer.h" +#include "sound/audiostream.h" +#include "sound/mididrv.h" +#include "sound/midiparser.h" +#include "common/mutex.h" +#include "common/savefile.h" + +#include "sci/sci.h" + +/* + Sound drivers info: (from driver cmd0) + Adlib/SB : track 0 , voices 9 , patch 3 ah=1 + ProAudioSp: track 0 , voices 9 , patch 3 ah=17 + GenerlMIDI: track 7 , voices 32, patch 4 ah=1 SCI1.1 + Game Blast: track 9 , voices 12, patch 101 ah=1 + MT-32 : track 12, voices 32, patch 1 ah=1 + PC Speaker: track 18, voices 1 , patch 0xFF ah=1 + Tandy : track 19, voices 3 , patch 101 ah=1 + IBM PS/1 : track 19, voices 3 , patch 101 ah=1 + + */ + +namespace Sci { + +typedef uint16 SCIHANDLE; +typedef uint16 HEAPHANDLE; + +class SoundRes { +public: + enum kTrackType { + kTrackAdlib = 0, + kTrackGameBlaster = 9, + kTrackMT32 = 12, + kTrackSpeaker = 18, + kTrackTandy = 19 + }; + + struct tagChannel { + byte number; + byte poly; + uint16 unk; + uint16 size; + byte *ptr; + long time; + byte prev; + }; + + struct tagTrack { + kTrackType type; + byte nDigital; + byte nChannels; + tagChannel *aChannels; + uint sz; + }; +public: + SoundRes(SCIHANDLE handle, uint32 ResId); + ~SoundRes(); + tagTrack *getTrackByNumber(uint16 number); + tagTrack *getTrackByType(kTrackType type); + +protected: + byte nTracks; + tagTrack *aTracks; +}; + +enum kSndStatus { + kStopped = 0, kPaused, kPlaying +}; + +// script-used struct to manipulate sound (358 bytes) +class MidiParser_SCI; + +struct sciSound { + //sciNode node; // [0-5] // we use a Common::List + uint16 resnum;// [6-7] + // byte * pMidiData; + Audio::AudioStream* pStreamAud; + MidiParser_SCI *pMidiParser; + Audio::SoundHandle hCurrentAud; + kSndStatus sndStatus; + + uint16 dataInc; //[338-339] + uint16 ticker; + uint16 signal; //[344] + byte prio; // 348 + byte loop; // 349 + byte volume; // 350 + + byte FadeTo; + short FadeStep; + uint32 FadeTicker; + uint32 FadeTickerStep; + + // byte unk7[7]; +}; + +class SciMusic { +public: + SciMusic(); + ~SciMusic(); + + void init(); + void loadPatch(); + void onTimer(); + bool saveState(Common::OutSaveFile *pFile); + bool restoreState(Common::InSaveFile *pFile); + void stopAll(); + void clearPlaylist() { + _playList.clear(); + } + // sound and midi functions + void soundInitSnd(SoundRes *res, sciSound *pSnd); + void soundPlay(sciSound *pSnd); + void soundStop(sciSound *pSnd); + void soundKill(sciSound *pSnd); + void soundPause(sciSound *pSnd); + void soundSetVolume(sciSound *pSnd, byte volume); + void soundSetPriority(sciSound *pSnd, byte prio); + uint16 soundGetMasterVolume(); + void soundSetMasterVolume(uint16 vol); + uint16 soundGetVoices(); + uint32 soundGetTempo() { + return _dwTempo; + } + + uint16 _savelen; +protected: + byte findAudEntry(uint16 nAud, byte&oVolume, uint32& oOffset, uint32&oSize); + void sortPlayList(); + void loadPatchMT32(); + void patchSysEx(byte * addr, byte *pdata, int len); + void patchUpdateAddr(byte *addr, int len); + void doFade(sciSound *pSnd); + + Audio::Mixer *_pMixer; + MidiDriver *_pMidiDrv; + int _midiType; + Common::Mutex _mutex; + + Common::Array _playList; + uint32 _dwTempo; + bool _bMultiMidi; // use adlib's digital track if midi track don't have one + +private: + static void miditimerCallback(void *p); + +}; + +class MidiParser_SCI : public MidiParser { +public: + MidiParser_SCI(); + ~MidiParser_SCI(); + bool loadMusic(SoundRes::tagTrack *ptrack, sciSound *psnd); + bool loadMusic(byte *, uint32) { + return false; + } + void unloadMusic(); + void setVolume(byte bVolume); + void stop() { + _abort_parse = true;/*hangAllActiveNotes();*/ + } + void pause() { + _abort_parse = true; /*hangAllActiveNotes();*/ + } + +protected: + void parseNextEvent(EventInfo &info); + byte *midiMixChannels(); + byte midiGetNextChannel(long ticker); + byte *_pMidiData; + SoundRes::tagTrack *_pTrack; + sciSound *_pSnd; + uint32 _loopTick; + byte _volume; +}; + +} // end of namespace + +#endif diff --git a/engines/sci/sfx/soundcmd.cpp b/engines/sci/sfx/soundcmd.cpp index 1af9da57ba..7b713ecec7 100644 --- a/engines/sci/sfx/soundcmd.cpp +++ b/engines/sci/sfx/soundcmd.cpp @@ -24,10 +24,13 @@ */ #include "sci/sfx/iterator.h" // for SongIteratorStatus +#include "sci/sfx/music.h" #include "sci/sfx/soundcmd.h" namespace Sci { +#define USE_OLD_MUSIC_FUNCTIONS + #define SCI1_SOUND_FLAG_MAY_PAUSE 1 /* Only here for completeness; The interpreter doesn't touch this bit */ #define SCI1_SOUND_FLAG_SCRIPTED_PRI 2 /* but does touch this */ @@ -126,6 +129,13 @@ void process_sound_events(EngineState *s) { /* Get all sound events, apply their SoundCommandParser::SoundCommandParser(ResourceManager *resMan, SegManager *segMan, SfxState *state, AudioPlayer *audio, SciVersion doSoundVersion) : _resMan(resMan), _segMan(segMan), _state(state), _audio(audio), _doSoundVersion(doSoundVersion) { + _hasNodePtr = (_doSoundVersion != SCI_VERSION_0_EARLY); + +#ifndef USE_OLD_MUSIC_FUNCTIONS + _music = new SciMusic(); + _music->init(); +#endif + switch (doSoundVersion) { case SCI_VERSION_0_EARLY: SOUNDCOMMAND(cmdInitHandle); @@ -220,10 +230,11 @@ void SoundCommandParser::cmdInitHandle(reg_t obj, SongHandle handle, int value) if (!obj.segment) return; +#ifdef USE_OLD_MUSIC_FUNCTIONS SongIteratorType type = (_doSoundVersion == SCI_VERSION_0_EARLY) ? SCI_SONG_ITERATOR_TYPE_SCI0 : SCI_SONG_ITERATOR_TYPE_SCI1; int number = GET_SEL32V(_segMan, obj, number); - if (_doSoundVersion != SCI_VERSION_0_EARLY) { + if (_hasNodePtr) { if (GET_SEL32V(_segMan, obj, nodePtr)) { _state->sfx_song_set_status(handle, SOUND_STATUS_STOPPED); _state->sfx_remove_song(handle); @@ -238,13 +249,36 @@ void SoundCommandParser::cmdInitHandle(reg_t obj, SongHandle handle, int value) _state->sfx_add_song(build_iterator(_resMan, number, type, handle), 0, handle, number); - if (_doSoundVersion == SCI_VERSION_0_EARLY) { + if (!_hasNodePtr) PUT_SEL32V(_segMan, obj, state, _K_SOUND_STATUS_INITIALIZED); - } else { + else PUT_SEL32(_segMan, obj, nodePtr, obj); - } PUT_SEL32(_segMan, obj, handle, obj); +#else + + uint16 resnum = GET_SEL32V(_segMan, obj, number); + Resource *res = resnum ? _resMan->findResource(ResourceId(kResourceTypeSound, resnum), true) : NULL; + + if (!GET_SEL32V(_segMan, obj, nodePtr)) { + PUT_SEL32(_segMan, obj, nodePtr, obj); + _soundList.push_back(obj.toUint16()); + } + + // TODO + /* + sciSound *pSnd = (sciSound *)heap2Ptr(hptr); + pSnd->resnum = resnum; + pSnd->loop = (GET_SEL32V(_segMan, obj, loop) == 0xFFFF ? 1 : 0); + pSnd->prio = GET_SEL32V(_segMan, obj, pri) & 0xFF; // priority + pSnd->volume = GET_SEL32V(_segMan, obj, vol) & 0xFF; // volume + pSnd->signal = pSnd->dataInc = 0; + + _music->soundKill(pSnd); + if (res) + _music->soundInitSnd(res, pSnd); + */ +#endif } void SoundCommandParser::cmdPlayHandle(reg_t obj, SongHandle handle, int value) { @@ -332,7 +366,7 @@ void SoundCommandParser::cmdDisposeHandle(reg_t obj, SongHandle handle, int valu if (obj.segment) { _state->sfx_remove_song(handle); - if (_doSoundVersion == SCI_VERSION_0_EARLY) + if (!_hasNodePtr) PUT_SEL32V(_segMan, obj, handle, 0x0000); } } @@ -340,12 +374,12 @@ void SoundCommandParser::cmdDisposeHandle(reg_t obj, SongHandle handle, int valu void SoundCommandParser::cmdStopHandle(reg_t obj, SongHandle handle, int value) { changeHandleStatus(obj, handle, SOUND_STATUS_STOPPED); - if (_doSoundVersion != SCI_VERSION_0_EARLY) + if (_hasNodePtr) PUT_SEL32V(_segMan, obj, signal, SIGNAL_OFFSET); } void SoundCommandParser::cmdSuspendHandle(reg_t obj, SongHandle handle, int value) { - if (_doSoundVersion == SCI_VERSION_0_EARLY) + if (!_hasNodePtr) changeHandleStatus(obj, handle, SOUND_STATUS_SUSPENDED); else changeHandleStatus(obj, handle, value ? SOUND_STATUS_SUSPENDED : SOUND_STATUS_PLAYING); @@ -387,7 +421,7 @@ void SoundCommandParser::cmdFadeHandle(reg_t obj, SongHandle handle, int value) ** than fading it! */ if (obj.segment) { _state->sfx_song_set_status(handle, SOUND_STATUS_STOPPED); - if (_doSoundVersion == SCI_VERSION_0_EARLY) + if (!_hasNodePtr) PUT_SEL32V(_segMan, obj, state, SOUND_STATUS_STOPPED); PUT_SEL32V(_segMan, obj, signal, SIGNAL_OFFSET); } diff --git a/engines/sci/sfx/soundcmd.h b/engines/sci/sfx/soundcmd.h index 60efa3b1dc..4061b10ea1 100644 --- a/engines/sci/sfx/soundcmd.h +++ b/engines/sci/sfx/soundcmd.h @@ -26,10 +26,12 @@ #ifndef SCI_SOUNDCMD_H #define SCI_SOUNDCMD_H +#include "common/list.h" #include "sci/engine/state.h" namespace Sci { +class SciMusic; class SoundCommandParser; typedef void (SoundCommandParser::*SoundCommand)(reg_t obj, SongHandle handle, int value); @@ -47,15 +49,19 @@ public: reg_t parseCommand(int argc, reg_t *argv, reg_t acc); private: + SciMusic *_music; Common::Array _soundCommands; ResourceManager *_resMan; SegManager *_segMan; SfxState *_state; AudioPlayer *_audio; + bool _hasNodePtr; SciVersion _doSoundVersion; reg_t _acc; int _midiCmd, _controller, _param; + Common::List _soundList; + void cmdInitHandle(reg_t obj, SongHandle handle, int value); void cmdPlayHandle(reg_t obj, SongHandle handle, int value); void cmdDummy(reg_t obj, SongHandle handle, int value); -- cgit v1.2.3