asound.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_DRAGONSPHERE_ASOUND_H
#define MADS_DRAGONSPHERE_ASOUND_H

#include "audio/fmopl.h"
#include "common/mutex.h"
#include "common/queue.h"
#include "common/util.h"
#include "mads/core/sound_manager.h"

namespace MADS {
namespace Dragonsphere {

#define ADLIB_CHANNEL_COUNT 9

struct AdlibChannel {
    static bool _isDisabled;

    // ---- byte fields (offsets 0x00 - 0x13) --------------------------------

    uint8  _activeCount = 0; // 0x00  duration tick countdown; 0 = channel idle
    uint8  _pitchBend = 0; // 0x01  signed pitch-bend offset applied by writePitchBend
    uint8  _volumeFadeStep = 0; // 0x02  signed per-period volume/velocity delta (0xFF = fade out)
    uint8  _vibratoDepth = 0; // 0x03  signed LFO depth; negated each period to oscillate
    uint8  _note = 0; // 0x04  MIDI note number for current event
    uint8  _sampleIndex = 0; // 0x05  index into _samples[] selecting the OPL patch
    uint8  _volume = 0; // 0x06  channel volume (0-127)
    uint8  _noteOffset = 0; // 0x07  subtracted from _activeCount to shorten note duration
    uint8  _durationOverride = 0; // 0x08  when non-zero, overrides the stream's duration byte
    uint8  _keyOnDelay = 0; // 0x09  countdown before the OPL key-on bit is cleared (gate time)
    uint8  _fadePeriodCounter = 0; // 0x0A  counts down to 0 before applying _volumeFadeStep
    uint8  _fadePeriodReload = 0; // 0x0B  reload value for _fadePeriodCounter
    uint8  _arpPeriodCounter = 0; // 0x0C  arpeggio tick counter (reloaded from _arpPeriodReload)
    uint8  _vibPeriodCounter = 0; // 0x0D  LFO tick counter; when it reaches 0 a vibrato step fires
    uint8  _vibPeriodReload = 0; // 0x0E  reload value for _vibPeriodCounter
    uint8  _patchAttenuation = 0; // 0x0F  per-note attenuation offset added on top of the patch TL
    uint8  _velocity = 0; // 0x10  note velocity (0-127); used together with _volume for TL
    uint8  _writeVolumePending = 0; // 0x11  non-zero -> call sub_11856 (secondary freq write) this tick
    uint8  _arpPeriodReload = 0; // 0x12  arpeggio period reload value (set by opcode 9)
    uint8  _arpCounterReload = 0; // 0x13  arpeggio counter reload (decremented; 0xFF = infinite)

    // ---- pointer fields (offsets 0x14 - 0x1F, word-sized in original) ----

    byte *_loopStartPtr = nullptr; // 0x14  start of the current loop body
    byte *_pSrc = nullptr; // 0x16  current read pointer into the sound-data stream
    byte *_innerLoopPtr = nullptr; // 0x18  inner-loop restart address
    byte *_outerLoopPtr = nullptr; // 0x1A  outer-loop restart address
    byte *_soundData = nullptr; // 0x1C  base address of this channel's sound-data block
    byte *_branchTargetPtr = nullptr; // 0x1E  target of the most recent branch/jump opcode

    // ---- word counter fields (offsets 0x20 - 0x29) ----------------------

    uint16 _innerLoopCount = 0; // 0x20  remaining inner-loop iterations (0 = infinite until opcode)
    uint16 _outerLoopCount = 0; // 0x22  remaining outer-loop iterations (0 = infinite until opcode)
    uint16 _noiseFreqMask = 0; // 0x24  AND mask applied to the random number in noise mode
    uint16 _freqAccum = 0; // 0x26  frequency sweep accumulator (base frequency + swept offset)
    uint16 _freqStep = 0; // 0x28  per-tick increment added to _freqAccum during a sweep

    // ---- sweep / pause state (offsets 0x2A - 0x2D) ----------------------

    // 0x2A-0x2B  Last computed OPL total-level bytes written by writeVolume.
    //            lo byte (0x2A) = carrier TL nibble; hi byte (0x2B) = modulator TL nibble.
    //            Written at the end of asound_writeVolume so that command7 (resume) can
    //            restore operator levels without a full recalculation.
    uint8  _cachedCarrierTL = 0; // 0x2A  cached carrier total-level (6-bit, 0 = loudest)
    uint8  _savedFreqSweep = 0; // 0x2B  copy of _freqSweepCounter saved by command6 (pause)
    uint8  _freqSweepCounter = 0; // 0x2C  countdown for frequency-sweep ticks; 0 = sweep done
    uint8  _savedSweepCounter = 0; // 0x2D  second save slot: _freqSweepCounter is mirrored here
    //       by command6/7 so command7 can restore the live value

// ---- tuning / control (offsets 0x2E - 0x31) ------------------------

