mt32gm.h

/* 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 3 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, see <http://www.gnu.org/licenses/>.
 *
 */

#ifndef AUDIO_MT32GM_H
#define AUDIO_MT32GM_H

#include "audio/mididrv.h"
#include "audio/mididrv_ms.h"
#include "common/list.h"
#include "common/mutex.h"

class MidiDriver_MT32GM : public MidiDriver_Multisource {
public:
    static const byte MT32_DEFAULT_INSTRUMENTS[8];
    static const byte MT32_DEFAULT_PANNING[8];
    static const uint8 MT32_DEFAULT_CHANNEL_VOLUME = 102;
    static const uint8 GM_DEFAULT_CHANNEL_VOLUME = 100;
    // Map for correcting Roland GS drumkit numbers.
    static const uint8 GS_DRUMKIT_FALLBACK_MAP[128];

    static const uint8 MT32_DISPLAY_NUM_CHARS = 20;
    static const uint32 MT32_DISPLAY_MEMORY_ADDRESS = 0x20 << 14;

protected:
    static const uint8 MAXIMUM_MT32_ACTIVE_NOTES = 48;
    static const uint8 MAXIMUM_GM_ACTIVE_NOTES = 96;

protected:
    struct MidiChannelControlData {
        // The source that last sent an event to this channel
        int8 source;
        // True if the source volume has been applied to this channel
        bool sourceVolumeApplied;

        uint16 pitchWheel;
        byte program;
        // The Roland GS instrument bank
        byte instrumentBank;
        byte channelPressure;

        byte modulation;
        // The volume specified by the MIDI data
        byte volume;
        // The volume set on the MIDI device. This is scaled using the source
        // volume and optionally the user-specified volume setting.
        byte scaledVolume;
        byte panPosition;
        byte expression;
        bool sustain;

        // The currently selected Registered Parameter Number
        uint16 rpn;
        byte pitchBendSensitivity;

        MidiChannelControlData() : source(-1),
            sourceVolumeApplied(false),
            pitchWheel(MIDI_PITCH_BEND_DEFAULT),
            program(0),
            instrumentBank(0),
            channelPressure(0),
            modulation(0),
            volume(0),
            scaledVolume(0),
            panPosition(MIDI_PANNING_DEFAULT),
            expression(MIDI_EXPRESSION_DEFAULT),
            sustain(false),
            rpn(MIDI_RPN_NULL),
            pitchBendSensitivity(0) { }
    };

    struct MidiSource {
        // Whether this source sends music or SFX MIDI data.
        SourceType type;
        // The source volume (relative volume for this source as defined by the game).
        // Default is the default neutral value (255).
        uint16 volume;
        // The source volume level at which no scaling is performed (volume as defined
        // in MIDI data is used directly). Volume values below this decrease volume,
        // values above increase volume (up to the maximum MIDI channel volume).
        // Set this to match the volume values used by the game engine to avoid having
        // to convert them. Default value is 255; minimum value is 1.
        uint16 neutralVolume;
        // The volume level at which the fade started.
        uint16 fadeStartVolume;
        // The target volume level for the fade.
        uint16 fadeEndVolume;
        // How much us has passed since the start of the fade.
        int32 fadePassedTime;
        // The total duration of the fade (us).
        int32 fadeDuration;
        // The mapping of MIDI data channels to output channels for this source.
        int8 channelMap[MIDI_CHANNEL_COUNT];
        // Bitmask specifying which MIDI channels are available for use by this source.
        uint16 availableChannels;

        MidiSource() : type(SOURCE_TYPE_UNDEFINED), volume(DEFAULT_SOURCE_NEUTRAL_VOLUME),
                neutralVolume(DEFAULT_SOURCE_NEUTRAL_VOLUME), fadeStartVolume(0),
                fadeEndVolume(0), fadePassedTime(0), fadeDuration(0), availableChannels(0xFFFF) {
            memset(channelMap, 0, sizeof(channelMap));
        }
    };

    struct ActiveNote {
        int8 source;
        uint8 channel;
        uint8 note;
        // True if the note is sustained. The note will turn off when the
        // sustain controller for the MIDI channel is turned off.
        bool sustain;

        ActiveNote() { clear(); }

        void clear() {
            source = 0x7F;
            channel = 0xFF;
            note = 0xFF;
            sustain = false;
        }

    };

    struct SysExData {
        byte data[270];
        uint16 length;
        int8 source;
        SysExData() : length(0), source(-1) {
            memset(data, 0, sizeof(data));
        }
    };

public:
    // Callback hooked up to the driver wrapped by the MIDI driver
    // object. Executes onTimer and the external callback set by
    // the setTimerCallback function.
    static void timerCallback(void *data);

    MidiDriver_MT32GM(MusicType midiType);
    ~MidiDriver_MT32GM();

    // MidiDriver interface
    int open() override;
    // Open the driver wrapping the specified MidiDriver instance.
    virtual int open(MidiDriver *driver, bool nativeMT32);
    void close() override;
    bool isOpen() const override { return _isOpen; }
    bool isReady(int8 source = -1) override;
    uint32 property(int prop, uint32 param) override;

