opl_class.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 NUVIE_SOUND_ADPLUG_OPL_CLASS_H
#define NUVIE_SOUND_ADPLUG_OPL_CLASS_H

#include "ultima/nuvie/sound/adplug/opl.h"

namespace Ultima {
namespace Nuvie {

#define HAS_YM3812  1
#define HAS_YM3526  0
#define HAS_Y8950   0

/* --- select emulation chips --- */
#define BUILD_YM3812 (HAS_YM3812)
#define BUILD_YM3526 (HAS_YM3526)
#define BUILD_Y8950  (HAS_Y8950)

/* select output bits size of output : 8 or 16 */
#define OPL_SAMPLE_BITS 16

#if (OPL_SAMPLE_BITS==16)
typedef int16 OPLSAMPLE;
#endif
#if (OPL_SAMPLE_BITS==8)
typedef int8 OPLSAMPLE;
#endif


typedef void (*OPL_TIMERHANDLER)(int channel, double interval_Sec);
typedef void (*OPL_IRQHANDLER)(int param, int irq);
typedef void (*OPL_UPDATEHANDLER)(int param, int min_interval_us);
typedef void (*OPL_PORTHANDLER_W)(int param, unsigned char data);
typedef unsigned char (*OPL_PORTHANDLER_R)(int param);

/* Saving is necessary for member of the 'R' mark for suspend/resume */

typedef struct {
    uint32  ar;         /* attack rate: AR<<2           */
    uint32  dr;         /* decay rate:  DR<<2           */
    uint32  rr;         /* release rate:RR<<2           */
    uint8   KSR;        /* key scale rate               */
    uint8   ksl;        /* keyscale level               */
    uint8   ksr;        /* key scale rate: kcode>>KSR   */
    uint8   mul;        /* multiple: mul_tab[ML]        */

    /* Phase Generator */
    uint32  Cnt;        /* frequency counter            */
    uint32  Incr;       /* frequency counter step       */
    uint8   FB;         /* feedback shift value         */
    signed int *connect1;  /* slot1 output pointer         */
    int32   op1_out[2]; /* slot1 output for feedback    */
    uint8   CON;        /* connection (algorithm) type  */

    /* Envelope Generator */
    uint8   eg_type;    /* percussive/non-percussive mode */
    uint8   state;      /* phase type                   */
    uint32  TL;         /* total level: TL << 2         */
    int32   TLL;        /* adjusted now TL              */
    int32   volume;     /* envelope counter             */
    uint32  sl;         /* sustain level: sl_tab[SL]    */

    uint8   eg_sh_ar;   /* (attack state)               */
    uint8   eg_sel_ar;  /* (attack state)               */
    uint8   eg_sh_dr;   /* (decay state)                */
    uint8   eg_sel_dr;  /* (decay state)                */
    uint8   eg_sh_rr;   /* (release state)              */
    uint8   eg_sel_rr;  /* (release state)              */

    uint32  key;        /* 0 = KEY OFF, >0 = KEY ON     */

    /* LFO */
    uint32  AMmask;     /* LFO Amplitude Modulation enable mask */
    uint8   vib;        /* LFO Phase Modulation enable flag (active high)*/

    /* waveform select */
    unsigned int wavetable;
} OPL_SLOT;

typedef struct {
    OPL_SLOT SLOT[2];
    /* phase generator state */
    uint32  block_fnum; /* block+fnum                   */
    uint32  fc;         /* Freq. Increment base         */
    uint32  ksl_base;   /* KeyScaleLevel Base step      */
    uint8   kcode;      /* key code (for key scaling)   */
} OPL_CH;

/* OPL state */
typedef struct fm_opl_f {
    /* FM channel slots */
    OPL_CH  P_CH[9];                /* OPL/OPL2 chips have 9 channels*/

    uint32  eg_cnt;                 /* global envelope generator counter    */
    uint32  eg_timer;               /* global envelope generator counter works at frequency = chipclock/72 */
    uint32  eg_timer_add;           /* step of eg_timer                     */
    uint32  eg_timer_overflow;      /* envelope generator timer overlfows every 1 sample (on real chip) */

    uint8   rhythm;                 /* Rhythm mode                  */

    uint32  fn_tab[1024];           /* fnumber->increment counter   */

    /* LFO */
    uint8   lfo_am_depth;
    uint8   lfo_pm_depth_range;
    uint32  lfo_am_cnt;
    uint32  lfo_am_inc;
    uint32  lfo_pm_cnt;
    uint32  lfo_pm_inc;

    uint32  noise_rng;              /* 23 bit noise shift register  */
    uint32  noise_p;                /* current noise 'phase'        */
    uint32  noise_f;                /* current noise period         */

    uint8   wavesel;                /* waveform select enable flag  */

    int     T[2];                   /* timer counters               */
    uint8   st[2];                  /* timer enable                 */

    /* external event callback handlers */
    OPL_TIMERHANDLER  TimerHandler; /* TIMER handler                */
    int TimerParam;                 /* TIMER parameter              */
    OPL_IRQHANDLER    IRQHandler;   /* IRQ handler                  */
    int IRQParam;                   /* IRQ parameter                */
    OPL_UPDATEHANDLER UpdateHandler;/* stream update handler        */
    int UpdateParam;                /* stream update parameter      */

    uint8 type;                     /* chip type                    */
    uint8 address;                  /* address register             */
    uint8 status;                   /* status flag                  */
    uint8 statusmask;               /* status mask                  */
    uint8 mode;                     /* Reg.08 : CSM,notesel,etc.    */

    int clock;                      /* master clock  (Hz)           */
    int rate;                       /* sampling rate (Hz)           */
    double freqbase;                /* frequency base               */
    double TimerBase;               /* Timer base time (==sampling time)*/
} FM_OPL;

#define MAX_OPL_CHIPS 2

/* sinwave entries */
#define SIN_BITS        10
#define SIN_LEN         (1<<SIN_BITS)
#define SIN_MASK        (SIN_LEN-1)

#define TL_RES_LEN      (256)   /* 8 bits addressing (real chip) */

/*  TL_TAB_LEN is calculated as:
*   12 - sinus amplitude bits     (Y axis)
*   2  - sinus sign bit           (Y axis)
*   TL_RES_LEN - sinus resolution (X axis)
*/
#define TL_TAB_LEN (12*2*TL_RES_LEN)

class OplClass: public Copl {
private:

