adlib_ms.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_ADLIB_MS_H
#define AUDIO_ADLIB_MS_H

#include "audio/mididrv_ms.h"
#include "audio/fmopl.h"

enum OplInstrumentRhythmType {
    RHYTHM_TYPE_UNDEFINED,
    RHYTHM_TYPE_HI_HAT,
    RHYTHM_TYPE_CYMBAL,
    RHYTHM_TYPE_TOM_TOM,
    RHYTHM_TYPE_SNARE_DRUM,
    RHYTHM_TYPE_BASS_DRUM
};

struct OplInstrumentOperatorDefinition {
    uint8 freqMultMisc;
    uint8 level;
    uint8 decayAttack;
    uint8 releaseSustain;
    uint8 waveformSelect;

    bool isEmpty();
};

struct OplInstrumentDefinition {
    bool fourOperator;

    OplInstrumentOperatorDefinition operator0;
    OplInstrumentOperatorDefinition operator1;
    OplInstrumentOperatorDefinition operator2;
    OplInstrumentOperatorDefinition operator3;

    uint8 connectionFeedback0;
    uint8 connectionFeedback1;

    uint8 rhythmNote;
    OplInstrumentRhythmType rhythmType;

    bool isEmpty();
    uint8 getNumberOfOperators();
    OplInstrumentOperatorDefinition &getOperatorDefinition(uint8 operatorNum);
};

#include "common/pack-start.h" // START STRUCT PACKING

struct AdLibBnkInstrumentOperatorDefinition {
    uint8 keyScalingLevel;
    uint8 frequencyMultiplier;
    uint8 feedback; // ignored for operator 1
    uint8 attack;
    uint8 sustain;
    uint8 envelopeGainType; // 0x00: not sustained, >= 0x01: sustained
    uint8 decay;
    uint8 release;
    uint8 level;
    uint8 amplitudeModulation; // 0x00: off, >= 0x01: on
    uint8 vibrato; // 0x00: off, >= 0x01: on
    uint8 keyScalingRate; // 0x00: low, >= 0x01: high
    uint8 connection; // 0x00: additive, >= 0x01: FM; ignored for operator 1

    void toOplInstrumentOperatorDefinition(OplInstrumentOperatorDefinition &operatorDef, uint8 waveformSelect);
} PACKED_STRUCT;

struct AdLibBnkInstrumentDefinition {
    uint8 instrumentType;
    uint8 rhythmVoiceNumber;

    AdLibBnkInstrumentOperatorDefinition operator0;
    AdLibBnkInstrumentOperatorDefinition operator1;

    uint8 waveformSelect0;
    uint8 waveformSelect1;

    void toOplInstrumentDefinition(OplInstrumentDefinition &instrumentDef);
} PACKED_STRUCT;

struct AdLibIbkInstrumentDefinition {
    uint8 o0FreqMultMisc;
    uint8 o1FreqMultMisc;
    uint8 o0Level;
    uint8 o1Level;
    uint8 o0DecayAttack;
    uint8 o1DecayAttack;
    uint8 o0ReleaseSustain;
    uint8 o1ReleaseSustain;
    uint8 o0WaveformSelect;
    uint8 o1WaveformSelect;
    uint8 connectionFeedback;
    uint8 rhythmType;
    int8 transpose;
    uint8 rhythmNote;
    uint8 padding1;
    uint8 padding2;

    void toOplInstrumentDefinition(OplInstrumentDefinition &instrumentDef);
} PACKED_STRUCT;

#include "common/pack-end.h" // END STRUCT PACKING

class MidiDriver_ADLIB_Multisource : public MidiDriver_Multisource {
public:
    enum AccuracyMode {
        ACCURACY_MODE_SB16_WIN95,
        ACCURACY_MODE_GM
    };

    enum ChannelAllocationMode {
        ALLOCATION_MODE_DYNAMIC,
        ALLOCATION_MODE_STATIC
    };

    enum InstrumentWriteMode {
        INSTRUMENT_WRITE_MODE_NOTE_ON,
        INSTRUMENT_WRITE_MODE_PROGRAM_CHANGE,
        INSTRUMENT_WRITE_MODE_FIRST_NOTE_ON
    };

    enum NoteSelectMode {
        NOTE_SELECT_MODE_0,
        NOTE_SELECT_MODE_1
    };

