rsound.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 MADS_NEBULAR_RSOUND_H
#define MADS_NEBULAR_RSOUND_H

#include "mads/core/sound_manager.h"

namespace MADS {
namespace RexNebular {

class RSound;

#define RSOUND_CHANNEL_COUNT 9

class Channel {
public:
    RSound *_owner = nullptr;
    int _midiChannel = 0;        // 1-9: the MIDI channel this struct drives

    int _activeCount = 0;        // gate/duration countdown; also freshly loaded from the duration byte of a note event
    int _pitchBendFadeStep = 0;  // per-step delta added to _pitchBend each ramp tick
    int _volumeFadeStep = 0;     // per-step delta added to _volume each ramp tick
    int _panFadeStep = 0;        // per-step delta added to _pan each ramp tick
    int _note = 0;               // MIDI note number, read from the note/duration stream
    int _program = 0;            // patch/instrument number, sent as a Program Change
    int _velocity = 0;           // note velocity, used by RSound::sendNoteOn()
    int _noteOffset = 0;         // subtracted from _activeCount to derive _keyOnDelay; 0xFF = sustain full duration +1 (no early cutoff)
    int _keyOnDelay = 0;         // countdown to RSound::Channel_flushHeldNotes()
    int _volumeFadeCounter = 0;  // counts down to 0 before applying _volumeFadeStep
    int _pitchBendFadeCounter = 0; // counts down to 0 before applying _pitchBendFadeStep
    int _panFadeCounter = 0;     // counts down to 0 before applying _panFadeStep
    int _volume = 0;             // current channel volume (MIDI CC#7)
    int _pitchBend = 0;          // current pitch bend value (status 0xEn, coarse/MSB only)
    int _pan = 0;                // current pan value (MIDI CC#10); 64 = center
    int _volumeFadeReload = 0;   // reload value for _volumeFadeCounter
    int _pitchBendFadeReload = 0; // reload value for _pitchBendFadeCounter
    int _panFadeReload = 0;      // reload value for _panFadeCounter
    int _pitchBendFadeCount = 0; // total ramp steps remaining before the pitch-bend ramp halts
    int _pendingStop = 0;        // non-zero while the channel is fading out to silence
    byte *_loopStartPtr = nullptr; // fixed restart anchor used by the full-reset/loop-restart opcode
    byte *_pSrc = nullptr;         // current read pointer into the sound-data stream
    byte *_innerLoopPtr = nullptr; // inner-loop restart address
    byte *_outerLoopPtr = nullptr; // outer-loop restart address
    int _innerLoopCount = 0;
    int _outerLoopCount = 0;
    byte *_soundData = nullptr;    // identity pointer used by RSound::isSoundActive()

public:
    Channel() {}

    void reset(byte *startPtr);

    void enable(int flag);

    void load(byte *pData);
};

class RSound : public SoundDriver {
    friend class Channel;
private:
    uint16 _randomSeed;
    int _masterVolume;
    byte _lastMidiStatus;             // running-status cache, avoids resending an unchanged status byte
    bool _noteTriggeredThisPoll;      // throttles note-on dispatch to at most one per update() tick, across all channels
    byte _heldNotes[RSOUND_CHANNEL_COUNT + 1][4]; // per-MIDI-channel held-note slots (index 0 unused; channels are 1-9)

    int _sysExOffset;

    static const byte _sysExHeader[5];

    void update();
    void pollAllChannels();
    void Channel_pollActive(Channel *channel);

    void resetChannelRange(int first, int last);

    void resetHeldNotes();

    void resetAllChannels();

    void checkFadingChannels();
    void Channel_checkFade(Channel *channel);

    void Channel_flushHeldNotes(Channel *channel);

protected:
    int _commandParam;

    byte *loadData(int offset) {
        return &_soundData[offset];
    }

    virtual void tickCallback() {
    }

    void resultCheck();

    Channel *playSound(int offset);

    Channel *playSoundAny(int offset) {
        return playSoundData(loadData(offset), 0);
    }

    Channel *playSoundData(byte *pData, int startingChannel = 5);

    bool isSoundActive(byte *pData);

    int getRandomNumber();

    // ---- Low-level MIDI send helpers -------------------------------
    // All funnel through sendMidiByte(), the single hook point for
    // wiring up real MT-32/MIDI output.
    void sendMidiByte(byte value);
    void sendStatus(int midiChannel, byte statusNibble);
    void sendNoteOn(int midiChannel, int note, int velocity);
    void sendProgramChange(int midiChannel, int program);
    void sendVolume(int midiChannel, int volume);
    void sendPitchBend(int midiChannel, int value);
    void sendPan(int midiChannel, int value);
    void muteChannel(int midiChannel);
    void restoreChannelVolume(int midiChannel, int volume);

    void sendGmReset(int first, int last);

    void sendSysEx(int offset);

    virtual int command0();
    int command1();
    int command2();
    int command3();
    int command4();
    int command5();
    int command6();
    int command7();
    int command8();

    int nullCommand() {
        return 0;
    }

public:
    Channel _channels[RSOUND_CHANNEL_COUNT];
    int _frameCounter;
    bool _isDisabled;
    int _pollResult;
    int _resultFlag;

public:
    static void validate();

public:
    RSound(Audio::Mixer *mixer, const Common::Path &filename,
        int dataOffset, int dataSize, int sysExOffset);

    ~RSound() override {
    }

    int stop() override;
    int poll() override;
    void noise() override {
        // No equivalent in the Roland driver - noise() is an Adlib/OPL-only concept
    }
    void setVolume(int volume) override;

    int getFrameCounter() {
        return _frameCounter;
    }

private:
    void onTimer();
};

} // namespace RexNebular
} // namespace MADS

#endif