mirror of
https://github.com/libretro/scummvm.git
synced 2025-04-02 14:51:40 +00:00
Initial version of proper MIDI support for KYRA.
svn-id: r35174
This commit is contained in:
Johannes Schickel
parent
fead4f304f
commit
893a79b01d
@ -53,6 +53,7 @@ MODULE_OBJS := \
|
||||
sequences_mr.o \
|
||||
sound_adlib.o \
|
||||
sound_digital.o \
|
||||
sound_midi.o \
|
||||
sound_towns.o \
|
||||
sound.o \
|
||||
sound_lok.o \
|
||||
|
||||
@ -159,325 +159,6 @@ uint32 Sound::voicePlayedTime(const char *file) {
|
||||
|
||||
#pragma mark -
|
||||
|
||||
SoundMidiPC::SoundMidiPC(KyraEngine_v1 *vm, Audio::Mixer *mixer, MidiDriver *driver) : Sound(vm, mixer) {
|
||||
_driver = driver;
|
||||
_passThrough = false;
|
||||
|
||||
_musicParser = _sfxParser = 0;
|
||||
_isMusicPlaying = _isSfxPlaying = false;
|
||||
_eventFromMusic = false;
|
||||
|
||||
_nativeMT32 = _useC55 = false;
|
||||
|
||||
_fadeStartTime = 0;
|
||||
_fadeMusicOut = false;
|
||||
|
||||
memset(_channel, 0, sizeof(_channel));
|
||||
memset(_channelVolume, 50, sizeof(_channelVolume));
|
||||
_channelVolume[10] = 100;
|
||||
for (int i = 0; i < 16; ++i)
|
||||
_virChannel[i] = i;
|
||||
|
||||
int ret = open();
|
||||
if (ret != MERR_ALREADY_OPEN && ret != 0)
|
||||
error("Couldn't open midi driver");
|
||||
}
|
||||
|
||||
SoundMidiPC::~SoundMidiPC() {
|
||||
Common::StackLock lock(_mutex);
|
||||
|
||||
delete _musicParser;
|
||||
delete _sfxParser;
|
||||
|
||||
_driver->setTimerCallback(0, 0);
|
||||
close();
|
||||
}
|
||||
|
||||
bool SoundMidiPC::init() {
|
||||
_musicParser = MidiParser::createParser_XMIDI();
|
||||
_sfxParser = MidiParser::createParser_XMIDI();
|
||||
|
||||
if (!_musicParser || !_sfxParser)
|
||||
return false;
|
||||
|
||||
_musicParser->setMidiDriver(this);
|
||||
_sfxParser->setMidiDriver(this);
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
void SoundMidiPC::updateVolumeSettings() {
|
||||
_musicVolume = CLIP(ConfMan.getInt("music_volume"), 0, 255);
|
||||
_sfxVolume = CLIP(ConfMan.getInt("sfx_volume"), 0, 255);
|
||||
|
||||
updateChannelVolume(_musicVolume);
|
||||
}
|
||||
|
||||
void SoundMidiPC::hasNativeMT32(bool nativeMT32) {
|
||||
_nativeMT32 = nativeMT32;
|
||||
|
||||
// C55 appears to be XMIDI for General MIDI instruments
|
||||
if (!_nativeMT32 && _vm->game() == GI_KYRA2)
|
||||
_useC55 = true;
|
||||
else
|
||||
_useC55 = false;
|
||||
}
|
||||
|
||||
void SoundMidiPC::updateChannelVolume(uint8 volume) {
|
||||
for (int i = 0; i < 32; ++i) {
|
||||
if (_channel[i]) {
|
||||
if (i >= 16)
|
||||
_channel[i]->volume(_channelVolume[i - 16] * volume / 255);
|
||||
else
|
||||
_channel[i]->volume(_channelVolume[i] * volume / 255);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
int SoundMidiPC::open() {
|
||||
// Don't ever call open without first setting the output driver!
|
||||
if (!_driver)
|
||||
return 255;
|
||||
|
||||
int ret = _driver->open();
|
||||
if (ret)
|
||||
return ret;
|
||||
|
||||
_driver->setTimerCallback(this, &onTimer);
|
||||
return 0;
|
||||
}
|
||||
|
||||
void SoundMidiPC::close() {
|
||||
if (_driver) {
|
||||
_driver->close();
|
||||
delete _driver;
|
||||
}
|
||||
_driver = 0;
|
||||
}
|
||||
|
||||
void SoundMidiPC::send(uint32 b) {
|
||||
if (_passThrough) {
|
||||
if ((b & 0xFFF0) == 0x007BB0)
|
||||
return;
|
||||
_driver->send(b);
|
||||
return;
|
||||
}
|
||||
|
||||
const int volume = /*_eventFromMusic ? */_musicVolume/* : _sfxVolume*/;
|
||||
|
||||
uint8 channel = (byte)(b & 0x0F);
|
||||
if (((b & 0xFFF0) == 0x6FB0 || (b & 0xFFF0) == 0x6EB0) && channel != 9) {
|
||||
if (_virChannel[channel] == channel) {
|
||||
_virChannel[channel] = channel + 16;
|
||||
if (!_channel[_virChannel[channel]])
|
||||
_channel[_virChannel[channel]] = _driver->allocateChannel();
|
||||
if (_channel[_virChannel[channel]])
|
||||
_channel[_virChannel[channel]]->volume(_channelVolume[channel] * volume / 255);
|
||||
}
|
||||
return;
|
||||
}
|
||||
|
||||
if ((b & 0xFFF0) == 0x07B0) {
|
||||
// Adjust volume changes by master volume
|
||||
uint8 vol = (uint8)((b >> 16) & 0x7F);
|
||||
_channelVolume[channel] = vol;
|
||||
vol = vol * volume / 255;
|
||||
b = (b & 0xFF00FFFF) | (vol << 16);
|
||||
} else if ((b & 0xF0) == 0xC0 && !_nativeMT32 && !_useC55) {
|
||||
b = (b & 0xFFFF00FF) | (MidiDriver::_mt32ToGm[(b >> 8) & 0xFF] << 8);
|
||||
} else if ((b & 0xFFF0) == 0x007BB0) {
|
||||
//Only respond to All Notes Off if this channel
|
||||
//has currently been allocated
|
||||
if (!_channel[/*_virChannel[channel]*/channel])
|
||||
return;
|
||||
}
|
||||
|
||||
if (!_channel[_virChannel[channel]]) {
|
||||
_channel[_virChannel[channel]] = (channel == 9) ? _driver->getPercussionChannel() : _driver->allocateChannel();
|
||||
if (_channel[_virChannel[channel]])
|
||||
_channel[_virChannel[channel]]->volume(_channelVolume[channel] * volume / 255);
|
||||
}
|
||||
if (_channel[_virChannel[channel]])
|
||||
_channel[_virChannel[channel]]->send(b);
|
||||
}
|
||||
|
||||
void SoundMidiPC::metaEvent(byte type, byte *data, uint16 length) {
|
||||
switch (type) {
|
||||
case 0x2F: // End of Track
|
||||
if (_eventFromMusic) {
|
||||
// remap all channels
|
||||
for (int i = 0; i < 16; ++i)
|
||||
_virChannel[i] = i;
|
||||
} else {
|
||||
_isSfxPlaying = false;
|
||||
}
|
||||
break;
|
||||
default:
|
||||
_driver->metaEvent(type, data, length);
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
struct DeleterArray {
|
||||
void operator ()(byte *ptr) {
|
||||
delete[] ptr;
|
||||
}
|
||||
};
|
||||
|
||||
void SoundMidiPC::loadSoundFile(uint file) {
|
||||
Common::StackLock lock(_mutex);
|
||||
|
||||
internalLoadFile(fileListEntry(file));
|
||||
}
|
||||
|
||||
void SoundMidiPC::loadSoundFile(Common::String file) {
|
||||
Common::StackLock lock(_mutex);
|
||||
|
||||
internalLoadFile(file);
|
||||
}
|
||||
|
||||
void SoundMidiPC::internalLoadFile(Common::String file) {
|
||||
Common::String filename = file;
|
||||
filename += ".";
|
||||
filename += _useC55 ? "C55" : "XMI";
|
||||
|
||||
if (filename == _currentTrack) {
|
||||
_isMusicPlaying = _isSfxPlaying = false;
|
||||
_fadeStartTime = 0;
|
||||
_fadeMusicOut = false;
|
||||
updateChannelVolume(_musicVolume);
|
||||
_musicParser->setTempo(0);
|
||||
_sfxParser->setTempo(0);
|
||||
_musicParser->property(MidiParser::mpAutoLoop, false);
|
||||
_sfxParser->property(MidiParser::mpAutoLoop, false);
|
||||
return;
|
||||
}
|
||||
|
||||
uint32 size;
|
||||
uint8 *data = (_vm->resource())->fileData(filename.c_str(), &size);
|
||||
|
||||
if (!data) {
|
||||
warning("Couldn't load soundfile '%s'", filename.c_str());
|
||||
return;
|
||||
}
|
||||
|
||||
_currentTrack = filename;
|
||||
|
||||
_musicParser->unloadMusic();
|
||||
_sfxParser->unloadMusic();
|
||||
_midiFile = Common::SharedPtr<byte>(data, DeleterArray());
|
||||
|
||||
_isMusicPlaying = _isSfxPlaying = false;
|
||||
_fadeStartTime = 0;
|
||||
_fadeMusicOut = false;
|
||||
updateChannelVolume(_musicVolume);
|
||||
|
||||
if (_musicParser->loadMusic(_midiFile.get(), size)) {
|
||||
_musicParser->setTimerRate(getBaseTempo());
|
||||
_musicParser->setTempo(0);
|
||||
_musicParser->property(MidiParser::mpAutoLoop, false);
|
||||
} else {
|
||||
warning("Error parsing music track '%s'", filename.c_str());
|
||||
}
|
||||
|
||||
if (_sfxParser->loadMusic(_midiFile.get(), size)) {
|
||||
_sfxParser->setTimerRate(getBaseTempo());
|
||||
_sfxParser->setTempo(0);
|
||||
_sfxParser->property(MidiParser::mpAutoLoop, false);
|
||||
} else {
|
||||
warning("Error parsing sfx track '%s'", filename.c_str());
|
||||
}
|
||||
}
|
||||
|
||||
void SoundMidiPC::onTimer(void *refCon) {
|
||||
SoundMidiPC *sound = (SoundMidiPC *)refCon;
|
||||
Common::StackLock lock(sound->_mutex);
|
||||
|
||||
// this should be set to the fadeToBlack value
|
||||
static const uint32 musicFadeTime = 1 * 1000;
|
||||
|
||||
if (sound->_fadeMusicOut) {
|
||||
if (sound->_fadeStartTime + musicFadeTime > sound->_vm->_system->getMillis()) {
|
||||
byte volume = (byte)((musicFadeTime - (sound->_vm->_system->getMillis() - sound->_fadeStartTime)) * sound->_musicVolume / musicFadeTime);
|
||||
sound->updateChannelVolume(volume);
|
||||
} else {
|
||||
sound->_fadeStartTime = 0;
|
||||
sound->_fadeMusicOut = false;
|
||||
sound->_isMusicPlaying = false;
|
||||
|
||||
sound->_eventFromMusic = true;
|
||||
// from sound/midiparser.cpp
|
||||
for (int i = 0; i < 128; ++i) {
|
||||
for (int j = 0; j < 16; ++j) {
|
||||
sound->send(0x80 | j | i << 8);
|
||||
}
|
||||
}
|
||||
|
||||
for (int i = 0; i < 16; ++i)
|
||||
sound->send(0x007BB0 | i);
|
||||
}
|
||||
}
|
||||
|
||||
if (sound->_isMusicPlaying) {
|
||||
sound->_eventFromMusic = true;
|
||||
sound->_musicParser->onTimer();
|
||||
}
|
||||
|
||||
if (sound->_isSfxPlaying) {
|
||||
sound->_eventFromMusic = false;
|
||||
sound->_sfxParser->onTimer();
|
||||
}
|
||||
}
|
||||
|
||||
void SoundMidiPC::playTrack(uint8 track) {
|
||||
Common::StackLock lock(_mutex);
|
||||
|
||||
if (_musicParser && (track != 0 || _nativeMT32) && _musicEnabled) {
|
||||
_isMusicPlaying = true;
|
||||
_fadeMusicOut = false;
|
||||
_fadeStartTime = 0;
|
||||
updateChannelVolume(_musicVolume);
|
||||
_musicParser->setTrack(track);
|
||||
_musicParser->jumpToTick(0);
|
||||
_musicParser->setTempo(1);
|
||||
_musicParser->property(MidiParser::mpAutoLoop, false);
|
||||
}
|
||||
}
|
||||
|
||||
void SoundMidiPC::haltTrack() {
|
||||
Common::StackLock lock(_mutex);
|
||||
|
||||
if (_musicParser) {
|
||||
_isMusicPlaying = false;
|
||||
_fadeMusicOut = false;
|
||||
_fadeStartTime = 0;
|
||||
updateChannelVolume(_musicVolume);
|
||||
_musicParser->setTrack(0);
|
||||
_musicParser->jumpToTick(0);
|
||||
_musicParser->setTempo(0);
|
||||
}
|
||||
}
|
||||
|
||||
void SoundMidiPC::playSoundEffect(uint8 track) {
|
||||
Common::StackLock lock(_mutex);
|
||||
|
||||
if (_sfxParser && _sfxEnabled) {
|
||||
_isSfxPlaying = true;
|
||||
_sfxParser->setTrack(track);
|
||||
_sfxParser->jumpToTick(0);
|
||||
_sfxParser->setTempo(1);
|
||||
_sfxParser->property(MidiParser::mpAutoLoop, false);
|
||||
}
|
||||
}
|
||||
|
||||
void SoundMidiPC::beginFadeOut() {
|
||||
_fadeMusicOut = true;
|
||||
_fadeStartTime = _vm->_system->getMillis();
|
||||
}
|
||||
|
||||
#pragma mark -
|
||||
|
||||
void KyraEngine_v1::snd_playTheme(int file, int track) {
|
||||
debugC(9, kDebugLevelMain | kDebugLevelSound, "KyraEngine_v1::snd_playTheme(%d, %d)", file, track);
|
||||
if (_curMusicTheme == file)
|
||||
|
||||
@ -300,24 +300,20 @@ private:
|
||||
static const int _kyra1SoundTriggers[];
|
||||
};
|
||||
|
||||
class MidiOutput;
|
||||
|
||||
/**
|
||||
* MIDI output device.
|
||||
*
|
||||
* This device supports both MT-32 MIDI, as used in
|
||||
* Kyrandia 1 and 2, and GM MIDI, as used in Kyrandia 2.
|
||||
*
|
||||
* Currently it does not initialize the MT-32 output properly,
|
||||
* so MT-32 output does sound a bit odd in some cases.
|
||||
*
|
||||
* TODO: this code needs some serious cleanup and rework
|
||||
* to support MT-32 and GM properly.
|
||||
*/
|
||||
class SoundMidiPC : public MidiDriver, public Sound {
|
||||
class SoundMidiPC : public Sound {
|
||||
public:
|
||||
SoundMidiPC(KyraEngine_v1 *vm, Audio::Mixer *mixer, MidiDriver *driver);
|
||||
~SoundMidiPC();
|
||||
|
||||
kType getMusicType() const { return isMT32() ? kMidiMT32 : kMidiGM; }
|
||||
kType getMusicType() const { return _nativeMT32 ? kMidiMT32 : kMidiGM; }
|
||||
|
||||
bool init();
|
||||
|
||||
@ -333,37 +329,11 @@ public:
|
||||
|
||||
void beginFadeOut();
|
||||
|
||||
//MidiDriver interface implementation
|
||||
int open();
|
||||
void close();
|
||||
void send(uint32 b);
|
||||
void metaEvent(byte type, byte *data, uint16 length);
|
||||
|
||||
void setTimerCallback(void *timerParam, void (*timerProc)(void *)) { }
|
||||
uint32 getBaseTempo(void) { return _driver ? _driver->getBaseTempo() : 0; }
|
||||
|
||||
//Channel allocation functions
|
||||
MidiChannel *allocateChannel() { return 0; }
|
||||
MidiChannel *getPercussionChannel() { return 0; }
|
||||
|
||||
void setPassThrough(bool b) { _passThrough = b; }
|
||||
|
||||
void hasNativeMT32(bool nativeMT32);
|
||||
bool isMT32() const { return _nativeMT32; }
|
||||
|
||||
private:
|
||||
void internalLoadFile(Common::String file);
|
||||
void updateChannelVolume(uint8 vol);
|
||||
|
||||
static void onTimer(void *data);
|
||||
|
||||
// Our channel handling
|
||||
uint8 _virChannel[16];
|
||||
uint8 _channelVolume[16];
|
||||
|
||||
MidiChannel *_channel[32];
|
||||
|
||||
// Music/Sfx volume
|
||||
uint8 _musicVolume;
|
||||
uint8 _sfxVolume;
|
||||
|
||||
@ -371,25 +341,18 @@ private:
|
||||
bool _fadeMusicOut;
|
||||
|
||||
// Midi file related
|
||||
Common::SharedPtr<byte> _midiFile;
|
||||
Common::String _currentTrack;
|
||||
byte *_musicFile, *_sfxFile;
|
||||
uint32 _musicFileSize, _sfxFileSize;
|
||||
|
||||
// Music related
|
||||
MidiParser *_musicParser;
|
||||
|
||||
bool _isMusicPlaying;
|
||||
bool _eventFromMusic;
|
||||
|
||||
// Sfx related
|
||||
MidiParser *_sfxParser;
|
||||
|
||||
bool _isSfxPlaying;
|
||||
MidiParser *_music;
|
||||
MidiParser *_sfx[3];
|
||||
|
||||
// misc
|
||||
bool _nativeMT32;
|
||||
bool _useC55;
|
||||
MidiDriver *_driver;
|
||||
bool _passThrough;
|
||||
MidiOutput *_output;
|
||||
|
||||
Common::Mutex _mutex;
|
||||
};
|
||||
|
||||
|
||||
563
engines/kyra/sound_midi.cpp
Normal file
563
engines/kyra/sound_midi.cpp
Normal file
@ -0,0 +1,563 @@
|
||||
/* 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 "kyra/sound.h"
|
||||
#include "kyra/resource.h"
|
||||
|
||||
#include "common/system.h"
|
||||
|
||||
namespace Kyra {
|
||||
|
||||
struct Controller {
|
||||
byte controller;
|
||||
byte value;
|
||||
};
|
||||
|
||||
class MidiOutput : public MidiDriver {
|
||||
public:
|
||||
MidiOutput(OSystem *system, MidiDriver *output, bool isMT32, bool defaultMT32);
|
||||
~MidiOutput();
|
||||
|
||||
void initSource(int source);
|
||||
void deinitSource(int source);
|
||||
void stopNotesOnChannel(int channel);
|
||||
|
||||
void setSoundSource(int source) { _curSource = source; }
|
||||
|
||||
void send(uint32 b);
|
||||
void sysEx(const byte *msg, uint16 length);
|
||||
void metaEvent(byte type, byte *data, uint16 length);
|
||||
|
||||
void setTimerCallback(void *timerParam, void (*timerProc)(void *)) { _output->setTimerCallback(timerParam, timerProc); }
|
||||
uint32 getBaseTempo(void) { return _output->getBaseTempo(); }
|
||||
|
||||
// DUMMY
|
||||
int open() { return 0; }
|
||||
void close() {}
|
||||
|
||||
MidiChannel *allocateChannel() { return 0; }
|
||||
MidiChannel *getPercussionChannel() { return 0; }
|
||||
private:
|
||||
void sendIntern(const byte event, const byte channel, byte param1, const byte param2);
|
||||
void sendSysEx(const byte p1, const byte p2, const byte p3, const byte *buffer, const int size);
|
||||
|
||||
OSystem *_system;
|
||||
MidiDriver *_output;
|
||||
|
||||
uint32 _lastSysEx;
|
||||
bool _isMT32;
|
||||
bool _defaultMT32;
|
||||
|
||||
enum {
|
||||
kChannelLocked = 0x80,
|
||||
kChannelProtected = 0x40
|
||||
};
|
||||
|
||||
struct Channel {
|
||||
byte flags;
|
||||
|
||||
byte program;
|
||||
int16 pitchWheel;
|
||||
|
||||
byte noteCount;
|
||||
|
||||
Controller controllers[9];
|
||||
} _channels[16];
|
||||
|
||||
int lockChannel();
|
||||
void unlockChannel(int channel);
|
||||
|
||||
int _curSource;
|
||||
|
||||
struct SoundSource {
|
||||
int8 channelMap[16];
|
||||
byte channelProgram[16];
|
||||
int16 channelPW[16];
|
||||
Controller controllers[16][9];
|
||||
|
||||
struct Note {
|
||||
byte channel;
|
||||
byte note;
|
||||
};
|
||||
|
||||
Note notes[32];
|
||||
} _sources[4];
|
||||
};
|
||||
|
||||
MidiOutput::MidiOutput(OSystem *system, MidiDriver *output, bool isMT32, bool defaultMT32) : _system(system), _output(output), _lastSysEx(0) {
|
||||
_isMT32 = isMT32;
|
||||
_defaultMT32 = defaultMT32;
|
||||
|
||||
int ret = _output->open();
|
||||
if (ret != MidiDriver::MERR_ALREADY_OPEN && ret != 0)
|
||||
error("Couldn't open midi driver");
|
||||
|
||||
static const Controller defaultControllers[] = {
|
||||
{ 0x07, 0x7F }, { 0x01, 0x00 }, { 0x0A, 0x40 },
|
||||
{ 0x0B, 0x7F }, { 0x40, 0x00 }, { 0x72, 0x00 },
|
||||
{ 0x6E, 0x00 }, { 0x6F, 0x00 }, { 0x70, 0x00 }
|
||||
};
|
||||
|
||||
static const byte defaultPrograms[] = {
|
||||
0x00, 0x44, 0x30, 0x5F, 0x4E, 0x29, 0x03, 0x6E, 0x7A, 0xFF
|
||||
};
|
||||
|
||||
static const byte sysEx1[] = { 1, 2, 3, 4, 5, 6, 7, 8, 9 };
|
||||
static const byte sysEx2[] = { 3, 4, 3, 4, 3, 4, 3, 4, 4 };
|
||||
static const byte sysEx3[] = { 0, 3, 2 };
|
||||
|
||||
sendSysEx(0x7F, 0x00, 0x00, sysEx1, 1);
|
||||
sendSysEx(0x10, 0x00, 0x0D, sysEx1, 9);
|
||||
sendSysEx(0x10, 0x00, 0x04, sysEx2, 9);
|
||||
sendSysEx(0x10, 0x00, 0x01, sysEx3, 3);
|
||||
|
||||
memset(_channels, 0, sizeof(_channels));
|
||||
for (int i = 0; i < 16; ++i) {
|
||||
for (int j = 0; j < 9; ++j)
|
||||
_channels[i].controllers[j] = defaultControllers[j];
|
||||
_channels[i].pitchWheel = -1;
|
||||
_channels[i].program = 0xFF;
|
||||
}
|
||||
|
||||
for (int i = 0; i < 9; ++i) {
|
||||
for (int j = 1; j <= 9; ++j)
|
||||
sendIntern(0xB0, j, defaultControllers[i].controller, defaultControllers[i].value);
|
||||
}
|
||||
|
||||
for (int i = 1; i <= 9; ++i) {
|
||||
sendIntern(0xE0, i, 0x00, 0x40);
|
||||
if (defaultPrograms[i] != 0xFF)
|
||||
sendIntern(0xC0, i, defaultPrograms[i], 0x00);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
MidiOutput::~MidiOutput() {
|
||||
_output->close();
|
||||
delete _output;
|
||||
}
|
||||
|
||||
void MidiOutput::send(uint32 b) {
|
||||
const byte event = b & 0xF0;
|
||||
const byte channel = b & 0x0F;
|
||||
const byte param1 = (b >> 8) & 0xFF;
|
||||
const byte param2 = (b >> 16) & 0xFF;
|
||||
|
||||
if (event == 0xE0) { // Pitch-Wheel
|
||||
_channels[channel].pitchWheel =
|
||||
_sources[_curSource].channelPW[channel] = (param2 << 8) | param1;
|
||||
} else if (event == 0xC0) { // Program change
|
||||
_channels[channel].program =
|
||||
_sources[_curSource].channelProgram[channel] = param1;
|
||||
} else if (event == 0xB0) { // Controller change
|
||||
for (int i = 0; i < 9; ++i) {
|
||||
Controller &cont = _sources[_curSource].controllers[channel][i];
|
||||
if (cont.controller == param1) {
|
||||
cont.value = param2;
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
if (param1 == 0x6E) { // Lock Channel
|
||||
if (param2 >= 0x40) { // Lock Channel
|
||||
int chan = lockChannel();
|
||||
if (chan < 0)
|
||||
chan = channel;
|
||||
_sources[_curSource].channelMap[channel] = chan;
|
||||
} else { // Unlock Channel
|
||||
stopNotesOnChannel(channel);
|
||||
unlockChannel(_sources[_curSource].channelMap[channel]);
|
||||
_sources[_curSource].channelMap[channel] = channel;
|
||||
}
|
||||
} else if (param1 == 0x6F) { // Protect Channel
|
||||
if (param2 >= 0x40) { // Protect Channel
|
||||
_channels[channel].flags |= kChannelProtected;
|
||||
} else { // Unprotect Channel
|
||||
_channels[channel].flags &= ~kChannelProtected;
|
||||
}
|
||||
} else if (param1 == 0x7B) { // All notes off
|
||||
// FIXME: Since the XMIDI parsers sends this
|
||||
// on track change, we simply ignore it.
|
||||
return;
|
||||
}
|
||||
} else if (event == 0x90 || event == 0x80) { // Note On/Off
|
||||
if (!(_channels[channel].flags & kChannelLocked)) {
|
||||
const bool remove = (event == 0x80) || (param2 == 0x00);
|
||||
int note = -1;
|
||||
|
||||
for (int i = 0; i < 32; ++i) {
|
||||
if (remove) {
|
||||
if (_sources[_curSource].notes[i].channel == channel &&
|
||||
_sources[_curSource].notes[i].note == param1) {
|
||||
note = i;
|
||||
break;
|
||||
}
|
||||
} else {
|
||||
if (_sources[_curSource].notes[i].channel == 0xFF) {
|
||||
note = i;
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if (note != -1) {
|
||||
if (remove) {
|
||||
_sources[_curSource].notes[note].channel = 0xFF;
|
||||
|
||||
--_channels[_sources[_curSource].channelMap[channel]].noteCount;
|
||||
} else {
|
||||
_sources[_curSource].notes[note].channel = channel;
|
||||
_sources[_curSource].notes[note].note = param1;
|
||||
|
||||
++_channels[_sources[_curSource].channelMap[channel]].noteCount;
|
||||
}
|
||||
|
||||
sendIntern(event, _sources[_curSource].channelMap[channel], param1, param2);
|
||||
}
|
||||
}
|
||||
return;
|
||||
}
|
||||
|
||||
if (!(_channels[channel].flags & kChannelLocked))
|
||||
sendIntern(event, _sources[_curSource].channelMap[channel], param1, param2);
|
||||
}
|
||||
|
||||
void MidiOutput::sendIntern(const byte event, const byte channel, byte param1, const byte param2) {
|
||||
if (event == 0xE0) {
|
||||
_channels[channel].pitchWheel = (param2 << 8) | param1;
|
||||
} else if (event == 0xC0) {
|
||||
_channels[channel].program = param1;
|
||||
|
||||
// MT32 -> GM conversion
|
||||
if (!_isMT32 && _defaultMT32)
|
||||
param1 = _mt32ToGm[param1];
|
||||
}
|
||||
|
||||
_output->send(event | channel, param1, param2);
|
||||
}
|
||||
|
||||
void MidiOutput::sysEx(const byte *msg, uint16 length) {
|
||||
uint32 curTime = _system->getMillis();
|
||||
|
||||
if (_lastSysEx + 40 > curTime)
|
||||
_system->delayMillis(_lastSysEx + 40 - curTime);
|
||||
|
||||
_output->sysEx(msg, length);
|
||||
|
||||
_lastSysEx = _system->getMillis();
|
||||
}
|
||||
|
||||
void MidiOutput::sendSysEx(const byte p1, const byte p2, const byte p3, const byte *buffer, const int size) {
|
||||
int bufferSize = 8 + size;
|
||||
byte *outBuffer = new byte[bufferSize];
|
||||
assert(outBuffer);
|
||||
|
||||
outBuffer[0] = 0x41;
|
||||
outBuffer[1] = 0x10;
|
||||
outBuffer[2] = 0x16;
|
||||
outBuffer[3] = 0x12;
|
||||
|
||||
outBuffer[4] = p1;
|
||||
outBuffer[5] = p2;
|
||||
outBuffer[6] = p3;
|
||||
|
||||
memcpy(outBuffer + 7, buffer, size);
|
||||
|
||||
uint16 checkSum = p1 + p2 + p3;
|
||||
for (int i = 0; i < size; ++i)
|
||||
checkSum += buffer[i];
|
||||
checkSum &= 0x7F;
|
||||
checkSum -= 0x80;
|
||||
checkSum = -checkSum;
|
||||
checkSum &= 0x7F;
|
||||
|
||||
outBuffer[7+size] = checkSum;
|
||||
|
||||
sysEx(outBuffer, bufferSize);
|
||||
|
||||
delete[] outBuffer;
|
||||
}
|
||||
|
||||
void MidiOutput::metaEvent(byte type, byte *data, uint16 length) {
|
||||
if (type == 0x2F) { // End of Track
|
||||
deinitSource(_curSource);
|
||||
//XXX
|
||||
}
|
||||
|
||||
_output->metaEvent(type, data, length);
|
||||
}
|
||||
|
||||
void MidiOutput::initSource(int source) {
|
||||
memset(_sources[source].notes, -1, sizeof(_sources[source].notes));
|
||||
|
||||
for (int i = 0; i < 16; ++i) {
|
||||
_sources[source].channelMap[i] = i;
|
||||
_sources[source].channelProgram[i] = 0xFF;
|
||||
_sources[source].channelPW[i] = -1;
|
||||
|
||||
for (int j = 0; j < 9; ++j)
|
||||
_sources[source].controllers[i][j] = _channels[i].controllers[j];
|
||||
}
|
||||
}
|
||||
|
||||
void MidiOutput::deinitSource(int source) {
|
||||
for (int i = 0; i < 16; ++i) {
|
||||
for (int j = 0; j < 9; ++j) {
|
||||
const Controller &cont = _sources[source].controllers[i][j];
|
||||
|
||||
if (cont.controller == 0x40) {
|
||||
if (cont.value >= 0x40)
|
||||
sendIntern(0xB0, i, 0x40, 0);
|
||||
} else if (cont.controller == 0x6E) {
|
||||
if (cont.value >= 0x40) {
|
||||
stopNotesOnChannel(/*_sources[source].channelMap[i]*/i);
|
||||
unlockChannel(_sources[source].channelMap[i]);
|
||||
_sources[source].channelMap[i] = i;
|
||||
}
|
||||
} else if (cont.controller == 0x6F) {
|
||||
if (cont.value >= 0x40)
|
||||
_channels[i].flags &= ~kChannelProtected;
|
||||
} else if (cont.controller == 0x70) {
|
||||
if (cont.value >= 0x40)
|
||||
sendIntern(0xB0, i, 0x70, 0);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
int MidiOutput::lockChannel() {
|
||||
int channel = -1;
|
||||
int notes = 0xFF;
|
||||
byte flags = kChannelLocked | kChannelProtected;
|
||||
|
||||
while (channel == -1) {
|
||||
for (int i = _isMT32 ? 8 : 15; i >= 1; --i) {
|
||||
if (_channels[i].flags & flags)
|
||||
continue;
|
||||
if (_channels[i].noteCount < notes) {
|
||||
channel = i;
|
||||
notes = _channels[i].noteCount;
|
||||
}
|
||||
}
|
||||
|
||||
if (channel == -1) {
|
||||
if (flags & kChannelProtected)
|
||||
flags &= ~kChannelProtected;
|
||||
else
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
if (channel == -1)
|
||||
return -1;
|
||||
|
||||
sendIntern(0xB0, channel, 0x40, 0);
|
||||
stopNotesOnChannel(channel);
|
||||
_channels[channel].noteCount = 0;
|
||||
_channels[channel].flags |= kChannelLocked;
|
||||
|
||||
return channel;
|
||||
}
|
||||
|
||||
void MidiOutput::unlockChannel(int channel) {
|
||||
if (!(_channels[channel].flags & kChannelLocked))
|
||||
return;
|
||||
|
||||
_channels[channel].flags &= ~kChannelLocked;
|
||||
_channels[channel].noteCount = 0;
|
||||
sendIntern(0xB0, channel, 0x40, 0);
|
||||
sendIntern(0xB0, channel, 0x7B, 0);
|
||||
|
||||
for (int i = 0; i < 9; ++i) {
|
||||
if (_channels[channel].controllers[i].value != 0xFF)
|
||||
sendIntern(0xB0, channel, _channels[channel].controllers[i].controller, _channels[channel].controllers[i].value);
|
||||
}
|
||||
|
||||
if (_channels[channel].program != 0xFF)
|
||||
sendIntern(0xC0, channel, _channels[channel].program, 0);
|
||||
|
||||
if (_channels[channel].pitchWheel != -1)
|
||||
sendIntern(0xE0, channel, _channels[channel].pitchWheel & 0xFF, (_channels[channel].pitchWheel >> 8) & 0xFF);
|
||||
}
|
||||
|
||||
void MidiOutput::stopNotesOnChannel(int channel) {
|
||||
for (int i = 0; i < 4; ++i) {
|
||||
SoundSource &sound = _sources[i];
|
||||
for (int j = 0; j < 32; ++j) {
|
||||
if (sound.notes[j].channel == channel) {
|
||||
sound.notes[j].channel = 0xFF;
|
||||
sendIntern(0x80, sound.channelMap[channel], sound.notes[j].note, 0);
|
||||
--_channels[sound.channelMap[channel]].noteCount;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#pragma mark -
|
||||
|
||||
SoundMidiPC::SoundMidiPC(KyraEngine_v1 *vm, Audio::Mixer *mixer, MidiDriver *driver) : Sound(vm, mixer) {
|
||||
_driver = driver;
|
||||
_output = 0;
|
||||
|
||||
_musicFile = _sfxFile = 0;
|
||||
_musicFileSize = _sfxFileSize = 0;
|
||||
|
||||
_music = MidiParser::createParser_XMIDI();
|
||||
assert(_music);
|
||||
for (int i = 0; i < 3; ++i) {
|
||||
_sfx[i] = MidiParser::createParser_XMIDI();
|
||||
assert(_sfx[i]);
|
||||
}
|
||||
}
|
||||
|
||||
SoundMidiPC::~SoundMidiPC() {
|
||||
Common::StackLock lock(_mutex);
|
||||
_output->setTimerCallback(0, 0);
|
||||
|
||||
delete _music;
|
||||
for (int i = 0; i < 3; ++i)
|
||||
delete _sfx[i];
|
||||
|
||||
delete _output; // This automatically frees _driver (!)
|
||||
|
||||
if (_musicFile != _sfxFile)
|
||||
delete[] _sfxFile;
|
||||
|
||||
delete[] _musicFile;
|
||||
|
||||
_nativeMT32 = false;
|
||||
_useC55 = false;
|
||||
}
|
||||
|
||||
void SoundMidiPC::hasNativeMT32(bool nativeMT32) {
|
||||
_nativeMT32 = nativeMT32;
|
||||
|
||||
// C55 is XMIDI for General MIDI instruments
|
||||
if (!_nativeMT32 && _vm->game() != GI_KYRA1)
|
||||
_useC55 = true;
|
||||
else
|
||||
_useC55 = false;
|
||||
}
|
||||
|
||||
bool SoundMidiPC::init() {
|
||||
_output = new MidiOutput(_vm->_system, _driver, _nativeMT32, !_useC55);
|
||||
assert(_output);
|
||||
_output->setTimerCallback(this, SoundMidiPC::onTimer);
|
||||
|
||||
/*loadSoundFile("INTRO");
|
||||
playTrack(0);
|
||||
while (_music->isPlaying())
|
||||
_vm->_system->delayMillis(10);*/
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
void SoundMidiPC::updateVolumeSettings() {
|
||||
//XXX
|
||||
}
|
||||
|
||||
void SoundMidiPC::loadSoundFile(uint file) {
|
||||
loadSoundFile(fileListEntry(file));
|
||||
}
|
||||
|
||||
void SoundMidiPC::loadSoundFile(Common::String file) {
|
||||
Common::StackLock lock(_mutex);
|
||||
|
||||
file += _useC55 ? ".C55" : ".XMI";
|
||||
if (!_vm->resource()->exists(file.c_str()))
|
||||
return;
|
||||
|
||||
if (_sfxFile != _musicFile)
|
||||
delete[] _sfxFile;
|
||||
delete[] _musicFile;
|
||||
|
||||
_musicFile = _sfxFile = _vm->resource()->fileData(file.c_str(), &_musicFileSize);
|
||||
_sfxFileSize = _musicFileSize;
|
||||
|
||||
_music->loadMusic(_musicFile, _musicFileSize);
|
||||
_music->setMidiDriver(_output);
|
||||
_music->setTempo(_output->getBaseTempo());
|
||||
_music->setTimerRate(_output->getBaseTempo());
|
||||
_music->stopPlaying();
|
||||
|
||||
for (int i = 0; i < 3; ++i) {
|
||||
_sfx[i]->loadMusic(_musicFile, _musicFileSize);
|
||||
_sfx[i]->setMidiDriver(_output);
|
||||
_sfx[i]->setTempo(_output->getBaseTempo());
|
||||
_sfx[i]->setTimerRate(_output->getBaseTempo());
|
||||
_sfx[i]->stopPlaying();
|
||||
}
|
||||
}
|
||||
|
||||
void SoundMidiPC::playTrack(uint8 track) {
|
||||
Common::StackLock lock(_mutex);
|
||||
_output->initSource(0);
|
||||
_music->setTrack(track);
|
||||
}
|
||||
|
||||
void SoundMidiPC::haltTrack() {
|
||||
Common::StackLock lock(_mutex);
|
||||
|
||||
// Some handling we need to interrupt a track
|
||||
// properly
|
||||
for (int i = 0; i < 16; ++i)
|
||||
_output->stopNotesOnChannel(i);
|
||||
_output->deinitSource(0);
|
||||
|
||||
_music->stopPlaying();
|
||||
}
|
||||
|
||||
void SoundMidiPC::playSoundEffect(uint8 track) {
|
||||
Common::StackLock lock(_mutex);
|
||||
for (int i = 0; i < 3; ++i) {
|
||||
if (!_sfx[i]->isPlaying()) {
|
||||
_output->initSource(i+1);
|
||||
_sfx[i]->setTrack(track);
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
void SoundMidiPC::beginFadeOut() {
|
||||
//FIXME: implement properly
|
||||
haltTrack();
|
||||
}
|
||||
|
||||
void SoundMidiPC::onTimer(void *data) {
|
||||
SoundMidiPC *midi = (SoundMidiPC *)data;
|
||||
|
||||
Common::StackLock lock(midi->_mutex);
|
||||
|
||||
midi->_output->setSoundSource(0);
|
||||
midi->_music->onTimer();
|
||||
|
||||
for (int i = 0; i < 3; ++i) {
|
||||
midi->_output->setSoundSource(i+1);
|
||||
midi->_sfx[i]->onTimer();
|
||||
}
|
||||
}
|
||||
|
||||
} // end of namespace Kyra
|
||||
|
||||
@ -209,8 +209,7 @@ void MidiParser::onTimer() {
|
||||
jumpToTick(0);
|
||||
parseNextEvent(_next_event);
|
||||
} else {
|
||||
allNotesOff();
|
||||
resetTracking();
|
||||
stopPlaying();
|
||||
_driver->metaEvent(info.ext.type, info.ext.data, (uint16)info.length);
|
||||
}
|
||||
return;
|
||||
@ -302,6 +301,17 @@ bool MidiParser::setTrack(int track) {
|
||||
return true;
|
||||
}
|
||||
|
||||
void MidiParser::stopPlaying() {
|
||||
if (_smartJump)
|
||||
hangAllActiveNotes();
|
||||
else
|
||||
allNotesOff();
|
||||
resetTracking();
|
||||
|
||||
_active_track = _num_tracks+1;
|
||||
memset(_active_notes, 0, sizeof(_active_notes));
|
||||
}
|
||||
|
||||
void MidiParser::hangAllActiveNotes() {
|
||||
// Search for note off events until we have
|
||||
// accounted for every active note.
|
||||
|
||||
@ -283,9 +283,7 @@ protected:
|
||||
bool _smartJump; //!< Support smart expiration of hanging notes when jumping
|
||||
bool _centerPitchWheelOnUnload; //!< Center the pitch wheels when unloading a song
|
||||
|
||||
// FIXME: Was 32 here, Kyra tracks use 120(!!!) which seems wrong. this is a hacky
|
||||
// workaround until situation is investigated.
|
||||
byte * _tracks[120]; //!< Multi-track MIDI formats are supported, up to 120 tracks.
|
||||
byte *_tracks[120]; //!< Multi-track MIDI formats are supported, up to 120 tracks.
|
||||
byte _num_tracks; //!< Count of total tracks for multi-track MIDI formats. 1 for single-track formats.
|
||||
byte _active_track; //!< Keeps track of the currently active track, in multi-track formats.
|
||||
|
||||
@ -366,6 +364,9 @@ public:
|
||||
void setTempo(uint32 tempo);
|
||||
void onTimer();
|
||||
|
||||
bool isPlaying() const { return (_position._play_pos != 0); }
|
||||
void stopPlaying();
|
||||
|
||||
bool setTrack(int track);
|
||||
bool jumpToTick(uint32 tick, bool fireEvents = false);
|
||||
|
||||
|
||||
Loading…
x
Reference in New Issue
Block a user