    enum ModulationDepth {
        MODULATION_DEPTH_LOW,
        MODULATION_DEPTH_HIGH
    };

    enum VibratoDepth {
        VIBRATO_DEPTH_LOW,
        VIBRATO_DEPTH_HIGH
    };

    static const uint8 OPL2_NUM_CHANNELS = 9;
    static const uint8 OPL3_NUM_CHANNELS = 18;
    static const uint8 MELODIC_CHANNELS_OPL2[9];
    static const uint8 MELODIC_CHANNELS_OPL2_RHYTHM[6];
    static const uint8 MELODIC_CHANNELS_OPL3[18];
    static const uint8 MELODIC_CHANNELS_OPL3_RHYTHM[15];
    static const uint8 OPL_NUM_RHYTHM_INSTRUMENTS = 5;
    static const uint8 OPL_RHYTHM_INSTRUMENT_CHANNELS[OPL_NUM_RHYTHM_INSTRUMENTS];

    static const uint8 OPL_REGISTER_TEST = 0x01;
    static const uint8 OPL_REGISTER_TIMER1 = 0x02;
    static const uint8 OPL_REGISTER_TIMER2 = 0x03;
    static const uint8 OPL_REGISTER_TIMERCONTROL = 0x04;

    static const uint8 OPL_REGISTER_NOTESELECT_CSM = 0x08;
    static const uint8 OPL_REGISTER_RHYTHM = 0xBD;

    static const uint8 OPL_REGISTER_BASE_FREQMULT_MISC = 0x20;
    static const uint8 OPL_REGISTER_BASE_LEVEL = 0x40;
    static const uint8 OPL_REGISTER_BASE_DECAY_ATTACK = 0x60;
    static const uint8 OPL_REGISTER_BASE_RELEASE_SUSTAIN = 0x80;
    static const uint8 OPL_REGISTER_BASE_WAVEFORMSELECT = 0xE0;

    static const uint8 OPL_REGISTER_BASE_FNUMLOW = 0xA0;
    static const uint8 OPL_REGISTER_BASE_FNUMHIGH_BLOCK_KEYON = 0xB0;
    static const uint8 OPL_REGISTER_BASE_CONNECTION_FEEDBACK_PANNING = 0xC0;

    static const uint16 OPL3_REGISTER_CONNECTIONSELECT = 0x104;
    static const uint16 OPL3_REGISTER_NEW = 0x105;

    static const uint16 OPL_REGISTER_SET_2_OFFSET = 0x100;

    static const uint8 OPL_REGISTER_RHYTHM_OFFSETS[];

    static const uint8 OPL_MASK_LEVEL = 0x3F;
    static const uint8 OPL_MASK_FNUMHIGH_BLOCK = 0x1F;
    static const uint8 OPL_MASK_KEYON = 0x20;
    static const uint8 OPL_MASK_PANNING = 0x30;

    static const uint8 OPL_PANNING_CENTER = 0x30;
    static const uint8 OPL_PANNING_LEFT = 0x10;
    static const uint8 OPL_PANNING_RIGHT = 0x20;

    static OplInstrumentDefinition OPL_INSTRUMENT_BANK[];
    static OplInstrumentDefinition OPL_RHYTHM_BANK[];

protected:
    static const uint8 OPL_LEVEL_DEFAULT = 0x3F;

    static const uint8 OPL_MIDI_PANNING_LEFT_LIMIT = 0x2F;
    static const uint8 OPL_MIDI_PANNING_RIGHT_LIMIT = 0x51;

    static const uint16 OPL_NOTE_FREQUENCIES[];
    static const uint8 OPL_VOLUME_LOOKUP[];

    struct MidiChannelControlData {
        uint8 program;
        uint8 channelPressure;
        uint16 pitchBend; // 14 bit value; 0x2000 is neutral

        uint8 modulation;
        uint8 volume;
        uint8 panning; // 0x40 is center
        uint8 expression;
        bool sustain;
        uint16 rpn; // Two 7 bit values stored in 8 bits each

        uint8 pitchBendSensitivity; // Semitones
        uint8 pitchBendSensitivityCents;
        uint16 masterTuningFine; // 14 bit value; 0x2000 is neutral
        uint8 masterTuningCoarse; // Semitones; 0x40 is neutral

