1531 lines
45 KiB
C
1531 lines
45 KiB
C
/**
|
|
* emu2413 v1.5.9
|
|
* https://github.com/digital-sound-antiques/emu2413
|
|
* Copyright (C) 2020 Mitsutaka Okazaki
|
|
*
|
|
* This source refers to the following documents. The author would like to thank all the authors who have
|
|
* contributed to the writing of them.
|
|
* - [YM2413 notes](http://www.smspower.org/Development/YM2413) by andete
|
|
* - ymf262.c by Jarek Burczynski
|
|
* - [VRC7 presets](https://siliconpr0n.org/archive/doku.php?id=vendor:yamaha:opl2#opll_vrc7_patch_format) by Nuke.YKT
|
|
* - YMF281B presets by Chabin
|
|
*/
|
|
#include "emu2413.h"
|
|
#include <math.h>
|
|
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
#include <string.h>
|
|
|
|
#ifndef INLINE
|
|
#if defined(_MSC_VER)
|
|
#define INLINE __inline
|
|
#elif defined(__GNUC__)
|
|
#define INLINE __inline__
|
|
#else
|
|
#define INLINE inline
|
|
#endif
|
|
#endif
|
|
|
|
#define _PI_ 3.14159265358979323846264338327950288
|
|
|
|
#define OPLL_TONE_NUM 4
|
|
/* clang-format off */
|
|
static uint8_t default_inst[OPLL_TONE_NUM][(16 + 3) * 8] = {{
|
|
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, // 0: User
|
|
0x71,0x61,0x1e,0x17,0xd0,0x78,0x00,0x17, // 1: Violin
|
|
0x13,0x41,0x1a,0x0d,0xd8,0xf7,0x23,0x13, // 2: Guitar
|
|
0x13,0x01,0x99,0x00,0xf2,0xc4,0x21,0x23, // 3: Piano
|
|
0x11,0x61,0x0e,0x07,0x8d,0x64,0x70,0x27, // 4: Flute
|
|
0x32,0x21,0x1e,0x06,0xe1,0x76,0x01,0x28, // 5: Clarinet
|
|
0x31,0x22,0x16,0x05,0xe0,0x71,0x00,0x18, // 6: Oboe
|
|
0x21,0x61,0x1d,0x07,0x82,0x81,0x11,0x07, // 7: Trumpet
|
|
0x33,0x21,0x2d,0x13,0xb0,0x70,0x00,0x07, // 8: Organ
|
|
0x61,0x61,0x1b,0x06,0x64,0x65,0x10,0x17, // 9: Horn
|
|
0x41,0x61,0x0b,0x18,0x85,0xf0,0x81,0x07, // A: Synthesizer
|
|
0x33,0x01,0x83,0x11,0xea,0xef,0x10,0x04, // B: Harpsichord
|
|
0x17,0xc1,0x24,0x07,0xf8,0xf8,0x22,0x12, // C: Vibraphone
|
|
0x61,0x50,0x0c,0x05,0xd2,0xf5,0x40,0x42, // D: Synthsizer Bass
|
|
0x01,0x01,0x55,0x03,0xe9,0x90,0x03,0x02, // E: Acoustic Bass
|
|
0x41,0x41,0x89,0x03,0xf1,0xe4,0xc0,0x13, // F: Electric Guitar
|
|
0x01,0x01,0x18,0x0f,0xdf,0xf8,0x6a,0x6d, // R: Bass Drum (from VRC7)
|
|
0x01,0x01,0x00,0x00,0xc8,0xd8,0xa7,0x68, // R: High-Hat(M) / Snare Drum(C) (from VRC7)
|
|
0x05,0x01,0x00,0x00,0xf8,0xaa,0x59,0x55, // R: Tom-tom(M) / Top Cymbal(C) (from VRC7)
|
|
},{
|
|
/* VRC7 presets from Nuke.YKT */
|
|
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
|
|
0x03,0x21,0x05,0x06,0xe8,0x81,0x42,0x27,
|
|
0x13,0x41,0x14,0x0d,0xd8,0xf6,0x23,0x12,
|
|
0x11,0x11,0x08,0x08,0xfa,0xb2,0x20,0x12,
|
|
0x31,0x61,0x0c,0x07,0xa8,0x64,0x61,0x27,
|
|
0x32,0x21,0x1e,0x06,0xe1,0x76,0x01,0x28,
|
|
0x02,0x01,0x06,0x00,0xa3,0xe2,0xf4,0xf4,
|
|
0x21,0x61,0x1d,0x07,0x82,0x81,0x11,0x07,
|
|
0x23,0x21,0x22,0x17,0xa2,0x72,0x01,0x17,
|
|
0x35,0x11,0x25,0x00,0x40,0x73,0x72,0x01,
|
|
0xb5,0x01,0x0f,0x0F,0xa8,0xa5,0x51,0x02,
|
|
0x17,0xc1,0x24,0x07,0xf8,0xf8,0x22,0x12,
|
|
0x71,0x23,0x11,0x06,0x65,0x74,0x18,0x16,
|
|
0x01,0x02,0xd3,0x05,0xc9,0x95,0x03,0x02,
|
|
0x61,0x63,0x0c,0x00,0x94,0xC0,0x33,0xf6,
|
|
0x21,0x72,0x0d,0x00,0xc1,0xd5,0x56,0x06,
|
|
0x01,0x01,0x18,0x0f,0xdf,0xf8,0x6a,0x6d,
|
|
0x01,0x01,0x00,0x00,0xc8,0xd8,0xa7,0x68,
|
|
0x05,0x01,0x00,0x00,0xf8,0xaa,0x59,0x55,
|
|
},{
|
|
/* YMF281B presets */
|
|
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, // 0: User
|
|
0x62,0x21,0x1a,0x07,0xf0,0x6f,0x00,0x16, // 1: Electric Strings (form Chabin's patch)
|
|
0x40,0x10,0x45,0x00,0xf6,0x83,0x73,0x63, // 2: Bow Wow (based on plgDavid's patch, KSL fixed)
|
|
0x13,0x01,0x99,0x00,0xf2,0xc3,0x21,0x23, // 3: Electric Guitar (similar to YM2413 but different DR(C))
|
|
0x01,0x61,0x0b,0x0f,0xf9,0x64,0x70,0x17, // 4: Organ (based on Chabin, TL/DR fixed)
|
|
0x32,0x21,0x1e,0x06,0xe1,0x76,0x01,0x28, // 5: Clarinet (identical to YM2413)
|
|
0x60,0x01,0x82,0x0e,0xf9,0x61,0x20,0x27, // 6: Saxophone (based on plgDavid, PM/EG fixed)
|
|
0x21,0x61,0x1c,0x07,0x84,0x81,0x11,0x07, // 7: Trumpet (similar to YM2413 but different TL/DR(M))
|
|
0x37,0x32,0xc9,0x01,0x66,0x64,0x40,0x28, // 8: Street Organ (from Chabin)
|
|
0x01,0x21,0x07,0x03,0xa5,0x71,0x51,0x07, // 9: Synth Brass (based on Chabin, TL fixed)
|
|
0x06,0x01,0x5e,0x07,0xf3,0xf3,0xf6,0x13, // A: Electric Piano (based on Chabin, DR/RR/KR fixed)
|
|
0x00,0x00,0x18,0x06,0xf5,0xf3,0x20,0x23, // B: Bass (based on Chabin, EG fixed)
|
|
0x17,0xc1,0x24,0x07,0xf8,0xf8,0x22,0x12, // C: Vibraphone (identical to YM2413)
|
|
0x35,0x64,0x00,0x00,0xff,0xf3,0x77,0xf5, // D: Chimes (from plgDavid)
|
|
0x11,0x31,0x00,0x07,0xdd,0xf3,0xff,0xfb, // E: Tom Tom II (from plgDavid)
|
|
0x3a,0x21,0x00,0x07,0x80,0x84,0x0f,0xf5, // F: Noise (based on plgDavid, AR fixed)
|
|
0x01,0x01,0x18,0x0f,0xdf,0xf8,0x6a,0x6d, // R: Bass Drum (identical to YM2413)
|
|
0x01,0x01,0x00,0x00,0xc8,0xd8,0xa7,0x68, // R: High-Hat(M) / Snare Drum(C) (identical to YM2413)
|
|
0x05,0x01,0x00,0x00,0xf8,0xaa,0x59,0x55, // R: Tom-tom(M) / Top Cymbal(C) (identical to YM2413)
|
|
},{
|
|
/* YM2423, taken from ymfm */
|
|
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
|
|
0x61,0x61,0x1B,0x07,0x94,0x5F,0x10,0x06,
|
|
0x93,0xB1,0x51,0x04,0xF3,0xF2,0x70,0xFB,
|
|
0x41,0x21,0x11,0x85,0xF2,0xF2,0x70,0x75,
|
|
0x93,0xB2,0x28,0x07,0xF3,0xF2,0x70,0xB4,
|
|
0x72,0x31,0x97,0x05,0x51,0x6F,0x60,0x09,
|
|
0x13,0x30,0x18,0x06,0xF7,0xF4,0x50,0x85,
|
|
0x51,0x31,0x1C,0x07,0x51,0x71,0x20,0x26,
|
|
0x41,0xF4,0x1B,0x07,0x74,0x34,0x00,0x06,
|
|
0x50,0x30,0x4D,0x03,0x42,0x65,0x20,0x06,
|
|
0x40,0x20,0x10,0x85,0xF3,0xF5,0x20,0x04,
|
|
0x61,0x61,0x1B,0x07,0xC5,0x96,0xF3,0xF6,
|
|
0xF9,0xF1,0xDC,0x00,0xF5,0xF3,0x77,0xF2,
|
|
0x60,0xA2,0x91,0x03,0x94,0xC1,0xF7,0xF7,
|
|
0x30,0x30,0x17,0x06,0xF3,0xF1,0xB7,0xFC,
|
|
0x31,0x36,0x0D,0x05,0xF2,0xF4,0x27,0x9C,
|
|
0x01,0x01,0x18,0x0F,0xDF,0xF8,0x6A,0x6D,
|
|
0x01,0x01,0x00,0x00,0xC8,0xD8,0xA7,0x48,
|
|
0x05,0x01,0x00,0x00,0xF8,0xAA,0x59,0x55,
|
|
}};
|
|
/* clang-format on */
|
|
|
|
/* phase increment counter */
|
|
#define DP_BITS 19
|
|
#define DP_WIDTH (1 << DP_BITS)
|
|
#define DP_BASE_BITS (DP_BITS - PG_BITS)
|
|
|
|
/* dynamic range of envelope output */
|
|
#define EG_STEP 0.375
|
|
#define EG_BITS 7
|
|
#define EG_MUTE ((1 << EG_BITS) - 1)
|
|
#define EG_MAX (EG_MUTE - 4)
|
|
|
|
/* dynamic range of total level */
|
|
#define TL_STEP 0.75
|
|
#define TL_BITS 6
|
|
|
|
/* dynamic range of sustine level */
|
|
#define SL_STEP 3.0
|
|
#define SL_BITS 4
|
|
|
|
/* damper speed before key-on. key-scale affects. */
|
|
#define DAMPER_RATE 12
|
|
|
|
#define TL2EG(d) ((d) << 1)
|
|
|
|
/* sine table */
|
|
#define PG_BITS 10 /* 2^10 = 1024 length sine table */
|
|
#define PG_WIDTH (1 << PG_BITS)
|
|
|
|
/* clang-format off */
|
|
/* exp_table[x] = round((exp2((double)x / 256.0) - 1) * 1024) */
|
|
static uint16_t exp_table[256] = {
|
|
0, 3, 6, 8, 11, 14, 17, 20, 22, 25, 28, 31, 34, 37, 40, 42,
|
|
45, 48, 51, 54, 57, 60, 63, 66, 69, 72, 75, 78, 81, 84, 87, 90,
|
|
93, 96, 99, 102, 105, 108, 111, 114, 117, 120, 123, 126, 130, 133, 136, 139,
|
|
142, 145, 148, 152, 155, 158, 161, 164, 168, 171, 174, 177, 181, 184, 187, 190,
|
|
194, 197, 200, 204, 207, 210, 214, 217, 220, 224, 227, 231, 234, 237, 241, 244,
|
|
248, 251, 255, 258, 262, 265, 268, 272, 276, 279, 283, 286, 290, 293, 297, 300,
|
|
304, 308, 311, 315, 318, 322, 326, 329, 333, 337, 340, 344, 348, 352, 355, 359,
|
|
363, 367, 370, 374, 378, 382, 385, 389, 393, 397, 401, 405, 409, 412, 416, 420,
|
|
424, 428, 432, 436, 440, 444, 448, 452, 456, 460, 464, 468, 472, 476, 480, 484,
|
|
488, 492, 496, 501, 505, 509, 513, 517, 521, 526, 530, 534, 538, 542, 547, 551,
|
|
555, 560, 564, 568, 572, 577, 581, 585, 590, 594, 599, 603, 607, 612, 616, 621,
|
|
625, 630, 634, 639, 643, 648, 652, 657, 661, 666, 670, 675, 680, 684, 689, 693,
|
|
698, 703, 708, 712, 717, 722, 726, 731, 736, 741, 745, 750, 755, 760, 765, 770,
|
|
774, 779, 784, 789, 794, 799, 804, 809, 814, 819, 824, 829, 834, 839, 844, 849,
|
|
854, 859, 864, 869, 874, 880, 885, 890, 895, 900, 906, 911, 916, 921, 927, 932,
|
|
937, 942, 948, 953, 959, 964, 969, 975, 980, 986, 991, 996, 1002, 1007, 1013, 1018
|
|
};
|
|
/* fullsin_table[x] = round(-log2(sin((x + 0.5) * PI / (PG_WIDTH / 4) / 2)) * 256) */
|
|
static uint16_t fullsin_table[PG_WIDTH] = {
|
|
2137, 1731, 1543, 1419, 1326, 1252, 1190, 1137, 1091, 1050, 1013, 979, 949, 920, 894, 869,
|
|
846, 825, 804, 785, 767, 749, 732, 717, 701, 687, 672, 659, 646, 633, 621, 609,
|
|
598, 587, 576, 566, 556, 546, 536, 527, 518, 509, 501, 492, 484, 476, 468, 461,
|
|
453, 446, 439, 432, 425, 418, 411, 405, 399, 392, 386, 380, 375, 369, 363, 358,
|
|
352, 347, 341, 336, 331, 326, 321, 316, 311, 307, 302, 297, 293, 289, 284, 280,
|
|
276, 271, 267, 263, 259, 255, 251, 248, 244, 240, 236, 233, 229, 226, 222, 219,
|
|
215, 212, 209, 205, 202, 199, 196, 193, 190, 187, 184, 181, 178, 175, 172, 169,
|
|
167, 164, 161, 159, 156, 153, 151, 148, 146, 143, 141, 138, 136, 134, 131, 129,
|
|
127, 125, 122, 120, 118, 116, 114, 112, 110, 108, 106, 104, 102, 100, 98, 96,
|
|
94, 92, 91, 89, 87, 85, 83, 82, 80, 78, 77, 75, 74, 72, 70, 69,
|
|
67, 66, 64, 63, 62, 60, 59, 57, 56, 55, 53, 52, 51, 49, 48, 47,
|
|
46, 45, 43, 42, 41, 40, 39, 38, 37, 36, 35, 34, 33, 32, 31, 30,
|
|
29, 28, 27, 26, 25, 24, 23, 23, 22, 21, 20, 20, 19, 18, 17, 17,
|
|
16, 15, 15, 14, 13, 13, 12, 12, 11, 10, 10, 9, 9, 8, 8, 7,
|
|
7, 7, 6, 6, 5, 5, 5, 4, 4, 4, 3, 3, 3, 2, 2, 2,
|
|
2, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0,
|
|
};
|
|
/* clang-format on */
|
|
|
|
static uint16_t halfsin_table[PG_WIDTH];
|
|
static uint16_t *wave_table_map[2] = {fullsin_table, halfsin_table};
|
|
|
|
/* pitch modulator */
|
|
/* offset to fnum, rough approximation of 14 cents depth. */
|
|
static int8_t pm_table[8][8] = {
|
|
{0, 0, 0, 0, 0, 0, 0, 0}, // fnum = 000xxxxxx
|
|
{0, 0, 1, 0, 0, 0, -1, 0}, // fnum = 001xxxxxx
|
|
{0, 1, 2, 1, 0, -1, -2, -1}, // fnum = 010xxxxxx
|
|
{0, 1, 3, 1, 0, -1, -3, -1}, // fnum = 011xxxxxx
|
|
{0, 2, 4, 2, 0, -2, -4, -2}, // fnum = 100xxxxxx
|
|
{0, 2, 5, 2, 0, -2, -5, -2}, // fnum = 101xxxxxx
|
|
{0, 3, 6, 3, 0, -3, -6, -3}, // fnum = 110xxxxxx
|
|
{0, 3, 7, 3, 0, -3, -7, -3}, // fnum = 111xxxxxx
|
|
};
|
|
|
|
/* amplitude lfo table */
|
|
/* The following envelop pattern is verified on real YM2413. */
|
|
/* each element repeates 64 cycles */
|
|
static uint8_t am_table[210] = {0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, //
|
|
2, 2, 2, 2, 2, 2, 2, 2, 3, 3, 3, 3, 3, 3, 3, 3, //
|
|
4, 4, 4, 4, 4, 4, 4, 4, 5, 5, 5, 5, 5, 5, 5, 5, //
|
|
6, 6, 6, 6, 6, 6, 6, 6, 7, 7, 7, 7, 7, 7, 7, 7, //
|
|
8, 8, 8, 8, 8, 8, 8, 8, 9, 9, 9, 9, 9, 9, 9, 9, //
|
|
10, 10, 10, 10, 10, 10, 10, 10, 11, 11, 11, 11, 11, 11, 11, 11, //
|
|
12, 12, 12, 12, 12, 12, 12, 12, //
|
|
13, 13, 13, //
|
|
12, 12, 12, 12, 12, 12, 12, 12, //
|
|
11, 11, 11, 11, 11, 11, 11, 11, 10, 10, 10, 10, 10, 10, 10, 10, //
|
|
9, 9, 9, 9, 9, 9, 9, 9, 8, 8, 8, 8, 8, 8, 8, 8, //
|
|
7, 7, 7, 7, 7, 7, 7, 7, 6, 6, 6, 6, 6, 6, 6, 6, //
|
|
5, 5, 5, 5, 5, 5, 5, 5, 4, 4, 4, 4, 4, 4, 4, 4, //
|
|
3, 3, 3, 3, 3, 3, 3, 3, 2, 2, 2, 2, 2, 2, 2, 2, //
|
|
1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0};
|
|
|
|
/* envelope decay increment step table */
|
|
/* based on andete's research */
|
|
static uint8_t eg_step_tables[4][8] = {
|
|
{0, 1, 0, 1, 0, 1, 0, 1},
|
|
{0, 1, 0, 1, 1, 1, 0, 1},
|
|
{0, 1, 1, 1, 0, 1, 1, 1},
|
|
{0, 1, 1, 1, 1, 1, 1, 1},
|
|
};
|
|
|
|
enum __OPLL_EG_STATE { ATTACK, DECAY, SUSTAIN, RELEASE, DAMP, UNKNOWN };
|
|
|
|
static uint32_t ml_table[16] = {1, 1 * 2, 2 * 2, 3 * 2, 4 * 2, 5 * 2, 6 * 2, 7 * 2,
|
|
8 * 2, 9 * 2, 10 * 2, 10 * 2, 12 * 2, 12 * 2, 15 * 2, 15 * 2};
|
|
|
|
#define dB2(x) ((x)*2)
|
|
static double kl_table[16] = {dB2(0.000), dB2(9.000), dB2(12.000), dB2(13.875), dB2(15.000), dB2(16.125),
|
|
dB2(16.875), dB2(17.625), dB2(18.000), dB2(18.750), dB2(19.125), dB2(19.500),
|
|
dB2(19.875), dB2(20.250), dB2(20.625), dB2(21.000)};
|
|
|
|
static uint32_t tll_table[8 * 16][1 << TL_BITS][4];
|
|
static int32_t rks_table[8 * 2][2];
|
|
|
|
static OPLL_PATCH null_patch = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
|
|
static OPLL_PATCH default_patch[OPLL_TONE_NUM][(16 + 3) * 2];
|
|
|
|
/* don't forget min/max is defined as a macro in stdlib.h of Visual C. */
|
|
#ifndef min
|
|
static INLINE int min(int i, int j) { return (i < j) ? i : j; }
|
|
#endif
|
|
#ifndef max
|
|
static INLINE int max(int i, int j) { return (i > j) ? i : j; }
|
|
#endif
|
|
|
|
/***************************************************
|
|
|
|
Internal Sample Rate Converter
|
|
|
|
****************************************************/
|
|
/* Note: to disable internal rate converter, set clock/72 to output sampling rate. */
|
|
|
|
/*
|
|
* LW is truncate length of sinc(x) calculation.
|
|
* Lower LW is faster, higher LW results better quality.
|
|
* LW must be a non-zero positive even number, no upper limit.
|
|
* LW=16 or greater is recommended when upsampling.
|
|
* LW=8 is practically okay for downsampling.
|
|
*/
|
|
#define LW 16
|
|
|
|
/* resolution of sinc(x) table. sinc(x) where 0.0<=x<1.0 corresponds to sinc_table[0...SINC_RESO-1] */
|
|
#define SINC_RESO 256
|
|
#define SINC_AMP_BITS 12
|
|
|
|
// double hamming(double x) { return 0.54 - 0.46 * cos(2 * PI * x); }
|
|
static double blackman(double x) { return 0.42 - 0.5 * cos(2 * _PI_ * x) + 0.08 * cos(4 * _PI_ * x); }
|
|
static double sinc(double x) { return (x == 0.0 ? 1.0 : sin(_PI_ * x) / (_PI_ * x)); }
|
|
static double windowed_sinc(double x) { return blackman(0.5 + 0.5 * x / (LW / 2)) * sinc(x); }
|
|
|
|
/* f_inp: input frequency. f_out: output frequencey, ch: number of channels */
|
|
OPLL_RateConv *OPLL_RateConv_new(double f_inp, double f_out, int ch) {
|
|
OPLL_RateConv *conv = malloc(sizeof(OPLL_RateConv));
|
|
int i;
|
|
|
|
conv->ch = ch;
|
|
conv->f_ratio = f_inp / f_out;
|
|
conv->buf = malloc(sizeof(void *) * ch);
|
|
for (i = 0; i < ch; i++) {
|
|
conv->buf[i] = malloc(sizeof(conv->buf[0][0]) * LW);
|
|
}
|
|
|
|
/* create sinc_table for positive 0 <= x < LW/2 */
|
|
conv->sinc_table = malloc(sizeof(conv->sinc_table[0]) * SINC_RESO * LW / 2);
|
|
for (i = 0; i < SINC_RESO * LW / 2; i++) {
|
|
const double x = (double)i / SINC_RESO;
|
|
if (f_out < f_inp) {
|
|
/* for downsampling */
|
|
conv->sinc_table[i] = (int16_t)((1 << SINC_AMP_BITS) * windowed_sinc(x / conv->f_ratio) / conv->f_ratio);
|
|
} else {
|
|
/* for upsampling */
|
|
conv->sinc_table[i] = (int16_t)((1 << SINC_AMP_BITS) * windowed_sinc(x));
|
|
}
|
|
}
|
|
|
|
return conv;
|
|
}
|
|
|
|
static INLINE int16_t lookup_sinc_table(int16_t *table, double x) {
|
|
int16_t index = (int16_t)(x * SINC_RESO);
|
|
if (index < 0)
|
|
index = -index;
|
|
return table[min(SINC_RESO * LW / 2 - 1, index)];
|
|
}
|
|
|
|
void OPLL_RateConv_reset(OPLL_RateConv *conv) {
|
|
int i;
|
|
conv->timer = 0;
|
|
for (i = 0; i < conv->ch; i++) {
|
|
memset(conv->buf[i], 0, sizeof(conv->buf[i][0]) * LW);
|
|
}
|
|
}
|
|
|
|
/* put original data to this converter at f_inp. */
|
|
void OPLL_RateConv_putData(OPLL_RateConv *conv, int ch, int16_t data) {
|
|
int16_t *buf = conv->buf[ch];
|
|
int i;
|
|
for (i = 0; i < LW - 1; i++) {
|
|
buf[i] = buf[i + 1];
|
|
}
|
|
buf[LW - 1] = data;
|
|
}
|
|
|
|
/* get resampled data from this converter at f_out. */
|
|
/* this function must be called f_out / f_inp times per one putData call. */
|
|
int16_t OPLL_RateConv_getData(OPLL_RateConv *conv, int ch) {
|
|
int16_t *buf = conv->buf[ch];
|
|
int32_t sum = 0;
|
|
int k;
|
|
double dn;
|
|
conv->timer += conv->f_ratio;
|
|
dn = conv->timer - floor(conv->timer);
|
|
conv->timer = dn;
|
|
|
|
for (k = 0; k < LW; k++) {
|
|
double x = ((double)k - (LW / 2 - 1)) - dn;
|
|
sum += buf[k] * lookup_sinc_table(conv->sinc_table, x);
|
|
}
|
|
return sum >> SINC_AMP_BITS;
|
|
}
|
|
|
|
void OPLL_RateConv_delete(OPLL_RateConv *conv) {
|
|
int i;
|
|
for (i = 0; i < conv->ch; i++) {
|
|
free(conv->buf[i]);
|
|
}
|
|
free(conv->buf);
|
|
free(conv->sinc_table);
|
|
free(conv);
|
|
}
|
|
|
|
/***************************************************
|
|
|
|
Create tables
|
|
|
|
****************************************************/
|
|
|
|
static void makeSinTable(void) {
|
|
int x;
|
|
|
|
for (x = 0; x < PG_WIDTH / 4; x++) {
|
|
fullsin_table[PG_WIDTH / 4 + x] = fullsin_table[PG_WIDTH / 4 - x - 1];
|
|
}
|
|
|
|
for (x = 0; x < PG_WIDTH / 2; x++) {
|
|
fullsin_table[PG_WIDTH / 2 + x] = 0x8000 | fullsin_table[x];
|
|
}
|
|
|
|
for (x = 0; x < PG_WIDTH / 2; x++)
|
|
halfsin_table[x] = fullsin_table[x];
|
|
|
|
for (x = PG_WIDTH / 2; x < PG_WIDTH; x++)
|
|
halfsin_table[x] = 0xfff;
|
|
}
|
|
|
|
static void makeTllTable(void) {
|
|
|
|
int32_t tmp;
|
|
int32_t fnum, block, TL, KL;
|
|
|
|
for (fnum = 0; fnum < 16; fnum++) {
|
|
for (block = 0; block < 8; block++) {
|
|
for (TL = 0; TL < 64; TL++) {
|
|
for (KL = 0; KL < 4; KL++) {
|
|
if (KL == 0) {
|
|
tll_table[(block << 4) | fnum][TL][KL] = TL2EG(TL);
|
|
} else {
|
|
tmp = (int32_t)(kl_table[fnum] - dB2(3.000) * (7 - block));
|
|
if (tmp <= 0)
|
|
tll_table[(block << 4) | fnum][TL][KL] = TL2EG(TL);
|
|
else
|
|
tll_table[(block << 4) | fnum][TL][KL] = (uint32_t)((tmp >> (3 - KL)) / EG_STEP) + TL2EG(TL);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
static void makeRksTable(void) {
|
|
int fnum8, block;
|
|
for (fnum8 = 0; fnum8 < 2; fnum8++)
|
|
for (block = 0; block < 8; block++) {
|
|
rks_table[(block << 1) | fnum8][1] = (block << 1) + fnum8;
|
|
rks_table[(block << 1) | fnum8][0] = block >> 1;
|
|
}
|
|
}
|
|
|
|
static void makeDefaultPatch(void) {
|
|
int i, j;
|
|
for (i = 0; i < OPLL_TONE_NUM; i++)
|
|
for (j = 0; j < 19; j++)
|
|
OPLL_getDefaultPatch(i, j, &default_patch[i][j * 2]);
|
|
}
|
|
|
|
static uint8_t table_initialized = 0;
|
|
|
|
static void initializeTables(void) {
|
|
makeTllTable();
|
|
makeRksTable();
|
|
makeSinTable();
|
|
makeDefaultPatch();
|
|
table_initialized = 1;
|
|
}
|
|
|
|
/*********************************************************
|
|
|
|
Synthesizing
|
|
|
|
*********************************************************/
|
|
#define SLOT_BD1 12
|
|
#define SLOT_BD2 13
|
|
#define SLOT_HH 14
|
|
#define SLOT_SD 15
|
|
#define SLOT_TOM 16
|
|
#define SLOT_CYM 17
|
|
|
|
/* utility macros */
|
|
#define MOD(o, x) (&(o)->slot[(x) << 1])
|
|
#define CAR(o, x) (&(o)->slot[((x) << 1) | 1])
|
|
#define BIT(s, b) (((s) >> (b)) & 1)
|
|
|
|
#if OPLL_DEBUG
|
|
static void _debug_print_patch(OPLL_SLOT *slot) {
|
|
OPLL_PATCH *p = slot->patch;
|
|
printf("[slot#%d am:%d pm:%d eg:%d kr:%d ml:%d kl:%d tl:%d ws:%d fb:%d A:%d D:%d S:%d R:%d]\n", slot->number, //
|
|
p->AM, p->PM, p->EG, p->KR, p->ML, //
|
|
p->KL, p->TL, p->WS, p->FB, //
|
|
p->AR, p->DR, p->SL, p->RR);
|
|
}
|
|
|
|
static char *_debug_eg_state_name(OPLL_SLOT *slot) {
|
|
switch (slot->eg_state) {
|
|
case ATTACK:
|
|
return "attack";
|
|
case DECAY:
|
|
return "decay";
|
|
case SUSTAIN:
|
|
return "sustain";
|
|
case RELEASE:
|
|
return "release";
|
|
case DAMP:
|
|
return "damp";
|
|
default:
|
|
return "unknown";
|
|
}
|
|
}
|
|
|
|
static INLINE void _debug_print_slot_info(OPLL_SLOT *slot) {
|
|
char *name = _debug_eg_state_name(slot);
|
|
printf("[slot#%d state:%s fnum:%03x rate:%d-%d]\n", slot->number, name, slot->blk_fnum, slot->eg_rate_h,
|
|
slot->eg_rate_l);
|
|
_debug_print_patch(slot);
|
|
fflush(stdout);
|
|
}
|
|
#endif
|
|
|
|
static INLINE int get_parameter_rate(OPLL_SLOT *slot) {
|
|
|
|
if ((slot->type & 1) == 0 && slot->key_flag == 0) {
|
|
return 0;
|
|
}
|
|
|
|
switch (slot->eg_state) {
|
|
case ATTACK:
|
|
return slot->patch->AR;
|
|
case DECAY:
|
|
return slot->patch->DR;
|
|
case SUSTAIN:
|
|
return slot->patch->EG ? 0 : slot->patch->RR;
|
|
case RELEASE:
|
|
if (slot->sus_flag) {
|
|
return 5;
|
|
} else if (slot->patch->EG) {
|
|
return slot->patch->RR;
|
|
} else {
|
|
return 7;
|
|
}
|
|
case DAMP:
|
|
return DAMPER_RATE;
|
|
default:
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
enum SLOT_UPDATE_FLAG {
|
|
UPDATE_WS = 1,
|
|
UPDATE_TLL = 2,
|
|
UPDATE_RKS = 4,
|
|
UPDATE_EG = 8,
|
|
UPDATE_ALL = 255,
|
|
};
|
|
|
|
static INLINE void request_update(OPLL_SLOT *slot, int flag) { slot->update_requests |= flag; }
|
|
|
|
static void commit_slot_update(OPLL_SLOT *slot) {
|
|
|
|
#if OPLL_DEBUG
|
|
if (slot->last_eg_state != slot->eg_state) {
|
|
_debug_print_slot_info(slot);
|
|
slot->last_eg_state = slot->eg_state;
|
|
}
|
|
#endif
|
|
|
|
if (slot->update_requests & UPDATE_WS) {
|
|
slot->wave_table = wave_table_map[slot->patch->WS];
|
|
}
|
|
|
|
if (slot->update_requests & UPDATE_TLL) {
|
|
if ((slot->type & 1) == 0) {
|
|
slot->tll = tll_table[slot->blk_fnum >> 5][slot->patch->TL][slot->patch->KL];
|
|
} else {
|
|
slot->tll = tll_table[slot->blk_fnum >> 5][slot->volume][slot->patch->KL];
|
|
}
|
|
}
|
|
|
|
if (slot->update_requests & UPDATE_RKS) {
|
|
slot->rks = rks_table[slot->blk_fnum >> 8][slot->patch->KR];
|
|
}
|
|
|
|
if (slot->update_requests & (UPDATE_RKS | UPDATE_EG)) {
|
|
int p_rate = get_parameter_rate(slot);
|
|
|
|
if (p_rate == 0) {
|
|
slot->eg_shift = 0;
|
|
slot->eg_rate_h = 0;
|
|
slot->eg_rate_l = 0;
|
|
return;
|
|
}
|
|
|
|
slot->eg_rate_h = min(15, p_rate + (slot->rks >> 2));
|
|
slot->eg_rate_l = slot->rks & 3;
|
|
if (slot->eg_state == ATTACK) {
|
|
slot->eg_shift = (0 < slot->eg_rate_h && slot->eg_rate_h < 12) ? (13 - slot->eg_rate_h) : 0;
|
|
} else {
|
|
slot->eg_shift = (slot->eg_rate_h < 13) ? (13 - slot->eg_rate_h) : 0;
|
|
}
|
|
}
|
|
|
|
slot->update_requests = 0;
|
|
}
|
|
|
|
static void reset_slot(OPLL_SLOT *slot, int number) {
|
|
slot->number = number;
|
|
slot->type = number % 2;
|
|
slot->pg_keep = 0;
|
|
slot->wave_table = wave_table_map[0];
|
|
slot->pg_phase = 0;
|
|
slot->output[0] = 0;
|
|
slot->output[1] = 0;
|
|
slot->eg_state = RELEASE;
|
|
slot->eg_shift = 0;
|
|
slot->rks = 0;
|
|
slot->tll = 0;
|
|
slot->key_flag = 0;
|
|
slot->sus_flag = 0;
|
|
slot->blk_fnum = 0;
|
|
slot->blk = 0;
|
|
slot->fnum = 0;
|
|
slot->volume = 0;
|
|
slot->pg_out = 0;
|
|
slot->eg_out = EG_MUTE;
|
|
slot->patch = &null_patch;
|
|
}
|
|
|
|
static INLINE void slotOn(OPLL *opll, int i) {
|
|
OPLL_SLOT *slot = &opll->slot[i];
|
|
slot->key_flag = 1;
|
|
slot->eg_state = DAMP;
|
|
request_update(slot, UPDATE_EG);
|
|
}
|
|
|
|
static INLINE void slotOff(OPLL *opll, int i) {
|
|
OPLL_SLOT *slot = &opll->slot[i];
|
|
slot->key_flag = 0;
|
|
if (slot->type & 1) {
|
|
slot->eg_state = RELEASE;
|
|
request_update(slot, UPDATE_EG);
|
|
}
|
|
}
|
|
|
|
static INLINE void update_key_status(OPLL *opll) {
|
|
const uint8_t r14 = opll->reg[0x0e];
|
|
const uint8_t rhythm_mode = BIT(r14, 5);
|
|
uint32_t new_slot_key_status = 0;
|
|
uint32_t updated_status;
|
|
int ch;
|
|
|
|
for (ch = 0; ch < 9; ch++)
|
|
if (opll->reg[0x20 + ch] & 0x10)
|
|
new_slot_key_status |= 3 << (ch * 2);
|
|
|
|
if (rhythm_mode) {
|
|
if (r14 & 0x10)
|
|
new_slot_key_status |= 3 << SLOT_BD1;
|
|
|
|
if (r14 & 0x01)
|
|
new_slot_key_status |= 1 << SLOT_HH;
|
|
|
|
if (r14 & 0x08)
|
|
new_slot_key_status |= 1 << SLOT_SD;
|
|
|
|
if (r14 & 0x04)
|
|
new_slot_key_status |= 1 << SLOT_TOM;
|
|
|
|
if (r14 & 0x02)
|
|
new_slot_key_status |= 1 << SLOT_CYM;
|
|
}
|
|
|
|
updated_status = opll->slot_key_status ^ new_slot_key_status;
|
|
|
|
if (updated_status) {
|
|
int i;
|
|
for (i = 0; i < 18; i++)
|
|
if (BIT(updated_status, i)) {
|
|
if (BIT(new_slot_key_status, i)) {
|
|
slotOn(opll, i);
|
|
} else {
|
|
slotOff(opll, i);
|
|
}
|
|
}
|
|
}
|
|
|
|
opll->slot_key_status = new_slot_key_status;
|
|
}
|
|
|
|
static INLINE void set_patch(OPLL *opll, int32_t ch, int32_t num) {
|
|
opll->patch_number[ch] = num;
|
|
MOD(opll, ch)->patch = &opll->patch[num * 2 + 0];
|
|
CAR(opll, ch)->patch = &opll->patch[num * 2 + 1];
|
|
request_update(MOD(opll, ch), UPDATE_ALL);
|
|
request_update(CAR(opll, ch), UPDATE_ALL);
|
|
}
|
|
|
|
static INLINE void set_sus_flag(OPLL *opll, int ch, int flag) {
|
|
CAR(opll, ch)->sus_flag = flag;
|
|
request_update(CAR(opll, ch), UPDATE_EG);
|
|
if (MOD(opll, ch)->type & 1) {
|
|
MOD(opll, ch)->sus_flag = flag;
|
|
request_update(MOD(opll, ch), UPDATE_EG);
|
|
}
|
|
}
|
|
|
|
/* set volume ( volume : 6bit, register value << 2 ) */
|
|
static INLINE void set_volume(OPLL *opll, int ch, int volume) {
|
|
CAR(opll, ch)->volume = volume;
|
|
request_update(CAR(opll, ch), UPDATE_TLL);
|
|
}
|
|
|
|
static INLINE void set_slot_volume(OPLL_SLOT *slot, int volume) {
|
|
slot->volume = volume;
|
|
request_update(slot, UPDATE_TLL);
|
|
}
|
|
|
|
/* set f-Nnmber ( fnum : 9bit ) */
|
|
static INLINE void set_fnumber(OPLL *opll, int ch, int fnum) {
|
|
OPLL_SLOT *car = CAR(opll, ch);
|
|
OPLL_SLOT *mod = MOD(opll, ch);
|
|
car->fnum = fnum;
|
|
car->blk_fnum = (car->blk_fnum & 0xe00) | (fnum & 0x1ff);
|
|
mod->fnum = fnum;
|
|
mod->blk_fnum = (mod->blk_fnum & 0xe00) | (fnum & 0x1ff);
|
|
request_update(car, UPDATE_EG | UPDATE_RKS | UPDATE_TLL);
|
|
request_update(mod, UPDATE_EG | UPDATE_RKS | UPDATE_TLL);
|
|
}
|
|
|
|
/* set block data (blk : 3bit ) */
|
|
static INLINE void set_block(OPLL *opll, int ch, int blk) {
|
|
OPLL_SLOT *car = CAR(opll, ch);
|
|
OPLL_SLOT *mod = MOD(opll, ch);
|
|
car->blk = blk;
|
|
car->blk_fnum = ((blk & 7) << 9) | (car->blk_fnum & 0x1ff);
|
|
mod->blk = blk;
|
|
mod->blk_fnum = ((blk & 7) << 9) | (mod->blk_fnum & 0x1ff);
|
|
request_update(car, UPDATE_EG | UPDATE_RKS | UPDATE_TLL);
|
|
request_update(mod, UPDATE_EG | UPDATE_RKS | UPDATE_TLL);
|
|
}
|
|
|
|
static INLINE void update_rhythm_mode(OPLL *opll) {
|
|
const uint8_t new_rhythm_mode = (opll->reg[0x0e] >> 5) & 1;
|
|
|
|
if (opll->rhythm_mode != new_rhythm_mode) {
|
|
|
|
if (new_rhythm_mode) {
|
|
opll->slot[SLOT_HH].type = 3;
|
|
opll->slot[SLOT_HH].pg_keep = 1;
|
|
opll->slot[SLOT_SD].type = 3;
|
|
opll->slot[SLOT_TOM].type = 3;
|
|
opll->slot[SLOT_CYM].type = 3;
|
|
opll->slot[SLOT_CYM].pg_keep = 1;
|
|
set_patch(opll, 6, 16);
|
|
set_patch(opll, 7, 17);
|
|
set_patch(opll, 8, 18);
|
|
set_slot_volume(&opll->slot[SLOT_HH], ((opll->reg[0x37] >> 4) & 15) << 2);
|
|
set_slot_volume(&opll->slot[SLOT_TOM], ((opll->reg[0x38] >> 4) & 15) << 2);
|
|
} else {
|
|
opll->slot[SLOT_HH].type = 0;
|
|
opll->slot[SLOT_HH].pg_keep = 0;
|
|
opll->slot[SLOT_SD].type = 1;
|
|
opll->slot[SLOT_TOM].type = 0;
|
|
opll->slot[SLOT_CYM].type = 1;
|
|
opll->slot[SLOT_CYM].pg_keep = 0;
|
|
set_patch(opll, 6, opll->reg[0x36] >> 4);
|
|
set_patch(opll, 7, opll->reg[0x37] >> 4);
|
|
set_patch(opll, 8, opll->reg[0x38] >> 4);
|
|
}
|
|
}
|
|
|
|
opll->rhythm_mode = new_rhythm_mode;
|
|
}
|
|
|
|
static void update_ampm(OPLL *opll) {
|
|
if (opll->test_flag & 2) {
|
|
opll->pm_phase = 0;
|
|
opll->am_phase = 0;
|
|
} else {
|
|
opll->pm_phase += (opll->test_flag & 8) ? 1024 : 1;
|
|
opll->am_phase += (opll->test_flag & 8) ? 64 : 1;
|
|
}
|
|
opll->lfo_am = am_table[(opll->am_phase >> 6) % sizeof(am_table)];
|
|
}
|
|
|
|
static void update_noise(OPLL *opll, int cycle) {
|
|
int i;
|
|
for (i = 0; i < cycle; i++) {
|
|
if (opll->noise & 1) {
|
|
opll->noise ^= 0x800200;
|
|
}
|
|
opll->noise >>= 1;
|
|
}
|
|
}
|
|
|
|
static void update_short_noise(OPLL *opll) {
|
|
const uint32_t pg_hh = opll->slot[SLOT_HH].pg_out;
|
|
const uint32_t pg_cym = opll->slot[SLOT_CYM].pg_out;
|
|
|
|
const uint8_t h_bit2 = BIT(pg_hh, PG_BITS - 8);
|
|
const uint8_t h_bit7 = BIT(pg_hh, PG_BITS - 3);
|
|
const uint8_t h_bit3 = BIT(pg_hh, PG_BITS - 7);
|
|
|
|
const uint8_t c_bit3 = BIT(pg_cym, PG_BITS - 7);
|
|
const uint8_t c_bit5 = BIT(pg_cym, PG_BITS - 5);
|
|
|
|
opll->short_noise = (h_bit2 ^ h_bit7) | (h_bit3 ^ c_bit5) | (c_bit3 ^ c_bit5);
|
|
}
|
|
|
|
static INLINE void calc_phase(OPLL_SLOT *slot, int32_t pm_phase, uint8_t reset) {
|
|
const int8_t pm = slot->patch->PM ? pm_table[(slot->fnum >> 6) & 7][(pm_phase >> 10) & 7] : 0;
|
|
if (reset) {
|
|
slot->pg_phase = 0;
|
|
}
|
|
slot->pg_phase += (((slot->fnum & 0x1ff) * 2 + pm) * ml_table[slot->patch->ML]) << slot->blk >> 2;
|
|
slot->pg_phase &= (DP_WIDTH - 1);
|
|
slot->pg_out = slot->pg_phase >> DP_BASE_BITS;
|
|
}
|
|
|
|
static INLINE uint8_t lookup_attack_step(OPLL_SLOT *slot, uint32_t counter) {
|
|
int index;
|
|
|
|
switch (slot->eg_rate_h) {
|
|
case 12:
|
|
index = (counter & 0xc) >> 1;
|
|
return 4 - eg_step_tables[slot->eg_rate_l][index];
|
|
case 13:
|
|
index = (counter & 0xc) >> 1;
|
|
return 3 - eg_step_tables[slot->eg_rate_l][index];
|
|
case 14:
|
|
index = (counter & 0xc) >> 1;
|
|
return 2 - eg_step_tables[slot->eg_rate_l][index];
|
|
case 0:
|
|
case 15:
|
|
return 0;
|
|
default:
|
|
index = counter >> slot->eg_shift;
|
|
return eg_step_tables[slot->eg_rate_l][index & 7] ? 4 : 0;
|
|
}
|
|
}
|
|
|
|
static INLINE uint8_t lookup_decay_step(OPLL_SLOT *slot, uint32_t counter) {
|
|
int index;
|
|
|
|
switch (slot->eg_rate_h) {
|
|
case 0:
|
|
return 0;
|
|
case 13:
|
|
index = ((counter & 0xc) >> 1) | (counter & 1);
|
|
return eg_step_tables[slot->eg_rate_l][index];
|
|
case 14:
|
|
index = ((counter & 0xc) >> 1);
|
|
return eg_step_tables[slot->eg_rate_l][index] + 1;
|
|
case 15:
|
|
return 2;
|
|
default:
|
|
index = counter >> slot->eg_shift;
|
|
return eg_step_tables[slot->eg_rate_l][index & 7];
|
|
}
|
|
}
|
|
|
|
static INLINE void start_envelope(OPLL_SLOT *slot) {
|
|
if (min(15, slot->patch->AR + (slot->rks >> 2)) == 15) {
|
|
slot->eg_state = DECAY;
|
|
slot->eg_out = 0;
|
|
} else {
|
|
slot->eg_state = ATTACK;
|
|
}
|
|
request_update(slot, UPDATE_EG);
|
|
}
|
|
|
|
static INLINE void calc_envelope(OPLL_SLOT *slot, OPLL_SLOT *buddy, uint16_t eg_counter, uint8_t test) {
|
|
|
|
uint32_t mask = (1 << slot->eg_shift) - 1;
|
|
uint8_t s;
|
|
|
|
if (slot->eg_state == ATTACK) {
|
|
if (0 < slot->eg_out && 0 < slot->eg_rate_h && (eg_counter & mask & ~3) == 0) {
|
|
s = lookup_attack_step(slot, eg_counter);
|
|
if (0 < s) {
|
|
slot->eg_out = max(0, ((int)slot->eg_out - (slot->eg_out >> s) - 1));
|
|
}
|
|
}
|
|
} else {
|
|
if (slot->eg_rate_h > 0 && (eg_counter & mask) == 0) {
|
|
slot->eg_out = min(EG_MUTE, slot->eg_out + lookup_decay_step(slot, eg_counter));
|
|
}
|
|
}
|
|
|
|
switch (slot->eg_state) {
|
|
case DAMP:
|
|
// DAMP to ATTACK transition is occured when the envelope reaches EG_MAX (max attenuation but it's not mute).
|
|
// Do not forget to check (eg_counter & mask) == 0 to synchronize it with the progress of the envelope.
|
|
if (slot->eg_out >= EG_MAX && (eg_counter & mask) == 0) {
|
|
start_envelope(slot);
|
|
if (slot->type & 1) {
|
|
if (!slot->pg_keep) {
|
|
slot->pg_phase = 0;
|
|
}
|
|
if (buddy && !buddy->pg_keep) {
|
|
buddy->pg_phase = 0;
|
|
}
|
|
}
|
|
}
|
|
break;
|
|
|
|
case ATTACK:
|
|
if (slot->eg_out == 0) {
|
|
slot->eg_state = DECAY;
|
|
request_update(slot, UPDATE_EG);
|
|
}
|
|
break;
|
|
|
|
case DECAY:
|
|
// DECAY to SUSTAIN transition must be checked at every cycle regardless of the conditions of the envelope rate and
|
|
// counter. i.e. the transition is not synchronized with the progress of the envelope.
|
|
if ((slot->eg_out >> 3) == slot->patch->SL) {
|
|
slot->eg_state = SUSTAIN;
|
|
request_update(slot, UPDATE_EG);
|
|
}
|
|
break;
|
|
|
|
case SUSTAIN:
|
|
case RELEASE:
|
|
default:
|
|
break;
|
|
}
|
|
|
|
if (test) {
|
|
slot->eg_out = 0;
|
|
}
|
|
}
|
|
|
|
static void update_slots(OPLL *opll) {
|
|
int i;
|
|
opll->eg_counter++;
|
|
|
|
for (i = 0; i < 18; i++) {
|
|
OPLL_SLOT *slot = &opll->slot[i];
|
|
OPLL_SLOT *buddy = NULL;
|
|
if (slot->type == 0) {
|
|
buddy = &opll->slot[i + 1];
|
|
}
|
|
if (slot->type == 1) {
|
|
buddy = &opll->slot[i - 1];
|
|
}
|
|
if (slot->update_requests) {
|
|
commit_slot_update(slot);
|
|
}
|
|
calc_envelope(slot, buddy, opll->eg_counter, opll->test_flag & 1);
|
|
calc_phase(slot, opll->pm_phase, opll->test_flag & 4);
|
|
}
|
|
}
|
|
|
|
/* output: -4095...4095 */
|
|
static INLINE int16_t lookup_exp_table(uint16_t i) {
|
|
/* from andete's expression */
|
|
int16_t t = (exp_table[(i & 0xff) ^ 0xff] + 1024);
|
|
int16_t res = t >> ((i & 0x7f00) >> 8);
|
|
return ((i & 0x8000) ? ~res : res) << 1;
|
|
}
|
|
|
|
static INLINE int16_t to_linear(uint16_t h, OPLL_SLOT *slot, int16_t am) {
|
|
uint16_t att;
|
|
if (slot->eg_out > EG_MAX)
|
|
return 0;
|
|
|
|
att = min(EG_MUTE, (slot->eg_out + slot->tll + am)) << 4;
|
|
return lookup_exp_table(h + att);
|
|
}
|
|
|
|
static INLINE int16_t calc_slot_car(OPLL *opll, int ch, int16_t fm) {
|
|
OPLL_SLOT *slot = CAR(opll, ch);
|
|
|
|
uint8_t am = slot->patch->AM ? opll->lfo_am : 0;
|
|
|
|
slot->output[1] = slot->output[0];
|
|
slot->output[0] = to_linear(slot->wave_table[(slot->pg_out + 2 * (fm >> 1)) & (PG_WIDTH - 1)], slot, am);
|
|
|
|
return slot->output[0];
|
|
}
|
|
|
|
static INLINE int16_t calc_slot_mod(OPLL *opll, int ch) {
|
|
OPLL_SLOT *slot = MOD(opll, ch);
|
|
|
|
int16_t fm = slot->patch->FB > 0 ? (slot->output[1] + slot->output[0]) >> (9 - slot->patch->FB) : 0;
|
|
uint8_t am = slot->patch->AM ? opll->lfo_am : 0;
|
|
|
|
slot->output[1] = slot->output[0];
|
|
slot->output[0] = to_linear(slot->wave_table[(slot->pg_out + fm) & (PG_WIDTH - 1)], slot, am);
|
|
|
|
return slot->output[0];
|
|
}
|
|
|
|
static INLINE int16_t calc_slot_tom(OPLL *opll) {
|
|
OPLL_SLOT *slot = MOD(opll, 8);
|
|
|
|
return to_linear(slot->wave_table[slot->pg_out], slot, 0);
|
|
}
|
|
|
|
/* Specify phase offset directly based on 10-bit (1024-length) sine table */
|
|
#define _PD(phase) ((PG_BITS < 10) ? (phase >> (10 - PG_BITS)) : (phase << (PG_BITS - 10)))
|
|
|
|
static INLINE int16_t calc_slot_snare(OPLL *opll) {
|
|
OPLL_SLOT *slot = CAR(opll, 7);
|
|
|
|
uint32_t phase;
|
|
|
|
if (BIT(slot->pg_out, PG_BITS - 2))
|
|
phase = (opll->noise & 1) ? _PD(0x300) : _PD(0x200);
|
|
else
|
|
phase = (opll->noise & 1) ? _PD(0x0) : _PD(0x100);
|
|
|
|
return to_linear(slot->wave_table[phase], slot, 0);
|
|
}
|
|
|
|
static INLINE int16_t calc_slot_cym(OPLL *opll) {
|
|
OPLL_SLOT *slot = CAR(opll, 8);
|
|
|
|
uint32_t phase = opll->short_noise ? _PD(0x300) : _PD(0x100);
|
|
|
|
return to_linear(slot->wave_table[phase], slot, 0);
|
|
}
|
|
|
|
static INLINE int16_t calc_slot_hat(OPLL *opll) {
|
|
OPLL_SLOT *slot = MOD(opll, 7);
|
|
|
|
uint32_t phase;
|
|
|
|
if (opll->short_noise)
|
|
phase = (opll->noise & 1) ? _PD(0x2d0) : _PD(0x234);
|
|
else
|
|
phase = (opll->noise & 1) ? _PD(0x34) : _PD(0xd0);
|
|
|
|
return to_linear(slot->wave_table[phase], slot, 0);
|
|
}
|
|
|
|
#define _MO(x) (-(x) >> 1)
|
|
#define _RO(x) (x)
|
|
|
|
static void update_output(OPLL *opll) {
|
|
int16_t *out;
|
|
int i;
|
|
|
|
update_ampm(opll);
|
|
update_short_noise(opll);
|
|
update_slots(opll);
|
|
|
|
out = opll->ch_out;
|
|
|
|
/* CH1-6 */
|
|
for (i = 0; i < 6; i++) {
|
|
if (!(opll->mask & OPLL_MASK_CH(i))) {
|
|
out[i] = _MO(calc_slot_car(opll, i, calc_slot_mod(opll, i)));
|
|
}
|
|
}
|
|
|
|
/* CH7 */
|
|
if (!opll->rhythm_mode) {
|
|
if (!(opll->mask & OPLL_MASK_CH(6))) {
|
|
out[6] = _MO(calc_slot_car(opll, 6, calc_slot_mod(opll, 6)));
|
|
}
|
|
} else {
|
|
if (!(opll->mask & OPLL_MASK_BD)) {
|
|
out[9] = _RO(calc_slot_car(opll, 6, calc_slot_mod(opll, 6)));
|
|
}
|
|
}
|
|
update_noise(opll, 14);
|
|
|
|
/* CH8 */
|
|
if (!opll->rhythm_mode) {
|
|
if (!(opll->mask & OPLL_MASK_CH(7))) {
|
|
out[7] = _MO(calc_slot_car(opll, 7, calc_slot_mod(opll, 7)));
|
|
}
|
|
} else {
|
|
if (!(opll->mask & OPLL_MASK_HH)) {
|
|
out[10] = _RO(calc_slot_hat(opll));
|
|
}
|
|
if (!(opll->mask & OPLL_MASK_SD)) {
|
|
out[11] = _RO(calc_slot_snare(opll));
|
|
}
|
|
}
|
|
update_noise(opll, 2);
|
|
|
|
/* CH9 */
|
|
if (!opll->rhythm_mode) {
|
|
if (!(opll->mask & OPLL_MASK_CH(8))) {
|
|
out[8] = _MO(calc_slot_car(opll, 8, calc_slot_mod(opll, 8)));
|
|
}
|
|
} else {
|
|
if (!(opll->mask & OPLL_MASK_TOM)) {
|
|
out[12] = _RO(calc_slot_tom(opll));
|
|
}
|
|
if (!(opll->mask & OPLL_MASK_CYM)) {
|
|
out[13] = _RO(calc_slot_cym(opll));
|
|
}
|
|
}
|
|
update_noise(opll, 2);
|
|
}
|
|
|
|
INLINE static void mix_output(OPLL *opll) {
|
|
int16_t out = 0;
|
|
int i;
|
|
for (i = 0; i < 14; i++) {
|
|
out += opll->ch_out[i];
|
|
}
|
|
if (opll->conv) {
|
|
OPLL_RateConv_putData(opll->conv, 0, out);
|
|
} else {
|
|
opll->mix_out[0] = out;
|
|
}
|
|
}
|
|
|
|
INLINE static void mix_output_stereo(OPLL *opll) {
|
|
int16_t *out = opll->mix_out;
|
|
int i;
|
|
out[0] = out[1] = 0;
|
|
for (i = 0; i < 14; i++) {
|
|
if (opll->pan[i] & 2)
|
|
out[0] += (int16_t)(opll->ch_out[i] * opll->pan_fine[i][0]);
|
|
if (opll->pan[i] & 1)
|
|
out[1] += (int16_t)(opll->ch_out[i] * opll->pan_fine[i][1]);
|
|
}
|
|
if (opll->conv) {
|
|
OPLL_RateConv_putData(opll->conv, 0, out[0]);
|
|
OPLL_RateConv_putData(opll->conv, 1, out[1]);
|
|
}
|
|
}
|
|
|
|
/***********************************************************
|
|
|
|
External Interfaces
|
|
|
|
***********************************************************/
|
|
|
|
OPLL *OPLL_new(uint32_t clk, uint32_t rate) {
|
|
OPLL *opll;
|
|
int i;
|
|
|
|
if (!table_initialized) {
|
|
initializeTables();
|
|
}
|
|
|
|
opll = (OPLL *)calloc(sizeof(OPLL), 1);
|
|
if (opll == NULL)
|
|
return NULL;
|
|
|
|
for (i = 0; i < 19 * 2; i++)
|
|
memcpy(&opll->patch[i], &null_patch, sizeof(OPLL_PATCH));
|
|
|
|
opll->clk = clk;
|
|
opll->rate = rate;
|
|
opll->mask = 0;
|
|
opll->conv = NULL;
|
|
opll->mix_out[0] = 0;
|
|
opll->mix_out[1] = 0;
|
|
|
|
OPLL_reset(opll);
|
|
OPLL_setChipType(opll, 0);
|
|
OPLL_resetPatch(opll, 0);
|
|
return opll;
|
|
}
|
|
|
|
void OPLL_delete(OPLL *opll) {
|
|
if (opll->conv) {
|
|
OPLL_RateConv_delete(opll->conv);
|
|
opll->conv = NULL;
|
|
}
|
|
free(opll);
|
|
}
|
|
|
|
static void reset_rate_conversion_params(OPLL *opll) {
|
|
const double f_out = opll->rate;
|
|
const double f_inp = opll->clk / 72.0;
|
|
|
|
opll->out_time = 0;
|
|
opll->out_step = f_inp;
|
|
opll->inp_step = f_out;
|
|
|
|
if (opll->conv) {
|
|
OPLL_RateConv_delete(opll->conv);
|
|
opll->conv = NULL;
|
|
}
|
|
|
|
if (floor(f_inp) != f_out && floor(f_inp + 0.5) != f_out) {
|
|
opll->conv = OPLL_RateConv_new(f_inp, f_out, 2);
|
|
}
|
|
|
|
if (opll->conv) {
|
|
OPLL_RateConv_reset(opll->conv);
|
|
}
|
|
}
|
|
|
|
void OPLL_reset(OPLL *opll) {
|
|
int i;
|
|
|
|
if (!opll)
|
|
return;
|
|
|
|
opll->adr = 0;
|
|
|
|
opll->pm_phase = 0;
|
|
opll->am_phase = 0;
|
|
|
|
opll->noise = 0x1;
|
|
opll->mask = 0;
|
|
|
|
opll->rhythm_mode = 0;
|
|
opll->slot_key_status = 0;
|
|
opll->eg_counter = 0;
|
|
|
|
reset_rate_conversion_params(opll);
|
|
|
|
for (i = 0; i < 18; i++)
|
|
reset_slot(&opll->slot[i], i);
|
|
|
|
for (i = 0; i < 9; i++) {
|
|
set_patch(opll, i, 0);
|
|
}
|
|
|
|
for (i = 0; i < 0x40; i++)
|
|
OPLL_writeReg(opll, i, 0);
|
|
|
|
for (i = 0; i < 15; i++) {
|
|
opll->pan[i] = 3;
|
|
opll->pan_fine[i][1] = opll->pan_fine[i][0] = 1.0f;
|
|
}
|
|
|
|
for (i = 0; i < 14; i++) {
|
|
opll->ch_out[i] = 0;
|
|
}
|
|
}
|
|
|
|
void OPLL_forceRefresh(OPLL *opll) {
|
|
int i;
|
|
|
|
if (opll == NULL)
|
|
return;
|
|
|
|
for (i = 0; i < 9; i++) {
|
|
set_patch(opll, i, opll->patch_number[i]);
|
|
}
|
|
|
|
for (i = 0; i < 18; i++) {
|
|
request_update(&opll->slot[i], UPDATE_ALL);
|
|
}
|
|
}
|
|
|
|
void OPLL_setRate(OPLL *opll, uint32_t rate) {
|
|
opll->rate = rate;
|
|
reset_rate_conversion_params(opll);
|
|
}
|
|
|
|
void OPLL_setQuality(OPLL *opll, uint8_t q) {}
|
|
|
|
void OPLL_setChipType(OPLL *opll, uint8_t type) { opll->chip_type = type; }
|
|
|
|
void OPLL_writeReg(OPLL *opll, uint32_t reg, uint8_t data) {
|
|
int ch, i;
|
|
|
|
if (reg >= 0x40)
|
|
return;
|
|
|
|
/* mirror registers */
|
|
if ((0x19 <= reg && reg <= 0x1f) || (0x29 <= reg && reg <= 0x2f) || (0x39 <= reg && reg <= 0x3f)) {
|
|
reg -= 9;
|
|
}
|
|
|
|
// is the compiler stupid or what?
|
|
// -Wstringop-overflow seems to be the buggiest thing known to humanity...
|
|
if (reg<0x40) {
|
|
opll->reg[reg] = (uint8_t)data;
|
|
}
|
|
|
|
switch (reg) {
|
|
case 0x00:
|
|
opll->patch[0].AM = (data >> 7) & 1;
|
|
opll->patch[0].PM = (data >> 6) & 1;
|
|
opll->patch[0].EG = (data >> 5) & 1;
|
|
opll->patch[0].KR = (data >> 4) & 1;
|
|
opll->patch[0].ML = (data)&15;
|
|
for (i = 0; i < 9; i++) {
|
|
if (opll->patch_number[i] == 0) {
|
|
request_update(MOD(opll, i), UPDATE_RKS | UPDATE_EG);
|
|
}
|
|
}
|
|
break;
|
|
|
|
case 0x01:
|
|
opll->patch[1].AM = (data >> 7) & 1;
|
|
opll->patch[1].PM = (data >> 6) & 1;
|
|
opll->patch[1].EG = (data >> 5) & 1;
|
|
opll->patch[1].KR = (data >> 4) & 1;
|
|
opll->patch[1].ML = (data)&15;
|
|
for (i = 0; i < 9; i++) {
|
|
if (opll->patch_number[i] == 0) {
|
|
request_update(CAR(opll, i), UPDATE_RKS | UPDATE_EG);
|
|
}
|
|
}
|
|
break;
|
|
|
|
case 0x02:
|
|
opll->patch[0].KL = (data >> 6) & 3;
|
|
opll->patch[0].TL = (data)&63;
|
|
for (i = 0; i < 9; i++) {
|
|
if (opll->patch_number[i] == 0) {
|
|
request_update(MOD(opll, i), UPDATE_TLL);
|
|
}
|
|
}
|
|
break;
|
|
|
|
case 0x03:
|
|
opll->patch[1].KL = (data >> 6) & 3;
|
|
opll->patch[1].WS = (data >> 4) & 1;
|
|
opll->patch[0].WS = (data >> 3) & 1;
|
|
opll->patch[0].FB = (data)&7;
|
|
for (i = 0; i < 9; i++) {
|
|
if (opll->patch_number[i] == 0) {
|
|
request_update(MOD(opll, i), UPDATE_WS);
|
|
request_update(CAR(opll, i), UPDATE_WS | UPDATE_TLL);
|
|
}
|
|
}
|
|
break;
|
|
|
|
case 0x04:
|
|
opll->patch[0].AR = (data >> 4) & 15;
|
|
opll->patch[0].DR = (data)&15;
|
|
for (i = 0; i < 9; i++) {
|
|
if (opll->patch_number[i] == 0) {
|
|
request_update(MOD(opll, i), UPDATE_EG);
|
|
}
|
|
}
|
|
break;
|
|
|
|
case 0x05:
|
|
opll->patch[1].AR = (data >> 4) & 15;
|
|
opll->patch[1].DR = (data)&15;
|
|
for (i = 0; i < 9; i++) {
|
|
if (opll->patch_number[i] == 0) {
|
|
request_update(CAR(opll, i), UPDATE_EG);
|
|
}
|
|
}
|
|
break;
|
|
|
|
case 0x06:
|
|
opll->patch[0].SL = (data >> 4) & 15;
|
|
opll->patch[0].RR = (data)&15;
|
|
for (i = 0; i < 9; i++) {
|
|
if (opll->patch_number[i] == 0) {
|
|
request_update(MOD(opll, i), UPDATE_EG);
|
|
}
|
|
}
|
|
break;
|
|
|
|
case 0x07:
|
|
opll->patch[1].SL = (data >> 4) & 15;
|
|
opll->patch[1].RR = (data)&15;
|
|
for (i = 0; i < 9; i++) {
|
|
if (opll->patch_number[i] == 0) {
|
|
request_update(CAR(opll, i), UPDATE_EG);
|
|
}
|
|
}
|
|
break;
|
|
|
|
case 0x0e:
|
|
if (opll->chip_type == 1)
|
|
break;
|
|
update_rhythm_mode(opll);
|
|
update_key_status(opll);
|
|
break;
|
|
|
|
case 0x0f:
|
|
opll->test_flag = data;
|
|
break;
|
|
|
|
case 0x10:
|
|
case 0x11:
|
|
case 0x12:
|
|
case 0x13:
|
|
case 0x14:
|
|
case 0x15:
|
|
case 0x16:
|
|
case 0x17:
|
|
case 0x18:
|
|
ch = reg - 0x10;
|
|
set_fnumber(opll, ch, data + ((opll->reg[0x20 + ch] & 1) << 8));
|
|
break;
|
|
|
|
case 0x20:
|
|
case 0x21:
|
|
case 0x22:
|
|
case 0x23:
|
|
case 0x24:
|
|
case 0x25:
|
|
case 0x26:
|
|
case 0x27:
|
|
case 0x28:
|
|
ch = reg - 0x20;
|
|
set_fnumber(opll, ch, ((data & 1) << 8) + opll->reg[0x10 + ch]);
|
|
set_block(opll, ch, (data >> 1) & 7);
|
|
set_sus_flag(opll, ch, (data >> 5) & 1);
|
|
update_key_status(opll);
|
|
break;
|
|
|
|
case 0x30:
|
|
case 0x31:
|
|
case 0x32:
|
|
case 0x33:
|
|
case 0x34:
|
|
case 0x35:
|
|
case 0x36:
|
|
case 0x37:
|
|
case 0x38:
|
|
if ((opll->reg[0x0e] & 32) && (reg >= 0x36)) {
|
|
switch (reg) {
|
|
case 0x37:
|
|
set_slot_volume(MOD(opll, 7), ((data >> 4) & 15) << 2);
|
|
break;
|
|
case 0x38:
|
|
set_slot_volume(MOD(opll, 8), ((data >> 4) & 15) << 2);
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
} else {
|
|
set_patch(opll, reg - 0x30, (data >> 4) & 15);
|
|
}
|
|
set_volume(opll, reg - 0x30, (data & 15) << 2);
|
|
break;
|
|
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
|
|
void OPLL_writeIO(OPLL *opll, uint32_t adr, uint8_t val) {
|
|
if (adr & 1)
|
|
OPLL_writeReg(opll, opll->adr, val);
|
|
else
|
|
opll->adr = val;
|
|
}
|
|
|
|
void OPLL_setPan(OPLL *opll, uint32_t ch, uint8_t pan) { opll->pan[ch & 15] = pan; }
|
|
|
|
void OPLL_setPanFine(OPLL *opll, uint32_t ch, float pan[2]) {
|
|
opll->pan_fine[ch & 15][0] = pan[0];
|
|
opll->pan_fine[ch & 15][1] = pan[1];
|
|
}
|
|
|
|
void OPLL_dumpToPatch(const uint8_t *dump, OPLL_PATCH *patch) {
|
|
patch[0].AM = (dump[0] >> 7) & 1;
|
|
patch[1].AM = (dump[1] >> 7) & 1;
|
|
patch[0].PM = (dump[0] >> 6) & 1;
|
|
patch[1].PM = (dump[1] >> 6) & 1;
|
|
patch[0].EG = (dump[0] >> 5) & 1;
|
|
patch[1].EG = (dump[1] >> 5) & 1;
|
|
patch[0].KR = (dump[0] >> 4) & 1;
|
|
patch[1].KR = (dump[1] >> 4) & 1;
|
|
patch[0].ML = (dump[0]) & 15;
|
|
patch[1].ML = (dump[1]) & 15;
|
|
patch[0].KL = (dump[2] >> 6) & 3;
|
|
patch[1].KL = (dump[3] >> 6) & 3;
|
|
patch[0].TL = (dump[2]) & 63;
|
|
patch[1].TL = 0;
|
|
patch[0].FB = (dump[3]) & 7;
|
|
patch[1].FB = 0;
|
|
patch[0].WS = (dump[3] >> 3) & 1;
|
|
patch[1].WS = (dump[3] >> 4) & 1;
|
|
patch[0].AR = (dump[4] >> 4) & 15;
|
|
patch[1].AR = (dump[5] >> 4) & 15;
|
|
patch[0].DR = (dump[4]) & 15;
|
|
patch[1].DR = (dump[5]) & 15;
|
|
patch[0].SL = (dump[6] >> 4) & 15;
|
|
patch[1].SL = (dump[7] >> 4) & 15;
|
|
patch[0].RR = (dump[6]) & 15;
|
|
patch[1].RR = (dump[7]) & 15;
|
|
}
|
|
|
|
void OPLL_getDefaultPatch(int32_t type, int32_t num, OPLL_PATCH *patch) {
|
|
OPLL_dumpToPatch(default_inst[type] + num * 8, patch);
|
|
}
|
|
|
|
void OPLL_setPatch(OPLL *opll, const uint8_t *dump) {
|
|
OPLL_PATCH patch[2];
|
|
int i;
|
|
for (i = 0; i < 19; i++) {
|
|
OPLL_dumpToPatch(dump + i * 8, patch);
|
|
memcpy(&opll->patch[i * 2 + 0], &patch[0], sizeof(OPLL_PATCH));
|
|
memcpy(&opll->patch[i * 2 + 1], &patch[1], sizeof(OPLL_PATCH));
|
|
}
|
|
}
|
|
|
|
void OPLL_patchToDump(const OPLL_PATCH *patch, uint8_t *dump) {
|
|
dump[0] = (uint8_t)((patch[0].AM << 7) + (patch[0].PM << 6) + (patch[0].EG << 5) + (patch[0].KR << 4) + patch[0].ML);
|
|
dump[1] = (uint8_t)((patch[1].AM << 7) + (patch[1].PM << 6) + (patch[1].EG << 5) + (patch[1].KR << 4) + patch[1].ML);
|
|
dump[2] = (uint8_t)((patch[0].KL << 6) + patch[0].TL);
|
|
dump[3] = (uint8_t)((patch[1].KL << 6) + (patch[1].WS << 4) + (patch[0].WS << 3) + patch[0].FB);
|
|
dump[4] = (uint8_t)((patch[0].AR << 4) + patch[0].DR);
|
|
dump[5] = (uint8_t)((patch[1].AR << 4) + patch[1].DR);
|
|
dump[6] = (uint8_t)((patch[0].SL << 4) + patch[0].RR);
|
|
dump[7] = (uint8_t)((patch[1].SL << 4) + patch[1].RR);
|
|
}
|
|
|
|
void OPLL_copyPatch(OPLL *opll, int32_t num, OPLL_PATCH *patch) {
|
|
memcpy(&opll->patch[num], patch, sizeof(OPLL_PATCH));
|
|
}
|
|
|
|
void OPLL_resetPatch(OPLL *opll, uint8_t type) {
|
|
int i;
|
|
for (i = 0; i < 19 * 2; i++)
|
|
OPLL_copyPatch(opll, i, &default_patch[type % OPLL_TONE_NUM][i]);
|
|
}
|
|
|
|
int16_t OPLL_calc(OPLL *opll) {
|
|
while (opll->out_step > opll->out_time) {
|
|
opll->out_time += opll->inp_step;
|
|
update_output(opll);
|
|
mix_output(opll);
|
|
}
|
|
opll->out_time -= opll->out_step;
|
|
if (opll->conv) {
|
|
opll->mix_out[0] = OPLL_RateConv_getData(opll->conv, 0);
|
|
}
|
|
return opll->mix_out[0];
|
|
}
|
|
|
|
void OPLL_calcStereo(OPLL *opll, int32_t out[2]) {
|
|
while (opll->out_step > opll->out_time) {
|
|
opll->out_time += opll->inp_step;
|
|
update_output(opll);
|
|
mix_output_stereo(opll);
|
|
}
|
|
opll->out_time -= opll->out_step;
|
|
if (opll->conv) {
|
|
out[0] = OPLL_RateConv_getData(opll->conv, 0);
|
|
out[1] = OPLL_RateConv_getData(opll->conv, 1);
|
|
} else {
|
|
out[0] = opll->mix_out[0];
|
|
out[1] = opll->mix_out[1];
|
|
}
|
|
}
|
|
|
|
uint32_t OPLL_setMask(OPLL *opll, uint32_t mask) {
|
|
uint32_t ret;
|
|
|
|
if (opll) {
|
|
ret = opll->mask;
|
|
opll->mask = mask;
|
|
return ret;
|
|
} else
|
|
return 0;
|
|
}
|
|
|
|
uint32_t OPLL_toggleMask(OPLL *opll, uint32_t mask) {
|
|
uint32_t ret;
|
|
|
|
if (opll) {
|
|
ret = opll->mask;
|
|
opll->mask ^= mask;
|
|
return ret;
|
|
} else
|
|
return 0;
|
|
}
|