From 2186ad138b1c6842c1ae2bf25cc55d75002cdb72 Mon Sep 17 00:00:00 2001 From: Robert Göffringmann Date: Wed, 28 May 2003 23:31:43 +0000 Subject: moved music drivers into seperated directory, added music support for diskdemo's adlib driver version. (maybe other sky versions also have this older adlib driver?) svn-id: r8069 --- sky/music/adlibchannel.cpp | 323 +++++++++++++++++++++++++++++++++++++++++++++ sky/music/adlibchannel.h | 101 ++++++++++++++ sky/music/adlibmusic.cpp | 108 +++++++++++++++ sky/music/adlibmusic.h | 47 +++++++ sky/music/gmchannel.cpp | 203 ++++++++++++++++++++++++++++ sky/music/gmchannel.h | 76 +++++++++++ sky/music/gmmusic.cpp | 146 ++++++++++++++++++++ sky/music/gmmusic.h | 49 +++++++ sky/music/mt32music.cpp | 182 +++++++++++++++++++++++++ sky/music/mt32music.h | 50 +++++++ sky/music/musicbase.cpp | 164 +++++++++++++++++++++++ sky/music/musicbase.h | 85 ++++++++++++ 12 files changed, 1534 insertions(+) create mode 100644 sky/music/adlibchannel.cpp create mode 100644 sky/music/adlibchannel.h create mode 100644 sky/music/adlibmusic.cpp create mode 100644 sky/music/adlibmusic.h create mode 100644 sky/music/gmchannel.cpp create mode 100644 sky/music/gmchannel.h create mode 100644 sky/music/gmmusic.cpp create mode 100644 sky/music/gmmusic.h create mode 100644 sky/music/mt32music.cpp create mode 100644 sky/music/mt32music.h create mode 100644 sky/music/musicbase.cpp create mode 100644 sky/music/musicbase.h (limited to 'sky/music') diff --git a/sky/music/adlibchannel.cpp b/sky/music/adlibchannel.cpp new file mode 100644 index 0000000000..26ad970814 --- /dev/null +++ b/sky/music/adlibchannel.cpp @@ -0,0 +1,323 @@ +/* ScummVM - Scumm Interpreter + * Copyright (C) 2003 The ScummVM project + * + * 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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + * + * $Header$ + * + */ + +#include "adlibchannel.h" +#include "sound/fmopl.h" + +SkyAdlibChannel::SkyAdlibChannel(uint8 *pMusicData, uint16 startOfData, uint32 version) +{ + _gameVersion = version; + _musicData = pMusicData; + _channelData.startOfData = startOfData; + _channelData.eventDataPtr = startOfData; + _channelData.channelActive = 1; + _channelData.freqDataSize = 2; + _channelData.tremoVibro = 0; + _channelData.assignedInstrument = 0xFF; + _channelData.channelVolume = 0x7F; + _channelData.nextEventTime = getNextEventTime(); + + _channelData.adlibChannelNumber = _channelData.lastCommand = _channelData.note = + _channelData.adlibReg1 = _channelData.adlibReg2 = _channelData.freqOffset = 0; + _channelData.frequency = 0; + _channelData.instrumentData = NULL; + + uint16 instrumentDataLoc; + + if (_gameVersion == 267) { + instrumentDataLoc = (_musicData[0x11FC] << 8) | _musicData[0x11FB]; + _frequenceTable = (uint16*)(_musicData+0x7F4); + _registerTable = _musicData+0xDF4; + _opOutputTable = _musicData+0xE06; + _adlibRegMirror = _musicData+0xF55; + } else { + instrumentDataLoc = (_musicData[0x1206] << 8) | _musicData[0x1205]; + _frequenceTable = (uint16*)(_musicData+0x7FE); + _registerTable = _musicData+0xDFE; + _opOutputTable = _musicData+0xE10; + _adlibRegMirror = _musicData+0xF5F; + } + + _instrumentMap = _musicData+instrumentDataLoc; + _instruments = (InstrumentStruct*)(_instrumentMap+0x80); + + _musicVolume = 0x100; +} + +void SkyAdlibChannel::updateVolume(uint16 pVolume) { + + _musicVolume = pVolume; +} + +/* This class uses the same area for the register mirror as the original + asm driver did (_musicData[0xF5F..0x105E]), so the cache is indeed shared + by all instances of the class. +*/ +void SkyAdlibChannel::setRegister(uint8 regNum, uint8 value) { + + if (_adlibRegMirror[regNum] != value) { + YM3812Write(0, 0, regNum); + YM3812Write(0, 1, value); + _adlibRegMirror[regNum] = value; + } +} + +void SkyAdlibChannel::stopNote(void) { + + if (_channelData.note & 0x20) { + _channelData.note &= ~0x20; + setRegister(0xB0 | _channelData.adlibChannelNumber, _channelData.note); + } +} + +int32 SkyAdlibChannel::getNextEventTime(void) +{ + int32 retV = 0; + uint8 cnt, lVal; + for (cnt = 0; cnt < 4; cnt++) { + lVal = _musicData[_channelData.eventDataPtr]; + _channelData.eventDataPtr++; + retV = (retV << 7) | (lVal & 0x7F); + if (!(lVal & 0x80)) break; + } + if (lVal & 0x80) { // should never happen + return -1; + } else return retV; + +} + +uint8 SkyAdlibChannel::process(uint16 aktTime) { + + if (!_channelData.channelActive) { + return 0; + } + + uint8 returnVal = 0; + + _channelData.nextEventTime -= aktTime; + uint8 opcode; + while ((_channelData.nextEventTime < 0) && (_channelData.channelActive)) { + opcode = _musicData[_channelData.eventDataPtr]; + _channelData.eventDataPtr++; + if (opcode&0x80) { + if (opcode == 0xFF) { + // dummy opcode + } else if (opcode >= 0x90) { + switch (opcode&0xF) { + case 0: com90_caseNoteOff(); break; + case 1: com90_stopChannel(); break; + case 2: com90_setupInstrument(); break; + case 3: + returnVal = com90_updateTempo(); + break; + case 5: com90_getFreqOffset(); break; + case 6: com90_getChannelVolume(); break; + case 7: com90_getTremoVibro(); break; + case 8: com90_rewindMusic(); break; + case 9: com90_keyOff(); break; + case 12: com90_setStartOfData(); break; + case 4: //com90_dummy(); + case 10: //com90_error(); + case 11: //com90_doLodsb(); + case 13: //com90_do_two_Lodsb(); + error("SkyChannel: dummy music routine 0x%02X was called",opcode); + _channelData.channelActive = 0; + break; + default: + // these opcodes aren't implemented in original music driver + error("SkyChannel: Not existant routine 0x%02X was called",opcode); + _channelData.channelActive = 0; + break; + } + } else { + // new adlib channel assignment + _channelData.adlibChannelNumber = opcode&0xF; + _channelData.adlibReg1 = _registerTable[(opcode&0xF)<<1]; + _channelData.adlibReg2 = _registerTable[((opcode&0xF)<<1)|1]; + } + } else { + _channelData.lastCommand = opcode; + stopNote(); + // not sure why this "if" is necessary...either a bug in my + // code or a bug in the music data (section 1, music 2) + if (_channelData.instrumentData || _channelData.tremoVibro) { + setupInstrument(opcode); + + opcode = _musicData[_channelData.eventDataPtr]; + _channelData.eventDataPtr++; + setupChannelVolume(opcode); + } else _channelData.eventDataPtr++; + } + if (_channelData.channelActive) + _channelData.nextEventTime += getNextEventTime(); + } + return returnVal; +} + +void SkyAdlibChannel::setupInstrument(uint8 opcode) { + + uint16 nextNote; + if (_channelData.tremoVibro) { + uint8 newInstrument = _instrumentMap[opcode]; + if (newInstrument != _channelData.assignedInstrument) { + _channelData.assignedInstrument = newInstrument; + _channelData.instrumentData = _instruments + newInstrument; + adlibSetupInstrument(); + } + _channelData.lastCommand = _channelData.instrumentData->bindedEffect; + nextNote = getNextNote(_channelData.lastCommand); + } else { + nextNote = getNextNote(opcode - 0x18 + _channelData.instrumentData->bindedEffect); + } + _channelData.frequency = nextNote; + setRegister(0xA0 | _channelData.adlibChannelNumber, (uint8)nextNote); + setRegister(0xB0 | _channelData.adlibChannelNumber, (uint8)((nextNote >> 8) | 0x20)); + _channelData.note = (uint8)((nextNote >> 8) | 0x20); +} + +void SkyAdlibChannel::setupChannelVolume(uint8 volume) { + + uint8 resultOp; + uint32 resVol = ((volume + 1) * (_channelData.instrumentData->totOutLev_Op2 + 1)) << 1; + resVol &= 0xFFFF; + resVol *= (_channelData.channelVolume+1)<<1; + resVol >>= 8; + resVol *= _musicVolume; + resVol >>= 16; + resultOp = ((_channelData.instrumentData->scalingLevel << 6) & 0xC0) | _opOutputTable[resVol]; + setRegister(0x40 | _channelData.adlibReg2, resultOp); + if (_channelData.instrumentData->feedBack & 1) { + resVol = ((volume + 1) * (_channelData.instrumentData->totOutLev_Op1 + 1)) << 1; + resVol &= 0xFFFF; + resVol *= (_channelData.channelVolume + 1)<<1; + resVol >>= 8; + resVol *= (_musicVolume & 0xFF); + resVol >>= 16; + } else resVol = _channelData.instrumentData->totOutLev_Op1; + resultOp = ((_channelData.instrumentData->scalingLevel << 2) & 0xC0) | _opOutputTable[resVol]; + setRegister(0x40 | _channelData.adlibReg1, resultOp); +} + +void SkyAdlibChannel::adlibSetupInstrument(void) { + + setRegister(0x60 | _channelData.adlibReg1, _channelData.instrumentData->ad_Op1); + setRegister(0x60 | _channelData.adlibReg2, _channelData.instrumentData->ad_Op2); + setRegister(0x80 | _channelData.adlibReg1, _channelData.instrumentData->sr_Op1); + setRegister(0x80 | _channelData.adlibReg2, _channelData.instrumentData->sr_Op2); + setRegister(0xE0 | _channelData.adlibReg1, _channelData.instrumentData->waveSelect_Op1); + setRegister(0xE0 | _channelData.adlibReg2, _channelData.instrumentData->waveSelect_Op2); + setRegister(0xC0 | _channelData.adlibChannelNumber, _channelData.instrumentData->feedBack); + setRegister(0x20 | _channelData.adlibReg1, _channelData.instrumentData->ampMod_Op1); + setRegister(0x20 | _channelData.adlibReg2, _channelData.instrumentData->ampMod_Op2); +} + +#ifdef SCUMM_BIG_ENDIAN +#define ENDIAN16(x) ((x >> 8) | ((x & 0xFF) << 8)) +#else +#define ENDIAN16(x) (x) +#endif + +uint16 SkyAdlibChannel::getNextNote(uint8 param) { + + int16 freqIndex = ((int16)_channelData.freqOffset) - 0x40; + if (freqIndex >= 0x3F) freqIndex++; + freqIndex *= _channelData.freqDataSize; + freqIndex += param<<6; + uint16 freqData = ENDIAN16(_frequenceTable[freqIndex % 0x300]); + if ((freqIndex%0x300 >= 0x1C0) || (freqIndex/0x300 > 0)) { + return (((freqIndex / 0x300) - 1) << 10) + (freqData & 0x7FF); + } else { + // looks like a bug. dunno why. It's what the ASM code says. + return (uint16)(((int16)freqData) >> 1); + } +} + +//- command 90h routines + +void SkyAdlibChannel::com90_caseNoteOff(void) { + + if (_musicData[_channelData.eventDataPtr] == _channelData.lastCommand) + stopNote(); + _channelData.eventDataPtr++; +} + +void SkyAdlibChannel::com90_stopChannel(void) { + + stopNote(); + _channelData.channelActive = 0; +} + +void SkyAdlibChannel::com90_setupInstrument(void) { + + _channelData.channelVolume = 0x7F; + _channelData.freqOffset = 0x40; + _channelData.assignedInstrument = _musicData[_channelData.eventDataPtr]; + _channelData.eventDataPtr++; + _channelData.instrumentData = _instruments + _channelData.assignedInstrument; + adlibSetupInstrument(); +} + +uint8 SkyAdlibChannel::com90_updateTempo(void) { + + uint8 retV = _musicData[_channelData.eventDataPtr]; + _channelData.eventDataPtr++; + return retV; +} + +void SkyAdlibChannel::com90_getFreqOffset(void) { + + _channelData.freqOffset = _musicData[_channelData.eventDataPtr]; + _channelData.eventDataPtr++; + if (_channelData.note & 0x20) { + uint16 nextNote = getNextNote( + _channelData.lastCommand - 0x18 + _channelData.instrumentData->bindedEffect); + setRegister(0xA0 | _channelData.adlibChannelNumber, (uint8)nextNote); + setRegister(0xB0 | _channelData.adlibChannelNumber, (uint8)((nextNote >> 8) | 0x20)); + _channelData.note = (uint8)(nextNote >> 8) | 0x20; + } +} + +void SkyAdlibChannel::com90_getChannelVolume(void) { + + _channelData.channelVolume = _musicData[_channelData.eventDataPtr]; + _channelData.eventDataPtr++; +} + +void SkyAdlibChannel::com90_getTremoVibro(void) { + + _channelData.tremoVibro = _musicData[_channelData.eventDataPtr]; + _channelData.eventDataPtr++; +} + +void SkyAdlibChannel::com90_rewindMusic(void) { + + _channelData.eventDataPtr = _channelData.startOfData; +} + +void SkyAdlibChannel::com90_keyOff(void) { + + stopNote(); +} + +void SkyAdlibChannel::com90_setStartOfData(void) { + + _channelData.startOfData = _channelData.eventDataPtr; +} diff --git a/sky/music/adlibchannel.h b/sky/music/adlibchannel.h new file mode 100644 index 0000000000..a9b43c3f9b --- /dev/null +++ b/sky/music/adlibchannel.h @@ -0,0 +1,101 @@ +/* ScummVM - Scumm Interpreter + * Copyright (C) 2003 The ScummVM project + * + * 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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + * + * $Header$ + * + */ + +#ifndef ADLIBCHANNEL_H +#define ADLIBCHANNEL_H + +#include "stdafx.h" +#include "common/engine.h" +#include "sky/music/musicbase.h" + +typedef struct { + uint8 ad_Op1, ad_Op2; + uint8 sr_Op1, sr_Op2; + uint8 ampMod_Op1, ampMod_Op2; + uint8 waveSelect_Op1, waveSelect_Op2; + uint8 bindedEffect; + uint8 feedBack; + uint8 totOutLev_Op1, totOutLev_Op2; + uint8 scalingLevel; + uint8 pad1, pad2, pad3; +} InstrumentStruct; + +typedef struct { + uint16 eventDataPtr; + int32 nextEventTime; + uint16 startOfData; + uint8 adlibChannelNumber; + uint8 lastCommand; + uint8 channelActive; + uint8 note; + uint8 adlibReg1, adlibReg2; + InstrumentStruct *instrumentData; + uint8 assignedInstrument; + uint8 channelVolume; + uint8 padding; // field_12 / not used by original driver + uint8 tremoVibro; + uint8 freqDataSize; + uint8 freqOffset; + uint16 frequency; +} AdlibChannelType; + +class SkyAdlibChannel : public SkyChannelBase { +public: + SkyAdlibChannel(uint8 *pMusicData, uint16 startOfData, uint32 version); + virtual void stopNote(void); + virtual uint8 process(uint16 aktTime); + virtual void updateVolume(uint16 pVolume); +private: + uint32 _gameVersion; + uint8 *_musicData; + uint16 _musicVolume; + AdlibChannelType _channelData; + //- + InstrumentStruct *_instruments; + uint16 *_frequenceTable; + uint8 *_instrumentMap; + uint8 *_registerTable, *_opOutputTable; + uint8 *_adlibRegMirror; + //- normal subs + void setRegister(uint8 regNum, uint8 value); + int32 getNextEventTime(void); + uint16 getNextNote(uint8 param); + void adlibSetupInstrument(void); + void setupInstrument(uint8 opcode); + void setupChannelVolume(uint8 volume); + //- Streamfunctions from Command90hTable + void com90_caseNoteOff(void); // 0 + void com90_stopChannel(void); // 1 + void com90_setupInstrument(void); // 2 + uint8 com90_updateTempo(void); // 3 + //void com90_dummy(void); // 4 + void com90_getFreqOffset(void); // 5 + void com90_getChannelVolume(void); // 6 + void com90_getTremoVibro(void); // 7 + void com90_rewindMusic(void); // 8 + void com90_keyOff(void); // 9 + //void com90_error(void); // 10 + //void com90_doLodsb(void); // 11 + void com90_setStartOfData(void); // 12 + //void com90_do_two_Lodsb(void); // 13 +}; + +#endif //ADLIBCHANNEL_H diff --git a/sky/music/adlibmusic.cpp b/sky/music/adlibmusic.cpp new file mode 100644 index 0000000000..b23afd879c --- /dev/null +++ b/sky/music/adlibmusic.cpp @@ -0,0 +1,108 @@ +/* ScummVM - Scumm Interpreter + * Copyright (C) 2003 The ScummVM project + * + * 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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + * + * $Header$ + * + */ + +#include "sky/music/adlibmusic.h" +#include "sound/fmopl.h" + +void SkyAdlibMusic::passMixerFunc(void *param, int16 *buf, uint len) { + + ((SkyAdlibMusic*)param)->premixerCall(buf, len); +} + +SkyAdlibMusic::SkyAdlibMusic(SoundMixer *pMixer, SkyDisk *pSkyDisk, uint32 version) + : SkyMusicBase(pSkyDisk, version) { + + _driverFileBase = 60202; + _mixer = pMixer; + _sampleRate = g_system->property(OSystem::PROP_GET_SAMPLE_RATE, 0); + if (0 != YM3812Init(1, 3579545, _sampleRate)) + error("Error initialising YM3812 sound chip emulation"); + _mixer->setupPremix(this, passMixerFunc); +} + +SkyAdlibMusic::~SkyAdlibMusic(void) { + + _mixer->setupPremix(NULL, NULL); + YM3812Shutdown(); +} + +void SkyAdlibMusic::premixerCall(int16 *buf, uint len) { + + if (_musicData == NULL) { + // no music loaded + memset(buf, 0, len * sizeof(int16)); + return; + } else if ((_currentMusic == 0) || (_numberOfChannels == 0)) { + // music loaded but not played as of yet + memset(buf, 0, len * sizeof(int16)); + // poll anyways as pollMusic() can activate the music + pollMusic(); + _nextMusicPoll = _sampleRate/50; + return; + } + uint32 render; + while (len) { + render = (len > _nextMusicPoll) ? (_nextMusicPoll) : (len); + len -= render; + _nextMusicPoll -= render; + YM3812UpdateOne(0, buf, render); + buf += render; + if (_nextMusicPoll == 0) { + pollMusic(); + _nextMusicPoll = _sampleRate/50; + } + } +} + +void SkyAdlibMusic::setupPointers(void) { + + printf("game version: %d\n",_gameVersion); + if (_gameVersion == 267) { + // disk demo uses a different adlib driver version, some offsets have changed + _musicDataLoc = (_musicData[0x11F8] << 8) | _musicData[0x11F7]; + _initSequence = _musicData + 0xE87; + } else { + _musicDataLoc = (_musicData[0x1202] << 8) | _musicData[0x1201]; + _initSequence = _musicData + 0xE91; + } + _nextMusicPoll = 0; +} + +void SkyAdlibMusic::setupChannels(uint8 *channelData) { + + _numberOfChannels = channelData[0]; + channelData++; + for (uint8 cnt = 0; cnt < _numberOfChannels; cnt++) { + uint16 chDataStart = ((channelData[(cnt << 1) | 1] << 8) | channelData[cnt << 1]) + _musicDataLoc; + _channels[cnt] = new SkyAdlibChannel(_musicData, chDataStart, _gameVersion); + } +} + +void SkyAdlibMusic::startDriver(void) { + + uint16 cnt = 0; + while (_initSequence[cnt] || _initSequence[cnt+1]) { + YM3812Write(0, 0, _initSequence[cnt]); + YM3812Write(0, 1, _initSequence[cnt+1]); + cnt += 2; + } + _allowedCommands = 0xD; +} diff --git a/sky/music/adlibmusic.h b/sky/music/adlibmusic.h new file mode 100644 index 0000000000..dcde24150c --- /dev/null +++ b/sky/music/adlibmusic.h @@ -0,0 +1,47 @@ +/* ScummVM - Scumm Interpreter + * Copyright (C) 2003 The ScummVM project + * + * 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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + * + * $Header$ + * + */ + +#ifndef ADLIBMUSIC_H +#define ADLIBMUSIC_H + +#include "stdafx.h" +#include "sound/mixer.h" +#include "common/engine.h" +#include "adlibchannel.h" +#include "musicbase.h" + +class SkyAdlibMusic : public SkyMusicBase { +public: + SkyAdlibMusic(SoundMixer *pMixer, SkyDisk *pSkyDisk, uint32 version); + ~SkyAdlibMusic(void); +private: + SoundMixer *_mixer; + uint8 *_initSequence; + uint32 _sampleRate, _nextMusicPoll; + virtual void setupPointers(void); + virtual void setupChannels(uint8 *channelData); + virtual void startDriver(void); + + void premixerCall(int16 *buf, uint len); + static void passMixerFunc(void *param, int16 *buf, uint len); +}; + +#endif //ADLIBMUSIC_H diff --git a/sky/music/gmchannel.cpp b/sky/music/gmchannel.cpp new file mode 100644 index 0000000000..5db1256388 --- /dev/null +++ b/sky/music/gmchannel.cpp @@ -0,0 +1,203 @@ +/* ScummVM - Scumm Interpreter + * Copyright (C) 2003 The ScummVM project + * + * 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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + * + * $Header$ + * + */ + +#include "gmchannel.h" + +// the MT32 is a lot more sensitive to velocities than most general midi devices, +// so we need to boost them a little +uint8 SkyGmChannel::_veloTab[128] = { +0x00, 0x30, 0x31, 0x31, 0x32, 0x33, 0x33, 0x34, 0x34, 0x35, 0x36, 0x36, 0x37, +0x38, 0x38, 0x39, 0x39, 0x3A, 0x3B, 0x3B, 0x3C, 0x3D, 0x3D, 0x3E, 0x3E, 0x3F, +0x40, 0x40, 0x41, 0x42, 0x42, 0x43, 0x43, 0x44, 0x45, 0x45, 0x46, 0x47, 0x47, +0x48, 0x48, 0x49, 0x4A, 0x4A, 0x4B, 0x4C, 0x4C, 0x4D, 0x4D, 0x4E, 0x4F, 0x4F, +0x50, 0x50, 0x51, 0x52, 0x52, 0x53, 0x54, 0x54, 0x55, 0x55, 0x56, 0x57, 0x57, +0x58, 0x59, 0x59, 0x5A, 0x5A, 0x5B, 0x5C, 0x5C, 0x5D, 0x5E, 0x5E, 0x5F, 0x5F, +0x60, 0x61, 0x61, 0x62, 0x63, 0x63, 0x64, 0x64, 0x65, 0x66, 0x66, 0x67, 0x68, +0x68, 0x69, 0x69, 0x6A, 0x6B, 0x6B, 0x6C, 0x6C, 0x6D, 0x6E, 0x6E, 0x6F, 0x70, +0x70, 0x71, 0x71, 0x72, 0x73, 0x73, 0x74, 0x75, 0x75, 0x76, 0x76, 0x77, 0x78, +0x78, 0x79, 0x7A, 0x7A, 0x7B, 0x7B, 0x7C, 0x7D, 0x7D, 0x7E, 0x7F }; + +SkyGmChannel::SkyGmChannel(uint8 *pMusicData, uint16 startOfData, MidiDriver *pMidiDrv, byte *pInstMap) +{ + _musicData = pMusicData; + _midiDrv = pMidiDrv; + _channelData.startOfData = startOfData; + _channelData.eventDataPtr = startOfData; + _channelData.channelActive = 1; + _channelData.nextEventTime = getNextEventTime(); + _mt32_to_gm = pInstMap; + + _musicVolume = 0x100; +} + +void SkyGmChannel::updateVolume(uint16 pVolume) { + + _musicVolume = pVolume; +} + +void SkyGmChannel::stopNote(void) { + + _midiDrv->send((0xB0 | _channelData.midiChannelNumber) | 0x7B00 | 0 | 0x79000000); + _midiDrv->send(0); +} + +int32 SkyGmChannel::getNextEventTime(void) +{ + int32 retV = 0; + uint8 cnt, lVal; + for (cnt = 0; cnt < 4; cnt++) { + lVal = _musicData[_channelData.eventDataPtr]; + _channelData.eventDataPtr++; + retV = (retV << 7) | (lVal & 0x7F); + if (!(lVal & 0x80)) break; + } + if (lVal & 0x80) { // should never happen + return -1; + } else return retV; + +} + +uint8 SkyGmChannel::process(uint16 aktTime) { + + if (!_channelData.channelActive) + return 0; + + uint8 returnVal = 0; + + _channelData.nextEventTime -= aktTime; + uint8 opcode; + + while ((_channelData.nextEventTime < 0) && (_channelData.channelActive)) { + opcode = _musicData[_channelData.eventDataPtr]; + _channelData.eventDataPtr++; + if (opcode&0x80) { + if (opcode == 0xFF) { + // dummy opcode + } else if (opcode >= 0x90) { + switch (opcode&0xF) { + case 0: com90_caseNoteOff(); break; + case 1: com90_stopChannel(); break; + case 2: com90_setupInstrument(); break; + case 3: + returnVal = com90_updateTempo(); + break; + case 5: com90_getPitch(); break; + case 6: com90_getChannelVolume(); break; + case 8: com90_rewindMusic(); break; + case 9: com90_keyOff(); break; + case 11: com90_getChannelPanValue(); break; + case 12: com90_setStartOfData(); break; + case 13: com90_getChannelControl(); break; + case 4: //com90_dummy(); + case 7: //com90_skipTremoVibro(); + case 10: //com90_error(); + error("SkyChannel: dummy music routine 0x%02X was called",opcode); + _channelData.channelActive = 0; + break; + default: + // these opcodes aren't implemented in original music driver + error("SkyChannel: Not existant routine 0x%02X was called",opcode); + _channelData.channelActive = 0; + break; + } + } else { + // new midi channel assignment + _channelData.midiChannelNumber = opcode&0xF; + } + } else { + _channelData.note = opcode; + uint8 velocity = _veloTab[_musicData[_channelData.eventDataPtr]]; + _channelData.eventDataPtr++; + _midiDrv->send((0x90 | _channelData.midiChannelNumber) | (opcode << 8) | (velocity << 16)); + } + if (_channelData.channelActive) + _channelData.nextEventTime += getNextEventTime(); + } + return returnVal; +} + +//- command 90h routines + +void SkyGmChannel::com90_caseNoteOff(void) { + + _midiDrv->send((0x90 | _channelData.midiChannelNumber) | (_musicData[_channelData.eventDataPtr] << 8)); + _channelData.eventDataPtr++; +} + +void SkyGmChannel::com90_stopChannel(void) { + + stopNote(); + _channelData.channelActive = 0; +} + +void SkyGmChannel::com90_setupInstrument(void) { + + _midiDrv->send((0xC0 | _channelData.midiChannelNumber) | (_mt32_to_gm[_musicData[_channelData.eventDataPtr]] << 8)); + _channelData.eventDataPtr++; +} + +uint8 SkyGmChannel::com90_updateTempo(void) { + + uint8 retV = _musicData[_channelData.eventDataPtr]; + _channelData.eventDataPtr++; + return retV; +} + +void SkyGmChannel::com90_getPitch(void) { + + _midiDrv->send((0xE0 | _channelData.midiChannelNumber) | 0 | (_musicData[_channelData.eventDataPtr] << 16)); + _channelData.eventDataPtr++; +} + +void SkyGmChannel::com90_getChannelVolume(void) { + + _midiDrv->send((0xB0 | _channelData.midiChannelNumber) | 0x700 | (_musicData[_channelData.eventDataPtr] << 16)); + _channelData.eventDataPtr++; +} + +void SkyGmChannel::com90_rewindMusic(void) { + + _channelData.eventDataPtr = _channelData.startOfData; +} + +void SkyGmChannel::com90_keyOff(void) { + + _midiDrv->send((0x90 | _channelData.midiChannelNumber) | (_channelData.note << 8) | 0); +} + +void SkyGmChannel::com90_setStartOfData(void) { + + _channelData.startOfData = _channelData.eventDataPtr; +} + +void SkyGmChannel::com90_getChannelPanValue(void) { + + _midiDrv->send((0xB0 | _channelData.midiChannelNumber) | 0x0A00 | (_musicData[_channelData.eventDataPtr] << 16)); + _channelData.eventDataPtr++; +} + +void SkyGmChannel::com90_getChannelControl(void) { + + uint8 conNum = _musicData[_channelData.eventDataPtr]; + uint8 conDat = _musicData[_channelData.eventDataPtr + 1]; + _channelData.eventDataPtr += 2; + _midiDrv->send((0xB0 | _channelData.midiChannelNumber) | (conNum << 8) | (conDat << 16)); +} diff --git a/sky/music/gmchannel.h b/sky/music/gmchannel.h new file mode 100644 index 0000000000..693eabf3d0 --- /dev/null +++ b/sky/music/gmchannel.h @@ -0,0 +1,76 @@ +/* ScummVM - Scumm Interpreter + * Copyright (C) 2003 The ScummVM project + * + * 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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + * + * $Header$ + * + */ + +#ifndef SKYGMCHANNEL_H +#define SKYGMCHANNEL_H + +#include "stdafx.h" +#include "sound/mididrv.h" +#include "common/engine.h" +#include "sky/music/musicbase.h" + +typedef struct { + uint16 eventDataPtr; + int32 nextEventTime; + uint16 startOfData; + uint8 midiChannelNumber; + uint8 note; + uint8 channelActive; +} MidiChannelType; + +class SkyGmChannel : public SkyChannelBase { +public: + SkyGmChannel(uint8 *pMusicData, uint16 startOfData, MidiDriver *pMidiDrv, byte *pInstMap); + virtual void stopNote(void); + virtual uint8 process(uint16 aktTime); + virtual void updateVolume(uint16 pVolume); +private: + byte *_mt32_to_gm; + static uint8 _veloTab[128]; + MidiDriver *_midiDrv; + uint8 *_musicData; + uint16 _musicVolume; + MidiChannelType _channelData; + //- normal subs + void setRegister(uint8 regNum, uint8 value); + int32 getNextEventTime(void); + uint16 getNextNote(uint8 param); + void adlibSetupInstrument(void); + void setupInstrument(uint8 opcode); + void setupChannelVolume(uint8 volume); + //- Streamfunctions from Command90hTable + void com90_caseNoteOff(void); // 0 + void com90_stopChannel(void); // 1 + void com90_setupInstrument(void); // 2 + uint8 com90_updateTempo(void); // 3 + //void com90_dummy(void); // 4 + void com90_getPitch(void); // 5 + void com90_getChannelVolume(void); // 6 + //void com90_skipTremoVibro(void); // 7 + void com90_rewindMusic(void); // 8 + void com90_keyOff(void); // 9 + //void com90_error(void); // 10 + void com90_getChannelPanValue(void); // 11 + void com90_setStartOfData(void); // 12 + void com90_getChannelControl(void); // 13 +}; + +#endif //SKYGMCHANNEL_H diff --git a/sky/music/gmmusic.cpp b/sky/music/gmmusic.cpp new file mode 100644 index 0000000000..3d2ddf947d --- /dev/null +++ b/sky/music/gmmusic.cpp @@ -0,0 +1,146 @@ +/* ScummVM - Scumm Interpreter + * Copyright (C) 2003 The ScummVM project + * + * 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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + * + * $Header$ + * + */ + +#include "sky/gmmusic.h" + +void SkyGmMusic::passTimerFunc(void *param) { + + ((SkyGmMusic*)param)->timerCall(); +} + +SkyGmMusic::SkyGmMusic(MidiDriver *pMidiDrv, SkyDisk *pSkyDisk, uint32 version) + : SkyMusicBase(pSkyDisk, version) { + + _driverFileBase = 60200; + _midiDrv = pMidiDrv; + int midiRes = _midiDrv->open(); + if (midiRes != 0) { + error("Can't open midi device. Errorcode: %d\n",midiRes); + } + _midiDrv->setTimerCallback(this, passTimerFunc); + _ignoreNextPoll = false; +} + +SkyGmMusic::~SkyGmMusic(void) { + + _midiDrv->setTimerCallback(NULL, NULL); + if (_currentMusic) stopMusic(); + _midiDrv->close(); + delete _midiDrv; +} + +void SkyGmMusic::timerCall(void) { + + // midi driver polls hundred times per sec. We only want 50 times. + _ignoreNextPoll = !_ignoreNextPoll; + if (!_ignoreNextPoll) return; + + if (_musicData != NULL) + pollMusic(); +} + +void SkyGmMusic::setupPointers(void) { + + _musicDataLoc = (_musicData[0x7DD] << 8) | _musicData[0x7DC]; + _sysExSequence = ((_musicData[0x7E1] << 8) | _musicData[0x7E0]) + _musicData; +} + +void SkyGmMusic::setupChannels(uint8 *channelData) { + + _numberOfChannels = channelData[0]; + channelData++; + for (uint8 cnt = 0; cnt < _numberOfChannels; cnt++) { + uint16 chDataStart = ((channelData[(cnt << 1) | 1] << 8) | channelData[cnt << 1]) + _musicDataLoc; + _channels[cnt] = new SkyGmChannel(_musicData, chDataStart, _midiDrv, _mt32_to_gm + 128 * _currentSection); + } +} + +void SkyGmMusic::startDriver(void) { + + //_midiDrv->send(0xFF); //ALSA can't handle this. + // skip all sysEx as it can't be handled anyways. +} + +// not sure about these tables. Now it's just 6 copies of jamiesons table in the +// instruments.cpp, but I still think that there must be something to be done to them. + +byte SkyGmMusic::_mt32_to_gm[6*128] = { +// Section 0: +// 0 1 2 3 4 5 6 7 8 9 A B C D E F + 0, 1, 0, 2, 4, 4, 5, 3, 16, 17, 18, 16, 16, 19, 20, 21, // 0x + 6, 6, 6, 7, 7, 7, 8, 112, 62, 62, 63, 63, 38, 38, 39, 39, // 1x + 88, 95, 52, 98, 97, 99, 14, 54, 102, 96, 53, 102, 81, 100, 14, 80, // 2x + 48, 48, 49, 45, 41, 40, 42, 42, 43, 46, 45, 24, 25, 28, 27, 104, // 3x + 32, 32, 34, 33, 36, 37, 35, 35, 79, 73, 72, 72, 74, 75, 64, 65, // 4x + 66, 67, 71, 71, 68, 69, 70, 22, 56, 59, 57, 57, 60, 60, 58, 61, // 5x + 61, 11, 11, 98, 14, 9, 14, 13, 12, 107, 107, 77, 78, 78, 76, 76, // 6x + 47, 117, 127, 118, 118, 116, 115, 119, 115, 112, 55, 124, 123, 0, 14, 117, // 7x +// Section 1: +// 0 1 2 3 4 5 6 7 8 9 A B C D E F + 0, 1, 0, 2, 4, 4, 5, 3, 16, 17, 18, 16, 16, 19, 20, 21, // 0x + 6, 6, 6, 7, 7, 7, 8, 112, 62, 62, 63, 63, 38, 38, 39, 39, // 1x + 88, 95, 52, 98, 97, 99, 14, 54, 102, 96, 53, 102, 81, 100, 14, 80, // 2x + 48, 48, 49, 45, 41, 40, 42, 42, 43, 46, 45, 24, 25, 28, 27, 104, // 3x + 32, 32, 34, 33, 36, 37, 35, 35, 79, 73, 72, 72, 74, 75, 64, 65, // 4x + 66, 67, 71, 71, 68, 69, 70, 22, 56, 59, 57, 57, 60, 60, 58, 61, // 5x + 61, 11, 11, 98, 14, 9, 14, 13, 12, 107, 107, 77, 78, 78, 76, 76, // 6x + 47, 117, 127, 118, 118, 116, 115, 119, 115, 112, 55, 124, 123, 0, 14, 117, // 7x +// Section 2: +// 0 1 2 3 4 5 6 7 8 9 A B C D E F + 0, 1, 0, 2, 4, 4, 5, 3, 16, 17, 18, 16, 16, 19, 20, 21, // 0x + 6, 6, 6, 7, 7, 7, 8, 112, 62, 62, 63, 63, 38, 38, 39, 39, // 1x + 88, 95, 52, 98, 97, 99, 14, 54, 102, 96, 53, 102, 81, 100, 14, 80, // 2x + 48, 48, 49, 45, 41, 40, 42, 42, 43, 46, 45, 24, 25, 28, 27, 104, // 3x + 32, 32, 34, 33, 36, 37, 35, 35, 79, 73, 72, 72, 74, 75, 64, 65, // 4x + 66, 67, 71, 71, 68, 69, 70, 22, 56, 59, 57, 57, 60, 60, 58, 61, // 5x + 61, 11, 11, 98, 14, 9, 14, 13, 12, 107, 107, 77, 78, 78, 76, 76, // 6x + 47, 117, 127, 118, 118, 116, 115, 119, 115, 112, 55, 124, 123, 0, 14, 117, // 7x +// Section 3: +// 0 1 2 3 4 5 6 7 8 9 A B C D E F + 0, 1, 0, 2, 4, 4, 5, 3, 16, 17, 18, 16, 16, 19, 20, 21, // 0x + 6, 6, 6, 7, 7, 7, 8, 112, 62, 62, 63, 63, 38, 38, 39, 39, // 1x + 88, 95, 52, 98, 97, 99, 14, 54, 102, 96, 53, 102, 81, 100, 14, 80, // 2x + 48, 48, 49, 45, 41, 40, 42, 42, 43, 46, 45, 24, 25, 28, 27, 104, // 3x + 32, 32, 34, 33, 36, 37, 35, 35, 79, 73, 72, 72, 74, 75, 64, 65, // 4x + 66, 67, 71, 71, 68, 69, 70, 22, 56, 59, 57, 57, 60, 60, 58, 61, // 5x + 61, 11, 11, 98, 14, 9, 14, 13, 12, 107, 107, 77, 78, 78, 76, 76, // 6x + 47, 117, 127, 118, 118, 116, 115, 119, 115, 112, 55, 124, 123, 0, 14, 117, // 7x +// Section 4: +// 0 1 2 3 4 5 6 7 8 9 A B C D E F + 0, 1, 0, 2, 4, 4, 5, 3, 16, 17, 18, 16, 16, 19, 20, 21, // 0x + 6, 6, 6, 7, 7, 7, 8, 112, 62, 62, 63, 63, 38, 38, 39, 39, // 1x + 88, 95, 52, 98, 97, 99, 14, 54, 102, 96, 53, 102, 81, 100, 14, 80, // 2x + 48, 48, 49, 45, 41, 40, 42, 42, 43, 46, 45, 24, 25, 28, 27, 104, // 3x + 32, 32, 34, 33, 36, 37, 35, 35, 79, 73, 72, 72, 74, 75, 64, 65, // 4x + 66, 67, 71, 71, 68, 69, 70, 22, 56, 59, 57, 57, 60, 60, 58, 61, // 5x + 61, 11, 11, 98, 14, 9, 14, 13, 12, 107, 107, 77, 78, 78, 76, 76, // 6x + 47, 117, 127, 118, 118, 116, 115, 119, 115, 112, 55, 124, 123, 0, 14, 117, // 7x +// Section 5: +// 0 1 2 3 4 5 6 7 8 9 A B C D E F + 0, 1, 0, 2, 4, 4, 5, 3, 16, 17, 18, 16, 16, 19, 20, 21, // 0x + 6, 6, 6, 7, 7, 7, 8, 112, 62, 62, 63, 63, 38, 38, 39, 39, // 1x + 88, 95, 52, 98, 97, 99, 14, 54, 102, 96, 53, 102, 81, 100, 14, 80, // 2x + 48, 48, 49, 45, 41, 40, 42, 42, 43, 46, 45, 24, 25, 28, 27, 104, // 3x + 32, 32, 34, 33, 36, 37, 35, 35, 79, 73, 72, 72, 74, 75, 64, 65, // 4x + 66, 67, 71, 71, 68, 69, 70, 22, 56, 59, 57, 57, 60, 60, 58, 61, // 5x + 61, 11, 11, 98, 14, 9, 14, 13, 12, 107, 107, 77, 78, 78, 76, 76, // 6x + 47, 117, 127, 118, 118, 116, 115, 119, 115, 112, 55, 124, 123, 0, 14, 117 // 7x +}; diff --git a/sky/music/gmmusic.h b/sky/music/gmmusic.h new file mode 100644 index 0000000000..be26bf26fd --- /dev/null +++ b/sky/music/gmmusic.h @@ -0,0 +1,49 @@ +/* ScummVM - Scumm Interpreter + * Copyright (C) 2003 The ScummVM project + * + * 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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + * + * $Header$ + * + */ + +#ifndef GMMUSIC_H +#define GMMUSIC_H + +#include "stdafx.h" +#include "common/engine.h" +#include "musicbase.h" +#include "sound/mididrv.h" +#include "gmchannel.h" + +class SkyGmMusic : public SkyMusicBase { +public: + SkyGmMusic(MidiDriver *pMidiDrv, SkyDisk *pSkyDisk, uint32 version); + ~SkyGmMusic(void); +private: + static void passTimerFunc(void *param); + void timerCall(void); + + bool _ignoreNextPoll; + uint8 *_sysExSequence; + MidiDriver *_midiDrv; + static byte _mt32_to_gm[6*128]; + + virtual void setupPointers(void); + virtual void setupChannels(uint8 *channelData); + virtual void startDriver(void); +}; + +#endif //GMMUSIC_H diff --git a/sky/music/mt32music.cpp b/sky/music/mt32music.cpp new file mode 100644 index 0000000000..53765f9941 --- /dev/null +++ b/sky/music/mt32music.cpp @@ -0,0 +1,182 @@ +/* ScummVM - Scumm Interpreter + * Copyright (C) 2003 The ScummVM project + * + * 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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + * + * $Header$ + * + */ + +#include "sky/mt32music.h" + +void SkyMT32Music::passTimerFunc(void *param) { + + ((SkyMT32Music*)param)->timerCall(); +} + +SkyMT32Music::SkyMT32Music(MidiDriver *pMidiDrv, SkyDisk *pSkyDisk, uint32 version) + : SkyMusicBase(pSkyDisk, version) { + + _driverFileBase = 60200; + _midiDrv = pMidiDrv; + int midiRes = _midiDrv->open(); + if (midiRes != 0) { + error("Can't open midi device. Errorcode: %d\n",midiRes); + } + _midiDrv->setTimerCallback(this, passTimerFunc); + _ignoreNextPoll = false; + for (uint8 cnt = 0; cnt < 128; cnt++) + _dummyMap[cnt] = cnt; +} + +SkyMT32Music::~SkyMT32Music(void) { + + _midiDrv->close(); + _midiDrv->setTimerCallback(NULL, NULL); + delete _midiDrv; +} + +void SkyMT32Music::timerCall(void) { + + // midi driver polls hundred times per sec. We only want 50 times. + _ignoreNextPoll = !_ignoreNextPoll; + if (!_ignoreNextPoll) return; + + if (_musicData != NULL) + pollMusic(); +} + +void SkyMT32Music::setupPointers(void) { + + _musicDataLoc = (_musicData[0x7DD] << 8) | _musicData[0x7DC]; + _sysExSequence = ((_musicData[0x7E1] << 8) | _musicData[0x7E0]) + _musicData; +} + +void SkyMT32Music::setupChannels(uint8 *channelData) { + + _numberOfChannels = channelData[0]; + channelData++; + for (uint8 cnt = 0; cnt < _numberOfChannels; cnt++) { + uint16 chDataStart = ((channelData[(cnt << 1) | 1] << 8) | channelData[cnt << 1]) + _musicDataLoc; + _channels[cnt] = new SkyGmChannel(_musicData, chDataStart, _midiDrv, _dummyMap); + } +} + +#define MIDI_PACK(a,b,c,d) ((a) | ((b) << 8) | ((c) << 16) | ((d) << 24)) + +bool SkyMT32Music::processPatchSysEx(uint8 *sysExData) { + + uint8 crc = 0; + if (sysExData[0] & 0x80) return false; + uint8 patchNum = sysExData[0]; + sysExData++; + + uint8 timbreGroup = sysExData[0] >> 6; + uint8 timbreNumber = sysExData[0] & 0x3F; + uint8 keyShift = sysExData[1] & 0x3F; + uint8 fineTune = sysExData[2] & 0x7F; + uint8 benderRange = sysExData[3] & 0x7F; + uint8 assignMode = sysExData[1] >> 6; + uint8 reverbSwitch = sysExData[2] >> 7; + + _midiDrv->send(MIDI_PACK(0xF0, 0x41, 0x10, 0x16)); + _midiDrv->send(MIDI_PACK(0x12, 5, patchNum >> 4, (patchNum & 0xF) << 3)); + + crc -= 5 + (patchNum >> 4) + ((patchNum & 0xF) << 3); + crc -= timbreGroup + timbreNumber + keyShift + fineTune; + crc -= benderRange + assignMode + reverbSwitch; + + _midiDrv->send(MIDI_PACK(timbreGroup, timbreNumber, keyShift, fineTune)); + _midiDrv->send(MIDI_PACK(benderRange, assignMode, reverbSwitch, crc)); + _midiDrv->send(0xF7); + + debug(3," Patch %02X:\n",patchNum); + debug(3," Timbre Group: %d\n",timbreGroup); + debug(3," Timbre Number: %d\n",timbreNumber); + debug(3," Key Shift: %d\n",keyShift); + debug(3," Fine Tune: %d\n",fineTune); + debug(3," Bender Range: %d\n",benderRange); + debug(3," Assign Mode: %d\n",assignMode); + debug(3," Reverb Switch: %d\n\n",reverbSwitch); + return true; +} + +void SkyMT32Music::startDriver(void) { + + _midiDrv->send(0xFF); // reset midi device + + // setup timbres and patches using SysEx data + uint8* sysExData = _sysExSequence; + uint8 timbreNum = sysExData[0]; + uint8 cnt, crc; + uint32 sysComb; + sysExData++; + for (cnt = 0; cnt < timbreNum; cnt++) { + crc = 0; + _midiDrv->send(MIDI_PACK(0xF0, 0x41, 0x10, 0x16)); + //- sendTimbreAddress + sysComb = (0x2 << 16) | (sysExData[0] << 8) | 0xA; + sysExData++; + uint8 sysByte1 = (uint8)(sysComb >> 14); + uint8 sysByte2 = (uint8)((sysComb & 0x3FFF) >> 7); + uint8 sysByte3 = (uint8)(sysComb & 0x7F); + _midiDrv->send(MIDI_PACK(0x12, sysByte1, sysByte2, sysByte3)); + debug(3,"InitBySysEx: Timbre address: %02X:%02X:%02X (%02X)\n",sysByte1,sysByte2,sysByte3,(sysExData-1)[0]); + crc -= sysByte1 + sysByte2 + sysByte3; + //- sendTimbreData + uint8 dataLen = sysExData[0]; + debug(3,"[%02X]",dataLen); + sysExData++; + uint32 nextSend = 0; + uint8 bytesInSend = 0; + debug(3," Timbre Data:"); + do { + uint8 rlVal = 1; + uint8 codeVal = sysExData[0]; + sysExData++; + + if (codeVal & 0x80) { + codeVal &= 0x7F; + rlVal = sysExData[0]; + sysExData++; + dataLen--; + } + for (uint8 cnt = 0; cnt < rlVal; cnt++) { + nextSend |= codeVal << (bytesInSend << 3); + crc -= codeVal; + debug(3," %02X",codeVal); + bytesInSend++; + if (bytesInSend == 4) { + _midiDrv->send(nextSend); + nextSend = bytesInSend = 0; + } + } + dataLen--; + } while (dataLen > 0); + crc &= 0x7F; + debug(3," %02X F7\n",crc); + nextSend |= crc << (bytesInSend << 3); + bytesInSend++; + if (bytesInSend == 4) { + _midiDrv->send(nextSend); + nextSend = bytesInSend = 0; + } + nextSend |= 0xF7 << (bytesInSend << 3); + _midiDrv->send(nextSend); + } + + while (processPatchSysEx(sysExData)) + sysExData += 5; +} diff --git a/sky/music/mt32music.h b/sky/music/mt32music.h new file mode 100644 index 0000000000..9b396b649d --- /dev/null +++ b/sky/music/mt32music.h @@ -0,0 +1,50 @@ +/* ScummVM - Scumm Interpreter + * Copyright (C) 2003 The ScummVM project + * + * 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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + * + * $Header$ + * + */ + +#ifndef MT32MUSIC_H +#define MT32MUSIC_H + +#include "stdafx.h" +#include "common/engine.h" +#include "musicbase.h" +#include "sound/mididrv.h" +#include "gmchannel.h" + +class SkyMT32Music : public SkyMusicBase { +public: + SkyMT32Music(MidiDriver *pMidiDrv, SkyDisk *pSkyDisk, uint32 version); + ~SkyMT32Music(void); +private: + static void passTimerFunc(void *param); + void timerCall(void); + bool processPatchSysEx(uint8 *sysExData); + + bool _ignoreNextPoll; + uint8 *_sysExSequence; + MidiDriver *_midiDrv; + uint8 _dummyMap[128]; + + virtual void setupPointers(void); + virtual void setupChannels(uint8 *channelData); + virtual void startDriver(void); +}; + +#endif //MT32MUSIC_H diff --git a/sky/music/musicbase.cpp b/sky/music/musicbase.cpp new file mode 100644 index 0000000000..7d930dae18 --- /dev/null +++ b/sky/music/musicbase.cpp @@ -0,0 +1,164 @@ +/* ScummVM - Scumm Interpreter + * Copyright (C) 2003 The ScummVM project + * + * 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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + * + * $Header$ + * + */ + +#include "musicbase.h" + +SkyMusicBase::SkyMusicBase(SkyDisk *pSkyDisk, uint32 version) { + + _gameVersion = version; + _musicData = NULL; + _allowedCommands = 0; + _skyDisk = pSkyDisk; + _currentMusic = 0; +} + +SkyMusicBase::~SkyMusicBase(void) +{ + if (_musicData) free(_musicData); +} + +void SkyMusicBase::loadSection(uint8 pSection) +{ + if (_currentMusic) stopMusic(); + if (_musicData) free(_musicData); + _currentSection = pSection; + _musicData = _skyDisk->loadFile(_driverFileBase + FILES_PER_SECTION * pSection, NULL); + _allowedCommands = 0; + _musicTempo0 = 0x78; // init constants taken from idb file, area ~0x1060 + _musicTempo1 = 0xC0; + _musicVolume = 0x100; + _onNextPoll.doReInit = false; + _onNextPoll.doStopMusic = false; + _onNextPoll.musicToProcess = 0; + _tempo = _aktTime = 0x10001; + _numberOfChannels = _currentMusic = 0; + setupPointers(); + startDriver(); +} + +void SkyMusicBase::musicCommand(uint16 command) +{ + if (_musicData == NULL) { + debug(1,"Got music command but driver is not yet loaded.\n"); + return ; + } + if ((command >> 8) > _allowedCommands) { + debug(1,"got musicCommand %d while expecting <= %d\n", command >> 8, _allowedCommands); + return ; + } + switch(command >> 8) { + case 0: + debug(1,"SkyMusic: got call to startAdlibDriver(). Not necessary in this implementation.\n"); + break; + case 1: + debug(1,"SkyMusic: got call to stopDriver(). Not necessary in this implementation.\n"); + break; + case 2: + debug(1,"SkyMusic: got call to SetTempo(). Tempo is fixed in this implementation.\n"); + break; + case 3: + debug(1,"SkyMusic: ignored direct call to driverPoll().\n"); + break; + case 4: + startMusic(command&0xFF); + break; + case 6: + reinitFM(); + break; + case 7: + stopMusic(); + break; + case 13: + setFMVolume(command&0xFF); + break; + default: + debug(1,"musicCommand %d ignored.\n",command>>8); + } +} + +void SkyMusicBase::setFMVolume(uint16 param) +{ + _musicVolume = param; + for (uint8 cnt = 0; cnt < _numberOfChannels; cnt++) + _channels[cnt]->updateVolume(_musicVolume); +} + +void SkyMusicBase::stopMusic(void) +{ + for (uint8 cnt = 0; cnt < _numberOfChannels; cnt++) { + _channels[cnt]->stopNote(); + delete _channels[cnt]; + } + _numberOfChannels = 0; +} + +void SkyMusicBase::updateTempo(void) +{ + uint16 tempoMul = _musicTempo0*_musicTempo1; + uint16 divisor = 0x4446390/23864; + _tempo = (tempoMul / divisor)<<16; + _tempo |= (((tempoMul%divisor)<<16) | (tempoMul/divisor)) / divisor; +} + +void SkyMusicBase::loadNewMusic(void) +{ + uint16 musicPos; + if (_onNextPoll.musicToProcess > _musicData[_musicDataLoc]) { + error("Music %d requested but doesn't exist in file.\n", _onNextPoll.musicToProcess); + return; + } + if (_currentMusic != 0) stopMusic(); + + _currentMusic = _onNextPoll.musicToProcess; + _onNextPoll.musicToProcess = 0; + + if (_currentMusic != 0) { + musicPos = (_musicData[_musicDataLoc+2]<<8) | _musicData[_musicDataLoc+1]; + musicPos += _musicDataLoc+((_currentMusic-1)<<1); + musicPos = ((_musicData[musicPos+1]<<8) | _musicData[musicPos]) + _musicDataLoc; + + _musicTempo0 = _musicData[musicPos]; + _musicTempo1 = _musicData[musicPos+1]; + + setupChannels(_musicData + musicPos + 2); + + updateTempo(); + } +} + +void SkyMusicBase::pollMusic(void) +{ + uint8 newTempo; + if (_onNextPoll.doReInit) startDriver(); + if (_onNextPoll.doStopMusic) stopMusic(); + if (_onNextPoll.musicToProcess) loadNewMusic(); + + _aktTime += _tempo; + + for (uint8 cnt = 0; cnt < _numberOfChannels; cnt++) { + newTempo = _channels[cnt]->process((uint16)(_aktTime >> 16)); + if (newTempo) { + _musicTempo1 = newTempo; + updateTempo(); + } + } + _aktTime &= 0xFFFF; +} diff --git a/sky/music/musicbase.h b/sky/music/musicbase.h new file mode 100644 index 0000000000..306cfaa0db --- /dev/null +++ b/sky/music/musicbase.h @@ -0,0 +1,85 @@ +/* ScummVM - Scumm Interpreter + * Copyright (C) 2003 The ScummVM project + * + * 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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + * + * $Header$ + * + */ + +#ifndef MUSICBASE_H +#define MUSICBASE_H + +#include "stdafx.h" +#include "common/engine.h" +#include "sky/disk.h" + +#define FILES_PER_SECTION 4 + +typedef struct { + bool doReInit, doStopMusic; + uint8 musicToProcess; +} Actions; + +class SkyChannelBase { +public: + virtual void stopNote(void) = 0; + virtual uint8 process(uint16 aktTime) = 0; + virtual void updateVolume(uint16 pVolume) = 0; +private: +}; + +class SkyMusicBase { +public: + SkyMusicBase(SkyDisk *pSkyDisk, uint32 version); + virtual ~SkyMusicBase(void); + void loadSection(uint8 pSection); + void musicCommand(uint16 command); + void startMusic(uint16 param) { _onNextPoll.musicToProcess = param & 0xF; }; // 4 + +protected: + uint32 _gameVersion; + + SkyDisk *_skyDisk; + uint8 *_musicData; + uint8 _allowedCommands; + uint16 _musicDataLoc; + uint16 _driverFileBase; + + uint16 _musicVolume, _numberOfChannels; + uint8 _currentMusic, _currentSection; + uint8 _musicTempo0; // can be changed by music stream + uint8 _musicTempo1; // given once per music + uint32 _tempo; // calculated from musicTempo0 and musicTempo1 + uint32 _aktTime; + Actions _onNextPoll; + SkyChannelBase *_channels[10]; + + virtual void setupPointers(void) = 0; + virtual void setupChannels(uint8 *channelData) = 0; + + void updateTempo(void); + void loadNewMusic(void); + //- functions from CommandTable @0x90 (the main interface) + virtual void startDriver(void) = 0; // 0 + void StopDriver(void); // 1 + void setTempo(uint16 newTempo); // 2 + void pollMusic(); // 3 + void reinitFM(void) { _onNextPoll.doReInit = true; }; // 6 + void stopMusic(); // 7 + void setFMVolume(uint16 param); // 13 +}; + +#endif //MUSICBASE_H -- cgit v1.2.3