kode54
/
cog
2
1
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity
cog/Frameworks/GME/gme/s_opl.c

1245 lines
32 KiB
C
Raw Blame History

/*
s_opl.c -- YM2413/Y8950/YM3526/YM3812 emulator by Mamiya, 2001.
References:
fmopl.c -- 1999,2000 written by Tatsuyuki Satoh (MAME development).
fmopl.c(fixed) -- 2000 modified by mamiya (NEZplug development).
fmgen.cpp -- 1999-2001 written by cisc.
emu2413.c -- a YM2413 emulator : written by Mitsutaka Okazaki 2001
fmpac.ill -- 2000 created by sama.
fmpac.ill -- 2000 created by NARUTO.
fmpac.ill -- 2001 created by Okazaki.
YM2413 application manual
*/
#include "kmsnddev.h"
#include "divfix.h"
#include "s_logtbl.h"
#include "s_opltbl.h"
#include "s_opl.h"
#include "s_deltat.h"
#include <string.h>
#define PG_SHIFT 10 /* fix */
#define CPS_SHIFTE 20
#define CPS_SHIFTP 14
#define LFO_SHIFT 16
#define OPLL_INST_WORK 0x40
#define OPLL_INST_WORK2 (OPLL_INST_WORK + 8 * 0x13)
#define AR_BITS 6 /* fix */
#define AR_SHIFT 14 /* fix */
#define EG_SHIFT 15 /* fix */
#define AR_PHASEMAX (((1 << AR_BITS) - 1) << AR_SHIFT)
#define EG_PHASEMAX (127 << EG_SHIFT)
#define EG_KEYOFF (128 << EG_SHIFT)
#define LOG_KEYOFF (31 << (LOG_BITS + 1))
#if 0
0-48dB
AR_BITS=6
AR_SHIFT=14
x = FC000h(20.7618(sec) * 3579545 / 72)cycles 63 * 4000h
x / 3 * 4 1730.15(ms)
x / 3 * 256 27.03(ms)
EG_BITS=7
EG_SHIFT=15
x = 3F8000h(83.7064(sec) * 3579545 / 72)cycles 127 * 8000h
x / 4 = 20926.6(ms)
#endif
#define TESTING_OPTIMIZE_AME 1
#define USE_FBBUF 1
typedef struct
{
Uint32 phase;
Uint32 spd;
Uint32 rng;
} OPL_PG;
enum {
EG_MODE_ATTACK,
EG_MODE_DECAY,
EG_MODE_SUSTINE,
EG_MODE_RELEASE,
EG_MODE_NUM,
EG_MODE_SUSHOLD,
EG_MODE_OFF = EG_MODE_NUM
};
typedef struct
{
Uint32 phasear;
Uint32 phase;
Uint32 spd [EG_MODE_NUM];
Uint32 dr_phasemax;
Uint8 mode;
Uint8 pad4_1;
Uint8 pad4_2;
Uint8 pad4_3;
} OPL_EG;
enum
{
FLAG_AME = (1 << 0),
FLAG_PME = (1 << 1),
FLAG_EGT = (1 << 2),
FLAG_KSR = (1 << 3)
};
typedef struct
{
OPL_PG pg;
OPL_EG eg;
Int32 input;
#if USE_FBBUF
Int32 fbbuf;
#endif
#if TESTING_OPTIMIZE_AME
Uint32* amin;
#endif
Uint32 tl_ofs;
Uint32* sintable;
Uint8 modcar; /* 1:m 0:c */
Uint8 fb;
Uint8 lvl;
Uint8 nst;
Uint8 tll;
Uint8 key;
Uint8 rkey;
Uint8 prevkey;
Uint8 enable;
Uint8 __enablehold__;
Uint8 flag;
Uint8 ksr;
Uint8 mul;
Uint8 ksl;
Uint8 ar;
Uint8 dr;
Uint8 sl;
Uint8 rr;
Uint8 tl;
Uint8 wf;
} OPL_OP;
typedef struct
{
OPL_OP op [2];
Uint8 con;
Uint8 freql;
Uint8 freqh;
Uint8 blk;
Uint8 kcode;
Uint8 sus;
Uint8 ksb;
Uint8 pad4_3;
} OPL_CH;
enum
{
LFO_UNIT_AM,
LFO_UNIT_PM,
LFO_UNIT_NUM
};
typedef struct
{
Uint32 output;
Uint32 cnt;
Uint32 sps; /* step per sample */
Uint32 adr;
Uint32 adrmask;
Uint32* table;
} OPL_LFO;
typedef struct
{
KMIF_SOUND_DEVICE kmif;
KMIF_SOUND_DEVICE* deltatpcm;
KMIF_LOGTABLE* logtbl;
KMIF_OPLTABLE* opltbl;
OPL_CH ch [9];
OPL_LFO lfo [LFO_UNIT_NUM];
struct OPLSOUND_COMMON_TAG
{
Uint32 cpsp;
Uint32 cnt;
Uint32* ar_table;
Uint32* tll2logtbl;
#if TESTING_OPTIMIZE_AME
Uint32 amzero;
#endif
Int32 mastervolume;
Uint32 sintablemask;
Uint32 ratetbla [4];
Uint32 ratetbl [4];
Uint8 adr;
Uint8 wfe;
Uint8 rc;
Uint8 rmode;
Uint8 enable;
} common;
Uint8 regs [0x100];
Uint8 opl_type;
} OPLSOUND;
static Uint8 romtone [3] [16 * 19] =
{
{
#include "i_fmpac.h"
},
{
#include "i_fmunit.h"
},
{
#include "i_vrc7.h"
},
};
static void SetOpOff(OPL_OP* opp )
{
opp->eg.mode = EG_MODE_OFF;
opp->eg.phase = EG_KEYOFF;
opp->enable = 0;
}
inline static void EgStep( OPLSOUND* sndp, OPL_OP* opp )
{
switch ( opp->eg.mode )
{
default:
NEVER_REACH
case EG_MODE_ATTACK:
opp->eg.phase = sndp->common.ar_table [opp->eg.phasear >> (AR_SHIFT + AR_BITS - ARTBL_BITS)] >> (ARTBL_SHIFT - EG_SHIFT);
opp->eg.phasear += opp->eg.spd [EG_MODE_ATTACK];
if ( opp->eg.phasear >= AR_PHASEMAX )
{
opp->eg.mode = EG_MODE_DECAY;
opp->eg.phase = 0;
}
break;
case EG_MODE_DECAY:
opp->eg.phase += opp->eg.spd [EG_MODE_DECAY];
if ( opp->eg.phase >= opp->eg.dr_phasemax )
{
opp->eg.phase = opp->eg.dr_phasemax;
opp->eg.mode = (opp->flag & FLAG_EGT) ? EG_MODE_SUSHOLD : EG_MODE_SUSTINE;
}
break;
case EG_MODE_SUSTINE:
case EG_MODE_RELEASE:
opp->eg.phase += opp->eg.spd [opp->eg.mode];
if ( opp->eg.phase >= EG_PHASEMAX )
SetOpOff(opp);
break;
case EG_MODE_SUSHOLD:
case EG_MODE_OFF:
break;
}
}
static void OpStep( OPLSOUND* sndp, OPL_OP* opp )
{
int step;
EgStep(sndp, opp);
step = opp->pg.spd;
if ( opp->flag & FLAG_PME )
step = (step * sndp->lfo [LFO_UNIT_PM].output) >> PM_SHIFT;
opp->pg.phase += step;
}
__inline static void OpStepNG( OPLSOUND* sndp, OPL_OP* opp )
{
Uint32 step;
EgStep(sndp, opp);
opp->pg.phase += opp->pg.spd;
step = opp->pg.phase >> opp->nst/*(PG_SHIFT + 5)*/;
opp->pg.phase &= (1 << opp->nst/*(PG_SHIFT + 5)*/) - 1;
while ( step-- )
{
opp->pg.rng ^= ((opp->pg.rng & 1) << 16) + ((opp->pg.rng & 1) << 13);
opp->pg.rng >>= 1;
}
}
#if -1 >> 1 == -1
/* RIGHT SHIFT IS SIGNED */
#define SSR(x, y) ((Int32)(x) >> (y))
#else
/* RIGHT SHIFT IS UNSIGNED */
#define SSR(x, y) (((x) >= 0) ? ((x) >> (y)) : (-((-(x) - 1) >> (y)) - 1))
#endif
inline static void OpSynthMod( OPLSOUND* sndp, OPL_OP* opp )
{
if ( opp->enable )
{
Uint32 tll;
Int32 output;
OpStep(sndp, opp);
tll = opp->tll + (opp->eg.phase >> EG_SHIFT);
tll = (tll >= (1 << TLLTBL_BITS)) ? LOG_KEYOFF : sndp->common.tll2logtbl [tll];
tll += opp->tl_ofs;
#if TESTING_OPTIMIZE_AME
tll += *opp->amin;
#else
if ( opp->flag & FLAG_AME )
tll += sndp->lfo [LFO_UNIT_AM].output;
#endif
tll += opp->sintable [sndp->common.sintablemask & (opp->input + (opp->pg.phase >> PG_SHIFT))];
output = LogToLin(sndp->logtbl, tll, -8 + ((LOG_LIN_BITS + 1) - (SINTBL_BITS + 2)));
if ( opp->fb )
{
#if USE_FBBUF
Int32 fbtmp;
fbtmp = opp->fbbuf + output;
opp->fbbuf = output;
opp->input = SSR(fbtmp, (9 - opp->fb));
#else
opp->input = SSR(output, (8 - opp->fb));
#endif
}
opp [1].input = output;
}
}
inline static Int32 OpSynthCarFb( OPLSOUND* sndp, OPL_OP* opp )
{
if ( opp->enable )
{
Uint32 tll;
OpStep(sndp, opp);
tll = opp->tll + (opp->eg.phase >> EG_SHIFT);
tll = (tll >= (1 << TLLTBL_BITS)) ? LOG_KEYOFF : sndp->common.tll2logtbl [tll];
tll += opp->tl_ofs;
#if TESTING_OPTIMIZE_AME
tll +=* opp->amin;
#else
if ( opp->flag & FLAG_AME) tll += sndp->lfo [LFO_UNIT_AM].output;
#endif
tll += opp->sintable [sndp->common.sintablemask & (opp->input + (opp->pg.phase >> PG_SHIFT))];
if ( opp->fb )
{
#if USE_FBBUF
Int32 output, fbtmp;
output = LogToLin(sndp->logtbl, tll, -8 + ((LOG_LIN_BITS + 1) - (SINTBL_BITS + 2)));
fbtmp = opp->fbbuf + output;
opp->fbbuf = output;
opp->input = SSR(fbtmp, (9 - opp->fb));
#else
Int32 output;
output = LogToLin(sndp->logtbl, tll, -8 + ((LOG_LIN_BITS + 1) - (SINTBL_BITS + 2)));
opp->input = SSR(output, (8 - opp->fb));
#endif
}
return LogToLin(sndp->logtbl, tll + sndp->common.mastervolume, -8 + LOG_LIN_BITS - 19 - opp->lvl);
}
return 0;
}
inline static Int32 OpSynthCar( OPLSOUND* sndp, OPL_OP* opp )
{
if ( opp->enable )
{
Uint32 tll;
OpStep(sndp, opp);
tll = opp->tll + (opp->eg.phase >> EG_SHIFT);
tll = (tll >= (1 << TLLTBL_BITS)) ? LOG_KEYOFF : sndp->common.tll2logtbl [tll];
tll += opp->tl_ofs;
#if TESTING_OPTIMIZE_AME
tll += *opp->amin;
#else
if ( opp->flag & FLAG_AME )
tll += sndp->lfo [LFO_UNIT_AM].output;
#endif
tll += opp->sintable [sndp->common.sintablemask & (opp->input + (opp->pg.phase >> PG_SHIFT))];
return LogToLin(sndp->logtbl, tll + sndp->common.mastervolume, -8 + LOG_LIN_BITS - 19 - opp->lvl);
}
return 0;
}
inline static Int32 OpSynthTom( OPLSOUND* sndp, OPL_OP* opp )
{
if ( opp->enable )
{
Uint32 tll;
OpStep(sndp, opp);
tll = opp->tll + (opp->eg.phase >> EG_SHIFT);
tll = (tll >= 128 - 16) ? LOG_KEYOFF : sndp->common.tll2logtbl [tll];
tll += opp->tl_ofs;
tll += opp->sintable [sndp->common.sintablemask & (opp->pg.phase >> PG_SHIFT)];
return LogToLin(sndp->logtbl, tll + sndp->common.mastervolume, -8 + LOG_LIN_BITS - 19 - opp->lvl);
}
return 0;
}
static Int32 OpSynthRym( OPLSOUND* sndp, OPL_OP* opp )
{
if ( opp->enable )
{
Uint32 tll;
OpStepNG(sndp, opp);
tll = opp->tll + (opp->eg.phase >> EG_SHIFT) + 0x10/* +6dB */;
tll = (tll >= (1 << TLLTBL_BITS)) ? LOG_KEYOFF : sndp->common.tll2logtbl [tll];
tll += opp->tl_ofs;
tll += (opp->pg.rng & 1);
return LogToLin(sndp->logtbl, tll + sndp->common.mastervolume, -8 + LOG_LIN_BITS - 19 - opp->lvl);
}
return 0;
}
inline static void LfoStep(OPL_LFO* lfop )
{
lfop->cnt += lfop->sps;
lfop->adr += lfop->cnt >> LFO_SHIFT;
lfop->cnt &= (1 << LFO_SHIFT) - 1;
lfop->output = lfop->table [lfop->adr & lfop->adrmask];
}
static int sndsynth( OPLSOUND* sndp )
{
Int32 accum = 0;
if ( sndp->common.enable )
{
Uint32 i, rch;
for ( i = 0; i < LFO_UNIT_NUM; i++ )
LfoStep(&sndp->lfo [i]);
rch = sndp->common.rmode ? 7 : 9;
for ( i = 0; i < rch; i++ )
{
if ( sndp->ch [i].op [0].modcar )
OpSynthMod(sndp, &sndp->ch [i].op [0]);
else
accum += OpSynthCarFb(sndp, &sndp->ch [i].op [0]);
accum += OpSynthCar(sndp, &sndp->ch [i].op [1]);
}
if ( sndp->common.rmode )
{
accum += OpSynthRym(sndp, &sndp->ch [7].op [0]);
accum += OpSynthRym(sndp, &sndp->ch [7].op [1]);
accum += OpSynthTom(sndp, &sndp->ch [8].op [0]);
accum += OpSynthRym(sndp, &sndp->ch [8].op [1]);
}
}
if ( sndp->deltatpcm )
{
accum += sndp->deltatpcm->synth(sndp->deltatpcm->ctx);
}
#if 0
/* NISE DAC */
if ( accum >= 0 )
accum = (Int32)(((Uint32) accum) & (((1 << 8) - 1) << (23 - 8)));
else
accum = -(Int32)(((Uint32)-accum) & (((1 << 8) - 1) << (23 - 8)));
#endif
return accum;
}
static void sndvolume( OPLSOUND* sndp, Int32 volume )
{
if ( sndp->deltatpcm) sndp->deltatpcm->volume(sndp->deltatpcm->ctx, volume);
volume = (volume << (LOG_BITS - 8)) << 1;
sndp->common.mastervolume = volume;
}
static Uint8 const op_table [0x20]=
{
0, 2, 4, 1, 3, 5,0xFF,0xFF,
6, 8, 10, 7, 9, 11,0xFF,0xFF,
12, 14, 16, 13, 15, 17,0xFF,0xFF,
0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,
};
static Uint8 const mul_table [0x10]=
{
1+0, 2+0, 4+0, 2+4, 8+0, 8+2, 8+4,16-2,
16+0,16+2,16+4,16+4,16+8,16+8,32-2,32-2,
};
#define DB2TLL(x) (x * 2 / 375 )
static Uint8 const ksl_table [8] [16]=
{
{
DB2TLL( 0), DB2TLL( 0), DB2TLL( 0), DB2TLL( 0),
DB2TLL( 0), DB2TLL( 0), DB2TLL( 0), DB2TLL( 0),
DB2TLL( 0), DB2TLL( 0), DB2TLL( 0), DB2TLL( 0),
DB2TLL( 0), DB2TLL( 0), DB2TLL( 0), DB2TLL( 0),
},{
DB2TLL( 0), DB2TLL( 0), DB2TLL( 0), DB2TLL( 0),
DB2TLL( 0), DB2TLL( 0), DB2TLL( 0), DB2TLL( 0),
DB2TLL( 0), DB2TLL( 750), DB2TLL( 1125), DB2TLL( 1500),
DB2TLL( 1875), DB2TLL( 2250), DB2TLL( 2625), DB2TLL( 3000),
},{
DB2TLL( 0), DB2TLL( 0), DB2TLL( 0), DB2TLL( 0),
DB2TLL( 0), DB2TLL( 1125), DB2TLL( 1875), DB2TLL( 2625),
DB2TLL( 3000), DB2TLL( 3750), DB2TLL( 4125), DB2TLL( 4500),
DB2TLL( 4875), DB2TLL( 5250), DB2TLL( 5625), DB2TLL( 6000),
},{
DB2TLL( 0), DB2TLL( 0), DB2TLL( 0), DB2TLL( 1875),
DB2TLL( 3000), DB2TLL( 4125), DB2TLL( 4875), DB2TLL( 5625),
DB2TLL( 6000), DB2TLL( 6750), DB2TLL( 7125), DB2TLL( 7500),
DB2TLL( 7875), DB2TLL( 8250), DB2TLL( 8625), DB2TLL( 9000),
},{
DB2TLL( 0), DB2TLL( 0), DB2TLL( 3000), DB2TLL( 4875),
DB2TLL( 6000), DB2TLL( 7125), DB2TLL( 7875), DB2TLL( 8625),
DB2TLL( 9000), DB2TLL( 9750), DB2TLL(10125), DB2TLL(10500),
DB2TLL(10875), DB2TLL(11250), DB2TLL(11625), DB2TLL(12000),
},{
DB2TLL( 0), DB2TLL( 3000), DB2TLL( 6000), DB2TLL( 7875),
DB2TLL( 9000), DB2TLL(10125), DB2TLL(10875), DB2TLL(11625),
DB2TLL(12000), DB2TLL(12750), DB2TLL(13125), DB2TLL(13500),
DB2TLL(13875), DB2TLL(14250), DB2TLL(14625), DB2TLL(15000),
},{
DB2TLL( 0), DB2TLL( 6000), DB2TLL( 9000), DB2TLL(10875),
DB2TLL(12000), DB2TLL(13125), DB2TLL(13875), DB2TLL(14625),
DB2TLL(15000), DB2TLL(15750), DB2TLL(16125), DB2TLL(16500),
DB2TLL(16875), DB2TLL(17250), DB2TLL(17625), DB2TLL(18000),
},{
DB2TLL( 0), DB2TLL( 9000), DB2TLL(12000), DB2TLL(13875),
DB2TLL(15000), DB2TLL(16125), DB2TLL(16875), DB2TLL(17625),
DB2TLL(18000), DB2TLL(18750), DB2TLL(19125), DB2TLL(19500),
DB2TLL(19875), DB2TLL(20250), DB2TLL(20625), DB2TLL(21000),
}
};
#undef DB2TLL
static Uint32 rateconvAR( OPLSOUND* sndp, Uint32 rrr, Uint32 ksr )
{
if ( !rrr )
return 0;
rrr = rrr + (ksr >> 2);
if ( rrr >= 15)
return AR_PHASEMAX;
return sndp->common.ratetbla [ksr & 3] >> (CPS_SHIFTE + 1 - rrr);
}
static Uint32 rateconv( OPLSOUND* sndp, Uint32 rrr, Uint32 ksr )
{
if ( !rrr )
return 0;
rrr = rrr + (ksr >> 2);
if ( rrr > 15 )
rrr = 15;
return sndp->common.ratetbl [ksr & 3] >> (CPS_SHIFTE + 1 - rrr);
}
static void OpUpdateWF( OPLSOUND* sndp, OPL_OP* opp )
{
opp->sintable = sndp->opltbl->sin_table [opp->wf & sndp->common.wfe];
}
static void OpUpdatePG( OPLSOUND* sndp, OPL_CH* chp, OPL_OP* opp )
{
opp->pg.spd = (((chp->freqh << 8) + chp->freql) * opp->mul * sndp->common.cpsp) >> (CPS_SHIFTP - chp->blk);
}
static void OpUpdateEG( OPLSOUND* sndp, OPL_CH* chp, OPL_OP* opp )
{
Uint32 sr, rr;
opp->ksr = chp->kcode >> ((opp->flag & FLAG_KSR) ? 0 : 2);
opp->eg.dr_phasemax = opp->sl << (1 + 2 + EG_SHIFT); /* 3dB->eg */
opp->eg.spd [EG_MODE_ATTACK] = rateconvAR(sndp, opp->ar, opp->ksr);
opp->eg.spd [EG_MODE_DECAY] = rateconv(sndp, opp->dr, opp->ksr);
if ( opp->flag & FLAG_EGT )
{
if ( opp->eg.mode == EG_MODE_SUSTINE )
opp->eg.mode = EG_MODE_SUSHOLD;
sr = 0;
rr = opp->rr;
}
else
{
if ( opp->eg.mode == EG_MODE_SUSHOLD )
opp->eg.mode = EG_MODE_SUSTINE;
sr = opp->rr;
rr = 7;
}
if ( chp->sus )
{
rr = 5;
}
opp->eg.spd [EG_MODE_SUSTINE] = rateconv(sndp, sr, opp->ksr);
opp->eg.spd [EG_MODE_RELEASE] = rateconv(sndp, rr, opp->ksr);
}
static void OpUpdateTLL( OPLSOUND* sndp, OPL_CH* chp, OPL_OP* opp )
{
opp->tll = (opp->tl + (chp->ksb >> opp->ksl)) << 1;
}
static void oplsetopmul( OPLSOUND* sndp, OPL_CH* chp, OPL_OP* opp, Uint32 v )
{
opp->flag &= ~(FLAG_AME | FLAG_PME | FLAG_EGT | FLAG_KSR);
#if TESTING_OPTIMIZE_AME
if ( v & 0x80 )
opp->amin = &sndp->lfo [LFO_UNIT_AM].output; else opp->amin = &sndp->common.amzero;
#else
if ( v & 0x80 )
opp->flag |= FLAG_AME;
#endif
if ( v & 0x40 ) opp->flag |= FLAG_PME;
if ( v & 0x20 ) opp->flag |= FLAG_EGT;
if ( v & 0x10 ) opp->flag |= FLAG_KSR;
opp->mul = mul_table [v & 0x0F];
OpUpdateEG(sndp, chp, opp);
OpUpdatePG(sndp, chp, opp);
}
static void oplsetopkstl( OPLSOUND* sndp, OPL_CH* chp, OPL_OP* opp, Uint32 v )
{
opp->ksl = (v >> 6) ? (3 - (v >> 6)) : 15; /* 0 / 1.5 / 3 / 6 db/OCT */
opp->tl = v & 0x3F; /* 0.75 db */
OpUpdateTLL(sndp, chp, opp);
}
static void oplsetopardr( OPLSOUND* sndp, OPL_CH* chp, OPL_OP* opp, Uint32 v )
{
opp->ar = v >> 4;
opp->dr = v & 0xF;
OpUpdateEG(sndp, chp, opp);
}
static void oplsetopslrr( OPLSOUND* sndp, OPL_CH* chp, OPL_OP* opp, Uint32 v )
{
opp->sl = v >> 4;
opp->rr = v & 0xF;
OpUpdateEG(sndp, chp, opp);
}
static void oplsetopwf( OPLSOUND* sndp, OPL_CH* chp, OPL_OP* opp, Uint32 v )
{
opp->wf = v & 0x3;
OpUpdateWF(sndp, opp);
}
static void oplsetopkey( OPLSOUND* sndp, OPL_OP* opp )
{
Uint8 nextkey = ((sndp->common.rmode) && opp->rkey) || opp->key;
if ( opp->prevkey ^ nextkey )
{
opp->prevkey = nextkey;
if ( nextkey )
{
sndp->common.enable = 1;
opp->eg.mode = EG_MODE_ATTACK;
opp->eg.phase = EG_KEYOFF;
opp->enable = 1;
opp->eg.phasear = 0;
}
else if ( !opp->modcar && opp->eg.mode != EG_MODE_OFF )
opp->eg.mode = EG_MODE_RELEASE;
}
}
static void oplsetchfreql( OPLSOUND* sndp, OPL_CH* chp, Uint32 v )
{
chp->freql = v & 0xFF;
chp->ksb = ksl_table [chp->blk] [(chp->freqh << 2) + (chp->freql >> 6)];
OpUpdatePG(sndp, chp, &chp->op [0]);
OpUpdatePG(sndp, chp, &chp->op [1]);
OpUpdateTLL(sndp, chp, &chp->op [0]);
OpUpdateTLL(sndp, chp, &chp->op [1]);
}
static void oplsetchfreqh( OPLSOUND* sndp, OPL_CH* chp, Uint32 v )
{
Uint32 key = v & 0x20;
chp->kcode = (v >> 1) & 15;
chp->freqh = v & 3;
chp->blk = (v >> 2) & 7;
chp->op [0].key = chp->op [1].key = key;
oplsetopkey(sndp, &chp->op [0]);
oplsetopkey(sndp, &chp->op [1]);
chp->sus = 0;
chp->ksb = ksl_table [chp->blk] [(chp->freqh << 2) + (chp->freql >> 6)];
OpUpdateEG(sndp, chp, &chp->op [0]);
OpUpdateEG(sndp, chp, &chp->op [1]);
OpUpdatePG(sndp, chp, &chp->op [0]);
OpUpdatePG(sndp, chp, &chp->op [1]);
OpUpdateTLL(sndp, chp, &chp->op [0]);
OpUpdateTLL(sndp, chp, &chp->op [1]);
}
static void oplsetchfbcon( OPLSOUND* sndp, OPL_CH* chp, Uint32 v )
{
chp->op [0].fb = (v >> 1) & 7;
#if USE_FBBUF
chp->op [0].fbbuf = 0;
#endif
chp->con = v & 1;
chp->op [0].modcar = (chp->con) ? 0 : 1;
OpUpdateEG(sndp, chp, &chp->op [0]);
chp->op [1].input = 0;
}
static void opllsetopvolume( OPLSOUND* sndp, OPL_CH* chp, OPL_OP* opp, Uint32 v )
{
opp->tl = v;
OpUpdateTLL(sndp, chp, opp);
}
static void opllsetchfreql( OPLSOUND* sndp, OPL_CH* chp, Uint32 v )
{
chp->freql = v & 0xFF;
chp->ksb = ksl_table [chp->blk] [(chp->freqh << 3) + (chp->freql >> 5)];
OpUpdatePG(sndp, chp, &chp->op [0]);
OpUpdatePG(sndp, chp, &chp->op [1]);
OpUpdateTLL(sndp, chp, &chp->op [0]);
OpUpdateTLL(sndp, chp, &chp->op [1]);
}
static void opllsetchfreqh( OPLSOUND* sndp, OPL_CH* chp, Uint32 v )
{
Uint32 key = v & 0x10;
chp->kcode = v & 15;
chp->freqh = v & 1;
chp->blk = (v >> 1) & 7;
chp->op [0].key = chp->op [1].key = key;
oplsetopkey(sndp, &chp->op [0]);
oplsetopkey(sndp, &chp->op [1]);
chp->sus = v & 0x20;
chp->ksb = ksl_table [chp->blk] [(chp->freqh << 3) + (chp->freql >> 5)];
OpUpdateEG(sndp, chp, &chp->op [0]);
OpUpdateEG(sndp, chp, &chp->op [1]);
OpUpdatePG(sndp, chp, &chp->op [0]);
OpUpdatePG(sndp, chp, &chp->op [1]);
OpUpdateTLL(sndp, chp, &chp->op [0]);
OpUpdateTLL(sndp, chp, &chp->op [1]);
}
static void SetOpTone( OPLSOUND* sndp, OPL_OP* opp, Uint8* tonep )
{
opp->flag &= ~(FLAG_AME | FLAG_PME | FLAG_EGT | FLAG_KSR);
#if TESTING_OPTIMIZE_AME
if ( tonep [0] & 0x80 ) opp->amin = &sndp->lfo [LFO_UNIT_AM].output; else opp->amin = &sndp->common.amzero;
#else
if ( tonep [0] & 0x80 ) opp->flag |= FLAG_AME;
#endif
if ( tonep [0] & 0x40 ) opp->flag |= FLAG_PME;
if ( tonep [0] & 0x20 ) opp->flag |= FLAG_EGT;
if ( tonep [0] & 0x10 ) opp->flag |= FLAG_KSR;
opp->mul = mul_table [tonep [0] & 0x0F] << 1;
opp->ksl = (tonep [2] >> 6) ? (3 - (tonep [2] >> 6)) : 15;
opp->ar = tonep [4] >> 4;
opp->dr = tonep [4] & 0xF;
opp->sl = tonep [6] >> 4;
opp->rr = tonep [6] & 0xF;
}
static void SetChTone( OPLSOUND* sndp, OPL_CH* chp, Uint8* tonep, Uint8* tlofsp )
{
Uint32 op;
for ( op = 0; op < 2; op++ )
SetOpTone(sndp, &chp->op [op], &tonep [op]);
chp->op [0].tl_ofs = (tlofsp [0] ^ 0x80) << (LOG_BITS - 4 + 1);
chp->op [1].tl_ofs = (tlofsp [1] ^ 0x80) << (LOG_BITS - 4 + 1);
chp->op [0].tl = tonep [2] & 0x3F;
chp->op [0].fb = tonep [3] & 0x7;
chp->op [0].wf = (tonep [3] >> 3) & 1;
chp->op [1].wf = (tonep [3] >> 4) & 1;
#if USE_FBBUF
chp->op [0].fbbuf = 0;
#endif
chp->op [1].input = 0;
OpUpdateWF(sndp, &chp->op [0]);
OpUpdateWF(sndp, &chp->op [1]);
OpUpdateEG(sndp, chp, &chp->op [0]);
OpUpdateEG(sndp, chp, &chp->op [1]);
OpUpdatePG(sndp, chp, &chp->op [0]);
OpUpdatePG(sndp, chp, &chp->op [1]);
OpUpdateTLL(sndp, chp, &chp->op [0]);
OpUpdateTLL(sndp, chp, &chp->op [1]);
}
static void opllsetchtone( OPLSOUND* sndp, OPL_CH* chp, Uint32 tone )
{
SetChTone(sndp, chp, &sndp->regs [OPLL_INST_WORK + (tone << 3)], &sndp->regs [OPLL_INST_WORK2 + (tone << 1) + 0]);
}
static void recovercon( OPLSOUND* sndp, OPL_CH* chp )
{
chp->op [0].modcar = (chp->con) ? 0 : 1;
chp->op [0].lvl = chp->con ? 1 : 0;
chp->op [1].lvl = 1;
OpUpdateEG(sndp, chp, &chp->op [0]);
chp->op [1].input = 0;
}
static void initrc_common( OPLSOUND* sndp, Uint32 rmode )
{
if ( rmode )
{
/* BD */
sndp->ch [6].op [0].modcar = 1;
sndp->ch [6].op [0].lvl = 0;
OpUpdateEG(sndp, &sndp->ch [6], &sndp->ch [6].op [0]);
sndp->ch [6].op [1].input = 0;
sndp->ch [6].op [1].lvl = 2;
/* CYM */
sndp->ch [7].op [0].modcar = 0;
sndp->ch [7].op [0].lvl = 1;
OpUpdateEG(sndp, &sndp->ch [7], &sndp->ch [7].op [0]);
/* SD */
sndp->ch [7].op [1].input = 0;
sndp->ch [7].op [1].lvl = 2;
/* TOM */
sndp->ch [8].op [0].modcar = 0;
sndp->ch [8].op [0].lvl = 2;
OpUpdateEG(sndp, &sndp->ch [8], &sndp->ch [8].op [0]);
/* HH */
sndp->ch [8].op [1].input = 0;
sndp->ch [8].op [1].lvl = 1;
}
else
{
recovercon(sndp, &sndp->ch [6]);
if ( !sndp->ch [6].op [0].key ) SetOpOff(&sndp->ch [6].op [0]);
if ( !sndp->ch [6].op [1].key ) SetOpOff(&sndp->ch [6].op [1]);
recovercon(sndp, &sndp->ch [7]);
if ( !sndp->ch [7].op [0].key ) SetOpOff(&sndp->ch [7].op [0]);
if ( !sndp->ch [7].op [1].key ) SetOpOff(&sndp->ch [7].op [1]);
recovercon(sndp, &sndp->ch [8]);
if ( !sndp->ch [8].op [0].key ) SetOpOff(&sndp->ch [8].op [0]);
if ( !sndp->ch [8].op [1].key ) SetOpOff(&sndp->ch [8].op [1]);
}
}
static void oplsetrc( OPLSOUND* sndp, Uint32 rc )
{
sndp->lfo [LFO_UNIT_AM].table = (rc & 0x80) ? sndp->opltbl->am_table1 : sndp->opltbl->am_table2;
sndp->lfo [LFO_UNIT_PM].table = (rc & 0x40) ? sndp->opltbl->pm_table1 : sndp->opltbl->pm_table2;
if ( (sndp->common.rmode ^ rc) & 0x20 )
{
if ( rc & 0x20 )
{
#if 0
static Uint8 volini [2] = { 0, 0 };
static Uint8 bdtone [8] = { 0x04, 0x20, 0x28, 0x00, 0xDF, 0xF8, 0xFF, 0xF8 };
SetChTone(sndp, &sndp->ch [6], bdtone, volini);
SetChTone(sndp, &sndp->ch [7], &romtone [0] [0x11 << 4], volini);
SetChTone(sndp, &sndp->ch [8], &romtone [0] [0x12 << 4], volini);
#endif
sndp->ch [7].op [0].nst = PG_SHIFT + 4;
sndp->ch [7].op [1].nst = PG_SHIFT + 6;
sndp->ch [8].op [1].nst = PG_SHIFT + 5;
}
initrc_common(sndp, rc & 0x20);
}
sndp->common.rmode = rc & 0x20;
sndp->common.rc = rc & 0x1F;
/* BD */
sndp->ch [6].op [0].rkey = sndp->ch [6].op [1].rkey = rc & 0x10;
oplsetopkey(sndp, &sndp->ch [6].op [0]);
oplsetopkey(sndp, &sndp->ch [6].op [1]);
/* CYM */
sndp->ch [7].op [0].rkey = rc & 0x01;
oplsetopkey(sndp, &sndp->ch [7].op [0]);
/* SD */
sndp->ch [7].op [1].rkey = rc & 0x08;
oplsetopkey(sndp, &sndp->ch [7].op [1]);
/* TOM */
sndp->ch [8].op [0].rkey = rc & 0x04;
oplsetopkey(sndp, &sndp->ch [8].op [0]);
/* HH */
sndp->ch [8].op [1].rkey = rc & 0x02;
oplsetopkey(sndp, &sndp->ch [8].op [1]);
}
static void opllsetrc( OPLSOUND* sndp, Uint32 rc )
{
if ( (sndp->common.rmode ^ rc) & 0x20 )
{
if ( rc & 0x20 )
{
opllsetchtone(sndp, &sndp->ch [6], 0x10);
opllsetchtone(sndp, &sndp->ch [7], 0x11);
opllsetchtone(sndp, &sndp->ch [8], 0x12);
opllsetopvolume(sndp, &sndp->ch [7], &sndp->ch [7].op [0], (sndp->regs [0x37] & 0xF0) >> 2);
opllsetopvolume(sndp, &sndp->ch [8], &sndp->ch [8].op [0], (sndp->regs [0x38] & 0xF0) >> 2);
sndp->ch [7].op [0].nst = PG_SHIFT + 5;
sndp->ch [7].op [1].nst = PG_SHIFT + 5;
sndp->ch [8].op [1].nst = PG_SHIFT + 5;
}
else
{
opllsetchtone(sndp, &sndp->ch [6], sndp->regs [0x36]>>4);
opllsetchtone(sndp, &sndp->ch [7], sndp->regs [0x37]>>4);
opllsetchtone(sndp, &sndp->ch [8], sndp->regs [0x38]>>4);
}
initrc_common(sndp, rc & 0x20);
}
sndp->common.rmode = rc & 0x20;
sndp->common.rc = rc & 0x1F;
/* BD */
sndp->ch [6].op [0].rkey = sndp->ch [6].op [1].rkey = rc & 0x10;
oplsetopkey(sndp, &sndp->ch [6].op [0]);
oplsetopkey(sndp, &sndp->ch [6].op [1]);
/* CYM */
sndp->ch [7].op [0].rkey = rc & 0x01;
oplsetopkey(sndp, &sndp->ch [7].op [0]);
/* SD */
sndp->ch [7].op [1].rkey = rc & 0x08;
oplsetopkey(sndp, &sndp->ch [7].op [1]);
/* TOM */
sndp->ch [8].op [0].rkey = rc & 0x04;
oplsetopkey(sndp, &sndp->ch [8].op [0]);
/* HH */
sndp->ch [8].op [1].rkey = rc & 0x02;
oplsetopkey(sndp, &sndp->ch [8].op [1]);
}
#define OPLSETOP(func) { \
Uint32 op = op_table [a & 0x1F]; \
if ( op != 0xFF) func(sndp, &sndp->ch [op >> 1], &sndp->ch [op >> 1].op [op & 1], v); \
}
__inline static void oplwritereg( OPLSOUND* sndp, Uint32 a, Uint32 v )
{
switch ( a >> 5 )
{
default:
NEVER_REACH
case 0:
switch ( a & 0x1F )
{
case 0x01:
if ( sndp->opl_type == OPL_TYPE_OPL2 )
{
Uint32 i;
sndp->common.wfe = (v & 0x20) ? 3 : 0;
for ( i = 0; i < 9; i++ )
{
OpUpdateWF(sndp, &sndp->ch [i].op [0]);
OpUpdateWF(sndp, &sndp->ch [i].op [1]);
}
}
break;
case 0x08:
/* CSM mode */
case 0x07: case 0x09: case 0x0A: case 0x0B: case 0x0C:
case 0x0D: case 0x0E: case 0x0F: case 0x10: case 0x11: case 0x12:
if ( sndp->deltatpcm )
sndp->deltatpcm->write(sndp->deltatpcm->ctx, a - 0x07, v);
break;
}
break;
case 1: OPLSETOP(oplsetopmul); break;
case 2: OPLSETOP(oplsetopkstl); break;
case 3: OPLSETOP(oplsetopardr); break;
case 4: OPLSETOP(oplsetopslrr); break;
case 7: OPLSETOP(oplsetopwf); break;
case 5:
if ( (a & 0x1F) == (0xBD & 0x1F) )
oplsetrc(sndp, v);
else if ( (a & 0x1F) < 9 )
oplsetchfreql(sndp, &sndp->ch [a & 0xF], v);
else if ( (a & 0xF) < 9 )
oplsetchfreqh(sndp, &sndp->ch [a & 0xF], v);
break;
case 6:
if ( (a & 0x1F) < 9) oplsetchfbcon(sndp, &sndp->ch [a & 0xF], v);
break;
}
}
static void oplwrite( OPLSOUND* sndp, Uint32 a, Uint32 v )
{
if ( a & 1 )
{
sndp->regs [sndp->common.adr] = v;
oplwritereg(sndp, sndp->common.adr, v);
}
else
sndp->common.adr = v;
}
static Uint32 oplread( OPLSOUND* sndp, Uint32 a )
{
if ( a & 1 )
return sndp->regs [sndp->common.adr];
else
return 0x80;
}
__inline static void opllwritereg( OPLSOUND* sndp, Uint32 a, Uint32 v )
{
switch ( a >> 3 )
{
default:
NEVER_REACH
case 0:
sndp->regs [OPLL_INST_WORK + (a & 7)] = v;
break;
case 1:
if ( a == 0xE) opllsetrc(sndp, v & 0x3F);
break;
case 2:
case 3:
a &= 0xF;
if ( a < 9) opllsetchfreql(sndp, &sndp->ch [a], v);
break;
case 4:
case 5:
a &= 0xF;
if ( a < 9) opllsetchfreqh(sndp, &sndp->ch [a], v);
break;
case 6:
case 7:
a &= 0xF;
if ( a < 9 )
{
if ( (sndp->common.rmode) && (a >= 6) )
{
if ( a != 6) opllsetopvolume(sndp, &sndp->ch [a], &sndp->ch [a].op [0], (v & 0xF0) >> 2);
}
else
{
opllsetchtone(sndp, &sndp->ch [a], (v & 0xF0) >> 4);
}
opllsetopvolume(sndp, &sndp->ch [a], &sndp->ch [a].op [1], (v & 0xF) << 2);
}
break;
}
}
static void opllwrite( OPLSOUND* sndp, Uint32 a, Uint32 v )
{
if ( a & 1 )
{
if ( sndp->common.adr < 0x40 )
{
sndp->regs [sndp->common.adr] = v;
opllwritereg(sndp, sndp->common.adr, v);
}
}
else
sndp->common.adr = v;
}
static Uint32 opllread( OPLSOUND* sndp, Uint32 a )
{
return 0xFF;
}
static void opreset( OPLSOUND* sndp, OPL_OP* opp )
{
/* XMEMSET(opp, 0, sizeof(OPL_OP)); */
SetOpOff(opp);
opp->tl_ofs = 0x80 << (LOG_BITS - 4 + 1);
#if TESTING_OPTIMIZE_AME
opp->amin = &sndp->common.amzero;
#endif
opp->pg.rng = 0xFFFF;
}
static void chreset( OPLSOUND* sndp, OPL_CH* chp, Uint32 clock, Uint32 freq )
{
Uint32 op;
XMEMSET(chp, 0, sizeof(OPL_CH));
for ( op = 0; op < 2; op++ )
{
opreset(sndp, &chp->op [op]);
}
recovercon(sndp, chp);
}
static void sndreset( OPLSOUND* sndp, Uint32 clock, Uint32 freq )
{
Uint32 i, cpse;
XMEMSET(&sndp->common, 0, sizeof(sndp->common));
XMEMSET(&sndp->lfo [LFO_UNIT_AM], 0, sizeof(OPL_LFO));
sndp->lfo [LFO_UNIT_AM].sps = DivFix(37 * (1 << AMTBL_BITS), freq * 10, LFO_SHIFT);
sndp->lfo [LFO_UNIT_AM].adrmask = (1 << AMTBL_BITS) - 1;
sndp->lfo [LFO_UNIT_AM].table = sndp->opltbl->am_table1;
XMEMSET(&sndp->lfo [LFO_UNIT_PM], 0, sizeof(OPL_LFO));
sndp->lfo [LFO_UNIT_PM].sps = DivFix(64 * (1 << PMTBL_BITS), freq * 10, LFO_SHIFT);
sndp->lfo [LFO_UNIT_PM].adrmask = (1 << PMTBL_BITS) - 1;
sndp->lfo [LFO_UNIT_PM].table = sndp->opltbl->pm_table1;
sndp->common.cpsp = DivFix(clock, 72 * freq, CPS_SHIFTP);
cpse = DivFix(clock, 72 * freq, CPS_SHIFTE);
for ( i = 0; i < 4; i++ )
{
sndp->common.ratetbl [i] = (i + 4) * cpse;
sndp->common.ratetbla [i] = 3 * sndp->common.ratetbl [i];
}
sndp->common.tll2logtbl = sndp->opltbl->tll2log_table;
sndp->common.sintablemask = (1 << SINTBL_BITS) - 1;
for ( i = 0; i < 9; i++ )
chreset(sndp, &sndp->ch [i], clock, freq);
if ( sndp->deltatpcm )
sndp->deltatpcm->reset(sndp->deltatpcm->ctx, clock, freq);
if ( sndp->opl_type & OPL_TYPE_OPL )
{
XMEMSET(&sndp->regs, 0, 0x100);
sndp->common.ar_table = sndp->opltbl->ar_tablepow;
sndp->common.sintablemask -= (1 << (SINTBL_BITS - 11)) - 1;
for ( i = 0x0; i < 0x100; i++ )
{
oplwrite(sndp, 0, i);
oplwrite(sndp, 1, 0x00);
}
for ( i = 0xA0; i < 0xA9; i++ )
{
oplwrite(sndp, 0, 0xA0 + i);
oplwrite(sndp, 1, 0x40);
oplwrite(sndp, 0, 0xB0 + i);
oplwrite(sndp, 1, 0x0E);
}
}
else
{
static Uint8 const fmbios_initdata [9] = "\x30\x10\x20\x20\xfb\xb2\xf3\xf3";
XMEMSET(&sndp->regs, 0, 0x40);
sndp->common.ar_table = sndp->opltbl->ar_tablelog;
sndp->common.wfe = 1;
sndp->common.sintablemask -= (1 << (SINTBL_BITS - 8)) - 1;
for ( i = 0; i < sizeof(fmbios_initdata)-1; i++ )
{
opllwrite(sndp, 0, i);
opllwrite(sndp, 1, fmbios_initdata [i]);
}
opllwrite(sndp, 0, 0x0E);
opllwrite(sndp, 1, 0x00);
opllwrite(sndp, 0, 0x0F);
opllwrite(sndp, 1, 0x00);
for ( i = 0; i < 9; i++ )
{
opllwrite(sndp, 0, 0x10 + i);
opllwrite(sndp, 1, 0x20);
opllwrite(sndp, 0, 0x20 + i);
opllwrite(sndp, 1, 0x07);
opllwrite(sndp, 0, 0x30 + i);
opllwrite(sndp, 1, 0xB3);
}
}
}
static void oplsetinst( OPLSOUND* sndp, Uint32 n, void* p, Uint32 l )
{
if ( sndp->deltatpcm) sndp->deltatpcm->setinst(sndp->deltatpcm->ctx, n, p, l);
}
__inline static Uint32 GetDwordLE(Uint8* p )
{
return p [0] | (p [1] << 8) | (p [2] << 16) | (p [3] << 24);
}
#define GetDwordLEM(p) (Uint32)((((Uint8* )p) [0] | (((Uint8* )p) [1] << 8) | (((Uint8* )p) [2] << 16) | (((Uint8* )p) [3] << 24)) )
static void opllsetinst( OPLSOUND* sndp, Uint32 n, Uint8* p, Uint32 l )
{
Int32 i, j, sb = 9;
if ( n )
return;
if ( (GetDwordLE(p) & 0xF0FFFFFF) == GetDwordLEM("ILL0") )
{
if ( 0 < p [4] && p [4] <= SINTBL_BITS) sb = p [4];
for ( j = 1; j < 16 + 3; j++ )
for ( i = 0; i < 8; i++ )
sndp->regs [OPLL_INST_WORK + (j << 3) + i] = p [(j << 4) + i];
for ( j = 0; j < 16 + 3; j++ )
{
sndp->regs [OPLL_INST_WORK2 + (j << 1) + 0] = p [(j << 4) + 8];
sndp->regs [OPLL_INST_WORK2 + (j << 1) + 1] = p [(j << 4) + 9];
}
}
else
{
for ( j = 1; j < 16; j++ )
for ( i = 0; i < 8; i++ )
sndp->regs [OPLL_INST_WORK + (j << 3) + i] = p [((j - 1) << 3) + i];
}
sndp->common.sintablemask = (1 << SINTBL_BITS) - 1;
sndp->common.sintablemask -= (1 << (SINTBL_BITS - sb)) - 1;
}
static void sndrelease( OPLSOUND* sndp )
{
if ( sndp->logtbl) sndp->logtbl->release(sndp->logtbl->ctx);
if ( sndp->opltbl) sndp->opltbl->release(sndp->opltbl->ctx);
if ( sndp->deltatpcm) sndp->deltatpcm->release(sndp->deltatpcm->ctx);
XFREE(sndp);
}
KMIF_SOUND_DEVICE* OPLSoundAlloc(Uint32 opl_type )
{
OPLSOUND* sndp;
sndp = (OPLSOUND*) XMALLOC(sizeof(OPLSOUND));
if ( !sndp) return 0;
sndp->opl_type = opl_type;
sndp->kmif.ctx = sndp;
sndp->kmif.release = (void (*)( void* )) sndrelease;
sndp->kmif.volume = (void (*)( void*, int )) sndvolume;
sndp->kmif.reset = (void (*)( void*, Uint32, Uint32 )) sndreset;
sndp->kmif.synth = (int (*)( void* )) sndsynth;
if ( sndp->opl_type == OPL_TYPE_MSXAUDIO )
{
sndp->deltatpcm = YMDELTATPCMSoundAlloc(YMDELTATPCM_TYPE_Y8950);
}
else
sndp->deltatpcm = 0;
if ( sndp->opl_type & OPL_TYPE_OPL )
{
sndp->kmif.write = (void (*)( void*, Uint32, Uint32 )) oplwrite;
sndp->kmif.read = (Uint32 (*)( void*, Uint32 )) oplread;
sndp->kmif.setinst = (void (*)( void*, Uint32, void*, Uint32 )) oplsetinst;
}
else
{
sndp->kmif.write = (void (*)( void*, Uint32, Uint32 )) opllwrite;
sndp->kmif.read = (Uint32 (*)( void*, Uint32 )) opllread;
sndp->kmif.setinst = (void (*)( void*, Uint32, void*, Uint32 )) opllsetinst;
switch ( sndp->opl_type )
{
case OPL_TYPE_OPLL:
case OPL_TYPE_MSXMUSIC:
opllsetinst(sndp, 0, romtone [0], 16 * 19);
break;
case OPL_TYPE_SMSFMUNIT:
opllsetinst(sndp, 0, romtone [1], 16 * 19);
break;
case OPL_TYPE_VRC7:
opllsetinst(sndp, 0, romtone [2], 16 * 19);
break;
}
}
sndp->logtbl = LogTableAddRef();
sndp->opltbl = OplTableAddRef();
if ( !sndp->logtbl || !sndp->opltbl )
{
sndrelease(sndp);
return 0;
}
return &sndp->kmif;
}
Reference in New Issue View Git Blame Copy Permalink