casio.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_CASIO_H
#define AUDIO_CASIO_H

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

class MidiDriver_Casio : public MidiDriver_Multisource {
protected:
    // Tracks a note currently playing on the device.
    struct ActiveNote {
        // The source that played the note (0x7F if no note is tracked).
        int8 source;
        // The output MIDI channel on which the note is playing
        // (0xFF if no note is tracked).
        uint8 channel;
        // The MIDI note number of the playing note
        // (0xFF if no note is tracked).
        uint8 note;
        // True if this note is sustained (turned off but held due to the
        // sustain controller).
        bool sustained;

        ActiveNote();

        // Sets the struct to values indicating no note is currently tracked.
        void clear();
    };

public:
    // The maximum polyphony for each output channel.
    static const int CASIO_CHANNEL_POLYPHONY[4];

    // Array for remapping instrument numbers from CT-460/CSM-1 to MT-540.
    static const uint8 INSTRUMENT_REMAPPING_CT460_TO_MT540[30];
    // Array for remapping instrument numbers from MT-540 to CT-460/CSM-1.
    static const uint8 INSTRUMENT_REMAPPING_MT540_TO_CT460[30];

    // The instrument number used for rhythm sounds on the MT-540.
    static const uint8 RHYTHM_INSTRUMENT_MT540;
    // The instrument number used for rhythm sounds on the CT-460 and CSM-1.
    static const uint8 RHYTHM_INSTRUMENT_CT460;

    // The instrument number used for the bass instruments on the MT-540.
    static const uint8 BASS_INSTRUMENT_MT540;
    // The instrument number used for the bass instruments on the CT-460 and
    // CSM-1.
    static const uint8 BASS_INSTRUMENT_CT460;

    MidiDriver_Casio(MusicType midiType);
    ~MidiDriver_Casio();

    int open() override;
    virtual int open(MidiDriver *driver, MusicType deviceType);
    void close() override;
    bool isOpen() const override;

    using MidiDriver_BASE::send;
    void send(int8 source, uint32 b) override;
    void metaEvent(int8 source, byte type, byte *data, uint16 length) override;

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

protected:
    virtual int8 mapSourceChannel(uint8 source, uint8 dataChannel);
    virtual void processEvent(int8 source, uint32 b, uint8 outputChannel);
    virtual void noteOff(byte outputChannel, byte command, byte note, byte velocity, int8 source);
    virtual void noteOn(byte outputChannel, byte note, byte velocity, int8 source);
    virtual void programChange(byte outputChannel, byte patchId, int8 source, bool applyRemapping = true);
    virtual void controlChange(byte outputChannel, byte controllerNumber, byte controllerValue, int8 source);

    virtual int8 mapNote(byte outputChannel, byte note);
    virtual byte calculateVelocity(int8 source, byte velocity);
    virtual byte mapInstrument(byte program, bool applyRemapping = true);
    virtual bool isRhythmChannel(uint8 outputChannel);
    // This implementation does nothing, because source volume is applied to
    // note velocity and cannot be applied immediately.
    void applySourceVolume(uint8 source) override;
    void stopAllNotes(uint8 source, uint8 channel) override;

    // The wrapped MIDI driver.
    MidiDriver *_driver;
    // The type of Casio device accessed by the wrapped driver: MT-540 or
    // CT-460/CSM-1.
    MusicType _deviceType;
    // The type of MIDI data supplied to the driver: MT-540 or CT-460/CSM-1.
    MusicType _midiType;
    // True if this MIDI driver has been opened.
    bool _isOpen;

    // The current instrument on each MIDI output channel. This is the
    // instrument number as specified in the program change events (before
    // remapping is applied).
    byte _instruments[4];
    // Indicates if each output channel is currently a rhythm channel (i.e. it
    // has the rhythm instrument set).
    bool _rhythmChannel[4];
    // Tracks the notes currently active on the MIDI device.
    ActiveNote _activeNotes[32];
    // Tracks the sustain controller status of the output channels.
    bool _sustain[4];

    // Optional remapping for rhythm notes. Should point to a 128 byte array
    // which maps the rhythm note numbers in the input MIDI data to the rhythm
    // note numbers used by the output device.
    byte *_rhythmNoteRemapping;

    // If true the driver will send note off events for notes which are not in
    // the active note registry. Typically this should be true to prevent
    // hanging notes in case there are more active notes than can be stored in
    // the active note registry. Can be set to false if these note offs are not
    // desirable, f.e. because the driver will be receiving note off events
    // without corresponding note on events.
    bool _sendUntrackedNoteOff;

    // Mutex for operations on active notes.
    Common::Mutex _mutex;

public:
    static void timerCallback(void *data);
};

#endif