mididrv.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_MIDIDRV_H
#define AUDIO_MIDIDRV_H

#include "common/scummsys.h"
#include "common/str.h"
#include "common/stream.h"
#include "common/timer.h"
#include "common/array.h"

class MidiChannel;

enum MusicType {
    MT_INVALID = -1,    // Invalid output
    MT_AUTO = 0,        // Auto
    MT_NULL,            // Null
    MT_PCSPK,           // PC Speaker
    MT_PCJR,            // PCjr
    MT_CMS,             // CMS
    MT_ADLIB,           // AdLib
    MT_C64,             // C64
    MT_AMIGA,           // Amiga
    MT_APPLEIIGS,       // Apple IIGS
    MT_TOWNS,           // FM-TOWNS
    MT_PC98,            // PC98
    MT_SEGACD,          // SegaCD
    MT_GM,              // General MIDI
    MT_MT32,            // MT-32
    MT_GS,              // Roland GS
    MT_MT540,           // Casio MT-540
    MT_CT460,           // Casio CT-460 / CSM-1
    MT_MACINTOSH        // Apple Macintosh
};

enum MidiDriverFlags {
    MDT_NONE                = 0,
    MDT_PCSPK               = 1 << 0,       // PC Speaker: Maps to MT_PCSPK and MT_PCJR
    MDT_CMS                 = 1 << 1,       // Creative Music System / Gameblaster: Maps to MT_CMS
    MDT_PCJR                = 1 << 2,       // Tandy/PC Junior driver
    MDT_ADLIB               = 1 << 3,       // AdLib: Maps to MT_ADLIB
    MDT_C64                 = 1 << 4,
    MDT_AMIGA               = 1 << 5,
    MDT_APPLEIIGS           = 1 << 6,
    MDT_TOWNS               = 1 << 7,       // FM-TOWNS: Maps to MT_TOWNS
    MDT_PC98                = 1 << 8,       // PC-98: Maps to MT_PC98
    MDT_SEGACD              = 1 << 9,
    MDT_MIDI                = 1 << 10,      // Real MIDI
    MDT_PREFER_MT32         = 1 << 11,      // MT-32 output is preferred
    MDT_PREFER_GM           = 1 << 12,      // GM output is preferred
    MDT_PREFER_FLUID        = 1 << 13,      // FluidSynth driver is preferred
    MDT_MACINTOSH           = 1 << 14,

    MDT_SUPPLIED_SOUND_FONT = 1 << 15,      // Engine will supply sound font (allows checkDevice to pass if it would fail due to missing sound font)
};

enum MidiDriverCheckFlags {
    MDCK_NONE                   = 0,

    MDCK_SUPPLIED_SOUND_FONT    = 1 << 0,   // Sound font will be supplied by the engine
    MDCK_AUTO                   = 1 << 1,   // Driver is being checked for automatic selection (i.e. MIDI device is set to "auto")
};

class MidiDriver_BASE {
public:
    static const uint8 MIDI_CHANNEL_COUNT = 16;
    static const uint8 MIDI_RHYTHM_CHANNEL = 9;

    static const byte MIDI_COMMAND_NOTE_OFF = 0x80;
    static const byte MIDI_COMMAND_NOTE_ON = 0x90;
    static const byte MIDI_COMMAND_POLYPHONIC_AFTERTOUCH = 0xA0;
    static const byte MIDI_COMMAND_CONTROL_CHANGE = 0xB0;
    static const byte MIDI_COMMAND_PROGRAM_CHANGE = 0xC0;
    static const byte MIDI_COMMAND_CHANNEL_AFTERTOUCH = 0xD0;
    static const byte MIDI_COMMAND_PITCH_BEND = 0xE0;
    static const byte MIDI_COMMAND_SYSTEM = 0xF0;

    static const byte MIDI_CONTROLLER_BANK_SELECT_MSB = 0x00;
    static const byte MIDI_CONTROLLER_MODULATION = 0x01;
    static const byte MIDI_CONTROLLER_DATA_ENTRY_MSB = 0x06;
    static const byte MIDI_CONTROLLER_VOLUME = 0x07;
    static const byte MIDI_CONTROLLER_BALANCE = 0x08;
    static const byte MIDI_CONTROLLER_PANNING = 0x0A;
    static const byte MIDI_CONTROLLER_EXPRESSION = 0x0B;
    static const byte MIDI_CONTROLLER_BANK_SELECT_LSB = 0x20;
    static const byte MIDI_CONTROLLER_DATA_ENTRY_LSB = 0x26;
    static const byte MIDI_CONTROLLER_SUSTAIN = 0x40;
    static const byte MIDI_CONTROLLER_PORTAMENTO = 0x41;
    static const byte MIDI_CONTROLLER_SOSTENUTO = 0x42;
    static const byte MIDI_CONTROLLER_SOFT = 0x43;
    static const byte MIDI_CONTROLLER_REVERB = 0x5B;
    static const byte MIDI_CONTROLLER_CHORUS = 0x5D;
    static const byte MIDI_CONTROLLER_RPN_LSB = 0x64;
    static const byte MIDI_CONTROLLER_RPN_MSB = 0x65;
    static const byte MIDI_CONTROLLER_ALL_SOUND_OFF = 0x78;
    static const byte MIDI_CONTROLLER_RESET_ALL_CONTROLLERS = 0x79;
    static const byte MIDI_CONTROLLER_ALL_NOTES_OFF = 0x7B;
    static const byte MIDI_CONTROLLER_OMNI_ON = 0x7C;
    static const byte MIDI_CONTROLLER_OMNI_OFF = 0x7D;
    static const byte MIDI_CONTROLLER_MONO_ON = 0x7E;
    static const byte MIDI_CONTROLLER_POLY_ON = 0x7F;

