mididrv_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_MIDIDRV_MS_H
#define AUDIO_MIDIDRV_MS_H

#include "common/mutex.h"

#include "audio/mididrv.h"

class MidiDriver_Multisource : public MidiDriver {
public:
    static const uint8 MAXIMUM_SOURCES = 10;
    static const uint16 DEFAULT_SOURCE_NEUTRAL_VOLUME = 255;

protected:
    // Timeout between updates of the channel volume for fades (25ms)
    static const uint16 FADING_DELAY = 25 * 1000;

public:
    enum SourceType {
        SOURCE_TYPE_UNDEFINED,
        SOURCE_TYPE_MUSIC,
        SOURCE_TYPE_SFX
    };

    enum FadeAbortType {
        FADE_ABORT_TYPE_END_VOLUME,
        FADE_ABORT_TYPE_CURRENT_VOLUME,
        FADE_ABORT_TYPE_START_VOLUME
    };

    enum ControllerDefaultType {
        CONTROLLER_DEFAULT_PROGRAM,
        CONTROLLER_DEFAULT_INSTRUMENT_BANK,
        CONTROLLER_DEFAULT_DRUMKIT,
        CONTROLLER_DEFAULT_CHANNEL_PRESSURE,
        CONTROLLER_DEFAULT_PITCH_BEND,
        CONTROLLER_DEFAULT_MODULATION,
        CONTROLLER_DEFAULT_VOLUME,
        CONTROLLER_DEFAULT_PANNING,
        CONTROLLER_DEFAULT_EXPRESSION,
        CONTROLLER_DEFAULT_SUSTAIN,
        CONTROLLER_DEFAULT_RPN,
        CONTROLLER_DEFAULT_PITCH_BEND_SENSITIVITY,
        CONTROLLER_DEFAULT_REVERB,
        CONTROLLER_DEFAULT_CHORUS
    };

protected:
    // This stores data about a specific source of MIDI data.
    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 the 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 time (microseconds) has passed since the start of the fade.
        int32 fadePassedTime;
        // The total duration of the fade (microseconds).
        int32 fadeDuration;

        MidiSource();
    };

    // Stores the default values that should be set for each controller.
    // -1 means no explicit default should be set for that controller.
    struct ControllerDefaults {
        int8 program[16];
        int8 instrumentBank;
        int8 drumkit;

        int8 channelPressure;
        int16 pitchBend;

        int8 modulation;
        int8 volume;
        int8 panning;
        int8 expression;
        int8 sustain;
        int8 reverb;
        int8 chorus;
        int16 rpn;

        int8 pitchBendSensitivity;

        ControllerDefaults();
    };

public:
    MidiDriver_Multisource();

    // MidiDriver functions
    using MidiDriver_BASE::send;
    void send(uint32 b) override;
    void send(int8 source, uint32 b) override = 0;

    uint32 property(int prop, uint32 param) override;

    virtual void deinitSource(uint8 source);
    void setSourceType(SourceType type);
    void setSourceType(uint8 source, SourceType type);
    void setSourceVolume(uint16 volume);
    void setSourceVolume(uint8 source, uint16 volume);
    void resetSourceVolume();
    void resetSourceVolume(uint8 source);
    void setSourceNeutralVolume(uint16 volume);
    void setSourceNeutralVolume(uint8 source, uint16 volume);

    void startFade(uint16 duration, uint16 targetVolume);
    void startFade(uint8 source, uint16 duration, uint16 targetVolume);
    void abortFade(FadeAbortType abortType = FADE_ABORT_TYPE_END_VOLUME);
    void abortFade(uint8 source, FadeAbortType abortType = FADE_ABORT_TYPE_END_VOLUME);
    bool isFading();
    bool isFading(uint8 source);

    void setControllerDefault(ControllerDefaultType type);
    void setControllerDefault(ControllerDefaultType type, int16 value);
    void setControllerDefaults(ControllerDefaultType type, const int16 *values);
    void clearControllerDefault(ControllerDefaultType type);

    void setInstrumentRemapping(const byte *instrumentRemapping);

    void syncSoundSettings();

    using MidiDriver::stopAllNotes;
    virtual void stopAllNotes(uint8 source, uint8 channel) = 0;

    void setTimerCallback(void *timer_param, Common::TimerManager::TimerProc timer_proc) override {
        _timer_param = timer_param;
        _timer_proc = timer_proc;
    }

protected:
    virtual void applySourceVolume(uint8 source) = 0;
    void updateFading();
    virtual void onTimer();

    // MIDI source data
    MidiSource _sources[MAXIMUM_SOURCES];

    // Default values for each controller
    ControllerDefaults _controllerDefaults;

    // Map for arbitrary instrument remapping.
    const byte *_instrumentRemapping;

    // True if the driver should scale MIDI channel volume to the user
    // specified volume settings.
    bool _userVolumeScaling;

    // User volume settings
    uint16 _userMusicVolume;
    uint16 _userSfxVolume;
    bool _userMute;

    Common::Mutex _fadingMutex; // For operations on fades

    // The number of microseconds to wait before the next fading step.
    uint16 _fadeDelay;

    // The number of microseconds between timer callback invocations.
    uint32 _timerRate;

    // External timer callback
    void *_timer_param;
    Common::TimerManager::TimerProc _timer_proc;
};

class MidiDriver_NULL_Multisource : public MidiDriver_Multisource {
public:
    int open() override;
    bool isOpen() const override { return true; }
    void close() override;
    uint32 getBaseTempo() override { return 10000; }
    MidiChannel *allocateChannel() override { return 0; }
    MidiChannel *getPercussionChannel() override { return 0; }

    using MidiDriver_Multisource::send;
    void send(int8 source, uint32 b) override { }
    using MidiDriver_Multisource::stopAllNotes;
    void stopAllNotes(uint8 source, uint8 channel) override { }

    static void timerCallback(void *data);

protected:
    void applySourceVolume(uint8 source) override { }
};

#endif