arcade: add ymfm-based core
less CPU usage at the cost of some quality
This commit is contained in:
tildearrow
parent
8de60fe2a6
commit
2879b5e4d0
|
|
@ -80,9 +80,10 @@ src/engine/platform/sound/c64/wave8580_PST.cc
|
|||
src/engine/platform/sound/c64/wave8580_P_T.cc
|
||||
src/engine/platform/sound/c64/wave8580__ST.cc
|
||||
|
||||
src/engine/platform/sound/ym2610/ymfm_adpcm.cpp
|
||||
src/engine/platform/sound/ym2610/ymfm_opn.cpp
|
||||
src/engine/platform/sound/ym2610/ymfm_ssg.cpp
|
||||
src/engine/platform/sound/ymfm/ymfm_adpcm.cpp
|
||||
src/engine/platform/sound/ymfm/ymfm_opm.cpp
|
||||
src/engine/platform/sound/ymfm/ymfm_opn.cpp
|
||||
src/engine/platform/sound/ymfm/ymfm_ssg.cpp
|
||||
|
||||
src/engine/platform/ym2610Interface.cpp
|
||||
|
||||
|
|
|
|||
|
|
@ -1236,6 +1236,7 @@ void DivEngine::initDispatch() {
|
|||
break;
|
||||
case DIV_SYSTEM_ARCADE:
|
||||
dispatch=new DivPlatformArcade;
|
||||
((DivPlatformArcade*)dispatch)->setYMFM(true);
|
||||
break;
|
||||
case DIV_SYSTEM_YM2610:
|
||||
dispatch=new DivPlatformYM2610;
|
||||
|
|
|
|||
|
|
@ -33,7 +33,7 @@ static int orderedOps[4]={
|
|||
|
||||
#define rWrite(a,v) pendingWrites[a]=v;
|
||||
|
||||
void DivPlatformArcade::acquire(short* bufL, short* bufR, size_t start, size_t len) {
|
||||
void DivPlatformArcade::acquire_nuked(short* bufL, short* bufR, size_t start, size_t len) {
|
||||
static int o[2];
|
||||
|
||||
for (size_t h=start; h<start+len; h++) {
|
||||
|
|
@ -92,6 +92,68 @@ void DivPlatformArcade::acquire(short* bufL, short* bufR, size_t start, size_t l
|
|||
}
|
||||
}
|
||||
|
||||
void DivPlatformArcade::acquire_ymfm(short* bufL, short* bufR, size_t start, size_t len) {
|
||||
static int os[2];
|
||||
|
||||
for (size_t h=start; h<start+len; h++) {
|
||||
os[0]=0; os[1]=0;
|
||||
if (!writes.empty()) {
|
||||
if (--delay<1) {
|
||||
QueuedWrite& w=writes.front();
|
||||
fm_ymfm->write(0x0+((w.addr>>8)<<1),w.addr);
|
||||
fm_ymfm->write(0x1+((w.addr>>8)<<1),w.val);
|
||||
writes.pop();
|
||||
delay=1;
|
||||
}
|
||||
}
|
||||
|
||||
fm_ymfm->generate(&out_ymfm);
|
||||
|
||||
pcmCycles+=31250;
|
||||
if (pcmCycles>=rate) {
|
||||
pcmCycles-=rate;
|
||||
|
||||
// do a PCM cycle
|
||||
pcmL=0; pcmR=0;
|
||||
for (int i=8; i<13; i++) {
|
||||
if (chan[i].pcm.sample>=0) {
|
||||
DivSample* s=parent->song.sample[chan[i].pcm.sample];
|
||||
if (s->depth==8) {
|
||||
pcmL+=(s->rendData[chan[i].pcm.pos>>8]*chan[i].chVolL);
|
||||
pcmR+=(s->rendData[chan[i].pcm.pos>>8]*chan[i].chVolR);
|
||||
} else {
|
||||
pcmL+=(s->rendData[chan[i].pcm.pos>>8]*chan[i].chVolL)>>8;
|
||||
pcmR+=(s->rendData[chan[i].pcm.pos>>8]*chan[i].chVolR)>>8;
|
||||
}
|
||||
chan[i].pcm.pos+=chan[i].pcm.freq;
|
||||
if (chan[i].pcm.pos>=(s->rendLength<<8)) {
|
||||
chan[i].pcm.sample=-1;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
os[0]=out_ymfm.data[0]+pcmL;
|
||||
if (os[0]<-32768) os[0]=-32768;
|
||||
if (os[0]>32767) os[0]=32767;
|
||||
|
||||
os[1]=out_ymfm.data[1]+pcmR;
|
||||
if (os[1]<-32768) os[1]=-32768;
|
||||
if (os[1]>32767) os[1]=32767;
|
||||
|
||||
bufL[h]=os[0];
|
||||
bufR[h]=os[1];
|
||||
}
|
||||
}
|
||||
|
||||
void DivPlatformArcade::acquire(short* bufL, short* bufR, size_t start, size_t len) {
|
||||
if (useYMFM) {
|
||||
acquire_ymfm(bufL,bufR,start,len);
|
||||
} else {
|
||||
acquire_nuked(bufL,bufR,start,len);
|
||||
}
|
||||
}
|
||||
|
||||
unsigned char noteMap[12]={
|
||||
0, 1, 2, 4, 5, 6, 8, 9, 10, 12, 13, 14
|
||||
};
|
||||
|
|
@ -343,8 +405,12 @@ int DivPlatformArcade::dispatch(DivCommand c) {
|
|||
|
||||
void DivPlatformArcade::reset() {
|
||||
while (!writes.empty()) writes.pop();
|
||||
memset(&fm,0,sizeof(opm_t));
|
||||
OPM_Reset(&fm);
|
||||
if (useYMFM) {
|
||||
fm_ymfm->reset();
|
||||
} else {
|
||||
memset(&fm,0,sizeof(opm_t));
|
||||
OPM_Reset(&fm);
|
||||
}
|
||||
for (int i=0; i<13; i++) {
|
||||
chan[i]=DivPlatformArcade::Channel();
|
||||
chan[i].vol=0x7f;
|
||||
|
|
@ -360,6 +426,7 @@ void DivPlatformArcade::reset() {
|
|||
pcmL=0;
|
||||
pcmR=0;
|
||||
sampleBank=0;
|
||||
delay=0;
|
||||
|
||||
rWrite(0x19,0xff);
|
||||
|
||||
|
|
@ -370,15 +437,27 @@ bool DivPlatformArcade::isStereo() {
|
|||
return true;
|
||||
}
|
||||
|
||||
void DivPlatformArcade::setYMFM(bool use) {
|
||||
useYMFM=use;
|
||||
}
|
||||
|
||||
int DivPlatformArcade::init(DivEngine* p, int channels, int sugRate, bool pal) {
|
||||
parent=p;
|
||||
rate=447443;
|
||||
if (useYMFM) {
|
||||
rate=447443/8;
|
||||
fm_ymfm=new ymfm::ym2151(iface);
|
||||
} else {
|
||||
rate=447443;
|
||||
}
|
||||
reset();
|
||||
|
||||
return 13;
|
||||
}
|
||||
|
||||
void DivPlatformArcade::quit() {
|
||||
if (useYMFM) {
|
||||
delete fm_ymfm;
|
||||
}
|
||||
}
|
||||
|
||||
DivPlatformArcade::~DivPlatformArcade() {
|
||||
|
|
|
|||
|
|
@ -3,6 +3,11 @@
|
|||
#include "../dispatch.h"
|
||||
#include <queue>
|
||||
#include "../../../extern/opm/opm.h"
|
||||
#include "sound/ymfm/ymfm_opm.h"
|
||||
|
||||
class DivArcadeInterface: public ymfm::ymfm_interface {
|
||||
|
||||
};
|
||||
|
||||
class DivPlatformArcade: public DivDispatch {
|
||||
protected:
|
||||
|
|
@ -38,13 +43,20 @@ class DivPlatformArcade: public DivDispatch {
|
|||
unsigned char sampleBank;
|
||||
unsigned char lastBusy;
|
||||
|
||||
bool extMode;
|
||||
ymfm::ym2151* fm_ymfm;
|
||||
ymfm::ym2151::output_data out_ymfm;
|
||||
DivArcadeInterface iface;
|
||||
|
||||
bool extMode, useYMFM;
|
||||
|
||||
short oldWrites[256];
|
||||
short pendingWrites[256];
|
||||
|
||||
int octave(int freq);
|
||||
int toFreq(int freq);
|
||||
|
||||
void acquire_nuked(short* bufL, short* bufR, size_t start, size_t len);
|
||||
void acquire_ymfm(short* bufL, short* bufR, size_t start, size_t len);
|
||||
|
||||
public:
|
||||
void acquire(short* bufL, short* bufR, size_t start, size_t len);
|
||||
|
|
@ -52,6 +64,7 @@ class DivPlatformArcade: public DivDispatch {
|
|||
void reset();
|
||||
void tick();
|
||||
bool isStereo();
|
||||
void setYMFM(bool use);
|
||||
int init(DivEngine* parent, int channels, int sugRate, bool pal);
|
||||
void quit();
|
||||
~DivPlatformArcade();
|
||||
|
|
|
|||
|
|
@ -0,0 +1,538 @@
|
|||
// BSD 3-Clause License
|
||||
//
|
||||
// Copyright (c) 2021, Aaron Giles
|
||||
// All rights reserved.
|
||||
//
|
||||
// Redistribution and use in source and binary forms, with or without
|
||||
// modification, are permitted provided that the following conditions are met:
|
||||
//
|
||||
// 1. Redistributions of source code must retain the above copyright notice, this
|
||||
// list of conditions and the following disclaimer.
|
||||
//
|
||||
// 2. Redistributions in binary form must reproduce the above copyright notice,
|
||||
// this list of conditions and the following disclaimer in the documentation
|
||||
// and/or other materials provided with the distribution.
|
||||
//
|
||||
// 3. Neither the name of the copyright holder nor the names of its
|
||||
// contributors may be used to endorse or promote products derived from
|
||||
// this software without specific prior written permission.
|
||||
//
|
||||
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
|
||||
// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
|
||||
// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
|
||||
// DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
|
||||
// FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
|
||||
// DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
|
||||
// SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
|
||||
// CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
|
||||
// OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
|
||||
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
|
||||
#include "ymfm_opm.h"
|
||||
#include "ymfm_fm.ipp"
|
||||
|
||||
namespace ymfm
|
||||
{
|
||||
|
||||
//*********************************************************
|
||||
// OPM REGISTERS
|
||||
//*********************************************************
|
||||
|
||||
//-------------------------------------------------
|
||||
// opm_registers - constructor
|
||||
//-------------------------------------------------
|
||||
|
||||
opm_registers::opm_registers() :
|
||||
m_lfo_counter(0),
|
||||
m_noise_lfsr(1),
|
||||
m_noise_counter(0),
|
||||
m_noise_state(0),
|
||||
m_noise_lfo(0),
|
||||
m_lfo_am(0)
|
||||
{
|
||||
// create the waveforms
|
||||
for (uint32_t index = 0; index < WAVEFORM_LENGTH; index++)
|
||||
m_waveform[0][index] = abs_sin_attenuation(index) | (bitfield(index, 9) << 15);
|
||||
|
||||
// create the LFO waveforms; AM in the low 8 bits, PM in the upper 8
|
||||
// waveforms are adjusted to match the pictures in the application manual
|
||||
for (uint32_t index = 0; index < LFO_WAVEFORM_LENGTH; index++)
|
||||
{
|
||||
// waveform 0 is a sawtooth
|
||||
uint8_t am = index ^ 0xff;
|
||||
int8_t pm = int8_t(index);
|
||||
m_lfo_waveform[0][index] = am | (pm << 8);
|
||||
|
||||
// waveform 1 is a square wave
|
||||
am = bitfield(index, 7) ? 0 : 0xff;
|
||||
pm = int8_t(am ^ 0x80);
|
||||
m_lfo_waveform[1][index] = am | (pm << 8);
|
||||
|
||||
// waveform 2 is a triangle wave
|
||||
am = bitfield(index, 7) ? (index << 1) : ((index ^ 0xff) << 1);
|
||||
pm = int8_t(bitfield(index, 6) ? am : ~am);
|
||||
m_lfo_waveform[2][index] = am | (pm << 8);
|
||||
|
||||
// waveform 3 is noise; it is filled in dynamically
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
//-------------------------------------------------
|
||||
// reset - reset to initial state
|
||||
//-------------------------------------------------
|
||||
|
||||
void opm_registers::reset()
|
||||
{
|
||||
std::fill_n(&m_regdata[0], REGISTERS, 0);
|
||||
|
||||
// enable output on both channels by default
|
||||
m_regdata[0x20] = m_regdata[0x21] = m_regdata[0x22] = m_regdata[0x23] = 0xc0;
|
||||
m_regdata[0x24] = m_regdata[0x25] = m_regdata[0x26] = m_regdata[0x27] = 0xc0;
|
||||
}
|
||||
|
||||
|
||||
//-------------------------------------------------
|
||||
// save_restore - save or restore the data
|
||||
//-------------------------------------------------
|
||||
|
||||
void opm_registers::save_restore(ymfm_saved_state &state)
|
||||
{
|
||||
state.save_restore(m_lfo_counter);
|
||||
state.save_restore(m_lfo_am);
|
||||
state.save_restore(m_noise_lfsr);
|
||||
state.save_restore(m_noise_counter);
|
||||
state.save_restore(m_noise_state);
|
||||
state.save_restore(m_noise_lfo);
|
||||
state.save_restore(m_regdata);
|
||||
}
|
||||
|
||||
|
||||
//-------------------------------------------------
|
||||
// operator_map - return an array of operator
|
||||
// indices for each channel; for OPM this is fixed
|
||||
//-------------------------------------------------
|
||||
|
||||
void opm_registers::operator_map(operator_mapping &dest) const
|
||||
{
|
||||
// Note that the channel index order is 0,2,1,3, so we bitswap the index.
|
||||
//
|
||||
// This is because the order in the map is:
|
||||
// carrier 1, carrier 2, modulator 1, modulator 2
|
||||
//
|
||||
// But when wiring up the connections, the more natural order is:
|
||||
// carrier 1, modulator 1, carrier 2, modulator 2
|
||||
static const operator_mapping s_fixed_map =
|
||||
{ {
|
||||
operator_list( 0, 16, 8, 24 ), // Channel 0 operators
|
||||
operator_list( 1, 17, 9, 25 ), // Channel 1 operators
|
||||
operator_list( 2, 18, 10, 26 ), // Channel 2 operators
|
||||
operator_list( 3, 19, 11, 27 ), // Channel 3 operators
|
||||
operator_list( 4, 20, 12, 28 ), // Channel 4 operators
|
||||
operator_list( 5, 21, 13, 29 ), // Channel 5 operators
|
||||
operator_list( 6, 22, 14, 30 ), // Channel 6 operators
|
||||
operator_list( 7, 23, 15, 31 ), // Channel 7 operators
|
||||
} };
|
||||
dest = s_fixed_map;
|
||||
}
|
||||
|
||||
|
||||
//-------------------------------------------------
|
||||
// write - handle writes to the register array
|
||||
//-------------------------------------------------
|
||||
|
||||
bool opm_registers::write(uint16_t index, uint8_t data, uint32_t &channel, uint32_t &opmask)
|
||||
{
|
||||
assert(index < REGISTERS);
|
||||
|
||||
// LFO AM/PM depth are written to the same register (0x19);
|
||||
// redirect the PM depth to an unused neighbor (0x1a)
|
||||
if (index == 0x19)
|
||||
m_regdata[index + bitfield(data, 7)] = data;
|
||||
else if (index != 0x1a)
|
||||
m_regdata[index] = data;
|
||||
|
||||
// handle writes to the key on index
|
||||
if (index == 0x08)
|
||||
{
|
||||
channel = bitfield(data, 0, 3);
|
||||
opmask = bitfield(data, 3, 4);
|
||||
return true;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
|
||||
//-------------------------------------------------
|
||||
// clock_noise_and_lfo - clock the noise and LFO,
|
||||
// handling clock division, depth, and waveform
|
||||
// computations
|
||||
//-------------------------------------------------
|
||||
|
||||
int32_t opm_registers::clock_noise_and_lfo()
|
||||
{
|
||||
// base noise frequency is measured at 2x 1/2 FM frequency; this
|
||||
// means each tick counts as two steps against the noise counter
|
||||
uint32_t freq = noise_frequency();
|
||||
for (int rep = 0; rep < 2; rep++)
|
||||
{
|
||||
// evidence seems to suggest the LFSR is clocked continually and just
|
||||
// sampled at the noise frequency for output purposes; note that the
|
||||
// low 8 bits are the most recent 8 bits of history while bits 8-24
|
||||
// contain the 17 bit LFSR state
|
||||
m_noise_lfsr <<= 1;
|
||||
m_noise_lfsr |= bitfield(m_noise_lfsr, 17) ^ bitfield(m_noise_lfsr, 14) ^ 1;
|
||||
|
||||
// compare against the frequency and latch when we exceed it
|
||||
if (m_noise_counter++ >= freq)
|
||||
{
|
||||
m_noise_counter = 0;
|
||||
m_noise_state = bitfield(m_noise_lfsr, 17);
|
||||
}
|
||||
}
|
||||
|
||||
// treat the rate as a 4.4 floating-point step value with implied
|
||||
// leading 1; this matches exactly the frequencies in the application
|
||||
// manual, though it might not be implemented exactly this way on chip
|
||||
uint32_t rate = lfo_rate();
|
||||
m_lfo_counter += (0x10 | bitfield(rate, 0, 4)) << bitfield(rate, 4, 4);
|
||||
|
||||
// bit 1 of the test register is officially undocumented but has been
|
||||
// discovered to hold the LFO in reset while active
|
||||
if (lfo_reset())
|
||||
m_lfo_counter = 0;
|
||||
|
||||
// now pull out the non-fractional LFO value
|
||||
uint32_t lfo = bitfield(m_lfo_counter, 22, 8);
|
||||
|
||||
// fill in the noise entry 1 ahead of our current position; this
|
||||
// ensures the current value remains stable for a full LFO clock
|
||||
// and effectively latches the running value when the LFO advances
|
||||
uint32_t lfo_noise = bitfield(m_noise_lfsr, 17, 8);
|
||||
m_lfo_waveform[3][(lfo + 1) & 0xff] = lfo_noise | (lfo_noise << 8);
|
||||
|
||||
// fetch the AM/PM values based on the waveform; AM is unsigned and
|
||||
// encoded in the low 8 bits, while PM signed and encoded in the upper
|
||||
// 8 bits
|
||||
int32_t ampm = m_lfo_waveform[lfo_waveform()][lfo];
|
||||
|
||||
// apply depth to the AM value and store for later
|
||||
m_lfo_am = ((ampm & 0xff) * lfo_am_depth()) >> 7;
|
||||
|
||||
// apply depth to the PM value and return it
|
||||
return ((ampm >> 8) * int32_t(lfo_pm_depth())) >> 7;
|
||||
}
|
||||
|
||||
|
||||
//-------------------------------------------------
|
||||
// lfo_am_offset - return the AM offset from LFO
|
||||
// for the given channel
|
||||
//-------------------------------------------------
|
||||
|
||||
uint32_t opm_registers::lfo_am_offset(uint32_t choffs) const
|
||||
{
|
||||
// OPM maps AM quite differently from OPN
|
||||
|
||||
// shift value for AM sensitivity is [*, 0, 1, 2],
|
||||
// mapping to values of [0, 23.9, 47.8, and 95.6dB]
|
||||
uint32_t am_sensitivity = ch_lfo_am_sens(choffs);
|
||||
if (am_sensitivity == 0)
|
||||
return 0;
|
||||
|
||||
// QUESTION: see OPN note below for the dB range mapping; it applies
|
||||
// here as well
|
||||
|
||||
// raw LFO AM value on OPM is 0-FF, which is already a factor of 2
|
||||
// larger than the OPN below, putting our staring point at 2x theirs;
|
||||
// this works out since our minimum is 2x their maximum
|
||||
return m_lfo_am << (am_sensitivity - 1);
|
||||
}
|
||||
|
||||
|
||||
//-------------------------------------------------
|
||||
// cache_operator_data - fill the operator cache
|
||||
// with prefetched data
|
||||
//-------------------------------------------------
|
||||
|
||||
void opm_registers::cache_operator_data(uint32_t choffs, uint32_t opoffs, opdata_cache &cache)
|
||||
{
|
||||
// set up the easy stuff
|
||||
cache.waveform = &m_waveform[0][0];
|
||||
|
||||
// get frequency from the channel
|
||||
uint32_t block_freq = cache.block_freq = ch_block_freq(choffs);
|
||||
|
||||
// compute the keycode: block_freq is:
|
||||
//
|
||||
// BBBCCCCFFFFFF
|
||||
// ^^^^^
|
||||
//
|
||||
// the 5-bit keycode is just the top 5 bits (block + top 2 bits
|
||||
// of the key code)
|
||||
uint32_t keycode = bitfield(block_freq, 8, 5);
|
||||
|
||||
// detune adjustment
|
||||
cache.detune = detune_adjustment(op_detune(opoffs), keycode);
|
||||
|
||||
// multiple value, as an x.1 value (0 means 0.5)
|
||||
cache.multiple = op_multiple(opoffs) * 2;
|
||||
if (cache.multiple == 0)
|
||||
cache.multiple = 1;
|
||||
|
||||
// phase step, or PHASE_STEP_DYNAMIC if PM is active; this depends on
|
||||
// block_freq, detune, and multiple, so compute it after we've done those
|
||||
if (lfo_pm_depth() == 0 || ch_lfo_pm_sens(choffs) == 0)
|
||||
cache.phase_step = compute_phase_step(choffs, opoffs, cache, 0);
|
||||
else
|
||||
cache.phase_step = opdata_cache::PHASE_STEP_DYNAMIC;
|
||||
|
||||
// total level, scaled by 8
|
||||
cache.total_level = op_total_level(opoffs) << 3;
|
||||
|
||||
// 4-bit sustain level, but 15 means 31 so effectively 5 bits
|
||||
cache.eg_sustain = op_sustain_level(opoffs);
|
||||
cache.eg_sustain |= (cache.eg_sustain + 1) & 0x10;
|
||||
cache.eg_sustain <<= 5;
|
||||
|
||||
// determine KSR adjustment for enevlope rates
|
||||
uint32_t ksrval = keycode >> (op_ksr(opoffs) ^ 3);
|
||||
cache.eg_rate[EG_ATTACK] = effective_rate(op_attack_rate(opoffs) * 2, ksrval);
|
||||
cache.eg_rate[EG_DECAY] = effective_rate(op_decay_rate(opoffs) * 2, ksrval);
|
||||
cache.eg_rate[EG_SUSTAIN] = effective_rate(op_sustain_rate(opoffs) * 2, ksrval);
|
||||
cache.eg_rate[EG_RELEASE] = effective_rate(op_release_rate(opoffs) * 4 + 2, ksrval);
|
||||
}
|
||||
|
||||
|
||||
//-------------------------------------------------
|
||||
// compute_phase_step - compute the phase step
|
||||
//-------------------------------------------------
|
||||
|
||||
uint32_t opm_registers::compute_phase_step(uint32_t choffs, uint32_t opoffs, opdata_cache const &cache, int32_t lfo_raw_pm)
|
||||
{
|
||||
// OPM logic is rather unique here, due to extra detune
|
||||
// and the use of key codes (not to be confused with keycode)
|
||||
|
||||
// start with coarse detune delta; table uses cents value from
|
||||
// manual, converted into 1/64ths
|
||||
static const int16_t s_detune2_delta[4] = { 0, (600*64+50)/100, (781*64+50)/100, (950*64+50)/100 };
|
||||
int32_t delta = s_detune2_delta[op_detune2(opoffs)];
|
||||
|
||||
// add in the PM delta
|
||||
uint32_t pm_sensitivity = ch_lfo_pm_sens(choffs);
|
||||
if (pm_sensitivity != 0)
|
||||
{
|
||||
// raw PM value is -127..128 which is +/- 200 cents
|
||||
// manual gives these magnitudes in cents:
|
||||
// 0, +/-5, +/-10, +/-20, +/-50, +/-100, +/-400, +/-700
|
||||
// this roughly corresponds to shifting the 200-cent value:
|
||||
// 0 >> 5, >> 4, >> 3, >> 2, >> 1, << 1, << 2
|
||||
if (pm_sensitivity < 6)
|
||||
delta += lfo_raw_pm >> (6 - pm_sensitivity);
|
||||
else
|
||||
delta += lfo_raw_pm << (pm_sensitivity - 5);
|
||||
}
|
||||
|
||||
// apply delta and convert to a frequency number
|
||||
uint32_t phase_step = opm_key_code_to_phase_step(cache.block_freq, delta);
|
||||
|
||||
// apply detune based on the keycode
|
||||
phase_step += cache.detune;
|
||||
|
||||
// apply frequency multiplier (which is cached as an x.1 value)
|
||||
return (phase_step * cache.multiple) >> 1;
|
||||
}
|
||||
|
||||
|
||||
//-------------------------------------------------
|
||||
// log_keyon - log a key-on event
|
||||
//-------------------------------------------------
|
||||
|
||||
std::string opm_registers::log_keyon(uint32_t choffs, uint32_t opoffs)
|
||||
{
|
||||
uint32_t chnum = choffs;
|
||||
uint32_t opnum = opoffs;
|
||||
|
||||
char buffer[256];
|
||||
char *end = &buffer[0];
|
||||
|
||||
end += sprintf(end, "%u.%02u freq=%04X dt2=%u dt=%u fb=%u alg=%X mul=%X tl=%02X ksr=%u adsr=%02X/%02X/%02X/%X sl=%X out=%c%c",
|
||||
chnum, opnum,
|
||||
ch_block_freq(choffs),
|
||||
op_detune2(opoffs),
|
||||
op_detune(opoffs),
|
||||
ch_feedback(choffs),
|
||||
ch_algorithm(choffs),
|
||||
op_multiple(opoffs),
|
||||
op_total_level(opoffs),
|
||||
op_ksr(opoffs),
|
||||
op_attack_rate(opoffs),
|
||||
op_decay_rate(opoffs),
|
||||
op_sustain_rate(opoffs),
|
||||
op_release_rate(opoffs),
|
||||
op_sustain_level(opoffs),
|
||||
ch_output_0(choffs) ? 'L' : '-',
|
||||
ch_output_1(choffs) ? 'R' : '-');
|
||||
|
||||
bool am = (lfo_am_depth() != 0 && ch_lfo_am_sens(choffs) != 0 && op_lfo_am_enable(opoffs) != 0);
|
||||
if (am)
|
||||
end += sprintf(end, " am=%u/%02X", ch_lfo_am_sens(choffs), lfo_am_depth());
|
||||
bool pm = (lfo_pm_depth() != 0 && ch_lfo_pm_sens(choffs) != 0);
|
||||
if (pm)
|
||||
end += sprintf(end, " pm=%u/%02X", ch_lfo_pm_sens(choffs), lfo_pm_depth());
|
||||
if (am || pm)
|
||||
end += sprintf(end, " lfo=%02X/%c", lfo_rate(), "WQTN"[lfo_waveform()]);
|
||||
if (noise_enable() && opoffs == 31)
|
||||
end += sprintf(end, " noise=1");
|
||||
|
||||
return buffer;
|
||||
}
|
||||
|
||||
|
||||
|
||||
//*********************************************************
|
||||
// YM2151
|
||||
//*********************************************************
|
||||
|
||||
//-------------------------------------------------
|
||||
// ym2151 - constructor
|
||||
//-------------------------------------------------
|
||||
|
||||
ym2151::ym2151(ymfm_interface &intf, opm_variant variant) :
|
||||
m_variant(variant),
|
||||
m_address(0),
|
||||
m_fm(intf)
|
||||
{
|
||||
}
|
||||
|
||||
|
||||
//-------------------------------------------------
|
||||
// reset - reset the system
|
||||
//-------------------------------------------------
|
||||
|
||||
void ym2151::reset()
|
||||
{
|
||||
// reset the engines
|
||||
m_fm.reset();
|
||||
}
|
||||
|
||||
|
||||
//-------------------------------------------------
|
||||
// save_restore - save or restore the data
|
||||
//-------------------------------------------------
|
||||
|
||||
void ym2151::save_restore(ymfm_saved_state &state)
|
||||
{
|
||||
m_fm.save_restore(state);
|
||||
state.save_restore(m_address);
|
||||
}
|
||||
|
||||
|
||||
//-------------------------------------------------
|
||||
// read_status - read the status register
|
||||
//-------------------------------------------------
|
||||
|
||||
uint8_t ym2151::read_status()
|
||||
{
|
||||
uint8_t result = m_fm.status();
|
||||
if (m_fm.intf().ymfm_is_busy())
|
||||
result |= fm_engine::STATUS_BUSY;
|
||||
return result;
|
||||
}
|
||||
|
||||
|
||||
//-------------------------------------------------
|
||||
// read - handle a read from the device
|
||||
//-------------------------------------------------
|
||||
|
||||
uint8_t ym2151::read(uint32_t offset)
|
||||
{
|
||||
uint8_t result = 0xff;
|
||||
switch (offset & 1)
|
||||
{
|
||||
case 0: // data port (unused)
|
||||
debug::log_unexpected_read_write("Unexpected read from YM2151 offset %d\n", offset & 3);
|
||||
break;
|
||||
|
||||
case 1: // status port, YM2203 compatible
|
||||
result = read_status();
|
||||
break;
|
||||
}
|
||||
return result;
|
||||
}
|
||||
|
||||
|
||||
//-------------------------------------------------
|
||||
// write_address - handle a write to the address
|
||||
// register
|
||||
//-------------------------------------------------
|
||||
|
||||
void ym2151::write_address(uint8_t data)
|
||||
{
|
||||
// just set the address
|
||||
m_address = data;
|
||||
}
|
||||
|
||||
|
||||
//-------------------------------------------------
|
||||
// write - handle a write to the register
|
||||
// interface
|
||||
//-------------------------------------------------
|
||||
|
||||
void ym2151::write_data(uint8_t data)
|
||||
{
|
||||
// write the FM register
|
||||
m_fm.write(m_address, data);
|
||||
|
||||
// special cases
|
||||
if (m_address == 0x1b)
|
||||
{
|
||||
// writes to register 0x1B send the upper 2 bits to the output lines
|
||||
m_fm.intf().ymfm_external_write(ACCESS_IO, 0, data >> 6);
|
||||
}
|
||||
|
||||
// mark busy for a bit
|
||||
m_fm.intf().ymfm_set_busy_end(32 * m_fm.clock_prescale());
|
||||
}
|
||||
|
||||
|
||||
//-------------------------------------------------
|
||||
// write - handle a write to the register
|
||||
// interface
|
||||
//-------------------------------------------------
|
||||
|
||||
void ym2151::write(uint32_t offset, uint8_t data)
|
||||
{
|
||||
switch (offset & 1)
|
||||
{
|
||||
case 0: // address port
|
||||
write_address(data);
|
||||
break;
|
||||
|
||||
case 1: // data port
|
||||
write_data(data);
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
//-------------------------------------------------
|
||||
// generate - generate one sample of sound
|
||||
//-------------------------------------------------
|
||||
|
||||
void ym2151::generate(output_data *output, uint32_t numsamples)
|
||||
{
|
||||
for (uint32_t samp = 0; samp < numsamples; samp++, output++)
|
||||
{
|
||||
// clock the system
|
||||
m_fm.clock(fm_engine::ALL_CHANNELS);
|
||||
|
||||
// update the FM content; OPM is full 14-bit with no intermediate clipping
|
||||
m_fm.output(output->clear(), 0, 32767, fm_engine::ALL_CHANNELS);
|
||||
|
||||
// YM2151 uses an external DAC (YM3012) with mantissa/exponent format
|
||||
// convert to 10.3 floating point value and back to simulate truncation
|
||||
output->roundtrip_fp();
|
||||
}
|
||||
}
|
||||
|
||||
}
|
||||
|
|
@ -0,0 +1,322 @@
|
|||
// BSD 3-Clause License
|
||||
//
|
||||
// Copyright (c) 2021, Aaron Giles
|
||||
// All rights reserved.
|
||||
//
|
||||
// Redistribution and use in source and binary forms, with or without
|
||||
// modification, are permitted provided that the following conditions are met:
|
||||
//
|
||||
// 1. Redistributions of source code must retain the above copyright notice, this
|
||||
// list of conditions and the following disclaimer.
|
||||
//
|
||||
// 2. Redistributions in binary form must reproduce the above copyright notice,
|
||||
// this list of conditions and the following disclaimer in the documentation
|
||||
// and/or other materials provided with the distribution.
|
||||
//
|
||||
// 3. Neither the name of the copyright holder nor the names of its
|
||||
// contributors may be used to endorse or promote products derived from
|
||||
// this software without specific prior written permission.
|
||||
//
|
||||
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
|
||||
// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
|
||||
// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
|
||||
// DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
|
||||
// FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
|
||||
// DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
|
||||
// SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
|
||||
// CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
|
||||
// OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
|
||||
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
|
||||
#ifndef YMFM_OPM_H
|
||||
#define YMFM_OPM_H
|
||||
|
||||
#pragma once
|
||||
|
||||
#include "ymfm.h"
|
||||
#include "ymfm_fm.h"
|
||||
|
||||
namespace ymfm
|
||||
{
|
||||
|
||||
//*********************************************************
|
||||
// REGISTER CLASSES
|
||||
//*********************************************************
|
||||
|
||||
// ======================> opm_registers
|
||||
|
||||
//
|
||||
// OPM register map:
|
||||
//
|
||||
// System-wide registers:
|
||||
// 01 xxxxxx-x Test register
|
||||
// ------x- LFO reset
|
||||
// 08 -x------ Key on/off operator 4
|
||||
// --x----- Key on/off operator 3
|
||||
// ---x---- Key on/off operator 2
|
||||
// ----x--- Key on/off operator 1
|
||||
// -----xxx Channel select
|
||||
// 0F x------- Noise enable
|
||||
// ---xxxxx Noise frequency
|
||||
// 10 xxxxxxxx Timer A value (upper 8 bits)
|
||||
// 11 ------xx Timer A value (lower 2 bits)
|
||||
// 12 xxxxxxxx Timer B value
|
||||
// 14 x------- CSM mode
|
||||
// --x----- Reset timer B
|
||||
// ---x---- Reset timer A
|
||||
// ----x--- Enable timer B
|
||||
// -----x-- Enable timer A
|
||||
// ------x- Load timer B
|
||||
// -------x Load timer A
|
||||
// 18 xxxxxxxx LFO frequency
|
||||
// 19 0xxxxxxx AM LFO depth
|
||||
// 1xxxxxxx PM LFO depth
|
||||
// 1B xx------ CT (2 output data lines)
|
||||
// ------xx LFO waveform
|
||||
//
|
||||
// Per-channel registers (channel in address bits 0-2)
|
||||
// 20-27 x------- Pan right
|
||||
// -x------ Pan left
|
||||
// --xxx--- Feedback level for operator 1 (0-7)
|
||||
// -----xxx Operator connection algorithm (0-7)
|
||||
// 28-2F -xxxxxxx Key code
|
||||
// 30-37 xxxxxx-- Key fraction
|
||||
// 38-3F -xxx---- LFO PM sensitivity
|
||||
// ------xx LFO AM shift
|
||||
//
|
||||
// Per-operator registers (channel in address bits 0-2, operator in bits 3-4)
|
||||
// 40-5F -xxx---- Detune value (0-7)
|
||||
// ----xxxx Multiple value (0-15)
|
||||
// 60-7F -xxxxxxx Total level (0-127)
|
||||
// 80-9F xx------ Key scale rate (0-3)
|
||||
// ---xxxxx Attack rate (0-31)
|
||||
// A0-BF x------- LFO AM enable
|
||||
// ---xxxxx Decay rate (0-31)
|
||||
// C0-DF xx------ Detune 2 value (0-3)
|
||||
// ---xxxxx Sustain rate (0-31)
|
||||
// E0-FF xxxx---- Sustain level (0-15)
|
||||
// ----xxxx Release rate (0-15)
|
||||
//
|
||||
// Internal (fake) registers:
|
||||
// 1A -xxxxxxx PM depth
|
||||
//
|
||||
|
||||
class opm_registers : public fm_registers_base
|
||||
{
|
||||
// LFO waveforms are 256 entries long
|
||||
static constexpr uint32_t LFO_WAVEFORM_LENGTH = 256;
|
||||
|
||||
public:
|
||||
// constants
|
||||
static constexpr uint32_t OUTPUTS = 2;
|
||||
static constexpr uint32_t CHANNELS = 8;
|
||||
static constexpr uint32_t ALL_CHANNELS = (1 << CHANNELS) - 1;
|
||||
static constexpr uint32_t OPERATORS = CHANNELS * 4;
|
||||
static constexpr uint32_t WAVEFORMS = 1;
|
||||
static constexpr uint32_t REGISTERS = 0x100;
|
||||
static constexpr uint32_t DEFAULT_PRESCALE = 2;
|
||||
static constexpr uint32_t EG_CLOCK_DIVIDER = 3;
|
||||
static constexpr uint32_t CSM_TRIGGER_MASK = ALL_CHANNELS;
|
||||
static constexpr uint32_t REG_MODE = 0x14;
|
||||
static constexpr uint8_t STATUS_TIMERA = 0x01;
|
||||
static constexpr uint8_t STATUS_TIMERB = 0x02;
|
||||
static constexpr uint8_t STATUS_BUSY = 0x80;
|
||||
static constexpr uint8_t STATUS_IRQ = 0;
|
||||
|
||||
// constructor
|
||||
opm_registers();
|
||||
|
||||
// reset to initial state
|
||||
void reset();
|
||||
|
||||
// save/restore
|
||||
void save_restore(ymfm_saved_state &state);
|
||||
|
||||
// map channel number to register offset
|
||||
static constexpr uint32_t channel_offset(uint32_t chnum)
|
||||
{
|
||||
assert(chnum < CHANNELS);
|
||||
return chnum;
|
||||
}
|
||||
|
||||
// map operator number to register offset
|
||||
static constexpr uint32_t operator_offset(uint32_t opnum)
|
||||
{
|
||||
assert(opnum < OPERATORS);
|
||||
return opnum;
|
||||
}
|
||||
|
||||
// return an array of operator indices for each channel
|
||||
struct operator_mapping { uint32_t chan[CHANNELS]; };
|
||||
void operator_map(operator_mapping &dest) const;
|
||||
|
||||
// handle writes to the register array
|
||||
bool write(uint16_t index, uint8_t data, uint32_t &chan, uint32_t &opmask);
|
||||
|
||||
// clock the noise and LFO, if present, returning LFO PM value
|
||||
int32_t clock_noise_and_lfo();
|
||||
|
||||
// return the AM offset from LFO for the given channel
|
||||
uint32_t lfo_am_offset(uint32_t choffs) const;
|
||||
|
||||
// return the current noise state, gated by the noise clock
|
||||
uint32_t noise_state() const { return m_noise_state; }
|
||||
|
||||
// caching helpers
|
||||
void cache_operator_data(uint32_t choffs, uint32_t opoffs, opdata_cache &cache);
|
||||
|
||||
// compute the phase step, given a PM value
|
||||
uint32_t compute_phase_step(uint32_t choffs, uint32_t opoffs, opdata_cache const &cache, int32_t lfo_raw_pm);
|
||||
|
||||
// log a key-on event
|
||||
std::string log_keyon(uint32_t choffs, uint32_t opoffs);
|
||||
|
||||
// system-wide registers
|
||||
uint32_t test() const { return byte(0x01, 0, 8); }
|
||||
uint32_t lfo_reset() const { return byte(0x01, 1, 1); }
|
||||
uint32_t noise_frequency() const { return byte(0x0f, 0, 5); }
|
||||
uint32_t noise_enable() const { return byte(0x0f, 7, 1); }
|
||||
uint32_t timer_a_value() const { return word(0x10, 0, 8, 0x11, 0, 2); }
|
||||
uint32_t timer_b_value() const { return byte(0x12, 0, 8); }
|
||||
uint32_t csm() const { return byte(0x14, 7, 1); }
|
||||
uint32_t reset_timer_b() const { return byte(0x14, 5, 1); }
|
||||
uint32_t reset_timer_a() const { return byte(0x14, 4, 1); }
|
||||
uint32_t enable_timer_b() const { return byte(0x14, 3, 1); }
|
||||
uint32_t enable_timer_a() const { return byte(0x14, 2, 1); }
|
||||
uint32_t load_timer_b() const { return byte(0x14, 1, 1); }
|
||||
uint32_t load_timer_a() const { return byte(0x14, 0, 1); }
|
||||
uint32_t lfo_rate() const { return byte(0x18, 0, 8); }
|
||||
uint32_t lfo_am_depth() const { return byte(0x19, 0, 7); }
|
||||
uint32_t lfo_pm_depth() const { return byte(0x1a, 0, 7); }
|
||||
uint32_t output_bits() const { return byte(0x1b, 6, 2); }
|
||||
uint32_t lfo_waveform() const { return byte(0x1b, 0, 2); }
|
||||
|
||||
// per-channel registers
|
||||
uint32_t ch_output_any(uint32_t choffs) const { return byte(0x20, 6, 2, choffs); }
|
||||
uint32_t ch_output_0(uint32_t choffs) const { return byte(0x20, 6, 1, choffs); }
|
||||
uint32_t ch_output_1(uint32_t choffs) const { return byte(0x20, 7, 1, choffs); }
|
||||
uint32_t ch_output_2(uint32_t choffs) const { return 0; }
|
||||
uint32_t ch_output_3(uint32_t choffs) const { return 0; }
|
||||
uint32_t ch_feedback(uint32_t choffs) const { return byte(0x20, 3, 3, choffs); }
|
||||
uint32_t ch_algorithm(uint32_t choffs) const { return byte(0x20, 0, 3, choffs); }
|
||||
uint32_t ch_block_freq(uint32_t choffs) const { return word(0x28, 0, 7, 0x30, 2, 6, choffs); }
|
||||
uint32_t ch_lfo_pm_sens(uint32_t choffs) const { return byte(0x38, 4, 3, choffs); }
|
||||
uint32_t ch_lfo_am_sens(uint32_t choffs) const { return byte(0x38, 0, 2, choffs); }
|
||||
|
||||
// per-operator registers
|
||||
uint32_t op_detune(uint32_t opoffs) const { return byte(0x40, 4, 3, opoffs); }
|
||||
uint32_t op_multiple(uint32_t opoffs) const { return byte(0x40, 0, 4, opoffs); }
|
||||
uint32_t op_total_level(uint32_t opoffs) const { return byte(0x60, 0, 7, opoffs); }
|
||||
uint32_t op_ksr(uint32_t opoffs) const { return byte(0x80, 6, 2, opoffs); }
|
||||
uint32_t op_attack_rate(uint32_t opoffs) const { return byte(0x80, 0, 5, opoffs); }
|
||||
uint32_t op_lfo_am_enable(uint32_t opoffs) const { return byte(0xa0, 7, 1, opoffs); }
|
||||
uint32_t op_decay_rate(uint32_t opoffs) const { return byte(0xa0, 0, 5, opoffs); }
|
||||
uint32_t op_detune2(uint32_t opoffs) const { return byte(0xc0, 6, 2, opoffs); }
|
||||
uint32_t op_sustain_rate(uint32_t opoffs) const { return byte(0xc0, 0, 5, opoffs); }
|
||||
uint32_t op_sustain_level(uint32_t opoffs) const { return byte(0xe0, 4, 4, opoffs); }
|
||||
uint32_t op_release_rate(uint32_t opoffs) const { return byte(0xe0, 0, 4, opoffs); }
|
||||
|
||||
protected:
|
||||
// return a bitfield extracted from a byte
|
||||
uint32_t byte(uint32_t offset, uint32_t start, uint32_t count, uint32_t extra_offset = 0) const
|
||||
{
|
||||
return bitfield(m_regdata[offset + extra_offset], start, count);
|
||||
}
|
||||
|
||||
// return a bitfield extracted from a pair of bytes, MSBs listed first
|
||||
uint32_t word(uint32_t offset1, uint32_t start1, uint32_t count1, uint32_t offset2, uint32_t start2, uint32_t count2, uint32_t extra_offset = 0) const
|
||||
{
|
||||
return (byte(offset1, start1, count1, extra_offset) << count2) | byte(offset2, start2, count2, extra_offset);
|
||||
}
|
||||
|
||||
// internal state
|
||||
uint32_t m_lfo_counter; // LFO counter
|
||||
uint32_t m_noise_lfsr; // noise LFSR state
|
||||
uint8_t m_noise_counter; // noise counter
|
||||
uint8_t m_noise_state; // latched noise state
|
||||
uint8_t m_noise_lfo; // latched LFO noise value
|
||||
uint8_t m_lfo_am; // current LFO AM value
|
||||
uint8_t m_regdata[REGISTERS]; // register data
|
||||
int16_t m_lfo_waveform[4][LFO_WAVEFORM_LENGTH]; // LFO waveforms; AM in low 8, PM in upper 8
|
||||
uint16_t m_waveform[WAVEFORMS][WAVEFORM_LENGTH]; // waveforms
|
||||
};
|
||||
|
||||
|
||||
|
||||
//*********************************************************
|
||||
// OPM IMPLEMENTATION CLASSES
|
||||
//*********************************************************
|
||||
|
||||
// ======================> ym2151
|
||||
|
||||
class ym2151
|
||||
{
|
||||
public:
|
||||
using fm_engine = fm_engine_base<opm_registers>;
|
||||
using output_data = fm_engine::output_data;
|
||||
static constexpr uint32_t OUTPUTS = fm_engine::OUTPUTS;
|
||||
|
||||
// constructor
|
||||
ym2151(ymfm_interface &intf) : ym2151(intf, VARIANT_YM2151) { }
|
||||
|
||||
// reset
|
||||
void reset();
|
||||
|
||||
// save/restore
|
||||
void save_restore(ymfm_saved_state &state);
|
||||
|
||||
// pass-through helpers
|
||||
uint32_t sample_rate(uint32_t input_clock) const { return m_fm.sample_rate(input_clock); }
|
||||
void invalidate_caches() { m_fm.invalidate_caches(); }
|
||||
|
||||
// read access
|
||||
uint8_t read_status();
|
||||
uint8_t read(uint32_t offset);
|
||||
|
||||
// write access
|
||||
void write_address(uint8_t data);
|
||||
void write_data(uint8_t data);
|
||||
void write(uint32_t offset, uint8_t data);
|
||||
|
||||
// generate one sample of sound
|
||||
void generate(output_data *output, uint32_t numsamples = 1);
|
||||
|
||||
protected:
|
||||
// variants
|
||||
enum opm_variant
|
||||
{
|
||||
VARIANT_YM2151,
|
||||
VARIANT_YM2164
|
||||
};
|
||||
|
||||
// internal constructor
|
||||
ym2151(ymfm_interface &intf, opm_variant variant);
|
||||
|
||||
// internal state
|
||||
opm_variant m_variant; // chip variant
|
||||
uint8_t m_address; // address register
|
||||
fm_engine m_fm; // core FM engine
|
||||
};
|
||||
|
||||
|
||||
|
||||
//*********************************************************
|
||||
// OPP IMPLEMENTATION CLASSES
|
||||
//*********************************************************
|
||||
|
||||
// ======================> ym2164
|
||||
|
||||
// the YM2164 is almost 100% functionally identical to the YM2151, except
|
||||
// it apparently has some mystery registers in the 00-07 range, and timer
|
||||
// B's frequency is half that of the 2151
|
||||
class ym2164 : public ym2151
|
||||
{
|
||||
public:
|
||||
// constructor
|
||||
ym2164(ymfm_interface &intf) : ym2151(intf, VARIANT_YM2164) { }
|
||||
};
|
||||
|
||||
}
|
||||
|
||||
|
||||
#endif // YMFM_OPM_H
|
||||
|
|
@ -3,7 +3,7 @@
|
|||
#include "../dispatch.h"
|
||||
#include "../macroInt.h"
|
||||
#include <queue>
|
||||
#include "sound/ym2610/ymfm_opn.h"
|
||||
#include "sound/ymfm/ymfm_opn.h"
|
||||
|
||||
class DivYM2610Interface: public ymfm::ymfm_interface {
|
||||
public:
|
||||
|
|
|
|||
|
|
@ -1,4 +1,4 @@
|
|||
#include "sound/ym2610/ymfm.h"
|
||||
#include "sound/ymfm/ymfm.h"
|
||||
#include "ym2610.h"
|
||||
#include "../engine.h"
|
||||
|
||||
|
|
|
|||
Loading…
Reference in New Issue