        MidiChannelControlData();

        void init();
    };

    struct ActiveNote {
        bool noteActive;
        bool noteSustained;

        uint8 note;
        uint8 velocity;
        uint8 channel;
        uint8 source;

        uint8 oplNote;
        uint16 oplFrequency;
        uint32 noteCounterValue;

        uint8 instrumentId;
        int16 lastWrittenInstrumentId;
        OplInstrumentDefinition *instrumentDef;

        bool channelAllocated;

        ActiveNote();

        void init();
    };

    struct InstrumentInfo {
        uint8 oplNote;
        OplInstrumentDefinition *instrumentDef;
        uint8 instrumentId;
    };

public:
    static bool detectOplType(OPL::Config::OplType oplType);

    MidiDriver_ADLIB_Multisource(OPL::Config::OplType oplType, int timerFrequency = OPL::OPL::kDefaultCallbackFrequency);
    ~MidiDriver_ADLIB_Multisource();

    int open() override;
    bool isOpen() const override;
    void close() override;
    uint32 property(int prop, uint32 param) override;
    uint32 getBaseTempo() override;
    MidiChannel *allocateChannel() override;
    MidiChannel *getPercussionChannel() override;

    using MidiDriver_Multisource::send;
    void send(int8 source, uint32 b) override;
    void sysEx(const byte *msg, uint16 length) override;
    void metaEvent(int8 source, byte type, byte *data, uint16 length) override;
    void stopAllNotes(bool stopSustainedNotes = false) override;

    void stopAllNotes(uint8 source, uint8 channel) override;
    void deinitSource(uint8 source) override;

protected:
    void applySourceVolume(uint8 source) override;

    virtual void initOpl();

    virtual void noteOff(uint8 channel, uint8 note, uint8 velocity, uint8 source);
    virtual void noteOn(uint8 channel, uint8 note, uint8 velocity, uint8 source);
    virtual void polyAftertouch(uint8 channel, uint8 note, uint8 pressure, uint8 source);
    virtual void controlChange(uint8 channel, uint8 controller, uint8 value, uint8 source);
    virtual void programChange(uint8 channel, uint8 program, uint8 source);
    virtual void channelAftertouch(uint8 channel, uint8 pressure, uint8 source);
    virtual void pitchBend(uint8 channel, uint8 pitchBendLsb, uint8 pitchBendMsb, uint8 source);

    virtual void modulation(uint8 channel, uint8 modulation, uint8 source);
    virtual void dataEntry(uint8 channel, uint8 dataMsb, uint8 dataLsb, uint8 source);
    virtual void volume(uint8 channel, uint8 volume, uint8 source);
    virtual void panning(uint8 channel, uint8 panning, uint8 source);
    virtual void expression(uint8 channel, uint8 expression, uint8 source);
    virtual void sustain(uint8 channel, uint8 sustain, uint8 source);
    virtual void registeredParameterNumber(uint8 channel, uint8 rpnMsb, uint8 rpnLsb, uint8 source);
    virtual void allSoundOff(uint8 channel, uint8 source);
    virtual void resetAllControllers(uint8 channel, uint8 source);
    virtual void allNotesOff(uint8 channel, uint8 source);

    virtual void applyControllerDefaults(uint8 source);

    virtual void recalculateFrequencies(uint8 channel, uint8 source);
    virtual void recalculateVolumes(uint8 channel, uint8 source);

    virtual InstrumentInfo determineInstrument(uint8 channel, uint8 source, uint8 note);
    virtual uint8 allocateOplChannel(uint8 channel, uint8 source, uint8 instrumentId);
    void determineMelodicChannels();
    virtual uint16 calculateFrequency(uint8 channel, uint8 source, uint8 note);
    virtual int32 calculatePitchBend(uint8 channel, uint8 source, uint16 oplFrequency);
    virtual uint8 calculateVolume(uint8 channel, uint8 source, uint8 velocity, OplInstrumentDefinition &instrumentDef, uint8 operatorNum);
    virtual uint8 calculateUnscaledVolume(uint8 channel, uint8 source, uint8 velocity, OplInstrumentDefinition &instrumentDef, uint8 operatorNum);
    virtual bool isVolumeApplicableToOperator(OplInstrumentDefinition &instrumentDef, uint8 operatorNum);
    virtual uint8 calculatePanning(uint8 channel, uint8 source);