    static const uint16 MIDI_RPN_PITCH_BEND_SENSITIVITY = 0x0000;
    static const uint16 MIDI_RPN_MASTER_TUNING_FINE = 0x0001;
    static const uint16 MIDI_RPN_MASTER_TUNING_COARSE = 0x0002;
    static const uint16 MIDI_RPN_NULL = 0x7F7F;

    static const uint8 MIDI_META_END_OF_TRACK = 0x2F;
    static const uint8 MIDI_META_SEQUENCER = 0x7F;

    static const uint16 MIDI_PITCH_BEND_DEFAULT = 0x2000;
    static const uint8 MIDI_PANNING_DEFAULT = 0x40;
    static const uint8 MIDI_EXPRESSION_DEFAULT = 0x7F;
    static const uint16 MIDI_MASTER_TUNING_FINE_DEFAULT = 0x2000;
    static const uint8 MIDI_MASTER_TUNING_COARSE_DEFAULT = 0x40;

    static const uint8 MT32_PITCH_BEND_SENSITIVITY_DEFAULT = 0x0C;
    static const uint8 GM_PITCH_BEND_SENSITIVITY_DEFAULT = 0x02;

    static const uint8 GS_RHYTHM_FIRST_NOTE = 0x1B;
    static const uint8 GS_RHYTHM_LAST_NOTE = 0x58;

    MidiDriver_BASE();

    virtual ~MidiDriver_BASE();

    virtual void send(uint32 b) = 0;

    virtual void send(int8 source, uint32 b) { send(b); }

    void send(byte status, byte firstOp, byte secondOp);

    void send(int8 source, byte status, byte firstOp, byte secondOp);

    virtual void sysEx(const byte *msg, uint16 length) { }

    virtual uint16 sysExNoDelay(const byte *msg, uint16 length) { sysEx(msg, length); return 0; }

    // TODO: Document this.
    virtual void metaEvent(byte type, byte *data, uint16 length) { }

    virtual void metaEvent(int8 source, byte type, byte *data, uint16 length) { metaEvent(type, data, length); }

    virtual void stopAllNotes(bool stopSustainedNotes = false);

    virtual bool isReady(int8 source = -1) { return true; }

protected:

    bool _midiDumpEnable;

    uint32 _prevMillis;

    Common::Array<byte> _midiDumpCache;

    void midiDumpInit();

    int midiDumpVarLength(const uint32 &delta);

    void midiDumpDelta();

    void midiDumpDo(uint32 b);

    void midiDumpSysEx(const byte *msg, uint16 length);

    void midiDumpFinish();

};

class MidiDriver : public MidiDriver_BASE {
public:
    typedef uint32 DeviceHandle;

    enum DeviceStringType {
        kDriverName,
        kDriverId,
        kDeviceName,
        kDeviceId
    };

    static Common::String musicType2GUIO(uint32 musicType);

    static MidiDriver *createMidi(DeviceHandle handle);

    static DeviceHandle detectDevice(int flags);

    static DeviceHandle getDeviceHandle(const Common::String &identifier);

    static bool checkDevice(DeviceHandle handle, int flags, bool quiet);

    static MusicType getMusicType(DeviceHandle handle);

    static Common::String getDeviceString(DeviceHandle handle, DeviceStringType type);

    void midiDriverCommonSend(uint32 b);

    void midiDriverCommonSysEx(const byte *msg, uint16 length);

private:
    // If detectDevice() detects MT32 and we have a preferred MT32 device
    // we use this to force getMusicType() to return MT_MT32 so that we don't
    // have to rely on the 'True Roland MT-32' config manager setting (since nobody
    // would possibly think about activating 'True Roland MT-32' when he has set
    // 'Music Driver' to '<default>')
    static bool _forceTypeMT32;

public:
    virtual ~MidiDriver() { }

    static const byte _mt32ToGm[128];
    static const byte _gmToMt32[128];