    uint8  _transpose = 0; // 0x2E  semitone offset added when looking up _semitoneFreqTable
    uint8  _octaveTranspose = 0; // 0x2F  octave shift: added to _note before octave calculation
    uint8  _pendingStop = 0; // 0x30  0xFF = channel is fading out and will go idle when silent
    uint8  _vibratoMode = 0; // 0x31  0xFF = one-shot vibrato (clamp & stop); else = continuous

    void reset();

    void load(byte *soundData);

    void setPtr2(byte *ptr);

    void enable();

    void processChannelFade();
};

// ---------------------------------------------------------------------------
// AdlibSample  (unchanged from Return of the Phantom, 0x16 bytes)
// ---------------------------------------------------------------------------
struct AdlibSample {
    uint8  _attackRate = 0;
    uint8  _decayRate = 0;
    uint8  _sustainLevel = 0;
    uint8  _releaseRate = 0;
    uint8  _egTyp = 0;
    uint8  _ksr = 0;
    uint8  _totalLevel = 0;
    uint8  _scalingLevel = 0;
    uint8  _waveformSelect = 0;
    uint8  _freqMultiple = 0;
    uint8  _feedback = 0;
    uint8  _ampMod = 0;
    uint8  _vib = 0;
    uint8  _alg = 0;
    uint8  _freqSweepInit = 0; // initial _freqSweepCounter value; 0 = immediate key-on
    uint8  _reserved = 0;
    uint16 _freqMask = 0; // loaded into channel _noiseFreqMask
    uint16 _freqBase = 0; // loaded into channel _freqAccum
    uint16 _outerLoopPtr = 0; // loaded into channel _freqStep

    AdlibSample() {
    }
    AdlibSample(Common::SeekableReadStream &s);
};

// ---------------------------------------------------------------------------
// ASound  -  Dragonsphere Adlib sound driver base class
//
// Command dispatch table layout (from off_11A14 / off_11A26 / off_11A2E /
// funcs_12251 / off_11A64 in the disassembly):
//
//   Table 1  off_11A14  commands  0- 8   (max=8,    base=0,    9 entries)
//   Table 2  off_11A26  commands 16-19   (max=0x13, base=0x10, 4 entries)
//             command16  = background-music dispatcher (calls command18)
//             command17  = play specific piece (loads 7 channels direct)
//             command18  = re-entrant music launcher (reads word_12370 to pick a sub-command)
//             command19  = no-op (asound_command98)
//   Table 3  off_11A2E  commands 24-32   (max=0x20, base=0x18, 9 entries)
//   Table 4  funcs_12251 commands 32-49  (max=0x31, base=0x20, 18 entries)
//             Includes asound_command32-48 (music pieces / SFX loaders)
//             and asound_command98 (no-op) in the last slot.
//   Table 5  off_11A64  commands 64-101  (max=0x65, base=0x40, 38 entries)
//             Includes asound_command64-101 (single-shot SFX loaders via
//             findFreeChannel / findFreeChannelFull) and two no-ops.
//
// The driver also exposes:
//   asound_command90 / 91  - two-voice SFX (findFreeChannelFull x2)
//   asound_command95       - four-voice music piece (findFreeChannel x4)
//   sub_11F98              - two-voice SFX (findFreeChannelFull x2)
//
// word_12370 tracks the "current music index" used by command18 to select
// which music-piece loader to call.
// ---------------------------------------------------------------------------
class ASound : public SoundDriver {
protected:
    typedef void (ASound::*CallbackFunction)();

private:
    OPL::OPL *_opl = OPL::Config::create();

    // ---- callback / tick state ------------------------------------------
    uint16 _callbackCounter = 0;  // per-tick countdown
    uint16 _callbackPeriod = 0;  // reload value; 0 = callback disabled
    // Pointer to the deferred sound-loader called when the
    // counter fires (stored as uint16 in the original; typed as a member
    // function pointer in the C++ port).
    CallbackFunction _callbackFnPtr = nullptr;

    // ---- active-channel context (set by pollAllChannels) ----------------
    AdlibChannel *_activeChannelPtr = nullptr;
    uint8          _activeChannelNumber = 0;
    uint16         _activeChannelReg = 0; // 0xA0+ch register for the active channel
    uint16         _currentOpBase = 0; // operator register base for the active channel

    // ---- per-frame working state ----------------------------------------
    AdlibSample *_samplePtr = nullptr; // patch being loaded/written
    byte *pSrc = nullptr; // current read pointer (mirrors channel _pSrc)
    int16          _pollResult = 0;
    int16          _resultFlag = 0;
    uint16         _randomSeed = 0x4D2;

    // ---- driver-wide flags ----------------------------------------------
    uint16 _isDisabled = 0; // non-zero while the engine is paused (command6)
    uint8  _findChannelMode = 0; // 0=full search, 1=ch0-5 only, 2=ch6-8 then pending