    virtual void setRhythmMode(bool rhythmMode);

    uint16 determineOperatorRegisterOffset(uint8 oplChannel, uint8 operatorNum, OplInstrumentRhythmType rhythmType = RHYTHM_TYPE_UNDEFINED, bool fourOperator = false);
    uint16 determineChannelRegisterOffset(uint8 oplChannel, bool fourOperator = false);
    void writeInstrument(uint8 oplChannel, InstrumentInfo instrument);
    void writeKeyOff(uint8 oplChannel, OplInstrumentRhythmType rhythmType = RHYTHM_TYPE_UNDEFINED, bool forceWrite = false);
    void writeRhythm(bool forceWrite = false);
    virtual void writeVolume(uint8 oplChannel, uint8 operatorNum, OplInstrumentRhythmType rhythmType = RHYTHM_TYPE_UNDEFINED);
    virtual void writePanning(uint8 oplChannel, OplInstrumentRhythmType rhythmType = RHYTHM_TYPE_UNDEFINED);
    virtual void writeFrequency(uint8 oplChannel, OplInstrumentRhythmType rhythmType = RHYTHM_TYPE_UNDEFINED);

    void writeRegister(uint16 reg, uint8 value, bool forceWrite = false);

    // The type of OPL chip to use.
    OPL::Config::OplType _oplType;
    // The OPL emulator / hardware interface.
    OPL::OPL *_opl;

    // True if the driver has been successfully opened.
    bool _isOpen;
    // The number of timer callbacks per second.
    int _timerFrequency;
    // Controls the behavior for calculating note frequency and volume.
    AccuracyMode _accuracyMode;
    // Controls the OPL channel allocation behavior.
    ChannelAllocationMode _allocationMode;
    // Controls when the instrument definitions are written.
    InstrumentWriteMode _instrumentWriteMode;
    // Controls response to rhythm note off events when rhythm mode is active.
    bool _rhythmModeIgnoreNoteOffs;
    // Controls whether MIDI channel 10 is treated as the rhythm channel or as
    // a melodic channel.
    bool _channel10Melodic;

    // The default MIDI channel volume (set when opening the driver).
    uint8 _defaultChannelVolume;

    // OPL global settings. Set these, then call oplInit or open to apply the
    // new values.
    NoteSelectMode _noteSelect;
    ModulationDepth _modulationDepth;
    VibratoDepth _vibratoDepth;
    // Current OPL rhythm mode setting. Use setRhythmMode to set and activate.
    bool _rhythmMode;

    // Pointer to the melodic instrument definitions.
    OplInstrumentDefinition *_instrumentBank;
    // Pointer to the rhythm instrument definitions.
    OplInstrumentDefinition *_rhythmBank;
    // The MIDI note value of the first rhythm instrument in the bank.
    uint8 _rhythmBankFirstNote;
    // The MIDI note value of the last rhythm instrument in the bank.
    uint8 _rhythmBankLastNote;

    // The current MIDI controller values for each MIDI channel and source.
    MidiChannelControlData _controlData[MAXIMUM_SOURCES][MIDI_CHANNEL_COUNT];
    // The active note data for each OPL channel.
    ActiveNote _activeNotes[OPL3_NUM_CHANNELS];
    // The active note data for the OPL rhythm instruments.
    ActiveNote _activeRhythmNotes[5];
    // The OPL channel allocated to each MIDI channel and source; 0xFF if a
    // MIDI channel has no OPL channel allocated. Note that this is only used by
    // the static channel allocation mode.
    uint8 _channelAllocations[MAXIMUM_SOURCES][MIDI_CHANNEL_COUNT];
    // Array containing the numbers of the available melodic channels.
    const uint8 *_melodicChannels;
    // The number of available melodic channels (length of _melodicChannels).
    uint8 _numMelodicChannels;
    // The amount of notes played since the driver was opened / reset.
    uint32 _noteCounter;

    // Factor to convert a frequency in Hertz to the format used by the OPL
    // registers (F - num).
    float _oplFrequencyConversionFactor;
    // The values last written to each OPL register.
    uint8 _shadowRegisters[0x200];

    Common::Mutex _allocationMutex; // For operations on channel allocations
    Common::Mutex _activeNotesMutex; // For operations on active notes
};

#endif