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_PHANTOM_SOUND_RSOUND_H
#define MADS_PHANTOM_SOUND_RSOUND_H

#include "audio/mt32gm.h"
#include "mads/core/native_sound_timer.h"
#include "mads/core/sound_manager.h"

namespace MADS {
namespace Phantom {
namespace Sound {

class RSound;

#define RSOUND_CHANNEL_COUNT 9

class Channel {
public:
    RSound *_owner = nullptr;
    int _midiChannel = 0;         // 1-9: the MIDI channel this struct drives (C++ convenience, not a real field)

    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;                // last-played note value (note + _transpose), used to detect a note change
    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 (relative mode)
    int _keyOnDelayOverride = 0;  // when non-zero, used directly as _keyOnDelay instead of the relative computation (absolute mode; new to Phantom)
    int _keyOnDelay = 0;          // countdown to RSound::Channel_flushHeldNotes()
    int _volumeFadeCounter = 0;   // counts down to 0 before applying _volumeFadeStep
    int _volumeFadeReload = 0;    // reload value for _volumeFadeCounter
    int _pitchBendFadeCounter = 0; // counts down to 0 before applying _pitchBendFadeStep
    int _panFadeCounter = 0;      // counts down to 0 before applying _panFadeStep
    int _panFadeReload = 0;       // reload value for _panFadeCounter
    int _pan = 0;                 // current pan value (MIDI CC#10); 64 = center
    int _volume = 0;              // current channel volume (MIDI CC#7)
    int _pitchBend = 0;           // current pitch bend value (status 0xEn, coarse/MSB only)
    int _pitchBendFadeReload = 0; // reload value for _pitchBendFadeCounter
    int _pitchBendFadeCount = 0;  // total ramp steps remaining before the pitch-bend ramp halts
    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
    uint16 _innerLoopCount = 0; // signed byte stored as a 16-bit loop count
    uint16 _outerLoopCount = 0; // signed byte stored as a 16-bit loop count
    byte *_soundData = nullptr;    // identity pointer used by RSound::isSoundActive()
    byte *_branchTarget = nullptr; // resume-after-branch pointer, used by the call/return opcode pair (new to Phantom)
    int _transpose = 0;            // added to note bytes before comparison/storage (new to Phantom)
    int _pendingStop = 0;          // non-zero while the channel is fading out to silence

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 = 255;
    int _stateChangedFlag;        // latches _pollResult=0xFFFF once per state change
    MidiDriver_MT32GM *_midiDriver;
    uint32 _driverCallbackDelta;
    NativeSoundTimer _hostTimer;

    byte _heldNotes[RSOUND_CHANNEL_COUNT + 1][4];

    int _sysExOffset;

    byte _scriptVariables[32];

    int _fadeCheckCounter;

    int _tickCounter;
    int _clockMedTarget;          // pending value for _clockMed, set by opcode 0xC0
    int _clockCoarseTarget;       // pending value for _clockCoarse, set by opcode 0xBF
    int _clockUnknown;            // default 0; doesn't fit the 4x pattern, standalone (opcode 0xBE)
    int _clockCoarse;             // default 112 (=28*4)
    int _clockMed;                // default 28 (=7*4)
    int _clockFine;               // default 7
    int _clockEnabled1;           // set to 1 by opcode 0xBF
    int _clockEnabled2;           // set to 1 by opcode 0xBF

    void update();
    void pollAllChannels();

    void pollActiveChannel(Channel *channel);

    int readScriptByte(byte *&pSrc);

    uint16 readScriptWord(byte *&pSrc);

    void resetAllChannels();
    void resetChannels1to5();

    void resetChannels4to9();

    void checkFadingChannels();
    void Channel_checkFade(Channel *channel, int midiChannel);
    void Channel_flushHeldNotes(Channel *channel);

protected:
    int _commandParam;

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

    int _randomAmbianceTriggerFlag;

    int _fadeCheckPeriod;

    void resetChannelRange(int first, int last);

    virtual void checkRandomAmbianceTrigger() {
    }

    void resultCheck();

    virtual bool callFunction(uint16 targetOffset) {
        (void)targetOffset;
        return false;
    }

    Channel *playSound(int offset);

    Channel *playSoundChannels1To5(int offset);

    Channel *playSoundAny(int offset);

    Channel *playSoundChannels5To8(int offset);

    Channel *playSoundChannels1To6(int offset);

    Channel *playSoundData(byte *pData, int startingChannel, int freeScanEnd, int fallbackScanEnd);

    bool isSoundActive(byte *pData);

    int getRandomNumber();

    // ---- Low-level MIDI send helpers -------------------------------
    void sendNoteOn(int midiChannel, int note, int velocity);
    void sendProgramChange(int midiChannel, int program);
    void sendVolume(int midiChannel, int volume);
    void sendVolumeCC(int midiChannel, int volume);
    void resetPitchBend(int midiChannel);
    void sendPitchBend(int midiChannel, int value);
    void sendPan(int midiChannel, int value);
    void muteChannel(int midiChannel);

    void sendGmReset(int count);

    const byte *sendSysExData(const byte *pData, uint maxLength);

    const byte *sendSysEx(int offset);

    void sendSysExSequence();

    void restorePatchMemory();

    void sendReverbSysEx(int mode, int time, int level);
    void onTimer();
    static void timerCallback(void *data);

    void noOpHandler(int param) {
    }

    virtual int command0();
    int command1();
    int command2();
    int command3();

    void enableUpperChannels();

    void resetAndGmResetUpperChannels();

    virtual int command4() = 0;
    virtual int command5() = 0;
    int command6();
    int command7();
    int command8();

    int nullCommand() {
        return 0;
    }

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

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;
    }
};

} // namespace Sound
} // namespace Phantom
} // namespace MADS

#endif