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_RSOUND_H
#define MADS_PHANTOM_RSOUND_H

#include "mads/core/sound_manager.h"

namespace MADS {
namespace Phantom {

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
    int _innerLoopCount = 0;
    int _outerLoopCount = 0;
    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;
    byte _lastMidiStatus;         // running-status cache, avoids resending an unchanged status byte
    byte _sysexChecksum;
    int _stateChangedFlag;        // word_12BB8 in the disassembly; latches _pollResult=0xFFFF once per state change

    byte _heldNotes[RSOUND_CHANNEL_COUNT + 1][4];

    int _sysExOffset;

    byte _scriptVariables[32];

    int _fadeCheckCounter;

    int _tickCounter;             // word_12BE5
    int _clockMedTarget;          // word_12BE7 - pending value for _clockMed, set by opcode 0xC0
    int _clockCoarseTarget;       // word_12BE9 - pending value for _clockCoarse, set by opcode 0xBF
    int _clockUnknown;            // word_12BEB - default 0; doesn't fit the 4x pattern, standalone (opcode 0xBE)
    int _clockCoarse;             // word_12BEE - default 112 (=28*4)
    int _clockMed;                // word_12BF0 - default 28 (=7*4)
    int _clockFine;               // word_12BF2 - default 7
    int _clockEnabled1;           // word_12BD3 - set to 1 by opcode 0xBF
    int _clockEnabled2;           // word_12BE3 - 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();

    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 -------------------------------
    // 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 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);

    void sendSysExData(const byte *pData);

    void sendSysEx(int offset);

    void sendPatchInitSequence();

    void sendReverbSysEx(int mode, int time, int level);

    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:
    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 Phantom
} // namespace MADS

#endif