psxspu.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/>.
 *
 */
/*
 * VGMTrans (c) 2002-2019
 * Licensed under the zlib license,
 * refer to the included VGMTrans_LICENSE.txt file
 */
#ifndef AUDIO_SOUNDFONT_PSXSPU_H
#define AUDIO_SOUNDFONT_PSXSPU_H

#include "audio/soundfont/common.h"
#include "common/str.h"
#include "common/util.h"
#include "audio/soundfont/vgminstrset.h"
#include "audio/soundfont/vgmsamp.h"
#include "audio/soundfont/vgmitem.h"

// All of the ADSR calculations herein (except where inaccurate) are derived from Neill Corlett's
// work in reverse-engineering the Playstation 1/2 SPU unit.

//**************************************************************************************************
// Type Redefinitions

typedef void v0;

#ifdef __cplusplus
#if defined __BORLANDC__
typedef bool b8;
#else
typedef unsigned char b8;
#endif
#else
typedef char b8;
#endif

typedef float f32;
//***********************************************************************************************

static unsigned long RateTable[160];
static bool bRateTableInitialized = 0;

// VAG format -----------------------------------

// Sample Block
typedef struct _VAGBlk {
    uint8 range;
    uint8 filter;

    struct {
        b8 end: 1;      // End block
        b8 looping: 1;  // VAG loops
        b8 loop: 1;     // Loop start point
    } flag;

    int8 brr[14];  // Compressed samples
} VAGBlk;

double LinAmpDecayTimeToLinDBDecayTime(double secondsToFullAtten, int linearVolumeRange);

// InitADSR is shamelessly ripped from P.E.Op.S
static inline void InitADSR() {
    unsigned long r, rs, rd;
    int i;

    // build the rate table according to Neill's rules
    memset(RateTable, 0, sizeof(unsigned long) * 160);

    r = 3;
    rs = 1;
    rd = 0;

    // we start at pos 32 with the real values... everything before is 0
    for (i = 32; i < 160; i++) {
        if (r < 0x3FFFFFFF) {
            r += rs;
            rd++;
            if (rd == 5) {
                rd = 1;
                rs *= 2;
            }
        }
        if (r > 0x3FFFFFFF)
            r = 0x3FFFFFFF;

        RateTable[i] = r;
    }
}

inline int RoundToZero(int val) {
    if (val < 0)
        val = 0;
    return val;
}

template<class T>
void PSXConvADSR(T *realADSR, unsigned short ADSR1, unsigned short ADSR2, bool bPS2) {
    uint8 Am = (ADSR1 & 0x8000) >> 15;  // if 1, then Exponential, else linear
    uint8 Ar = (ADSR1 & 0x7F00) >> 8;
    uint8 Dr = (ADSR1 & 0x00F0) >> 4;
    uint8 Sl = ADSR1 & 0x000F;
    uint8 Rm = (ADSR2 & 0x0020) >> 5;
    uint8 Rr = ADSR2 & 0x001F;

    // The following are unimplemented in conversion (because DLS and SF2 do not support Sustain
    // Rate)
    uint8 Sm = (ADSR2 & 0x8000) >> 15;
    uint8 Sd = (ADSR2 & 0x4000) >> 14;
    uint8 Sr = (ADSR2 >> 6) & 0x7F;

    PSXConvADSR(realADSR, Am, Ar, Dr, Sl, Sm, Sd, Sr, Rm, Rr, bPS2);
}