    FM_OPL *OPL_YM3812[MAX_OPL_CHIPS];  /* array of pointers to the YM3812's */
    int YM3812NumChips;                 /* number of chips */

    signed int tl_tab[TL_TAB_LEN];

    /* sin waveform table in 'decibel' scale */
    /* four waveforms on OPL2 type chips */
    unsigned int sin_tab[SIN_LEN * 4];

    /* lock level of common table */
    int num_lock;

    /* work table */
    void *cur_chip; /* current chip point */
    OPL_SLOT *SLOT7_1, *SLOT7_2, *SLOT8_1, *SLOT8_2;

    signed int phase_modulation;        /* phase modulation input (SLOT 2) */
    signed int output[1];

    uint32  LFO_AM;
    int32   LFO_PM;

    bool    use16bit, stereo;
    int oplRate;

public:
    OplClass(int rate, bool bit16, bool usestereo); // rate = sample rate
    ~OplClass() override {
        YM3812Shutdown();
    }

    int getRate() {
        return oplRate;
    }

    void update(short *buf, int samples);   // fill buffer

    // template methods
    void write(int reg, int val) override;
    void init() override;

private:
    int  YM3812Init(int num, int clock, int rate);
    void YM3812Shutdown(void);
    void YM3812ResetChip(int which);
    int  YM3812Write(int which, int a, int v);
    unsigned char YM3812Read(int which, int a);
    int  YM3812TimerOver(int which, int c);
    void YM3812UpdateOne(int which, int16 *buffer, int length);

    void YM3812SetTimerHandler(int which, OPL_TIMERHANDLER TimerHandler, int channelOffset);
    void YM3812SetIRQHandler(int which, OPL_IRQHANDLER IRQHandler, int param);
    void YM3812SetUpdateHandler(int which, OPL_UPDATEHANDLER UpdateHandler, int param);

    int init_tables(void);
    void OPLWriteReg(FM_OPL *OPL, int r, int v);
    void OPLResetChip(FM_OPL *OPL);
    int OPL_LockTable(void);
    FM_OPL *OPLCreate(int type, int clock, int rate);
    void OPL_UnLockTable(void);
    void OPLDestroy(FM_OPL *OPL);
    int OPLWrite(FM_OPL *OPL, int a, int v);

    inline void advance_lfo(FM_OPL *OPL);
    inline void advancex(FM_OPL *OPL);
    inline signed int op_calc(uint32 phase, unsigned int env, signed int pm, unsigned int wave_tab);
    inline signed int op_calc1(uint32 phase, unsigned int env, signed int pm, unsigned int wave_tab);
    inline void OPL_CALC_CH(OPL_CH *CH);
    inline void OPL_CALC_RH(OPL_CH *CH, unsigned int noise);
};

} // End of namespace Nuvie
} // End of namespace Ultima

#endif