    using MidiDriver_BASE::send;
    void send(uint32 b) override;
    void send(int8 source, uint32 b) override;
    void sysEx(const byte *msg, uint16 length) override;
    uint16 sysExNoDelay(const byte *msg, uint16 length) override;
    void sysExQueue(const byte *msg, uint16 length, int8 source = -1);
    uint16 sysExMT32(const byte *msg, uint16 length, const uint32 targetAddress, bool queue = false, bool delay = true, int8 source = -1);
    void metaEvent(int8 source, byte type, byte *data, uint16 length) override;

    void stopAllNotes(bool stopSustainedNotes = false) override;
    void clearSysExQueue();
    MidiChannel *allocateChannel() override;
    MidiChannel *getPercussionChannel() override;
    uint32 getBaseTempo() override;

    virtual bool allocateSourceChannels(uint8 source, uint8 numChannels);
    void deinitSource(uint8 source) override;

protected:
    virtual void initControlData();
    virtual void initMidiDevice();
    virtual void initMT32(bool initForGM);
    virtual void initGM(bool initForMT32, bool enableGS);
    virtual void processEvent(int8 source, uint32 b, uint8 outputChannel,
        MidiChannelControlData &controlData, bool channelLockedByOtherSource = false);
    virtual void applyControllerDefaults(uint8 source, MidiChannelControlData &controlData, uint8 outputChannel, bool channelLockedByOtherSource);
    virtual void noteOnOff(byte outputChannel, byte command, byte note, byte velocity,
        int8 source, MidiChannelControlData &controlData);
    virtual void polyAftertouch(byte outputChannel, byte note, byte pressure,
        int8 source, MidiChannelControlData &controlData, bool channelLockedByOtherSource = false);
    virtual void controlChange(byte outputChannel, byte controllerNumber, byte controllerValue,
        int8 source, MidiChannelControlData &controlData, bool channelLockedByOtherSource = false);
    virtual void programChange(byte outputChannel, byte patchId, int8 source,
        MidiChannelControlData &controlData, bool channelLockedByOtherSource = false);
    virtual void channelAftertouch(byte outputChannel, byte pressure, int8 source,
        MidiChannelControlData &controlData, bool channelLockedByOtherSource = false);
    virtual void pitchBend(byte outputChannel, uint8 pitchBendLsb, uint8 pitchBendMsb,
        int8 source, MidiChannelControlData &controlData, bool channelLockedByOtherSource = false);

    virtual bool addActiveNote(uint8 outputChannel, uint8 note, int8 source);
    virtual bool removeActiveNote(uint8 outputChannel, uint8 note, int8 source);
    virtual void removeActiveNotes(uint8 outputChannel, bool sustainedNotes);
    bool isOutputChannelUsed(int8 outputChannel);
    virtual byte mapMT32InstrumentToGM(byte mt32Instrument);
    virtual byte mapGMInstrumentToMT32(byte gmInstrument);
    byte correctInstrumentBank(byte outputChannel, byte patchId);

    virtual int8 mapSourceChannel(uint8 source, uint8 dataChannel);

    void applySourceVolume(uint8 source) override;
    void stopAllNotes(uint8 source, uint8 channel) override;
    void onTimer() override;

    Common::Mutex _allocationMutex; // For operations on MIDI channel allocation
    Common::Mutex _activeNotesMutex; // For operations on active notes registration

    // The wrapped MIDI driver.
    MidiDriver *_driver;
    // The type of MIDI data supplied to the driver: MT-32 or General MIDI.
    MusicType _midiType;
    // True if the MIDI output is an MT-32 (hardware or 100% emulated),
    // false if the MIDI output is a General MIDI device.
    bool _nativeMT32;
    // True if the General MIDI output supports Roland GS for improved MT-32 mapping.
    bool _enableGS;
    // Indicates if the stereo panning in the MIDI data is reversed
    // compared to the stereo panning of the intended MIDI device.
    bool _midiDataReversePanning;
    // Indicates if the stereo panning of the output MIDI device is
    // reversed compared to the stereo panning of the type of MIDI
    // device targeted by the MIDI data (i.e. MT-32 data playing on
    // a GM device or the other way around).
    bool _midiDeviceReversePanning;
    // True if GS percussion channel volume should be scaled to match MT-32 volume.
    bool _scaleGSPercussionVolumeToMT32;

    // True if this MIDI driver has been opened.
    bool _isOpen;
    // Bitmask of the MIDI channels in use by the output device.
    uint16 _outputChannelMask;
    int _baseFreq;

    // stores the controller values for each MIDI channel
    MidiChannelControlData *_controlData[MIDI_CHANNEL_COUNT];
    // The mapping of MIDI data channels to output channels for each source.
    int8 _channelMap[MAXIMUM_SOURCES][MIDI_CHANNEL_COUNT];
    // Bitmask specifying which MIDI channels are available for use by each source.
    uint16 _availableChannels[MAXIMUM_SOURCES];

    // Maps used for MT-32 <> GM instrument mapping. Set these to an alternate
    // 128 byte array to customize the mapping.
    const byte *_mt32ToGMInstrumentMap;
    const byte *_gmToMT32InstrumentMap;
    // The maximum active notes for the current MIDI device.
    uint8 _maximumActiveNotes;
    // Active note registration
    ActiveNote *_activeNotes;

    // The current number of microseconds that have to elapse before the next
    // SysEx message can be sent.
    uint32 _sysExDelay;
    // Queue of SysEx messages to be sent to the MIDI device.
    Common::List<SysExData> _sysExQueue;
    // Mutex for write access to the SysEx queue.
    Common::Mutex _sysExQueueMutex;
};
#endif