template<class T>
void PSXConvADSR(T *realADSR, uint8 Am, uint8 Ar, uint8 Dr, uint8 Sl, uint8 Sm,
                 uint8 Sd, uint8 Sr, uint8 Rm, uint8 Rr, bool bPS2) {
    // Make sure all the ADSR values are within the valid ranges
    if (((Am & ~0x01) != 0) || ((Ar & ~0x7F) != 0) || ((Dr & ~0x0F) != 0) || ((Sl & ~0x0F) != 0) ||
        ((Rm & ~0x01) != 0) || ((Rr & ~0x1F) != 0) || ((Sm & ~0x01) != 0) || ((Sd & ~0x01) != 0) ||
        ((Sr & ~0x7F) != 0)) {
        error("ADSR parameter(s) out of range");
    }

    // PS1 games use 44k, PS2 uses 48k
    double sampleRate = bPS2 ? 48000 : 44100;

    long envelope_level;
    double samples = 0.0;
    unsigned long rate;
    unsigned long remainder;
    double timeInSecs;
    int l;

    if (!bRateTableInitialized) {
        InitADSR();
        bRateTableInitialized = true;
    }

    // to get the dls 32 bit time cents, take log base 2 of number of seconds * 1200 * 65536
    // (dls1v11a.pdf p25).

    //  if (RateTable[(Ar^0x7F)-0x10 + 32] == 0)
    //      realADSR->attack_time = 0;
    //  else
    //  {
    if ((Ar ^ 0x7F) < 0x10)
        Ar = 0;
    // if linear Ar Mode
    if (Am == 0) {
        rate = RateTable[RoundToZero((Ar ^ 0x7F) - 0x10) + 32];
        samples = ceil(0x7FFFFFFF / (double) rate);
    } else if (Am == 1) {
        rate = RateTable[RoundToZero((Ar ^ 0x7F) - 0x10) + 32];
        samples = (unsigned long)(0x60000000 / rate);
        remainder = 0x60000000 % rate;
        rate = RateTable[RoundToZero((Ar ^ 0x7F) - 0x18) + 32];
        samples += ceil(MAX<double>(0, 0x1FFFFFFF - (long) remainder) / (double) rate);
    }
    timeInSecs = samples / sampleRate;
    realADSR->_attack_time = timeInSecs;
    //  }

    // Decay Time

    envelope_level = 0x7FFFFFFF;

    bool bSustainLevFound = false;
    uint32 realSustainLevel = 0x7FFFFFFF;
    // DLS decay rate value is to -96db (silence) not the sustain level
    for (l = 0; envelope_level > 0; l++) {
        if (4 * (Dr ^ 0x1F) < 0x18)
            Dr = 0;
        switch ((envelope_level >> 28) & 0x7) {
        case 0:
            envelope_level -= RateTable[RoundToZero((4 * (Dr ^ 0x1F)) - 0x18 + 0) + 32];
            break;
        case 1:
            envelope_level -= RateTable[RoundToZero((4 * (Dr ^ 0x1F)) - 0x18 + 4) + 32];
            break;
        case 2:
            envelope_level -= RateTable[RoundToZero((4 * (Dr ^ 0x1F)) - 0x18 + 6) + 32];
            break;
        case 3:
            envelope_level -= RateTable[RoundToZero((4 * (Dr ^ 0x1F)) - 0x18 + 8) + 32];
            break;
        case 4:
            envelope_level -= RateTable[RoundToZero((4 * (Dr ^ 0x1F)) - 0x18 + 9) + 32];
            break;
        case 5:
            envelope_level -= RateTable[RoundToZero((4 * (Dr ^ 0x1F)) - 0x18 + 10) + 32];
            break;
        case 6:
            envelope_level -= RateTable[RoundToZero((4 * (Dr ^ 0x1F)) - 0x18 + 11) + 32];
            break;
        case 7:
            envelope_level -= RateTable[RoundToZero((4 * (Dr ^ 0x1F)) - 0x18 + 12) + 32];
            break;
        }
        if (!bSustainLevFound && ((envelope_level >> 27) & 0xF) <= Sl) {
            realSustainLevel = envelope_level;
            bSustainLevFound = true;
        }
    }
    samples = l;
    timeInSecs = samples / sampleRate;
    realADSR->_decay_time = timeInSecs;

    // Sustain Rate

    envelope_level = 0x7FFFFFFF;
    // increasing... we won't even bother
    if (Sd == 0) {
        realADSR->_sustain_time = -1;
    } else {
        if (Sr == 0x7F)
            realADSR->_sustain_time = -1;  // this is actually infinite
        else {
            // linear
            if (Sm == 0) {
                rate = RateTable[RoundToZero((Sr ^ 0x7F) - 0x0F) + 32];
                samples = ceil(0x7FFFFFFF / (double) rate);
            } else {
                l = 0;
                // DLS decay rate value is to -96db (silence) not the sustain level
                while (envelope_level > 0) {
                    long envelope_level_diff;
                    long envelope_level_target;

                    switch ((envelope_level >> 28) & 0x7) {
                    case 0:
                    default:
                        envelope_level_target = 0x00000000;
                        envelope_level_diff =
                                RateTable[RoundToZero((Sr ^ 0x7F) - 0x1B + 0) + 32];
                        break;
                    case 1:
                        envelope_level_target = 0x0fffffff;
                        envelope_level_diff =
                                RateTable[RoundToZero((Sr ^ 0x7F) - 0x1B + 4) + 32];
                        break;
                    case 2:
                        envelope_level_target = 0x1fffffff;
                        envelope_level_diff =
                                RateTable[RoundToZero((Sr ^ 0x7F) - 0x1B + 6) + 32];
                        break;
                    case 3:
                        envelope_level_target = 0x2fffffff;
                        envelope_level_diff =
                                RateTable[RoundToZero((Sr ^ 0x7F) - 0x1B + 8) + 32];
                        break;
                    case 4:
                        envelope_level_target = 0x3fffffff;
                        envelope_level_diff =
                                RateTable[RoundToZero((Sr ^ 0x7F) - 0x1B + 9) + 32];
                        break;
                    case 5:
                        envelope_level_target = 0x4fffffff;
                        envelope_level_diff =
                                RateTable[RoundToZero((Sr ^ 0x7F) - 0x1B + 10) + 32];
                        break;
                    case 6:
                        envelope_level_target = 0x5fffffff;
                        envelope_level_diff =
                                RateTable[RoundToZero((Sr ^ 0x7F) - 0x1B + 11) + 32];
                        break;
                    case 7:
                        envelope_level_target = 0x6fffffff;
                        envelope_level_diff =
                                RateTable[RoundToZero((Sr ^ 0x7F) - 0x1B + 12) + 32];
                        break;
                    }

                    long steps =
                            (envelope_level - envelope_level_target + (envelope_level_diff - 1)) /
                            envelope_level_diff;
                    envelope_level -= (envelope_level_diff * steps);
                    l += steps;
                }
                samples = l;
            }
            timeInSecs = samples / sampleRate;
            realADSR->_sustain_time =
                    /*Sm ? timeInSecs : */ LinAmpDecayTimeToLinDBDecayTime(timeInSecs, 0x800);
        }
    }

    // Sustain Level
    // realADSR->sustain_level =
    // (double)envelope_level/(double)0x7FFFFFFF;//(long)ceil((double)envelope_level *
    // 0.030517578139210854);   //in DLS, sustain level is measured as a percentage
    if (Sl == 0)
        realSustainLevel = 0x07FFFFFF;
    realADSR->_sustain_level = realSustainLevel / (double) 0x7FFFFFFF;

    // If decay is going unused, and there's a sustain rate with sustain level close to max...
    //  we'll put the sustain_rate in place of the decay rate.
    if ((realADSR->_decay_time < 2 || (Dr == 0x0F && Sl >= 0x0C)) && Sr < 0x7E && Sd == 1) {
        realADSR->_sustain_level = 0;
        realADSR->_decay_time = realADSR->_sustain_time;
        // realADSR->decay_time = 0.5;
    }

    // Release Time

    // sustain_envelope_level = envelope_level;

    // We do this because we measure release time from max volume to 0, not from sustain level to 0
    envelope_level = 0x7FFFFFFF;

    // if linear Rr Mode
    if (Rm == 0) {
        rate = RateTable[RoundToZero((4 * (Rr ^ 0x1F)) - 0x0C) + 32];

        if (rate != 0)
            samples = ceil((double) envelope_level / (double) rate);
        else
            samples = 0;
    } else if (Rm == 1) {
        if ((Rr ^ 0x1F) * 4 < 0x18)
            Rr = 0;
        for (l = 0; envelope_level > 0; l++) {
            switch ((envelope_level >> 28) & 0x7) {
            case 0:
                envelope_level -= RateTable[RoundToZero((4 * (Rr ^ 0x1F)) - 0x18 + 0) + 32];
                break;
            case 1:
                envelope_level -= RateTable[RoundToZero((4 * (Rr ^ 0x1F)) - 0x18 + 4) + 32];
                break;
            case 2:
                envelope_level -= RateTable[RoundToZero((4 * (Rr ^ 0x1F)) - 0x18 + 6) + 32];
                break;
            case 3:
                envelope_level -= RateTable[RoundToZero((4 * (Rr ^ 0x1F)) - 0x18 + 8) + 32];
                break;
            case 4:
                envelope_level -= RateTable[RoundToZero((4 * (Rr ^ 0x1F)) - 0x18 + 9) + 32];
                break;
            case 5:
                envelope_level -= RateTable[RoundToZero((4 * (Rr ^ 0x1F)) - 0x18 + 10) + 32];
                break;
            case 6:
                envelope_level -= RateTable[RoundToZero((4 * (Rr ^ 0x1F)) - 0x18 + 11) + 32];
                break;
            case 7:
                envelope_level -= RateTable[RoundToZero((4 * (Rr ^ 0x1F)) - 0x18 + 12) + 32];
                break;
            }
        }
        samples = l;
    }
    timeInSecs = samples / sampleRate;

    // theRate = timeInSecs / sustain_envelope_level;
    // timeInSecs = 0x7FFFFFFF * theRate;   //the release time value is more like a rate.  It is the
    // time from max value to 0, not from sustain level. if (Rm == 0) // if it's linear     timeInSecs *=
    //LINEAR_RELEASE_COMPENSATION;

    realADSR->_release_time =
            /*Rm ? timeInSecs : */ LinAmpDecayTimeToLinDBDecayTime(timeInSecs, 0x800);

    // We need to compensate the decay and release times to represent them as the time from full vol
    // to -100db where the drop in db is a fixed amount per time unit (SoundFont2 spec for vol
    // envelopes, pg44.)
    //  We assume the psx envelope is using a linear scale wherein envelope_level / 2 == half
    //  loudness. For a linear release mode (Rm == 0), the time to reach half volume is simply half
    //  the time to reach 0.
    // Half perceived loudness is -10db. Therefore, time_to_half_vol * 10 == full_time * 5 == the
    // correct SF2 time
    // realADSR->decay_time = LinAmpDecayTimeToLinDBDecayTime(realADSR->decay_time, 0x800);
    // realADSR->sustain_time = LinAmpDecayTimeToLinDBDecayTime(realADSR->sustain_time, 0x800);
    // realADSR->release_time = LinAmpDecayTimeToLinDBDecayTime(realADSR->release_time, 0x800);

    // Calculations are done, so now add the articulation data
    // artic->AddADSR(attack_time, Am, decay_time, sustain_lev, release_time, 0);
}

class PSXSampColl : public VGMSampColl {
public:
    PSXSampColl(VGMInstrSet *instrset, uint32 offset, uint32 length,
                const Common::Array<SizeOffsetPair> &vagLocations);

    virtual bool
    GetSampleInfo();  // retrieve sample info, including pointers to data, # channels, rate, etc.

protected:
    Common::Array<SizeOffsetPair> _vagLocations;
};

class PSXSamp : public VGMSamp {
public:
    PSXSamp(VGMSampColl *sampColl, uint32 offset, uint32 length, uint32 dataOffset,
            uint32 dataLen, uint8 nChannels, uint16 theBPS, uint32 theRate,
            Common::String name, bool bSetLoopOnConversion = true);

    ~PSXSamp() override {}

    // ratio of space conserved.  should generally be > 1
    // used to calculate both uncompressed sample size and loopOff after conversion
    double GetCompressionRatio() override;

    void ConvertToStdWave(uint8 *buf) override;

private:
    void DecompVAGBlk(int16 *pSmp, VAGBlk *pVBlk, f32 *prev1, f32 *prev2);

public:

    bool _setLoopOnConversion;
};

#endif // AUDIO_SOUNDFONT_PSXSPU_H