diff options
Diffstat (limited to 'engines/kyra/sound_pcspk.cpp')
-rw-r--r-- | engines/kyra/sound_pcspk.cpp | 390 |
1 files changed, 390 insertions, 0 deletions
diff --git a/engines/kyra/sound_pcspk.cpp b/engines/kyra/sound_pcspk.cpp new file mode 100644 index 0000000000..98569db5e2 --- /dev/null +++ b/engines/kyra/sound_pcspk.cpp @@ -0,0 +1,390 @@ +/* + * 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. + * + * LGPL License + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + + * This library 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 + * Lesser General Public License for more details. + + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + * + * $URL$ + * $Id$ + * + */ + +#include "kyra/sound_intern.h" + +#include "sound/mixer.h" +#include "sound/softsynth/pcspk.h" + +namespace Kyra { + +MidiDriver_PCSpeaker::MidiDriver_PCSpeaker(Audio::Mixer *mixer) + : MidiDriver_Emulated(mixer), _rate(mixer->getOutputRate()) { + _timerValue = 0; + memset(_channel, 0, sizeof(_channel)); + memset(_note, 0, sizeof(_note)); + + for (int i = 0; i < 2; ++i) + _note[i].hardwareChannel = 0xFF; + + _speaker = new Audio::PCSpeaker(_rate); + assert(_speaker); + _mixer->playInputStream(Audio::Mixer::kMusicSoundType, &_mixerSoundHandle, this, -1, Audio::Mixer::kMaxChannelVolume, 0, false, true); + + _countdown = 0xFFFF; + _hardwareChannel[0] = 0xFF; + _modulationFlag = false; +} + +MidiDriver_PCSpeaker::~MidiDriver_PCSpeaker() { + _mixer->stopHandle(_mixerSoundHandle); + delete _speaker; + _speaker = 0; +} + +void MidiDriver_PCSpeaker::send(uint32 data) { + Common::StackLock lock(_mutex); + + uint8 channel = data & 0x0F; + uint8 param1 = (data >> 8) & 0xFF; + uint8 param2 = (data >> 16) & 0xFF; + + uint8 flags = 0; + + switch (data & 0xF0) { + case 0x80: // note off + noteOff(channel, param1); + return; + + case 0x90: // note on + if (channel > 1) + return; + + if (param2) + noteOn(channel, param1, param2); + else + noteOff(channel, param1); + return; + + case 0xB0: // controller + switch (param1) { + case 0x01: // modulation + _channel[channel].modulation = param2; + flags = 0x00; + break; + + case 0x07: // volume + _channel[channel].volume = param2; + flags = 0x40; + break; + + case 0x40: // hold + _channel[channel].hold = param2; + if (param2 < 0x40) + resetController(channel); + return; + + case 0x70: // voice protect + _channel[channel].voiceProtect = param2; + return; + + case 0x79: // all notes off + _channel[channel].hold = 0; + resetController(channel); + _channel[channel].modulation = 0; + _channel[channel].expression = 0x7F; + _channel[channel].pitchBendLow = 0; + _channel[channel].pitchBendHigh = 0x40; + flags = 0x41; + break; + + case 0xB0: // expression + _channel[channel].expression = param2; + flags = 0x40; + break; + + default: + return; + } + break; + + case 0xE0: // pitch bend + flags = 0x01; + _channel[channel].pitchBendLow = param1; + _channel[channel].pitchBendHigh = param2; + break; + + default: + return; + } + + for (int i = 0; i < 2; ++i) { + if (_note[i].enabled && _note[i].midiChannel == channel) { + _note[i].flags |= flags; + setupTone(i); + } + } +} + +void MidiDriver_PCSpeaker::resetController(int channel) { + for (int i = 0; i < 2; ++i) { + if (_note[i].enabled && _note[i].midiChannel == channel && _note[i].processHold) + noteOff(channel, _note[i].note2); + } +} + +void MidiDriver_PCSpeaker::noteOn(int channel, int note, int velocity) { + int n = 0; + + while (n < 2 && _note[n].enabled) + ++n; + + if (n >= 2) + return; + + _note[n].midiChannel = channel; + _note[n].note1 = _note[n].note2 = note; + _note[n].velocity = _velocityTable[((uint8)velocity) >> 3]; + _note[n].enabled = true; + _note[n].processHold = false; + _note[n].hardwareFlags = 0x20; + _note[n].priority = 0x7FFF; + _note[n].flags = 0x41; + + turnNoteOn(n); +} + +void MidiDriver_PCSpeaker::turnNoteOn(int note) { + if (_hardwareChannel[0] == 0xFF) { + _note[note].hardwareChannel = 0; + ++_channel[_note[note].midiChannel].noteCount; + _hardwareChannel[0] = _note[note].midiChannel; + _note[note].flags = 0x41; + + setupTone(note); + } else { + overwriteNote(note); + } +} + +void MidiDriver_PCSpeaker::overwriteNote(int note) { + int totalNotes = 0; + for (int i = 0; i < 2; ++i) { + if (_note[i].enabled) { + ++totalNotes; + const int channel = _note[i].midiChannel; + + uint16 priority = 0xFFFF; + if (_channel[channel].voiceProtect < 0x40) + priority = _note[i].priority; + + if (_channel[channel].noteCount > priority) + priority = 0; + else + priority -= _channel[channel].noteCount; + + _note[i].precedence = priority; + } + } + + if (totalNotes <= 1) + return; + + do { + uint16 maxValue = 0; + uint16 minValue = 0xFFFF; + int newNote = 0; + + for (int i = 0; i < 2; ++i) { + if (_note[i].enabled) { + if (_note[i].hardwareChannel == 0xFF) { + if (_note[i].precedence >= maxValue) { + maxValue = _note[i].precedence; + newNote = i; + } + } else { + if (_note[i].precedence <= minValue) { + minValue = _note[i].precedence; + note = i; + } + } + } + } + + if (maxValue < minValue) + return; + + turnNoteOff(_note[note].hardwareChannel); + _note[note].enabled = false; + + _note[newNote].hardwareChannel = _note[note].hardwareChannel; + ++_channel[_note[newNote].midiChannel].noteCount; + _hardwareChannel[_note[note].hardwareChannel] = _note[newNote].midiChannel; + _note[newNote].flags = 0x41; + + setupTone(newNote); + } while (--totalNotes); +} + +void MidiDriver_PCSpeaker::noteOff(int channel, int note) { + for (int i = 0; i < 2; ++i) { + if (_note[i].enabled && _note[i].note1 == note && _note[i].midiChannel == channel) { + if (_channel[i].hold < 0x40) { + turnNoteOff(i); + _note[i].enabled = false; + } else { + _note[i].processHold = true; + } + } + } +} + +void MidiDriver_PCSpeaker::turnNoteOff(int note) { + if (_note[note].hardwareChannel != 0xFF) { + _note[note].hardwareFlags &= 0xDF; + _note[note].flags |= 1; + + setupTone(note); + + --_channel[_note[note].midiChannel].noteCount; + + _hardwareChannel[_note[note].hardwareChannel] = 0xFF; + _note[note].hardwareChannel = 0xFF; + } +} + +void MidiDriver_PCSpeaker::setupTone(int note) { + if (_note[note].hardwareChannel == 0xFF) + return; + + if (_note[note].flags & 0x40) + _note[note].flags &= 0xBF; + if (!(_note[note].flags & 0x01)) + return; + + if (!(_note[note].hardwareFlags & 0x20)) { + _speaker->stop(); + } else { + const int midiChannel = _note[note].midiChannel; + uint16 pitchBend = (_channel[midiChannel].pitchBendHigh << 7) | _channel[midiChannel].pitchBendLow; + + int noteValue = _note[note].note2; + + noteValue -= 24; + do { + noteValue += 12; + } while (noteValue < 0); + + noteValue += 12; + do { + noteValue -= 12; + } while (noteValue > 95); + + int16 modulation = _note[note].modulation; + + int tableIndex = MAX(noteValue - 12, 0); + uint16 note1 = (_noteTable2[tableIndex] << 8) | _noteTable1[tableIndex]; + tableIndex = MIN(noteValue + 12, 95); + uint16 note2 = (_noteTable2[tableIndex] << 8) | _noteTable1[tableIndex]; + uint16 note3 = (_noteTable2[noteValue] << 8) | _noteTable1[noteValue]; + + int32 countdown = pitchBend - 0x2000; + countdown += modulation; + + if (countdown >= 0) + countdown *= (note2 - note3); + else + countdown *= (note3 - note1); + + countdown /= 0x2000; + countdown += note3; + + countdown = uint16(countdown & 0xFFFF); + if (countdown != _countdown) + _countdown = countdown; + + _speaker->play(Audio::PCSpeaker::kWaveFormSquare, 1193180 / _countdown, -1); + } + + _note[note].flags &= 0xFE; +} + +void MidiDriver_PCSpeaker::generateSamples(int16 *buffer, int numSamples) { + Common::StackLock lock(_mutex); + _speaker->readBuffer(buffer, numSamples); +} + +void MidiDriver_PCSpeaker::onTimer() { + /*Common::StackLock lock(_mutex); + + _timerValue += 20; + if (_timerValue < 120) + return; + _timerValue -= 120; + + _modulationFlag = !_modulationFlag; + for (int i = 0; i < 2; ++i) { + if (_note[i].enabled) { + uint16 modValue = 5 * _channel[_note[i].midiChannel].modulation; + if (_modulationFlag) + modValue = -modValue; + _note[i].modulation = modValue; + _note[i].flags |= 1; + + setupTone(i); + } + }*/ +} + +const uint8 MidiDriver_PCSpeaker::_velocityTable[] = { + 0x52, 0x55, 0x58, 0x5B, 0x5E, 0x61, 0x64, 0x67, + 0x6A, 0x6D, 0x70, 0x73, 0x76, 0x79, 0x7C, 0x7F +}; + +const uint8 MidiDriver_PCSpeaker::_noteTable1[] = { + 0x88, 0xB5, 0x4E, 0x40, 0x41, 0xCD, 0xC4, 0x3D, + 0x43, 0x7C, 0x2A, 0xD6, 0x88, 0xB5, 0xFF, 0xD1, + 0x20, 0xA7, 0xE2, 0x1E, 0xCE, 0xBE, 0xF2, 0x8A, + 0x44, 0x41, 0x7F, 0xE8, 0x90, 0x63, 0x63, 0x8F, + 0xE7, 0x5F, 0x01, 0xBD, 0xA2, 0xA0, 0xBF, 0xF4, + 0x48, 0xB1, 0x31, 0xC7, 0x70, 0x2F, 0xFE, 0xE0, + 0xD1, 0xD0, 0xDE, 0xFB, 0x24, 0x58, 0x98, 0xE3, + 0x39, 0x97, 0xFF, 0x6F, 0xE8, 0x68, 0xEF, 0x7D, + 0x11, 0xAC, 0x4C, 0xF1, 0x9C, 0x4B, 0xFF, 0xB7, + 0x74, 0x34, 0xF7, 0xBE, 0x88, 0x56, 0x26, 0xF8, + 0xCE, 0xA5, 0x7F, 0x5B, 0x3A, 0x1A, 0xFB, 0xDF, + 0xC4, 0xAB, 0x93, 0x7C, 0x67, 0x52, 0x3F, 0x2D +}; + +const uint8 MidiDriver_PCSpeaker::_noteTable2[] = { + 0x8E, 0x86, 0xFD, 0xF0, 0xE2, 0xD5, 0xC9, 0xBE, + 0xB3, 0xA9, 0xA0, 0x96, 0x8E, 0x86, 0x7E, 0x77, + 0x71, 0x6A, 0x64, 0x5F, 0x59, 0x54, 0x4F, 0x4B, + 0x47, 0x43, 0x3F, 0x3B, 0x38, 0x35, 0x32, 0x2F, + 0x2C, 0x2A, 0x28, 0x25, 0x23, 0x21, 0x1F, 0x1D, + 0x1C, 0x1A, 0x19, 0x17, 0x16, 0x15, 0x13, 0x12, + 0x11, 0x10, 0x0F, 0x0E, 0x0E, 0x0D, 0x0C, 0x0B, + 0x0B, 0x0A, 0x09, 0x09, 0x08, 0x08, 0x07, 0x07, + 0x07, 0x06, 0x06, 0x05, 0x05, 0x05, 0x04, 0x04, + 0x04, 0x04, 0x03, 0x03, 0x03, 0x03, 0x03, 0x02, + 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x01, 0x01, + 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01 +}; + +} // end of namespace Kyra + |