    // ---- per-channel sweep shadows (for channel 5 special-casing) -------
    //      Not present as separate globals in Dragonsphere; the channel
    //      struct fields _savedFreqSweep / _savedSweepCounter handle this.

    // ---- misc globals ---------------------------------------------------
    uint8  _anySweepActive = 0; // set to 1 if any channel has _freqSweepCounter > 0
    int    _frameNumber2 = 0; // secondary frame counter incremented every update

    // ---- script / sequencer registers -----------------------------------
    uint8  _scriptVars[32] = {}; // byte_16A10: 32 general-purpose script registers

    // ---- music-index tracker (word_12370) --------------------------------
    // Tracks which music piece was last launched by command18.
    uint16 _musicIndex = 0;

    // ---- tempo / sequencer state (from opcodes3 group 2 handlers) --------
    uint8  _musicOnlyFlag = 0;     // byte_12393: 1=music-only check, 0=all channels
    uint16 _tempoFineStep = 0;     // word_124F2: fine tempo step (opcode A6)
    uint16 _tempoCoarseStep = 0;   // word_124F0: coarse tempo step (opcode A7)
    uint16 _tempoPeriod = 0;       // word_124EE: tempo period in ticks (opcode A8)
    uint8  _tempoEnabled = 0;      // non-zero when tempo tick is active (opcode A8)
    uint16 _tempoTickCounter = 0;  // countdown for tempo callback
    uint16 _tempoShift = 0;        // word_124F4: tempo shift (opcode A9)

    // =========================================================================
    // Private helpers
    // =========================================================================

    void onTimer();

    void clearCallback();
    void resetCallback() {
        clearCallback();
    }

    void adlib_channelOff(uint8 portIndex);

    void writeVolume();

    void writeFrequency();

    void writePitchBend();

    void writeArpeggio();

    void updateOctave();

    void noteOn();

    void writeSampleRegs();

    void loadSample();

    void update();

    void update1(int channelIndex);

    void setFrequency(uint8 voice, uint16 freq);

    void noise_inner(int channelIndex);

    void updateAllChannels();

    uint16 readWord_impl();

    void tickCallback();

protected:
    // ---- nine AdlibChannel instances ------------------------------------
    AdlibChannel _channel0, _channel1, _channel2;
    AdlibChannel _channel3, _channel4, _channel5;
    AdlibChannel _channel6, _channel7, _channel8;
    AdlibChannel *_channels[ADLIB_CHANNEL_COUNT] = {
        &_channel0, &_channel1, &_channel2,
        &_channel3, &_channel4, &_channel5,
        &_channel6, &_channel7, &_channel8
    };

    uint8  _adlibPorts[0x100] = { 0 };
    Common::Array<AdlibSample> _samples;

protected:
    // =========================================================================
    // Protected helpers  (used by ASound1–ASound9)
    // =========================================================================

    int isMusicChannelsActive();

    int isAnyChannelActive();

    void scheduleCallback(CallbackFunction fn) { _callbackFnPtr = fn; }

    void resetCallbackTimer(uint16 period) {
        _callbackFnPtr = nullptr;
        _callbackCounter = period;
        _callbackPeriod = period;
    }

    void resetCallbackTimerEx(uint16 counter, uint16 period) {
        _callbackFnPtr = nullptr;
        _callbackCounter = counter;
        _callbackPeriod = period;
    }

    void setMusicIndex(uint16 idx) { _musicIndex = idx; }
    uint16 getMusicIndex() const { return _musicIndex; }

    void setScriptVar(int idx, uint8 val) { _scriptVars[idx] = val; }
    void write(uint8 reg, uint8 value);

    uint16 getRandomNumber();

    void adlib_channelOn(uint8 portIndex);

    void signalSoundPlaying();

    void pollAllChannels();

    void pollActiveChannel();

    bool isSoundActive(byte *ptr) const;

    void findFreeChannel(byte *soundData);

    void findFreeChannelFull(byte *soundData);

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

protected:
    // =========================================================================
    // Core commands (0-8)  -  identical in purpose to Return of the Phantom
    // =========================================================================

    int command0();

    int command1();

    int command2();

    int command3();

    int command4();

    int command5();

    int command6();

    int command7();

    int command8();

    virtual void callFunction(uint16 offset);

    // =========================================================================
    // Music-index launcher (called via command18)
    // =========================================================================

    int command18();

public:
    static void validate(bool isDemo);

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

    ~ASound() override {
        delete _opl;
    }

    virtual int stop() override;

    int poll() override;

    void noise() override;

    void playSound(int offset);

    void setVolume(int volume) override {
        // TODO: implement if needed
    }
};

} // namespace Dragonsphere
} // namespace MADS

#endif