From e9075334a3cb515c88f1bb4822cac53affde46fd Mon Sep 17 00:00:00 2001 From: khokh2001 Date: Sun, 23 Nov 2014 00:36:22 +0900 Subject: [PATCH 1/3] new opl3 emulator --- src/CMakeLists.txt | 1 + src/oplsynth/mlopl_io.cpp | 4 +- src/oplsynth/nukedopl3.cpp | 1145 ++++++++++++++++++++++++++++++++++++ src/oplsynth/nukedopl3.h | 118 ++++ src/oplsynth/opl.h | 1 + wadsrc/static/menudef.txt | 1 + zdoom.vcproj | 8 + 7 files changed, 1276 insertions(+), 2 deletions(-) create mode 100644 src/oplsynth/nukedopl3.cpp create mode 100644 src/oplsynth/nukedopl3.h diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt index 2484b3ad9..605e32f23 100644 --- a/src/CMakeLists.txt +++ b/src/CMakeLists.txt @@ -992,6 +992,7 @@ add_executable( zdoom WIN32 oplsynth/opl_mus_player.cpp oplsynth/dosbox/opl.cpp oplsynth/OPL3.cpp + oplsynth/nukedopl3.cpp resourcefiles/ancientzip.cpp resourcefiles/file_7z.cpp resourcefiles/file_grp.cpp diff --git a/src/oplsynth/mlopl_io.cpp b/src/oplsynth/mlopl_io.cpp index b9d06629f..691463470 100644 --- a/src/oplsynth/mlopl_io.cpp +++ b/src/oplsynth/mlopl_io.cpp @@ -323,7 +323,7 @@ int OPLio::OPLinit(uint numchips, bool stereo, bool initopl3) { assert(numchips >= 1 && numchips <= countof(chips)); uint i; - IsOPL3 = (opl_core == 1 || opl_core == 2); + IsOPL3 = (opl_core == 1 || opl_core == 2 || opl_core == 3); memset(chips, 0, sizeof(chips)); if (IsOPL3) @@ -332,7 +332,7 @@ int OPLio::OPLinit(uint numchips, bool stereo, bool initopl3) } for (i = 0; i < numchips; ++i) { - OPLEmul *chip = IsOPL3 ? (opl_core == 1 ? DBOPLCreate(stereo) : JavaOPLCreate(stereo)) : YM3812Create(stereo); + OPLEmul *chip = IsOPL3 ? (opl_core == 1 ? DBOPLCreate(stereo) : (opl_core == 2 ? JavaOPLCreate(stereo) : NukedOPL3Create(stereo))) : YM3812Create(stereo); if (chip == NULL) { break; diff --git a/src/oplsynth/nukedopl3.cpp b/src/oplsynth/nukedopl3.cpp new file mode 100644 index 000000000..95d03ae8d --- /dev/null +++ b/src/oplsynth/nukedopl3.cpp @@ -0,0 +1,1145 @@ +/* +* Copyright (C) 2013-2014 Nuke.YKT +* +* This library is free software; you can redistribute it and/or +* modify it under the terms of the GNU Lesser General Public +* License as published by the Free Software Foundation; either +* version 2.1 of the License, or (at your option) any later version. +* +* This library 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 +* Lesser General Public License for more details. +* +* You should have received a copy of the GNU Lesser General Public +* License along with this library; if not, write to the Free Software +* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA +*/ + +/* + Nuked Yamaha YMF262(aka OPL3) emulator. + Thanks: + MAME Development Team: + Feedback and Rhythm part calculation information. + forums.submarine.org.uk(carbon14, opl3): + Tremolo and phase generator calculation information. +*/ + +//version 1.4.2 + +/* Changelog: + v1.1: + Vibrato's sign fix + v1.2: + Operator key fix + Corrected 4-operator mode + Corrected rhythm mode + Some small fixes + v1.2.1: + Small envelope generator fix + Removed EX_Get function(not used) + v1.3: + Complete rewrite + (Not released) + v1.4: + New envelope and waveform generator + Some small fixes. + (Not released) + v1.4.1: + Envelope generator rate calculation fix + (Not released) + v1.4.2: + Version for ZDoom. +*/ + + +/* Verified: + Noise generator. + Waveform generator. + Envelope generator increase table. + Tremolo. +*/ + +/* TODO: + Verify: + kslrom[15] value(is it 128?). + Sustain level = 15. + Vibrato, Phase generator. + Rhythm part. + Envelope generator state switching(decay->sustain when egt = 1 and decay->release). + Feedback. + Register write. + 4-operator. +*/ + +#include +#include +#include "nukedopl3.h" + +// Channel types + +enum { + ch_4op2, + ch_2op, + ch_4op, + ch_drum +}; + +// Envelope generator states + +enum { + eg_off, + eg_attack, + eg_decay, + eg_sustain, + eg_release +}; + +// Envelope key types + +enum { + egk_norm = 1, + egk_drum = 2 +}; + +// +// logsin table +// + +static const Bit16u logsinrom[256] = { + 0x859, 0x6c3, 0x607, 0x58b, 0x52e, 0x4e4, 0x4a6, 0x471, 0x443, 0x41a, 0x3f5, 0x3d3, 0x3b5, 0x398, 0x37e, 0x365, + 0x34e, 0x339, 0x324, 0x311, 0x2ff, 0x2ed, 0x2dc, 0x2cd, 0x2bd, 0x2af, 0x2a0, 0x293, 0x286, 0x279, 0x26d, 0x261, + 0x256, 0x24b, 0x240, 0x236, 0x22c, 0x222, 0x218, 0x20f, 0x206, 0x1fd, 0x1f5, 0x1ec, 0x1e4, 0x1dc, 0x1d4, 0x1cd, + 0x1c5, 0x1be, 0x1b7, 0x1b0, 0x1a9, 0x1a2, 0x19b, 0x195, 0x18f, 0x188, 0x182, 0x17c, 0x177, 0x171, 0x16b, 0x166, + 0x160, 0x15b, 0x155, 0x150, 0x14b, 0x146, 0x141, 0x13c, 0x137, 0x133, 0x12e, 0x129, 0x125, 0x121, 0x11c, 0x118, + 0x114, 0x10f, 0x10b, 0x107, 0x103, 0x0ff, 0x0fb, 0x0f8, 0x0f4, 0x0f0, 0x0ec, 0x0e9, 0x0e5, 0x0e2, 0x0de, 0x0db, + 0x0d7, 0x0d4, 0x0d1, 0x0cd, 0x0ca, 0x0c7, 0x0c4, 0x0c1, 0x0be, 0x0bb, 0x0b8, 0x0b5, 0x0b2, 0x0af, 0x0ac, 0x0a9, + 0x0a7, 0x0a4, 0x0a1, 0x09f, 0x09c, 0x099, 0x097, 0x094, 0x092, 0x08f, 0x08d, 0x08a, 0x088, 0x086, 0x083, 0x081, + 0x07f, 0x07d, 0x07a, 0x078, 0x076, 0x074, 0x072, 0x070, 0x06e, 0x06c, 0x06a, 0x068, 0x066, 0x064, 0x062, 0x060, + 0x05e, 0x05c, 0x05b, 0x059, 0x057, 0x055, 0x053, 0x052, 0x050, 0x04e, 0x04d, 0x04b, 0x04a, 0x048, 0x046, 0x045, + 0x043, 0x042, 0x040, 0x03f, 0x03e, 0x03c, 0x03b, 0x039, 0x038, 0x037, 0x035, 0x034, 0x033, 0x031, 0x030, 0x02f, + 0x02e, 0x02d, 0x02b, 0x02a, 0x029, 0x028, 0x027, 0x026, 0x025, 0x024, 0x023, 0x022, 0x021, 0x020, 0x01f, 0x01e, + 0x01d, 0x01c, 0x01b, 0x01a, 0x019, 0x018, 0x017, 0x017, 0x016, 0x015, 0x014, 0x014, 0x013, 0x012, 0x011, 0x011, + 0x010, 0x00f, 0x00f, 0x00e, 0x00d, 0x00d, 0x00c, 0x00c, 0x00b, 0x00a, 0x00a, 0x009, 0x009, 0x008, 0x008, 0x007, + 0x007, 0x007, 0x006, 0x006, 0x005, 0x005, 0x005, 0x004, 0x004, 0x004, 0x003, 0x003, 0x003, 0x002, 0x002, 0x002, + 0x002, 0x001, 0x001, 0x001, 0x001, 0x001, 0x001, 0x001, 0x000, 0x000, 0x000, 0x000, 0x000, 0x000, 0x000, 0x000 +}; + +// +// exp table +// + +static const Bit16u exprom[256] = { + 0x000, 0x003, 0x006, 0x008, 0x00b, 0x00e, 0x011, 0x014, 0x016, 0x019, 0x01c, 0x01f, 0x022, 0x025, 0x028, 0x02a, + 0x02d, 0x030, 0x033, 0x036, 0x039, 0x03c, 0x03f, 0x042, 0x045, 0x048, 0x04b, 0x04e, 0x051, 0x054, 0x057, 0x05a, + 0x05d, 0x060, 0x063, 0x066, 0x069, 0x06c, 0x06f, 0x072, 0x075, 0x078, 0x07b, 0x07e, 0x082, 0x085, 0x088, 0x08b, + 0x08e, 0x091, 0x094, 0x098, 0x09b, 0x09e, 0x0a1, 0x0a4, 0x0a8, 0x0ab, 0x0ae, 0x0b1, 0x0b5, 0x0b8, 0x0bb, 0x0be, + 0x0c2, 0x0c5, 0x0c8, 0x0cc, 0x0cf, 0x0d2, 0x0d6, 0x0d9, 0x0dc, 0x0e0, 0x0e3, 0x0e7, 0x0ea, 0x0ed, 0x0f1, 0x0f4, + 0x0f8, 0x0fb, 0x0ff, 0x102, 0x106, 0x109, 0x10c, 0x110, 0x114, 0x117, 0x11b, 0x11e, 0x122, 0x125, 0x129, 0x12c, + 0x130, 0x134, 0x137, 0x13b, 0x13e, 0x142, 0x146, 0x149, 0x14d, 0x151, 0x154, 0x158, 0x15c, 0x160, 0x163, 0x167, + 0x16b, 0x16f, 0x172, 0x176, 0x17a, 0x17e, 0x181, 0x185, 0x189, 0x18d, 0x191, 0x195, 0x199, 0x19c, 0x1a0, 0x1a4, + 0x1a8, 0x1ac, 0x1b0, 0x1b4, 0x1b8, 0x1bc, 0x1c0, 0x1c4, 0x1c8, 0x1cc, 0x1d0, 0x1d4, 0x1d8, 0x1dc, 0x1e0, 0x1e4, + 0x1e8, 0x1ec, 0x1f0, 0x1f5, 0x1f9, 0x1fd, 0x201, 0x205, 0x209, 0x20e, 0x212, 0x216, 0x21a, 0x21e, 0x223, 0x227, + 0x22b, 0x230, 0x234, 0x238, 0x23c, 0x241, 0x245, 0x249, 0x24e, 0x252, 0x257, 0x25b, 0x25f, 0x264, 0x268, 0x26d, + 0x271, 0x276, 0x27a, 0x27f, 0x283, 0x288, 0x28c, 0x291, 0x295, 0x29a, 0x29e, 0x2a3, 0x2a8, 0x2ac, 0x2b1, 0x2b5, + 0x2ba, 0x2bf, 0x2c4, 0x2c8, 0x2cd, 0x2d2, 0x2d6, 0x2db, 0x2e0, 0x2e5, 0x2e9, 0x2ee, 0x2f3, 0x2f8, 0x2fd, 0x302, + 0x306, 0x30b, 0x310, 0x315, 0x31a, 0x31f, 0x324, 0x329, 0x32e, 0x333, 0x338, 0x33d, 0x342, 0x347, 0x34c, 0x351, + 0x356, 0x35b, 0x360, 0x365, 0x36a, 0x370, 0x375, 0x37a, 0x37f, 0x384, 0x38a, 0x38f, 0x394, 0x399, 0x39f, 0x3a4, + 0x3a9, 0x3ae, 0x3b4, 0x3b9, 0x3bf, 0x3c4, 0x3c9, 0x3cf, 0x3d4, 0x3da, 0x3df, 0x3e4, 0x3ea, 0x3ef, 0x3f5, 0x3fa +}; + +// +// freq mult table multiplied by 2 +// +// 1/2, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 10, 12, 12, 15, 15 +// + +static const Bit8u mt[16] = { 1, 2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 20, 24, 24, 30, 30 }; + +// +// ksl table +// + +static const Bit8u kslrom[16] = { 0, 64, 80, 90, 96, 102, 106, 110, 112, 116, 118, 120, 122, 124, 126, 127 }; + +static const Bit8u kslshift[4] = { 8, 1, 2, 0 }; + +// +// LFO vibrato +// + +static const Bit8u vib_table[8] = { 3, 1, 0, 1, 3, 1, 0, 1 }; +static const Bit8s vibsgn_table[8] = { 1, 1, 1, 1, -1, -1, -1, -1 }; + +// +// envelope generator constants +// + +static const Bit8u eg_incstep[3][4][8] = { + { { 0, 0, 0, 0, 0, 0, 0, 0 }, { 0, 0, 0, 0, 0, 0, 0, 0 }, { 0, 0, 0, 0, 0, 0, 0, 0 }, { 0, 0, 0, 0, 0, 0, 0, 0 } }, + { { 0, 1, 0, 1, 0, 1, 0, 1 }, { 1, 1, 0, 1, 0, 1, 0, 1 }, { 1, 1, 0, 1, 1, 1, 0, 1 }, { 1, 1, 1, 1, 1, 1, 0, 1 } }, + { { 1, 1, 1, 1, 1, 1, 1, 1 }, { 2, 2, 1, 1, 1, 1, 1, 1 }, { 2, 2, 1, 1, 2, 2, 1, 1 }, { 2, 2, 2, 2, 2, 2, 1, 1 } } +}; + +// +// address decoding +// + +static const Bit8s ad_slot[0x20] = { 0, 2, 4, 1, 3, 5, -1, -1, 6, 8, 10, 7, 9, 11, -1, -1, 12, 14, 16, 13, 15, 17, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1 }; + +static const Bit8u op_offset[18] = { 0x00, 0x03, 0x01, 0x04, 0x02, 0x05, 0x08, 0x0b, 0x09, 0x0c, 0x0a, 0x0d, 0x10, 0x13, 0x11, 0x14, 0x12, 0x15 }; + + + +static const Bit8u eg_incdesc[16] = { + 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 2 +}; + +static const Bit8s eg_incsh[16] = { + 0, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0, 0, -1, -2 +}; + +typedef Bit16s(*envelope_sinfunc)(Bit16u phase, Bit16u envelope); +typedef void(*envelope_genfunc)(slot *slott); + +// +// Phase generator +// + +void PG_Generate(chip *opl, Bit8u op) { + slot *slt = &opl->OPs[op]; + channel *chan = &opl->Channels[op / 2]; + Bit16u fnum = chan->f_number; + if (slt->vibrato) { + Bit8u fnum_high = chan->f_number >> (7 + vib_table[opl->vib_pos] + (!opl->dvb)); + fnum += fnum_high * vibsgn_table[opl->vib_pos]; + } + slt->PG_pos += (((fnum << chan->block) >> 1) * mt[slt->mult]) >> 1; +} + +// +// Envelope generator +// + +Bit16s envelope_calcexp(Bit32u level) { + return ((exprom[(level & 0xff) ^ 0xff] | 0x400) << 1) >> (level >> 8); +} + +Bit16s envelope_calcsin0(Bit16u phase, Bit16u envelope) { + phase &= 0x3ff; + Bit16u out = 0; + Bit16u neg = 0; + if (phase & 0x200 && (phase & 0x1ff)) { + phase--; + neg = ~0; + } + if (phase & 0x100) { + out = logsinrom[(phase & 0xff) ^ 0xff]; + } + else { + out = logsinrom[phase & 0xff]; + } + return envelope_calcexp(out + (envelope << 3)) ^ neg; +} + +Bit16s envelope_calcsin1(Bit16u phase, Bit16u envelope) { + phase &= 0x3ff; + Bit16u out = 0; + if (phase & 0x200) { + out = 0x1000; + } + else if (phase & 0x100) { + out = logsinrom[(phase & 0xff) ^ 0xff]; + } + else { + out = logsinrom[phase & 0xff]; + } + return envelope_calcexp(out + (envelope << 3)); +} + +Bit16s envelope_calcsin2(Bit16u phase, Bit16u envelope) { + phase &= 0x3ff; + Bit16u out = 0; + if (phase & 0x100) { + out = logsinrom[(phase & 0xff) ^ 0xff]; + } + else { + out = logsinrom[phase & 0xff]; + } + return envelope_calcexp(out + (envelope << 3)); +} + +Bit16s envelope_calcsin3(Bit16u phase, Bit16u envelope) { + phase &= 0x3ff; + Bit16u out = 0; + if (phase & 0x100) { + out = 0x1000; + } + else { + out = logsinrom[phase & 0xff]; + } + return envelope_calcexp(out + (envelope << 3)); +} + +Bit16s envelope_calcsin4(Bit16u phase, Bit16u envelope) { + phase &= 0x3ff; + Bit16u out = 0; + Bit16u neg = 0; + if ((phase & 0x300) == 0x100 && (phase & 0xff)) { + phase--; + neg = ~0; + } + if (phase & 0x200) { + out = 0x1000; + } + else if (phase & 0x80) { + out = logsinrom[((phase ^ 0xff) << 1) & 0xff]; + } + else { + out = logsinrom[(phase << 1) & 0xff]; + } + return envelope_calcexp(out + (envelope << 3)) ^ neg; +} + +Bit16s envelope_calcsin5(Bit16u phase, Bit16u envelope) { + phase &= 0x3ff; + Bit16u out = 0; + if (phase & 0x200) { + out = 0x1000; + } + else if (phase & 0x80) { + out = logsinrom[((phase ^ 0xff) << 1) & 0xff]; + } + else { + out = logsinrom[(phase << 1) & 0xff]; + } + return envelope_calcexp(out + (envelope << 3)); +} + +Bit16s envelope_calcsin6(Bit16u phase, Bit16u envelope) { + phase &= 0x3ff; + Bit16u neg = 0; + if (phase & 0x200 && (phase & 0x1ff)) { + phase--; + neg = ~0; + } + return envelope_calcexp(envelope << 3) ^ neg; +} + +Bit16s envelope_calcsin7(Bit16u phase, Bit16u envelope) { + phase &= 0x3ff; + Bit16u out = 0; + Bit16u neg = 0; + if (phase & 0x200 && (phase & 0x1ff)) { + phase--; + neg = ~0; + phase = (phase & 0x1ff) ^ 0x1ff; + } + out = phase << 3; + return envelope_calcexp(out + (envelope << 3)) ^ neg; +} + +envelope_sinfunc envelope_sin[8] = { + envelope_calcsin0, + envelope_calcsin1, + envelope_calcsin2, + envelope_calcsin3, + envelope_calcsin4, + envelope_calcsin5, + envelope_calcsin6, + envelope_calcsin7 +}; + +void envelope_gen_off(slot *slott); +void envelope_gen_change(slot *slott); +void envelope_gen_attack(slot *slott); +void envelope_gen_decay(slot *slott); +void envelope_gen_sustain(slot *slott); +void envelope_gen_release(slot *slott); + +envelope_genfunc envelope_gen[6] = { + envelope_gen_off, + envelope_gen_attack, + envelope_gen_decay, + envelope_gen_sustain, + envelope_gen_release, + envelope_gen_change +}; + +enum envelope_gen_num { + envelope_gen_num_off = 0, + envelope_gen_num_attack = 1, + envelope_gen_num_decay = 2, + envelope_gen_num_sustain = 3, + envelope_gen_num_release = 4, + envelope_gen_num_change = 5 +}; + +void envelope_gen_off(slot *slott) { + slott->EG_out = 0x1ff; +} + +void envelope_gen_change(slot *slott) { + slott->eg_gen = slott->eg_gennext; +} + +void envelope_gen_attack(slot *slott) { + slott->EG_out += ((~slott->EG_out) *slott->eg_inc) >> 3; + if (slott->EG_out < 0x00) { + slott->EG_out = 0x00; + } + if (slott->EG_out == 0x00) { + slott->eg_gen = envelope_gen_num_change; + slott->eg_gennext = envelope_gen_num_decay; + } +} + +void envelope_gen_decay(slot *slott) { + slott->EG_out += slott->eg_inc; + if (slott->EG_out >= slott->EG_sl << 4) { + slott->eg_gen = envelope_gen_num_change; + slott->eg_gennext = envelope_gen_num_sustain; + } +} + +void envelope_gen_sustain(slot *slott) { + if (!slott->EG_type) { + envelope_gen_release(slott); + } +} + +void envelope_gen_release(slot *slott) { + slott->EG_out += slott->eg_inc; + if (slott->EG_out >= 0x1ff) { + slott->eg_gen = envelope_gen_num_change; + slott->eg_gennext = envelope_gen_num_off; + } +} + +Bit8u EG_CalcRate(chip *opl, Bit8u op, Bit8u rate) { + slot *slt = &opl->OPs[op]; + channel *chan = &opl->Channels[op / 2]; + if (rate == 0x00) { + return 0x00; + } + Bit8u rof = slt->ksr ? chan->ksv : (chan->ksv >> 2); + Bit8u rat = (rate << 2) + rof; + if (rat > 0x3c) { + rat = 0x3c; + } + return rat; +} + +void envelope_calc(chip *opl, Bit8u op) { + slot *slott = &opl->OPs[op]; + Bit16u timer = opl->timer; + Bit8u rate_h, rate_l; + Bit8u rate; + Bit8u reg_rate = 0;; + switch (slott->eg_gen) { + case envelope_gen_num_attack: + reg_rate = slott->EG_ar; + break; + case envelope_gen_num_decay: + reg_rate = slott->EG_dr; + break; + case envelope_gen_num_sustain: + case envelope_gen_num_release: + reg_rate = slott->EG_rr; + break; + } + rate = EG_CalcRate(opl, op, reg_rate); + rate_h = rate >> 2; + rate_l = rate & 3; + Bit8u inc = 0; + if (slott->eg_gen == envelope_gen_num_attack && rate_h == 0x0f) { + inc = 8; + } + else if (eg_incsh[rate_h] > 0) { + if ((timer & ((1 << eg_incsh[rate_h]) - 1)) == 0) { + inc = eg_incstep[eg_incdesc[rate_h]][rate_l][((timer) >> eg_incsh[rate_h]) & 0x07]; + } + } + else { + inc = eg_incstep[eg_incdesc[rate_h]][rate_l][timer & 0x07] << (-eg_incsh[rate_h]); + } + slott->eg_inc = inc; + envelope_gen[slott->eg_gen](slott); +} + +void EG_UpdateKSL(chip *opl, Bit8u op) { + slot *slt = &opl->OPs[op]; + channel *chan = &opl->Channels[op / 2]; + Bit8u fnum_high = (chan->f_number >> 6) & 0x0f; + Bit16s ksl = (kslrom[fnum_high] << 1) - ((chan->block ^ 0x07) << 5) - 0x20; + if (ksl < 0x00) { + ksl = 0x00; + } + slt->EG_ksl = ksl >> kslshift[slt->ksl]; +} + +void EG_Generate(chip *opl, Bit8u op) { + slot *slt = &opl->OPs[op]; + envelope_calc(opl, op); + slt->EG_mout = slt->EG_out + slt->EG_ksl + (slt->EG_tl << 2); + if (slt->tremolo) { + slt->EG_mout += opl->trem_val; + } + if (slt->EG_mout > 0x1ff) { + slt->EG_mout = 0x1ff; + } +} + +void EG_KeyOn(chip *opl, Bit8u op, Bit8u type) { + slot *slt = &opl->OPs[op]; + if (!slt->key) { + slt->EG_state = eg_attack; + slt->eg_gen = envelope_gen_num_change; + slt->eg_gennext = envelope_gen_num_attack; + slt->PG_pos = 0; + } + slt->key |= type; +} + +void EG_KeyOff(chip *opl, Bit8u op, Bit8u type) { + slot *slt = &opl->OPs[op]; + if (slt->key) { + slt->key &= (~type); + if (slt->key == 0x00) { + slt->EG_state = eg_release; + slt->eg_gen = envelope_gen_num_change; + slt->eg_gennext = envelope_gen_num_release; + } + } +} + +// +// Noise Generator +// + +void N_Generate(chip *opl) { + if (opl->noise & 1) { + opl->noise ^= 0x800302; + } + opl->noise >>= 1; +} + +// +// Operator(Slot) +// + +void OP_Update20(chip *opl, Bit8u op) { + slot *slt = &opl->OPs[op]; + slt->tremolo = (opl->opl_memory[0x20 + slt->offset] >> 7); + slt->vibrato = (opl->opl_memory[0x20 + slt->offset] >> 6) & 0x01; + slt->EG_type = (opl->opl_memory[0x20 + slt->offset] >> 5) & 0x01; + slt->ksr = (opl->opl_memory[0x20 + slt->offset] >> 4) & 0x01; + slt->mult = (opl->opl_memory[0x20 + slt->offset]) & 0x0f; +} + +void OP_Update40(chip *opl, Bit8u op) { + slot *slt = &opl->OPs[op]; + slt->EG_tl = (opl->opl_memory[0x40 + slt->offset]) & 0x3f; + slt->ksl = (opl->opl_memory[0x40 + slt->offset] >> 6) & 0x03; + EG_UpdateKSL(opl, op); +} + +void OP_Update60(chip *opl, Bit8u op) { + slot *slt = &opl->OPs[op]; + slt->EG_dr = (opl->opl_memory[0x60 + slt->offset]) & 0x0f; + slt->EG_ar = (opl->opl_memory[0x60 + slt->offset] >> 4) & 0x0f; +} + +void OP_Update80(chip *opl, Bit8u op) { + slot *slt = &opl->OPs[op]; + slt->EG_rr = (opl->opl_memory[0x80 + slt->offset]) & 0x0f; + slt->EG_sl = (opl->opl_memory[0x80 + slt->offset] >> 4) & 0x0f; + if (slt->EG_sl == 0x0f) { + slt->EG_sl = 0x1f; + } +} + +void OP_UpdateE0(chip *opl, Bit8u op) { + slot *slt = &opl->OPs[op]; + slt->waveform = opl->opl_memory[0xe0 + slt->offset] & 0x07; + if (!opl->newm) { + slt->waveform &= 0x03; + } +} + +void OP_GeneratePhase(chip *opl, Bit8u op, Bit16u phase) { + slot *slt = &opl->OPs[op]; + slt->out = envelope_sin[slt->waveform](phase, slt->EG_out); +} + +void OP_Generate(chip *opl, Bit8u op) { + slot *slt = &opl->OPs[op]; + slt->out = envelope_sin[slt->waveform]((Bit16u)((slt->PG_pos >> 9) + (*slt->mod)), slt->EG_mout); +} + +void OP_GenerateZM(chip *opl, Bit8u op) { + slot *slt = &opl->OPs[op]; + slt->out = envelope_sin[slt->waveform]((Bit16u)(slt->PG_pos >> 9), slt->EG_mout); +} + +void OP_CalcFB(chip *opl, Bit8u op) { + slot *slt = &opl->OPs[op]; + channel *chan = &opl->Channels[op / 2]; + slt->prevout[1] = slt->prevout[0]; + slt->prevout[0] = slt->out; + if (chan->feedback) { + slt->fbmod = (slt->prevout[0] + slt->prevout[1]) >> chan->feedback; + } else { + slt->fbmod = 0; + } +} + +// +// Channel +// + +void CH_UpdateRhythm(chip *opl) { + opl->rhythm = (opl->opl_memory[0xbd] & 0x3f); + if (opl->rhythm & 0x20) { + for (Bit8u i = 6; i < 9; i++) { + opl->Channels[i].chtype = ch_drum; + } + //HH + if (opl->rhythm & 0x01) { + EG_KeyOn(opl, 14, egk_drum); + } else { + EG_KeyOff(opl, 14, egk_drum); + } + //TC + if (opl->rhythm & 0x02) { + EG_KeyOn(opl, 17, egk_drum); + } else { + EG_KeyOff(opl, 17, egk_drum); + } + //TOM + if (opl->rhythm & 0x04) { + EG_KeyOn(opl, 16, egk_drum); + } else { + EG_KeyOff(opl, 16, egk_drum); + } + //SD + if (opl->rhythm & 0x08) { + EG_KeyOn(opl, 15, egk_drum); + } else { + EG_KeyOff(opl, 15, egk_drum); + } + //BD + if (opl->rhythm & 0x10) { + EG_KeyOn(opl, 12, egk_drum); + EG_KeyOn(opl, 13, egk_drum); + } else { + EG_KeyOff(opl, 12, egk_drum); + EG_KeyOff(opl, 13, egk_drum); + } + } else { + for (Bit8u i = 6; i < 9; i++) { + opl->Channels[i].chtype = ch_2op; + } + } +} + +void CH_UpdateAB0(chip *opl, Bit8u ch) { + channel *chan = &opl->Channels[ch]; + if (opl->newm && chan->chtype == ch_4op2) { + return; + } + Bit16u f_number = (opl->opl_memory[0xa0 + chan->offset]) | (((opl->opl_memory[0xb0 + chan->offset]) & 0x03) << 8); + Bit8u block = ((opl->opl_memory[0xb0 + chan->offset]) >> 2) & 0x07; + Bit8u ksv = block * 2 | ((f_number >> (9 - opl->nts)) & 0x01); + chan->f_number = f_number; + chan->block = block; + chan->ksv = ksv; + EG_UpdateKSL(opl, ch * 2); + EG_UpdateKSL(opl, ch * 2 + 1); + OP_Update60(opl, ch * 2); + OP_Update60(opl, ch * 2 + 1); + OP_Update80(opl, ch * 2); + OP_Update80(opl, ch * 2 + 1); + if (opl->newm && chan->chtype == ch_4op) { + chan = &opl->Channels[ch + 3]; + chan->f_number = f_number; + chan->block = block; + chan->ksv = ksv; + EG_UpdateKSL(opl, (ch + 3) * 2); + EG_UpdateKSL(opl, (ch + 3) * 2 + 1); + OP_Update60(opl, (ch + 3) * 2); + OP_Update60(opl, (ch + 3) * 2 + 1); + OP_Update80(opl, (ch + 3) * 2); + OP_Update80(opl, (ch + 3) * 2 + 1); + } +} + +void CH_SetupAlg(chip *opl, Bit8u ch) { + channel *chan = &opl->Channels[ch]; + if (chan->alg & 0x08) { + return; + } + if (chan->alg & 0x04) { + switch (chan->alg & 0x03) { + case 0: + opl->OPs[(ch - 3) * 2].mod = &opl->OPs[(ch - 3) * 2].fbmod; + opl->OPs[(ch - 3) * 2 + 1].mod = &opl->OPs[(ch - 3) * 2].out; + opl->OPs[ch * 2].mod = &opl->OPs[(ch - 3) * 2 + 1].out; + opl->OPs[ch * 2 + 1].mod = &opl->OPs[ch * 2].out; + break; + case 1: + opl->OPs[(ch - 3) * 2].mod = &opl->OPs[(ch - 3) * 2].fbmod; + opl->OPs[(ch - 3) * 2 + 1].mod = &opl->OPs[(ch - 3) * 2].out; + opl->OPs[ch * 2].mod = &opl->zm; + opl->OPs[ch * 2 + 1].mod = &opl->OPs[ch * 2].out; + break; + case 2: + opl->OPs[(ch - 3) * 2].mod = &opl->OPs[(ch - 3) * 2].fbmod; + opl->OPs[(ch - 3) * 2 + 1].mod = &opl->zm; + opl->OPs[ch * 2].mod = &opl->OPs[(ch - 3) * 2 + 1].out; + opl->OPs[ch * 2 + 1].mod = &opl->OPs[ch * 2].out; + break; + case 3: + opl->OPs[(ch - 3) * 2].mod = &opl->OPs[(ch - 3) * 2].fbmod; + opl->OPs[(ch - 3) * 2 + 1].mod = &opl->zm; + opl->OPs[ch * 2].mod = &opl->OPs[(ch - 3) * 2 + 1].out; + opl->OPs[ch * 2 + 1].mod = &opl->zm; + break; + } + } else { + switch (chan->alg & 0x01) { + case 0: + opl->OPs[ch * 2].mod = &opl->OPs[ch * 2].fbmod; + opl->OPs[ch * 2 + 1].mod = &opl->OPs[ch * 2].out; + break; + case 1: + opl->OPs[ch * 2].mod = &opl->OPs[ch * 2].fbmod; + opl->OPs[ch * 2 + 1].mod = &opl->zm; + break; + } + } +} + +void CH_UpdateC0(chip *opl, Bit8u ch) { + channel *chan = &opl->Channels[ch]; + Bit8u fb = (opl->opl_memory[0xc0 + chan->offset] & 0x0e) >> 1; + chan->feedback = fb ? (9 - fb) : 0; + chan->con = opl->opl_memory[0xc0 + chan->offset] & 0x01; + chan->alg = chan->con; + if (opl->newm) { + if (chan->chtype == ch_4op) { + channel *chan1 = &opl->Channels[ch + 3]; + chan1->alg = 0x04 | (chan->con << 1) | (chan1->con); + chan->alg = 0x08; + CH_SetupAlg(opl, ch + 3); + } else if (chan->chtype == ch_4op2) { + channel *chan1 = &opl->Channels[ch - 3]; + chan->alg = 0x04 | (chan1->con << 1) | (chan->con); + chan1->alg = 0x08; + CH_SetupAlg(opl, ch); + } else { + CH_SetupAlg(opl, ch); + } + } else { + CH_SetupAlg(opl, ch); + } + if (opl->newm) { + chan->cha = ((opl->opl_memory[0xc0 + chan->offset] >> 4) & 0x01) ? ~0 : 0; + chan->chb = ((opl->opl_memory[0xc0 + chan->offset] >> 5) & 0x01) ? ~0 : 0; + chan->chc = ((opl->opl_memory[0xc0 + chan->offset] >> 6) & 0x01) ? ~0 : 0; + chan->chd = ((opl->opl_memory[0xc0 + chan->offset] >> 7) & 0x01) ? ~0 : 0; + } else { + opl->Channels[ch].cha = opl->Channels[ch].chb = ~0; + opl->Channels[ch].chc = opl->Channels[ch].chd = 0; + } +} + +void CH_Set2OP(chip *opl) { + for (Bit8u i = 0; i < 18; i++) { + opl->Channels[i].chtype = ch_2op; + CH_UpdateC0(opl, i); + } +} + +void CH_Set4OP(chip *opl) { + for (Bit8u i = 0; i < 3; i++) { + if ((opl->opl_memory[0x104] >> i) & 0x01) { + opl->Channels[i].chtype = ch_4op; + opl->Channels[i + 3].chtype = ch_4op2; + CH_UpdateC0(opl, i); + CH_UpdateC0(opl, i + 3); + } + if ((opl->opl_memory[0x104] >> (i + 3)) & 0x01) { + opl->Channels[i + 9].chtype = ch_4op; + opl->Channels[i + 3 + 9].chtype = ch_4op2; + CH_UpdateC0(opl, i + 9); + CH_UpdateC0(opl, i + 3 + 9); + } + } +} + +void CH_GenerateRhythm(chip *opl) { + if (opl->rhythm & 0x20) { + channel *chan6 = &opl->Channels[6]; + channel *chan7 = &opl->Channels[7]; + channel *chan8 = &opl->Channels[8]; + slot *slt12 = &opl->OPs[12]; + slot *slt13 = &opl->OPs[13]; + slot *slt14 = &opl->OPs[14]; + slot *slt15 = &opl->OPs[15]; + slot *slt16 = &opl->OPs[16]; + slot *slt17 = &opl->OPs[17]; + //BD + OP_Generate(opl, 12); + OP_Generate(opl, 13); + chan6->out = slt13->out * 2; + Bit16u P14 = (slt14->PG_pos >> 9) & 0x3ff; + Bit16u P17 = (slt17->PG_pos >> 9) & 0x3ff; + Bit16u phase = 0; + // HH TC Phase bit + Bit16u PB = ((P14 & 0x08) | (((P14 >> 5) ^ P14) & 0x04) | (((P17 >> 2) ^ P17) & 0x08)) ? 0x01 : 0x00; + //HH + phase = (PB << 9) | (0x34 << ((PB ^ (opl->noise & 0x01) << 1))); + OP_GeneratePhase(opl, 14, phase); + //SD + phase = (0x100 << ((P14 >> 8) & 0x01)) ^ ((opl->noise & 0x01) << 8); + OP_GeneratePhase(opl, 15, phase); + //TT + OP_GenerateZM(opl, 16); + //TC + phase = 0x100 | (PB << 9); + OP_GeneratePhase(opl, 17, phase); + chan7->out = (slt14->out + slt15->out) * 2; + chan8->out = (slt16->out + slt17->out) * 2; + } +} + +void CH_Generate(chip *opl, Bit8u ch) { + channel *chan = &opl->Channels[ch]; + if (chan->chtype == ch_drum) { + return; + } + if (chan->alg & 0x08) { + chan->out = 0; + return; + } else if (chan->alg & 0x04) { + OP_Generate(opl, (ch - 3) * 2); + OP_Generate(opl, (ch - 3) * 2 + 1); + OP_Generate(opl, ch * 2); + OP_Generate(opl, ch * 2 + 1); + switch (chan->alg & 0x03) { + case 0: + chan->out = opl->OPs[ch * 2 + 1].out; + break; + case 1: + chan->out = opl->OPs[(ch - 3) * 2 + 1].out + opl->OPs[ch * 2 + 1].out; + break; + case 2: + chan->out = opl->OPs[(ch - 3) * 2].out + opl->OPs[ch * 2 + 1].out; + break; + case 3: + chan->out = opl->OPs[(ch - 3) * 2].out + opl->OPs[ch * 2].out + opl->OPs[ch * 2 + 1].out; + break; + } + } + else { + OP_Generate(opl, ch * 2); + OP_Generate(opl, ch * 2 + 1); + switch (chan->alg & 0x01) { + case 0: + chan->out = opl->OPs[ch * 2 + 1].out; + break; + case 1: + chan->out = opl->OPs[ch * 2].out + opl->OPs[ch * 2 + 1].out; + break; + } + } +} + +void CH_Enable(chip *opl, Bit8u ch) { + channel *chan = &opl->Channels[ch]; + if (opl->newm) { + if (chan->chtype == ch_4op) { + EG_KeyOn(opl, ch * 2, egk_norm); + EG_KeyOn(opl, ch * 2 + 1, egk_norm); + EG_KeyOn(opl, (ch + 3) * 2, egk_norm); + EG_KeyOn(opl, (ch + 3) * 2 + 1, egk_norm); + } + else if (chan->chtype == ch_2op || chan->chtype == ch_drum) { + EG_KeyOn(opl, ch * 2, egk_norm); + EG_KeyOn(opl, ch * 2 + 1, egk_norm); + } + } + else { + EG_KeyOn(opl, ch * 2, egk_norm); + EG_KeyOn(opl, ch * 2 + 1, egk_norm); + } +} + +void CH_Disable(chip *opl, Bit8u ch) { + channel *chan = &opl->Channels[ch]; + if (opl->newm) { + if (chan->chtype == ch_4op) { + EG_KeyOff(opl, ch * 2, egk_norm); + EG_KeyOff(opl, ch * 2 + 1, egk_norm); + EG_KeyOff(opl, (ch + 3) * 2, egk_norm); + EG_KeyOff(opl, (ch + 3) * 2 + 1, egk_norm); + } + else if (chan->chtype == ch_2op || chan->chtype == ch_drum) { + EG_KeyOff(opl, ch * 2, egk_norm); + EG_KeyOff(opl, ch * 2 + 1, egk_norm); + } + } + else { + EG_KeyOff(opl, ch * 2, egk_norm); + EG_KeyOff(opl, ch * 2 + 1, egk_norm); + } +} + +Bit16s limshort(Bit32s a) { + if (a > 32767) { + a = 32767; + } + else if (a < -32768) { + a = -32768; + } + return (Bit16s)a; +} + +void NukedOPL3::Reset() { + for (Bit8u i = 0; i < 36; i++) { + opl3.OPs[i].PG_pos = 0; + opl3.OPs[i].PG_inc = 0; + opl3.OPs[i].EG_out = 0x1ff; + opl3.OPs[i].EG_mout = 0x1ff; + opl3.OPs[i].eg_inc = 0; + opl3.OPs[i].eg_gen = 0; + opl3.OPs[i].eg_gennext = 0; + opl3.OPs[i].EG_ksl = 0; + opl3.OPs[i].EG_ar = 0; + opl3.OPs[i].EG_dr = 0; + opl3.OPs[i].EG_sl = 0; + opl3.OPs[i].EG_rr = 0; + opl3.OPs[i].EG_state = eg_off; + opl3.OPs[i].EG_type = 0; + opl3.OPs[i].out = 0; + opl3.OPs[i].prevout[0] = 0; + opl3.OPs[i].prevout[1] = 0; + opl3.OPs[i].fbmod = 0; + opl3.OPs[i].offset = op_offset[i % 18] + ((i > 17) << 8); + opl3.OPs[i].mult = 0; + opl3.OPs[i].vibrato = 0; + opl3.OPs[i].tremolo = 0; + opl3.OPs[i].ksr = 0; + opl3.OPs[i].EG_tl = 0; + opl3.OPs[i].ksl = 0; + opl3.OPs[i].key = 0; + opl3.OPs[i].waveform = 0; + } + for (Bit8u i = 0; i < 9; i++) { + opl3.Channels[i].con = 0; + opl3.Channels[i + 9].con = 0; + opl3.Channels[i].chtype = ch_2op; + opl3.Channels[i + 9].chtype = ch_2op; + opl3.Channels[i].alg = 0; + opl3.Channels[i + 9].alg = 0; + opl3.Channels[i].offset = i; + opl3.Channels[i + 9].offset = 0x100 + i; + opl3.Channels[i].feedback = 0; + opl3.Channels[i + 9].feedback = 0; + opl3.Channels[i].out = 0; + opl3.Channels[i + 9].out = 0; + opl3.Channels[i].cha = ~0; + opl3.Channels[i + 9].cha = ~0; + opl3.Channels[i].chb = ~0; + opl3.Channels[i + 9].chb = ~0; + opl3.Channels[i].chc = 0; + opl3.Channels[i + 9].chc = 0; + opl3.Channels[i].chd = 0; + opl3.Channels[i + 9].chd = 0; + opl3.Channels[i].out = 0; + opl3.Channels[i + 9].out = 0; + opl3.Channels[i].f_number = 0; + opl3.Channels[i + 9].f_number = 0; + opl3.Channels[i].block = 0; + opl3.Channels[i + 9].block = 0; + opl3.Channels[i].ksv = 0; + opl3.Channels[i + 9].ksv = 0; + opl3.Channels[i].panl = (float)CENTER_PANNING_POWER; + opl3.Channels[i + 9].panl = (float)CENTER_PANNING_POWER; + opl3.Channels[i].panr = (float)CENTER_PANNING_POWER; + opl3.Channels[i + 9].panr = (float)CENTER_PANNING_POWER; + } + memset(opl3.opl_memory, 0, 0x200); + opl3.newm = 0; + opl3.nts = 0; + opl3.rhythm = 0; + opl3.dvb = 0; + opl3.dam = 0; + opl3.noise = 0x306600; + opl3.vib_pos = 0; + opl3.timer = 0; + opl3.trem_inc = 0; + opl3.trem_tval = 0; + opl3.trem_dir = 0; + opl3.trem_val = 0; + opl3.zm = 0; + CH_Set2OP(&opl3); +} + +void NukedOPL3::WriteReg(int reg, int v) { + v &= 0xff; + reg &= 0x1ff; + Bit8u highbank = (reg >> 8) & 0x01; + Bit8u regm = reg & 0xff; + opl3.opl_memory[reg & 0x1ff] = v; + switch (regm & 0xf0) { + case 0x00: + if (highbank) { + switch (regm & 0x0f) { + case 0x04: + CH_Set2OP(&opl3); + CH_Set4OP(&opl3); + break; + case 0x05: + opl3.newm = v & 0x01; + break; + } + } + else { + switch (regm & 0x0f) { + case 0x08: + opl3.nts = (v >> 6) & 0x01; + break; + } + } + break; + case 0x20: + case 0x30: + if (ad_slot[regm & 0x1f] >= 0) { + OP_Update20(&opl3, 18 * highbank + ad_slot[regm & 0x1f]); + } + break; + case 0x40: + case 0x50: + if (ad_slot[regm & 0x1f] >= 0) { + OP_Update40(&opl3, 18 * highbank + ad_slot[regm & 0x1f]); + } + break; + case 0x60: + case 0x70: + if (ad_slot[regm & 0x1f] >= 0) { + OP_Update60(&opl3, 18 * highbank + ad_slot[regm & 0x1f]); + } + break; + case 0x80: + case 0x90: + if (ad_slot[regm & 0x1f] >= 0) { + OP_Update80(&opl3, 18 * highbank + ad_slot[regm & 0x1f]); + } + break; + case 0xe0: + case 0xf0: + if (ad_slot[regm & 0x1f] >= 0) { + OP_UpdateE0(&opl3, 18 * highbank + ad_slot[regm & 0x1f]); + } + break; + case 0xa0: + if ((regm & 0x0f) < 9) { + CH_UpdateAB0(&opl3, 9 * highbank + (regm & 0x0f)); + } + break; + case 0xb0: + if (regm == 0xbd && !highbank) { + opl3.dam = v >> 7; + opl3.dvb = (v >> 6) & 0x01; + CH_UpdateRhythm(&opl3); + } + else if ((regm & 0x0f) < 9) { + CH_UpdateAB0(&opl3, 9 * highbank + (regm & 0x0f)); + if (v & 0x20) { + CH_Enable(&opl3, 9 * highbank + (regm & 0x0f)); + } + else { + CH_Disable(&opl3, 9 * highbank + (regm & 0x0f)); + } + } + break; + case 0xc0: + if ((regm & 0x0f) < 9) { + CH_UpdateC0(&opl3, 9 * highbank + (regm & 0x0f)); + } + break; + } +} + +void NukedOPL3::Update(float* sndptr, int numsamples) { + Bit32s outa, outb; + Bit8u ii = 0; + for (Bit32u i = 0; i < (Bit32u)numsamples; i++) { + outa = 0; + outb = 0; + for (ii = 0; ii < 36; ii++) { + OP_CalcFB(&opl3, ii); + } + CH_GenerateRhythm(&opl3); + for (ii = 0; ii < 18; ii++) { + CH_Generate(&opl3, ii); + if (FullPan) { + outa += (Bit16s)(opl3.Channels[ii].out * opl3.Channels[ii].panl); + outb += (Bit16s)(opl3.Channels[ii].out * opl3.Channels[ii].panr); + } + else { + outa += (Bit16s)(opl3.Channels[ii].out & opl3.Channels[ii].cha); + outb += (Bit16s)(opl3.Channels[ii].out & opl3.Channels[ii].chb); + } + } + for (ii = 0; ii < 36; ii++) { + EG_Generate(&opl3, ii); + PG_Generate(&opl3, ii); + } + N_Generate(&opl3); + opl3.trem_inc++; + if (!(opl3.trem_inc & 0x3f)) { + if (!opl3.trem_dir) { + if (opl3.trem_tval == 105) { + opl3.trem_tval--; + opl3.trem_dir = 1; + } + else { + opl3.trem_tval++; + } + } + else { + if (opl3.trem_tval == 0) { + opl3.trem_tval++; + opl3.trem_dir = 0; + } + else { + opl3.trem_tval--; + } + } + opl3.trem_val = (opl3.trem_tval >> 2) >> ((!opl3.dam) << 1); + } + opl3.timer++; + opl3.vib_pos = (opl3.timer >> 10) & 0x07; + *sndptr++ += (float)(outa / 10240.0); + *sndptr++ += (float)(outb / 10240.0); + } +} + +void NukedOPL3::SetPanning(int c, float left, float right) { + if (FullPan) { + opl3.Channels[c].panl = left; + opl3.Channels[c].panr = right; + } +} + +NukedOPL3::NukedOPL3(bool stereo) { + FullPan = stereo; + Reset(); +} + +OPLEmul *NukedOPL3Create(bool stereo) { + return new NukedOPL3(stereo); +} \ No newline at end of file diff --git a/src/oplsynth/nukedopl3.h b/src/oplsynth/nukedopl3.h new file mode 100644 index 000000000..51b78935b --- /dev/null +++ b/src/oplsynth/nukedopl3.h @@ -0,0 +1,118 @@ +/* +* Copyright (C) 2013-2014 Nuke.YKT +* +* This library is free software; you can redistribute it and/or +* modify it under the terms of the GNU Lesser General Public +* License as published by the Free Software Foundation; either +* version 2.1 of the License, or (at your option) any later version. +* +* This library 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 +* Lesser General Public License for more details. +* +* You should have received a copy of the GNU Lesser General Public +* License along with this library; if not, write to the Free Software +* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA +*/ + +/* + Nuked Yamaha YMF262(aka OPL3) emulator. + Thanks: + MAME Development Team: + Feedback and Rhythm part calculation information. + forums.submarine.org.uk(carbon14, opl3): + Tremolo and phase generator calculation information. +*/ + +//version 1.4.2 + +#include "opl.h" +#include "muslib.h" + +typedef uintptr_t Bitu; +typedef intptr_t Bits; +typedef DWORD Bit32u; +typedef SDWORD Bit32s; +typedef WORD Bit16u; +typedef SWORD Bit16s; +typedef BYTE Bit8u; +typedef SBYTE Bit8s; + +struct channel { + Bit8u con; + Bit8u chtype; + Bit8u alg; + Bit16u offset; + Bit8u feedback; + Bit16u cha, chb, chc, chd; + Bit16s out; + Bit16u f_number; + Bit8u block; + Bit8u ksv; + float panl; + float panr; +}; + +struct slot { + Bit32u PG_pos; + Bit32u PG_inc; + Bit16s EG_out; + Bit8u eg_inc; + Bit8u eg_gen; + Bit8u eg_gennext; + Bit16u EG_mout; + Bit8u EG_ksl; + Bit8u EG_ar; + Bit8u EG_dr; + Bit8u EG_sl; + Bit8u EG_rr; + Bit8u EG_state; + Bit8u EG_type; + Bit16s out; + Bit16s *mod; + Bit16s prevout[2]; + Bit16s fbmod; + Bit16u offset; + Bit8u mult; + Bit8u vibrato; + Bit8u tremolo; + Bit8u ksr; + Bit8u EG_tl; + Bit8u ksl; + Bit8u key; + Bit8u waveform; +}; + + +struct chip { + Bit8u opl_memory[0x200]; + Bit8u newm; + Bit8u nts; + Bit8u rhythm; + Bit8u dvb; + Bit8u dam; + Bit32u noise; + Bit16u vib_pos; + Bit16u timer; + Bit8u trem_inc; + Bit8u trem_tval; + Bit8u trem_dir; + Bit8u trem_val; + channel Channels[18]; + slot OPs[36]; + Bit16s zm; +}; + +class NukedOPL3 : public OPLEmul { +private: + chip opl3; + bool FullPan; +public: + void Reset(); + void Update(float* sndptr, int numsamples); + void WriteReg(int reg, int v); + void SetPanning(int c, float left, float right); + + NukedOPL3(bool stereo); +}; \ No newline at end of file diff --git a/src/oplsynth/opl.h b/src/oplsynth/opl.h index 661258a26..2cbb19c32 100644 --- a/src/oplsynth/opl.h +++ b/src/oplsynth/opl.h @@ -20,6 +20,7 @@ public: OPLEmul *YM3812Create(bool stereo); OPLEmul *DBOPLCreate(bool stereo); OPLEmul *JavaOPLCreate(bool stereo); +OPLEmul *NukedOPL3Create(bool stereo); #define OPL_SAMPLE_RATE 49716.0 #define CENTER_PANNING_POWER 0.70710678118 /* [RH] volume at center for EQP */ diff --git a/wadsrc/static/menudef.txt b/wadsrc/static/menudef.txt index 408e534a8..abc654252 100644 --- a/wadsrc/static/menudef.txt +++ b/wadsrc/static/menudef.txt @@ -1478,6 +1478,7 @@ OptionValue OplCores 0, "MAME OPL2" 1, "DOSBox OPL3" 2, "Java OPL3" + 3, "Nuked OPL3" } OptionMenu AdvSoundOptions diff --git a/zdoom.vcproj b/zdoom.vcproj index cabc6c84f..21aaccb8e 100644 --- a/zdoom.vcproj +++ b/zdoom.vcproj @@ -2632,6 +2632,14 @@ RelativePath=".\src\oplsynth\opl_mus_player.h" > + + + + From 88f4305e7e985e8bfaa954c7d09bc85a15efc26e Mon Sep 17 00:00:00 2001 From: khokh2001 Date: Sun, 23 Nov 2014 00:39:26 +0900 Subject: [PATCH 2/3] new opl3 emulator --- src/oplsynth/nukedopl3.cpp | 2 +- src/oplsynth/nukedopl3.h | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/src/oplsynth/nukedopl3.cpp b/src/oplsynth/nukedopl3.cpp index 95d03ae8d..ee95741f5 100644 --- a/src/oplsynth/nukedopl3.cpp +++ b/src/oplsynth/nukedopl3.cpp @@ -1142,4 +1142,4 @@ NukedOPL3::NukedOPL3(bool stereo) { OPLEmul *NukedOPL3Create(bool stereo) { return new NukedOPL3(stereo); -} \ No newline at end of file +} diff --git a/src/oplsynth/nukedopl3.h b/src/oplsynth/nukedopl3.h index 51b78935b..7a032cb5a 100644 --- a/src/oplsynth/nukedopl3.h +++ b/src/oplsynth/nukedopl3.h @@ -115,4 +115,4 @@ public: void SetPanning(int c, float left, float right); NukedOPL3(bool stereo); -}; \ No newline at end of file +}; From 5ed70d97a6ca00891cfa281734d1e370ea2aec8d Mon Sep 17 00:00:00 2001 From: khokh2001 Date: Sun, 23 Nov 2014 02:18:40 +0900 Subject: [PATCH 3/3] New OPL3 emulator. --- src/oplsynth/nukedopl3.cpp | 4 +++- src/oplsynth/nukedopl3.h | 4 +++- 2 files changed, 6 insertions(+), 2 deletions(-) diff --git a/src/oplsynth/nukedopl3.cpp b/src/oplsynth/nukedopl3.cpp index ee95741f5..90673d855 100644 --- a/src/oplsynth/nukedopl3.cpp +++ b/src/oplsynth/nukedopl3.cpp @@ -19,10 +19,12 @@ /* Nuked Yamaha YMF262(aka OPL3) emulator. Thanks: - MAME Development Team: + MAME Development Team(Jarek Burczynski, Tatsuyuki Satoh): Feedback and Rhythm part calculation information. forums.submarine.org.uk(carbon14, opl3): Tremolo and phase generator calculation information. + OPLx decapsulated(Matthew Gambrell and Olli Niemitalo): + OPL2 ROMs. */ //version 1.4.2 diff --git a/src/oplsynth/nukedopl3.h b/src/oplsynth/nukedopl3.h index 7a032cb5a..15f264c1a 100644 --- a/src/oplsynth/nukedopl3.h +++ b/src/oplsynth/nukedopl3.h @@ -19,10 +19,12 @@ /* Nuked Yamaha YMF262(aka OPL3) emulator. Thanks: - MAME Development Team: + MAME Development Team(Jarek Burczynski, Tatsuyuki Satoh): Feedback and Rhythm part calculation information. forums.submarine.org.uk(carbon14, opl3): Tremolo and phase generator calculation information. + OPLx decapsulated(Matthew Gambrell and Olli Niemitalo): + OPL2 ROMs. */ //version 1.4.2