    enum {
        MERR_CANNOT_CONNECT = 1,
//      MERR_STREAMING_NOT_AVAILABLE = 2,
        MERR_DEVICE_NOT_AVAILABLE = 3,
        MERR_ALREADY_OPEN = 4
    };

    enum {
        //      PROP_TIMEDIV = 1,
        PROP_OLD_ADLIB = 2,
        PROP_CHANNEL_MASK = 3,
        // HACK: Not so nice, but our SCUMM AdLib code is in audio/
        PROP_SCUMM_OPL3 = 4,
        PROP_USER_VOLUME_SCALING = 5,
        PROP_MIDI_DATA_REVERSE_PANNING = 6,
        PROP_OPL_ACCURACY_MODE = 7,
        PROP_OPL_CHANNEL_ALLOCATION_MODE = 8,
        PROP_MILES_VERSION = 9,
        PROP_OPL_RHYTHM_MODE_IGNORE_NOTE_OFF = 10
    };

    virtual int open() = 0;

    virtual bool isOpen() const = 0;

    virtual void close() = 0;

    virtual uint32 property(int prop, uint32 param) { return 0; }

    static const char *getErrorName(int error_code);

    // HIGH-LEVEL SEMANTIC METHODS
    virtual void setPitchBendRange(byte channel, uint range) {
        send(MIDI_COMMAND_CONTROL_CHANGE | channel, MIDI_CONTROLLER_RPN_MSB, MIDI_RPN_PITCH_BEND_SENSITIVITY >> 8);
        send(MIDI_COMMAND_CONTROL_CHANGE | channel, MIDI_CONTROLLER_RPN_LSB, MIDI_RPN_PITCH_BEND_SENSITIVITY & 0xFF);
        send(MIDI_COMMAND_CONTROL_CHANGE | channel, MIDI_CONTROLLER_DATA_ENTRY_MSB, range); // Semi-tones
        send(MIDI_COMMAND_CONTROL_CHANGE | channel, MIDI_CONTROLLER_DATA_ENTRY_LSB, 0); // Cents
        send(MIDI_COMMAND_CONTROL_CHANGE | channel, MIDI_CONTROLLER_RPN_MSB, MIDI_RPN_NULL >> 8);
        send(MIDI_COMMAND_CONTROL_CHANGE | channel, MIDI_CONTROLLER_RPN_LSB, MIDI_RPN_NULL & 0xFF);
    }

    void sendMT32Reset();

    void sendGMReset();

    // Timing functions - MidiDriver now operates timers
    virtual void setTimerCallback(void *timer_param, Common::TimerManager::TimerProc timer_proc) = 0;

    virtual uint32 getBaseTempo() = 0;

    // Channel allocation functions
    virtual MidiChannel *allocateChannel() = 0;
    virtual MidiChannel *getPercussionChannel() = 0;

    // Allow an engine to supply its own soundFont data. This stream will be destroyed after use.
    virtual void setEngineSoundFont(Common::SeekableReadStream *soundFontData) { }

    // Does this driver accept soundFont data?
    virtual bool acceptsSoundFontData() { return false; }
};

class MidiChannel {
public:
    virtual ~MidiChannel() {}

    virtual MidiDriver *device() = 0;
    virtual byte getNumber() = 0;
    virtual void release() = 0;

    virtual void send(uint32 b) = 0; // 4-bit channel portion is ignored

    // Regular messages
    virtual void noteOff(byte note) = 0;
    virtual void noteOn(byte note, byte velocity) = 0;
    virtual void programChange(byte program) = 0;
    virtual void pitchBend(int16 bend) = 0; // -0x2000 to +0x1FFF

    // Control Change messages
    virtual void controlChange(byte control, byte value) = 0;
    virtual void modulationWheel(byte value) { controlChange(MidiDriver::MIDI_CONTROLLER_MODULATION, value); }
    virtual void volume(byte value) { controlChange(MidiDriver::MIDI_CONTROLLER_VOLUME, value); }
    virtual void panPosition(byte value) { controlChange(MidiDriver::MIDI_CONTROLLER_PANNING, value); }
    virtual void pitchBendFactor(byte value) = 0;
    virtual void transpose(int8 value) {}
    virtual void detune(int16 value) { controlChange(17, value & 0xff); }
    virtual void priority(byte value) { }
    virtual void sustain(bool value) { controlChange(MidiDriver::MIDI_CONTROLLER_SUSTAIN, value ? 1 : 0); }
    virtual void effectLevel(byte value) { controlChange(MidiDriver::MIDI_CONTROLLER_REVERB, value); }
    virtual void chorusLevel(byte value) { controlChange(MidiDriver::MIDI_CONTROLLER_CHORUS, value); }
    virtual void allNotesOff() { controlChange(MidiDriver::MIDI_CONTROLLER_ALL_NOTES_OFF, 0); }

    // SysEx messages
    virtual void sysEx_customInstrument(uint32 type, const byte *instr, uint32 dataSize) = 0;
};
#endif