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_PHANTOM_ASOUND_H
#define MADS_PHANTOM_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 Phantom {

#define ADLIB_CHANNEL_COUNT 9

struct AdlibChannel {
    static bool _isDisabled;
    uint8  _activeCount = 0;
    uint8  _pitchBend = 0;
    uint8  _volumeFadeStep = 0;
    uint8  _vibratoDepth = 0;
    uint8  _note = 0;
    uint8  _sampleIndex = 0;
    uint8  _volume = 0;
    uint8  _noteOffset = 0;
    uint8  _keyOnDelay = 0;
    uint8  _fadePeriodCounter = 0;
    uint8  _fadePeriodReload = 0;
    uint8  _vibPeriodCounter = 0;
    uint8  _vibPeriodReload = 0;
    uint8  _patchAttenuation = 0;
    byte *_loopStartPtr = nullptr;
    byte *_pSrc = nullptr;
    byte *_innerLoopPtr = nullptr;
    byte *_outerLoopPtr = nullptr;
    byte *_soundData = nullptr;
    byte *_branchTargetPtr = nullptr;
    uint16 _innerLoopCount = 0;
    uint16 _outerLoopCount = 0;
    uint16 _noiseFreqMask = 0;
    uint16 _freqAccum = 0;
    uint16 _freqStep = 0;
    uint8  _freqSweepCounter = 0;
    uint8  _savedFreqSweep = 0;
    uint8  _transpose = 0;
    uint8  _velocity = 0;
    uint8  _opVolBytes = 0;
    uint8  _opVolBytes2 = 0;
    uint8  _octaveTranspose = 0;
    uint8  _pendingStop = 0;
    uint8  _durationOverride = 0;

    void reset();

    void load(byte *soundData);

    void setPtr2(byte *ptr);

    void enable();

    void processChannelFade();
};

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;
    uint8  _reserved = 0;
    uint16 _freqMask = 0;
    uint16 _freqBase = 0;
    uint16 _outerLoopPtr = 0;

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

class ASound : public SoundDriver {
private:
    OPL::OPL *_opl = OPL::Config::create();
    uint16 _callbackCounter = 0;        // Period counter
    uint16 _callbackPeriod = 0;         // Period reload
    AdlibChannel *_activeChannelPtr = NULL;
    uint8 _activeChannelNumber = 0;
    uint16 _activeChannelReg = 0;
    uint16 _currentOpBase = 0;          // Current operator base
    AdlibSample *_samplePtr = NULL;
    byte *pSrc = nullptr;               // Current read pointer
    int16 _pollResult = 0;
    int16 _resultFlag = 0;
    uint16 _randomSeed = 0x4D2;
    uint8  _isDisabled = 0;
    uint8  _findChannelMode = 0;        // findFreeChannel mode
    uint8  _ch5SweepLive = 0;           // Channel5 savedFreqSweep shadow
    uint8  _ch5SweepSaved = 0;          // Channel5 savedFreqSweep shadow 2
    uint8  _ch5PendingStop = 0;         // Channel5 pendingStop shadow
    uint8 _anySweepActive = 0;          // any-sweep-active flag
    int _frameNumber2 = 0;
    uint8 _scriptVars[32];              // General-purpose script registers
    uint16 _tickEnabled = 1;
    uint16 _tickCounter = 0;
    uint16 _tempoReload = 0;
    uint16 _tempoTarget = 0;
    uint16 _tempoShift = 0;
    uint16 _tempoBase = 0xA0;
    uint16 _tempoCurrent = 0x28;
    uint16 _tempoScale = 0x0A;

    void onTimer();

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

    void adlib_channelOff(uint8 portIndex);


    void writeVolume();

    void writeFrequency();

    void writePitchBend();

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

protected:
    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:
    void write(uint8 reg, uint8 value);

    uint16 getRandomNumber();

    void adlib_channelOn(uint8 portIndex, uint8 vol);

    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:
    void playSound(int offset);

    int command0();

    /*
     * Fade out all channels (calls command2 + command4 via
     * the command3/command5 helpers that enable pending-stop on each channel).
     */
    int command1();

    int command2();

    int command3();

    int command4();

    /*
     * Stop SFX channels (6-8) with pending-stop flag.
     *
     * Marks each of the three SFX channels (6, 7, 8) as pending-stop by setting
     * their _pendingStop field to 0xFF and redirecting their sound-data pointer
     * to the null/silence stream.  Channels that are already inactive
     * (_activeCount == 0) are skipped.
     *
     * Unlike command4 (which forces an immediate fade-out via AdlibChannel_setPtr2),
     * this command lets each channel finish its current envelope naturally:
     * asound_processChannelFade checks _pendingStop each frame and only silences
     * the channel once both _velocity and _volume have reached zero.
     */
    int command5();

    int command6();

    int command7();

    int command8();

    virtual void callFunction(uint16 offset);

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 setVolume(int volume) override {
        // TODO: Does this need implementation?
    }
};

} // namespace Phantom
} // namespace MADS

#endif