2196 lines
97 KiB
C#
2196 lines
97 KiB
C#
using System;
|
||
using System.IO;
|
||
|
||
namespace MAME.Core
|
||
{
|
||
public class YM2151
|
||
{
|
||
public struct YM2151Operator
|
||
{
|
||
public uint phase;
|
||
public uint freq;
|
||
public int dt1;
|
||
public uint mul;
|
||
public uint dt1_i;
|
||
public uint dt2;
|
||
|
||
public int mem_value;
|
||
|
||
public uint fb_shift;
|
||
public int fb_out_curr;
|
||
public int fb_out_prev;
|
||
public uint kc;
|
||
public uint kc_i;
|
||
public uint pms;
|
||
public uint ams;
|
||
|
||
public uint AMmask;
|
||
public uint state;
|
||
public byte eg_sh_ar;
|
||
public byte eg_sel_ar;
|
||
public uint tl;
|
||
public int volume;
|
||
public byte eg_sh_d1r;
|
||
public byte eg_sel_d1r;
|
||
public uint d1l;
|
||
public byte eg_sh_d2r;
|
||
public byte eg_sel_d2r;
|
||
public byte eg_sh_rr;
|
||
public byte eg_sel_rr;
|
||
|
||
public uint key;
|
||
|
||
public uint ks;
|
||
public uint ar;
|
||
public uint d1r;
|
||
public uint d2r;
|
||
public uint rr;
|
||
|
||
public uint reserved0;
|
||
public uint reserved1;
|
||
};
|
||
public struct YM2151Struct
|
||
{
|
||
public YM2151Operator[] oper;
|
||
|
||
public uint[] pan;
|
||
|
||
public int lastreg0;
|
||
public uint eg_cnt;
|
||
public uint eg_timer;
|
||
public uint eg_timer_add;
|
||
public uint eg_timer_overflow;
|
||
|
||
public uint lfo_phase;
|
||
public uint lfo_timer;
|
||
public uint lfo_timer_add;
|
||
public uint lfo_overflow;
|
||
public uint lfo_counter;
|
||
public uint lfo_counter_add;
|
||
public byte lfo_wsel;
|
||
public byte amd;
|
||
public sbyte pmd;
|
||
public uint lfa;
|
||
public int lfp;
|
||
|
||
public byte test;
|
||
public byte ct;
|
||
|
||
public uint noise;
|
||
public uint noise_rng;
|
||
public uint noise_p;
|
||
public uint noise_f;
|
||
|
||
public uint csm_req;
|
||
|
||
public uint irq_enable;
|
||
public uint status;
|
||
public byte[] connect;
|
||
|
||
public EmuTimer.emu_timer timer_A;
|
||
public EmuTimer.emu_timer timer_B;
|
||
public Atime[] timer_A_time;
|
||
public Atime[] timer_B_time;
|
||
public int irqlinestate;
|
||
|
||
public uint timer_A_index;
|
||
public uint timer_B_index;
|
||
public uint timer_A_index_old;
|
||
public uint timer_B_index_old;
|
||
|
||
public uint[] freq;
|
||
|
||
public int[] dt1_freq;
|
||
|
||
public uint[] noise_tab;
|
||
|
||
public int clock;
|
||
public int sampfreq;
|
||
public irqhandler irqhandler;
|
||
public porthandler porthandler;
|
||
};
|
||
private static int[] iconnect = new int[32], imem = new int[32];//m2=8,c1=9,c2=10,mem=11,null=12
|
||
private static int[] tl_tab = new int[13 * 2 * 0x100];
|
||
private static uint[] sin_tab = new uint[0x400];
|
||
private static uint[] d1l_tab = new uint[16];
|
||
|
||
private static byte[] eg_inc = new byte[19 * 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,
|
||
|
||
1,1, 1,1, 1,1, 1,1,
|
||
1,1, 1,2, 1,1, 1,2,
|
||
1,2, 1,2, 1,2, 1,2,
|
||
1,2, 2,2, 1,2, 2,2,
|
||
|
||
2,2, 2,2, 2,2, 2,2,
|
||
2,2, 2,4, 2,2, 2,4,
|
||
2,4, 2,4, 2,4, 2,4,
|
||
2,4, 4,4, 2,4, 4,4,
|
||
|
||
4,4, 4,4, 4,4, 4,4,
|
||
4,4, 4,8, 4,4, 4,8,
|
||
4,8, 4,8, 4,8, 4,8,
|
||
4,8, 8,8, 4,8, 8,8,
|
||
|
||
8,8, 8,8, 8,8, 8,8,
|
||
16,16,16,16,16,16,16,16,
|
||
0,0, 0,0, 0,0, 0,0,
|
||
};
|
||
|
||
private static uint[] dt2_tab = new uint[4] { 0, 384, 500, 608 };
|
||
|
||
private static ushort[] phaseinc_rom = new ushort[768]{
|
||
1299,1300,1301,1302,1303,1304,1305,1306,1308,1309,1310,1311,1313,1314,1315,1316,
|
||
1318,1319,1320,1321,1322,1323,1324,1325,1327,1328,1329,1330,1332,1333,1334,1335,
|
||
1337,1338,1339,1340,1341,1342,1343,1344,1346,1347,1348,1349,1351,1352,1353,1354,
|
||
1356,1357,1358,1359,1361,1362,1363,1364,1366,1367,1368,1369,1371,1372,1373,1374,
|
||
1376,1377,1378,1379,1381,1382,1383,1384,1386,1387,1388,1389,1391,1392,1393,1394,
|
||
1396,1397,1398,1399,1401,1402,1403,1404,1406,1407,1408,1409,1411,1412,1413,1414,
|
||
1416,1417,1418,1419,1421,1422,1423,1424,1426,1427,1429,1430,1431,1432,1434,1435,
|
||
1437,1438,1439,1440,1442,1443,1444,1445,1447,1448,1449,1450,1452,1453,1454,1455,
|
||
1458,1459,1460,1461,1463,1464,1465,1466,1468,1469,1471,1472,1473,1474,1476,1477,
|
||
1479,1480,1481,1482,1484,1485,1486,1487,1489,1490,1492,1493,1494,1495,1497,1498,
|
||
1501,1502,1503,1504,1506,1507,1509,1510,1512,1513,1514,1515,1517,1518,1520,1521,
|
||
1523,1524,1525,1526,1528,1529,1531,1532,1534,1535,1536,1537,1539,1540,1542,1543,
|
||
1545,1546,1547,1548,1550,1551,1553,1554,1556,1557,1558,1559,1561,1562,1564,1565,
|
||
1567,1568,1569,1570,1572,1573,1575,1576,1578,1579,1580,1581,1583,1584,1586,1587,
|
||
1590,1591,1592,1593,1595,1596,1598,1599,1601,1602,1604,1605,1607,1608,1609,1610,
|
||
1613,1614,1615,1616,1618,1619,1621,1622,1624,1625,1627,1628,1630,1631,1632,1633,
|
||
1637,1638,1639,1640,1642,1643,1645,1646,1648,1649,1651,1652,1654,1655,1656,1657,
|
||
1660,1661,1663,1664,1666,1667,1669,1670,1672,1673,1675,1676,1678,1679,1681,1682,
|
||
1685,1686,1688,1689,1691,1692,1694,1695,1697,1698,1700,1701,1703,1704,1706,1707,
|
||
1709,1710,1712,1713,1715,1716,1718,1719,1721,1722,1724,1725,1727,1728,1730,1731,
|
||
1734,1735,1737,1738,1740,1741,1743,1744,1746,1748,1749,1751,1752,1754,1755,1757,
|
||
1759,1760,1762,1763,1765,1766,1768,1769,1771,1773,1774,1776,1777,1779,1780,1782,
|
||
1785,1786,1788,1789,1791,1793,1794,1796,1798,1799,1801,1802,1804,1806,1807,1809,
|
||
1811,1812,1814,1815,1817,1819,1820,1822,1824,1825,1827,1828,1830,1832,1833,1835,
|
||
1837,1838,1840,1841,1843,1845,1846,1848,1850,1851,1853,1854,1856,1858,1859,1861,
|
||
1864,1865,1867,1868,1870,1872,1873,1875,1877,1879,1880,1882,1884,1885,1887,1888,
|
||
1891,1892,1894,1895,1897,1899,1900,1902,1904,1906,1907,1909,1911,1912,1914,1915,
|
||
1918,1919,1921,1923,1925,1926,1928,1930,1932,1933,1935,1937,1939,1940,1942,1944,
|
||
1946,1947,1949,1951,1953,1954,1956,1958,1960,1961,1963,1965,1967,1968,1970,1972,
|
||
1975,1976,1978,1980,1982,1983,1985,1987,1989,1990,1992,1994,1996,1997,1999,2001,
|
||
2003,2004,2006,2008,2010,2011,2013,2015,2017,2019,2021,2022,2024,2026,2028,2029,
|
||
2032,2033,2035,2037,2039,2041,2043,2044,2047,2048,2050,2052,2054,2056,2058,2059,
|
||
2062,2063,2065,2067,2069,2071,2073,2074,2077,2078,2080,2082,2084,2086,2088,2089,
|
||
2092,2093,2095,2097,2099,2101,2103,2104,2107,2108,2110,2112,2114,2116,2118,2119,
|
||
2122,2123,2125,2127,2129,2131,2133,2134,2137,2139,2141,2142,2145,2146,2148,2150,
|
||
2153,2154,2156,2158,2160,2162,2164,2165,2168,2170,2172,2173,2176,2177,2179,2181,
|
||
2185,2186,2188,2190,2192,2194,2196,2197,2200,2202,2204,2205,2208,2209,2211,2213,
|
||
2216,2218,2220,2222,2223,2226,2227,2230,2232,2234,2236,2238,2239,2242,2243,2246,
|
||
2249,2251,2253,2255,2256,2259,2260,2263,2265,2267,2269,2271,2272,2275,2276,2279,
|
||
2281,2283,2285,2287,2288,2291,2292,2295,2297,2299,2301,2303,2304,2307,2308,2311,
|
||
2315,2317,2319,2321,2322,2325,2326,2329,2331,2333,2335,2337,2338,2341,2342,2345,
|
||
2348,2350,2352,2354,2355,2358,2359,2362,2364,2366,2368,2370,2371,2374,2375,2378,
|
||
2382,2384,2386,2388,2389,2392,2393,2396,2398,2400,2402,2404,2407,2410,2411,2414,
|
||
2417,2419,2421,2423,2424,2427,2428,2431,2433,2435,2437,2439,2442,2445,2446,2449,
|
||
2452,2454,2456,2458,2459,2462,2463,2466,2468,2470,2472,2474,2477,2480,2481,2484,
|
||
2488,2490,2492,2494,2495,2498,2499,2502,2504,2506,2508,2510,2513,2516,2517,2520,
|
||
2524,2526,2528,2530,2531,2534,2535,2538,2540,2542,2544,2546,2549,2552,2553,2556,
|
||
2561,2563,2565,2567,2568,2571,2572,2575,2577,2579,2581,2583,2586,2589,2590,2593
|
||
};
|
||
public static byte[] lfo_noise_waveform = new byte[256]{
|
||
0xFF,0xEE,0xD3,0x80,0x58,0xDA,0x7F,0x94,0x9E,0xE3,0xFA,0x00,0x4D,0xFA,0xFF,0x6A,
|
||
0x7A,0xDE,0x49,0xF6,0x00,0x33,0xBB,0x63,0x91,0x60,0x51,0xFF,0x00,0xD8,0x7F,0xDE,
|
||
0xDC,0x73,0x21,0x85,0xB2,0x9C,0x5D,0x24,0xCD,0x91,0x9E,0x76,0x7F,0x20,0xFB,0xF3,
|
||
0x00,0xA6,0x3E,0x42,0x27,0x69,0xAE,0x33,0x45,0x44,0x11,0x41,0x72,0x73,0xDF,0xA2,
|
||
|
||
0x32,0xBD,0x7E,0xA8,0x13,0xEB,0xD3,0x15,0xDD,0xFB,0xC9,0x9D,0x61,0x2F,0xBE,0x9D,
|
||
0x23,0x65,0x51,0x6A,0x84,0xF9,0xC9,0xD7,0x23,0xBF,0x65,0x19,0xDC,0x03,0xF3,0x24,
|
||
0x33,0xB6,0x1E,0x57,0x5C,0xAC,0x25,0x89,0x4D,0xC5,0x9C,0x99,0x15,0x07,0xCF,0xBA,
|
||
0xC5,0x9B,0x15,0x4D,0x8D,0x2A,0x1E,0x1F,0xEA,0x2B,0x2F,0x64,0xA9,0x50,0x3D,0xAB,
|
||
|
||
0x50,0x77,0xE9,0xC0,0xAC,0x6D,0x3F,0xCA,0xCF,0x71,0x7D,0x80,0xA6,0xFD,0xFF,0xB5,
|
||
0xBD,0x6F,0x24,0x7B,0x00,0x99,0x5D,0xB1,0x48,0xB0,0x28,0x7F,0x80,0xEC,0xBF,0x6F,
|
||
0x6E,0x39,0x90,0x42,0xD9,0x4E,0x2E,0x12,0x66,0xC8,0xCF,0x3B,0x3F,0x10,0x7D,0x79,
|
||
0x00,0xD3,0x1F,0x21,0x93,0x34,0xD7,0x19,0x22,0xA2,0x08,0x20,0xB9,0xB9,0xEF,0x51,
|
||
|
||
0x99,0xDE,0xBF,0xD4,0x09,0x75,0xE9,0x8A,0xEE,0xFD,0xE4,0x4E,0x30,0x17,0xDF,0xCE,
|
||
0x11,0xB2,0x28,0x35,0xC2,0x7C,0x64,0xEB,0x91,0x5F,0x32,0x0C,0x6E,0x00,0xF9,0x92,
|
||
0x19,0xDB,0x8F,0xAB,0xAE,0xD6,0x12,0xC4,0x26,0x62,0xCE,0xCC,0x0A,0x03,0xE7,0xDD,
|
||
0xE2,0x4D,0x8A,0xA6,0x46,0x95,0x0F,0x8F,0xF5,0x15,0x97,0x32,0xD4,0x28,0x1E,0x55
|
||
};
|
||
public static YM2151Struct PSG;
|
||
public static int[] chanout = new int[12];
|
||
public delegate void irqhandler(int irq);
|
||
public delegate void porthandler(int offset, byte data);
|
||
|
||
private static void init_tables()
|
||
{
|
||
int i, x, n;
|
||
double o, m;
|
||
for (x = 0; x < 0x100; x++)
|
||
{
|
||
m = (1 << 16) / Math.Pow(2, (x + 1) * (1.0 / 256));
|
||
m = Math.Floor(m);
|
||
n = (int)m;
|
||
n >>= 4;
|
||
if ((n & 1) != 0)
|
||
{
|
||
n = (n >> 1) + 1;
|
||
}
|
||
else
|
||
{
|
||
n = n >> 1;
|
||
}
|
||
n <<= 2;
|
||
tl_tab[x * 2] = n;
|
||
tl_tab[x * 2 + 1] = -tl_tab[x * 2];
|
||
for (i = 1; i < 13; i++)
|
||
{
|
||
tl_tab[x * 2 + i * 2 * 0x100] = tl_tab[x * 2] >> i;
|
||
tl_tab[x * 2 + 1 + i * 2 * 0x100] = -tl_tab[x * 2 + i * 2 * 0x100];
|
||
}
|
||
}
|
||
for (i = 0; i < 0x400; i++)
|
||
{
|
||
m = Math.Sin(((i * 2) + 1) * Math.PI / 0x400);
|
||
if (m > 0.0)
|
||
{
|
||
o = 8 * Math.Log(1.0 / m) / Math.Log(2);
|
||
}
|
||
else
|
||
{
|
||
o = 8 * Math.Log(-1.0 / m) / Math.Log(2);
|
||
}
|
||
o = o / (1.0 / 32);
|
||
n = (int)(2.0 * o);
|
||
if ((n & 1) != 0)
|
||
{
|
||
n = (n >> 1) + 1;
|
||
}
|
||
else
|
||
{
|
||
n = n >> 1;
|
||
}
|
||
sin_tab[i] = (uint)(n * 2 + (m >= 0.0 ? 0 : 1));
|
||
}
|
||
for (i = 0; i < 16; i++)
|
||
{
|
||
m = (i != 15 ? i : i + 16) * 32;
|
||
d1l_tab[i] = (uint)m;
|
||
}
|
||
}
|
||
private static void init_chip_tables()
|
||
{
|
||
int i, j;
|
||
double mult, phaseinc, Hz;
|
||
double scaler;
|
||
Atime pom;
|
||
scaler = ((double)PSG.clock / 64.0) / ((double)PSG.sampfreq);
|
||
/*logerror("scaler = %20.15f\n", scaler);*/
|
||
/* this loop calculates Hertz values for notes from c-0 to b-7 */
|
||
/* including 64 'cents' (100/64 that is 1.5625 of real cent) per note */
|
||
/* i*100/64/1200 is equal to i/768 */
|
||
/* real chip works with 10 bits fixed point values (10.10) */
|
||
mult = (1 << 6); /* -10 because phaseinc_rom table values are already in 10.10 format */
|
||
for (i = 0; i < 768; i++)
|
||
{
|
||
/* 3.4375 Hz is note A; C# is 4 semitones higher */
|
||
Hz = 1000;
|
||
|
||
phaseinc = phaseinc_rom[i]; /* real chip phase increment */
|
||
phaseinc *= scaler; /* adjust */
|
||
|
||
/* octave 2 - reference octave */
|
||
PSG.freq[768 + 2 * 768 + i] = (uint)(((int)(phaseinc * mult)) & 0xffffffc0); /* adjust to X.10 fixed point */
|
||
/* octave 0 and octave 1 */
|
||
for (j = 0; j < 2; j++)
|
||
{
|
||
PSG.freq[768 + j * 768 + i] = (PSG.freq[768 + 2 * 768 + i] >> (2 - j)) & 0xffffffc0; /* adjust to X.10 fixed point */
|
||
}
|
||
/* octave 3 to 7 */
|
||
for (j = 3; j < 8; j++)
|
||
{
|
||
PSG.freq[768 + j * 768 + i] = PSG.freq[768 + 2 * 768 + i] << (j - 2);
|
||
}
|
||
}
|
||
/* octave -1 (all equal to: oct 0, _KC_00_, _KF_00_) */
|
||
for (i = 0; i < 768; i++)
|
||
{
|
||
PSG.freq[i] = PSG.freq[768];
|
||
}
|
||
/* octave 8 and 9 (all equal to: oct 7, _KC_14_, _KF_63_) */
|
||
for (j = 8; j < 10; j++)
|
||
{
|
||
for (i = 0; i < 768; i++)
|
||
{
|
||
PSG.freq[768 + j * 768 + i] = PSG.freq[768 + 8 * 768 - 1];
|
||
}
|
||
}
|
||
mult = (1 << 16);
|
||
for (j = 0; j < 4; j++)
|
||
{
|
||
for (i = 0; i < 32; i++)
|
||
{
|
||
Hz = ((double)FM.dt_tab[j * 32 + i] * ((double)PSG.clock / 64.0)) / (double)(1 << 20);
|
||
|
||
/*calculate phase increment*/
|
||
phaseinc = (Hz * 0x400) / (double)PSG.sampfreq;
|
||
|
||
/*positive and negative values*/
|
||
PSG.dt1_freq[j * 32 + i] = (int)(phaseinc * mult);
|
||
PSG.dt1_freq[(j + 4) * 32 + i] = -PSG.dt1_freq[j * 32 + i];
|
||
}
|
||
}
|
||
/* calculate timers' deltas */
|
||
/* User's Manual pages 15,16 */
|
||
mult = (1 << 16);
|
||
for (i = 0; i < 1024; i++)
|
||
{
|
||
/* ASG 980324: changed to compute both tim_A_tab and timer_A_time */
|
||
pom = Attotime.attotime_mul(new Atime(0, Attotime.ATTOSECONDS_PER_SECOND / PSG.clock), (uint)(64 * (1024 - i)));
|
||
PSG.timer_A_time[i] = pom;//(long)Math.Pow(10, 18)
|
||
}
|
||
for (i = 0; i < 256; i++)
|
||
{
|
||
/* ASG 980324: changed to compute both tim_B_tab and timer_B_time */
|
||
pom = Attotime.attotime_mul(new Atime(0, Attotime.ATTOSECONDS_PER_SECOND / PSG.clock), (uint)(1024 * (256 - i)));
|
||
PSG.timer_B_time[i] = pom;
|
||
}
|
||
/* calculate noise periods table */
|
||
//scaler = ((double)PSG.clock / 64.0) / ((double)PSG.sampfreq);
|
||
for (i = 0; i < 32; i++)
|
||
{
|
||
j = (i != 31 ? i : 30); /* rate 30 and 31 are the same */
|
||
j = 32 - j;
|
||
j = (int)(65536.0 / (double)(j * 32.0)); /* number of samples per one shift of the shift register */
|
||
/*chip->noise_tab[i] = j * 64;*/
|
||
/* number of chip clock cycles per one shift */
|
||
PSG.noise_tab[i] = (uint)(j * 64 * scaler);
|
||
/*logerror("noise_tab[%02x]=%08x\n", i, chip->noise_tab[i]);*/
|
||
}
|
||
}
|
||
private static void KEY_ON(uint op1, uint key_set)//YM2151Operator op, uint key_set)
|
||
{
|
||
if (PSG.oper[op1].key == 0)
|
||
{
|
||
PSG.oper[op1].phase = 0; /* clear phase */
|
||
PSG.oper[op1].state = 4; /* KEY ON = attack */
|
||
PSG.oper[op1].volume += (~PSG.oper[op1].volume *
|
||
(eg_inc[PSG.oper[op1].eg_sel_ar + ((PSG.eg_cnt >> PSG.oper[op1].eg_sh_ar) & 7)])
|
||
) >> 4;
|
||
if (PSG.oper[op1].volume <= 0)
|
||
{
|
||
PSG.oper[op1].volume = 0;
|
||
PSG.oper[op1].state = 3;
|
||
}
|
||
}
|
||
PSG.oper[op1].key |= key_set;
|
||
}
|
||
private static void KEY_OFF(uint op1, uint key_clr)//YM2151Operator op, uint key_clr)
|
||
{
|
||
if (PSG.oper[op1].key != 0)
|
||
{
|
||
PSG.oper[op1].key &= key_clr;
|
||
if (PSG.oper[op1].key == 0)
|
||
{
|
||
if (PSG.oper[op1].state > 1)
|
||
PSG.oper[op1].state = 1;/* KEY OFF = release */
|
||
}
|
||
}
|
||
}
|
||
private static void envelope_KONKOFF(uint i, int v)
|
||
{
|
||
if ((v & 0x08) != 0) /* M1 */
|
||
KEY_ON(i, 1);
|
||
else
|
||
KEY_OFF(i, 0xfffffffe);
|
||
if ((v & 0x20) != 0) /* M2 */
|
||
KEY_ON(i + 1, 1);
|
||
else
|
||
KEY_OFF(i + 1, 0xfffffffe);
|
||
if ((v & 0x10) != 0) /* C1 */
|
||
KEY_ON(i + 2, 1);
|
||
else
|
||
KEY_OFF(i + 2, 0xfffffffe);
|
||
if ((v & 0x40) != 0) /* C2 */
|
||
KEY_ON(i + 3, 1);
|
||
else
|
||
KEY_OFF(i + 3, 0xfffffffe);
|
||
}
|
||
public static void irqAon_callback()
|
||
{
|
||
int oldstate = PSG.irqlinestate;
|
||
PSG.irqlinestate |= 1;
|
||
if (oldstate == 0)
|
||
{
|
||
PSG.irqhandler(1);
|
||
}
|
||
}
|
||
public static void irqBon_callback()
|
||
{
|
||
int oldstate = PSG.irqlinestate;
|
||
PSG.irqlinestate |= 2;
|
||
if (oldstate == 0)
|
||
{
|
||
PSG.irqhandler(1);
|
||
}
|
||
}
|
||
public static void irqAoff_callback()
|
||
{
|
||
int oldstate = PSG.irqlinestate;
|
||
PSG.irqlinestate &= ~1;
|
||
if (oldstate == 1)
|
||
{
|
||
PSG.irqhandler(0);
|
||
}
|
||
}
|
||
public static void irqBoff_callback()
|
||
{
|
||
int oldstate = PSG.irqlinestate;
|
||
PSG.irqlinestate &= ~2;
|
||
if (oldstate == 2)
|
||
{
|
||
PSG.irqhandler(0);
|
||
}
|
||
}
|
||
public static void timer_callback_a()
|
||
{
|
||
EmuTimer.timer_adjust_periodic(PSG.timer_A, PSG.timer_A_time[PSG.timer_A_index], Attotime.ATTOTIME_NEVER);
|
||
PSG.timer_A_index_old = PSG.timer_A_index;
|
||
if ((PSG.irq_enable & 0x04) != 0)
|
||
{
|
||
PSG.status |= 1;
|
||
EmuTimer.timer_set_internal(EmuTimer.TIME_ACT.YM2151_irqAon_callback);
|
||
}
|
||
if ((PSG.irq_enable & 0x80) != 0)
|
||
{
|
||
PSG.csm_req = 2; /* request KEY ON / KEY OFF sequence */
|
||
}
|
||
}
|
||
public static void timer_callback_b()
|
||
{
|
||
EmuTimer.timer_adjust_periodic(PSG.timer_B, PSG.timer_B_time[PSG.timer_B_index], Attotime.ATTOTIME_NEVER);
|
||
PSG.timer_B_index_old = PSG.timer_B_index;
|
||
if ((PSG.irq_enable & 0x08) != 0)
|
||
{
|
||
PSG.status |= 2;
|
||
EmuTimer.timer_set_internal(EmuTimer.TIME_ACT.YM2151_irqBon_callback);
|
||
}
|
||
}
|
||
private static void set_connect(int cha, int v)
|
||
{
|
||
/* set connect algorithm */
|
||
/* MEM is simply one sample delay */
|
||
switch (v & 7)
|
||
{
|
||
case 0:
|
||
/* M1---C1---MEM---M2---C2---OUT */
|
||
//PSG.oper[i1].connect = c1;
|
||
//oc1.connect = mem;
|
||
//om2.connect = c2;
|
||
//PSG.oper[i1].mem_connect = m2;
|
||
iconnect[cha * 4] = 9;
|
||
iconnect[cha * 4 + 2] = 11;
|
||
iconnect[cha * 4 + 1] = 10;
|
||
imem[cha * 4] = 8;
|
||
break;
|
||
|
||
case 1:
|
||
/* M1------+-MEM---M2---C2---OUT */
|
||
/* C1-+ */
|
||
//PSG.oper[i1].connect = mem;
|
||
//oc1.connect = mem;
|
||
//om2.connect = c2;
|
||
//PSG.oper[i1].mem_connect = m2;
|
||
iconnect[cha * 4] = 11;
|
||
iconnect[cha * 4 + 2] = 11;
|
||
iconnect[cha * 4 + 1] = 10;
|
||
imem[cha * 4] = 8;
|
||
break;
|
||
|
||
case 2:
|
||
/* M1-----------------+-C2---OUT */
|
||
/* C1---MEM---M2-+ */
|
||
//PSG.oper[i1].connect = c2;
|
||
//oc1.connect = mem;
|
||
//om2.connect = c2;
|
||
//PSG.oper[i1].mem_connect = m2;
|
||
iconnect[cha * 4] = 10;
|
||
iconnect[cha * 4 + 2] = 11;
|
||
iconnect[cha * 4 + 1] = 10;
|
||
imem[cha * 4] = 8;
|
||
break;
|
||
|
||
case 3:
|
||
/* M1---C1---MEM------+-C2---OUT */
|
||
/* M2-+ */
|
||
//PSG.oper[i1].connect = c1;
|
||
//oc1.connect = mem;
|
||
//om2.connect = c2;
|
||
//PSG.oper[i1].mem_connect = c2;
|
||
iconnect[cha * 4] = 9;
|
||
iconnect[cha * 4 + 2] = 11;
|
||
iconnect[cha * 4 + 1] = 10;
|
||
imem[cha * 4] = 10;
|
||
break;
|
||
|
||
case 4:
|
||
/* M1---C1-+-OUT */
|
||
/* M2---C2-+ */
|
||
/* MEM: not used */
|
||
//PSG.oper[i1].connect = c1;
|
||
//oc1.connect = chanout[cha];
|
||
//om2.connect = c2;
|
||
//PSG.oper[i1].mem_connect = mem; /* store it anywhere where it will not be used */
|
||
iconnect[cha * 4] = 9;
|
||
iconnect[cha * 4 + 2] = cha;
|
||
iconnect[cha * 4 + 1] = 10;
|
||
imem[cha * 4] = 11;
|
||
break;
|
||
|
||
case 5:
|
||
/* +----C1----+ */
|
||
/* M1-+-MEM---M2-+-OUT */
|
||
/* +----C2----+ */
|
||
//PSG.oper[i1].connect = 0; /* special mark */
|
||
//oc1.connect = chanout[cha];
|
||
//om2.connect = chanout[cha];
|
||
//PSG.oper[i1].mem_connect = m2;
|
||
iconnect[cha * 4] = 12;
|
||
iconnect[cha * 4 + 2] = cha;
|
||
iconnect[cha * 4 + 1] = cha;
|
||
imem[cha * 4] = 8;
|
||
break;
|
||
|
||
case 6:
|
||
/* M1---C1-+ */
|
||
/* M2-+-OUT */
|
||
/* C2-+ */
|
||
/* MEM: not used */
|
||
//PSG.oper[i1].connect = c1;
|
||
//oc1.connect = chanout[cha];
|
||
//om2.connect = chanout[cha];
|
||
//PSG.oper[i1].mem_connect = mem; /* store it anywhere where it will not be used */
|
||
iconnect[cha * 4] = 9;
|
||
iconnect[cha * 4 + 2] = cha;
|
||
iconnect[cha * 4 + 1] = cha;
|
||
imem[cha * 4] = 11;
|
||
break;
|
||
|
||
case 7:
|
||
/* M1-+ */
|
||
/* C1-+-OUT */
|
||
/* M2-+ */
|
||
/* C2-+ */
|
||
/* MEM: not used*/
|
||
//PSG.oper[i1].connect = chanout[cha];
|
||
//oc1.connect = chanout[cha];
|
||
//om2.connect = chanout[cha];
|
||
//PSG.oper[i1].mem_connect = mem; /* store it anywhere where it will not be used */
|
||
iconnect[cha * 4] = cha;
|
||
iconnect[cha * 4 + 2] = cha;
|
||
iconnect[cha * 4 + 1] = cha;
|
||
imem[cha * 4] = 11;
|
||
break;
|
||
}
|
||
}
|
||
private static void refresh_EG(int i1)
|
||
{
|
||
uint kc;
|
||
uint v;
|
||
kc = PSG.oper[i1].kc;
|
||
/* v = 32 + 2*RATE + RKS = max 126 */
|
||
v = kc >> (int)PSG.oper[i1].ks;
|
||
if ((PSG.oper[i1].ar + v) < 94)
|
||
{
|
||
PSG.oper[i1].eg_sh_ar = FM.eg_rate_shift[PSG.oper[i1].ar + v];
|
||
PSG.oper[i1].eg_sel_ar = FM.eg_rate_select[PSG.oper[i1].ar + v];
|
||
}
|
||
else
|
||
{
|
||
PSG.oper[i1].eg_sh_ar = 0;
|
||
PSG.oper[i1].eg_sel_ar = 17 * 8;
|
||
}
|
||
PSG.oper[i1].eg_sh_d1r = FM.eg_rate_shift[PSG.oper[i1].d1r + v];
|
||
PSG.oper[i1].eg_sel_d1r = FM.eg_rate_select[PSG.oper[i1].d1r + v];
|
||
PSG.oper[i1].eg_sh_d2r = FM.eg_rate_shift[PSG.oper[i1].d2r + v];
|
||
PSG.oper[i1].eg_sel_d2r = FM.eg_rate_select[PSG.oper[i1].d2r + v];
|
||
PSG.oper[i1].eg_sh_rr = FM.eg_rate_shift[PSG.oper[i1].rr + v];
|
||
PSG.oper[i1].eg_sel_rr = FM.eg_rate_select[PSG.oper[i1].rr + v];
|
||
i1 += 1;
|
||
v = kc >> (int)PSG.oper[i1].ks;
|
||
if ((PSG.oper[i1].ar + v) < 94)
|
||
{
|
||
PSG.oper[i1].eg_sh_ar = FM.eg_rate_shift[PSG.oper[i1].ar + v];
|
||
PSG.oper[i1].eg_sel_ar = FM.eg_rate_select[PSG.oper[i1].ar + v];
|
||
}
|
||
else
|
||
{
|
||
PSG.oper[i1].eg_sh_ar = 0;
|
||
PSG.oper[i1].eg_sel_ar = 17 * 8;
|
||
}
|
||
PSG.oper[i1].eg_sh_d1r = FM.eg_rate_shift[PSG.oper[i1].d1r + v];
|
||
PSG.oper[i1].eg_sel_d1r = FM.eg_rate_select[PSG.oper[i1].d1r + v];
|
||
PSG.oper[i1].eg_sh_d2r = FM.eg_rate_shift[PSG.oper[i1].d2r + v];
|
||
PSG.oper[i1].eg_sel_d2r = FM.eg_rate_select[PSG.oper[i1].d2r + v];
|
||
PSG.oper[i1].eg_sh_rr = FM.eg_rate_shift[PSG.oper[i1].rr + v];
|
||
PSG.oper[i1].eg_sel_rr = FM.eg_rate_select[PSG.oper[i1].rr + v];
|
||
i1 += 1;
|
||
v = kc >> (int)PSG.oper[i1].ks;
|
||
if ((PSG.oper[i1].ar + v) < 94)
|
||
{
|
||
PSG.oper[i1].eg_sh_ar = FM.eg_rate_shift[PSG.oper[i1].ar + v];
|
||
PSG.oper[i1].eg_sel_ar = FM.eg_rate_select[PSG.oper[i1].ar + v];
|
||
}
|
||
else
|
||
{
|
||
PSG.oper[i1].eg_sh_ar = 0;
|
||
PSG.oper[i1].eg_sel_ar = 17 * 8;
|
||
}
|
||
PSG.oper[i1].eg_sh_d1r = FM.eg_rate_shift[PSG.oper[i1].d1r + v];
|
||
PSG.oper[i1].eg_sel_d1r = FM.eg_rate_select[PSG.oper[i1].d1r + v];
|
||
PSG.oper[i1].eg_sh_d2r = FM.eg_rate_shift[PSG.oper[i1].d2r + v];
|
||
PSG.oper[i1].eg_sel_d2r = FM.eg_rate_select[PSG.oper[i1].d2r + v];
|
||
PSG.oper[i1].eg_sh_rr = FM.eg_rate_shift[PSG.oper[i1].rr + v];
|
||
PSG.oper[i1].eg_sel_rr = FM.eg_rate_select[PSG.oper[i1].rr + v];
|
||
i1 += 1;
|
||
v = kc >> (int)PSG.oper[i1].ks;
|
||
if ((PSG.oper[i1].ar + v) < 94)
|
||
{
|
||
PSG.oper[i1].eg_sh_ar = FM.eg_rate_shift[PSG.oper[i1].ar + v];
|
||
PSG.oper[i1].eg_sel_ar = FM.eg_rate_select[PSG.oper[i1].ar + v];
|
||
}
|
||
else
|
||
{
|
||
PSG.oper[i1].eg_sh_ar = 0;
|
||
PSG.oper[i1].eg_sel_ar = 17 * 8;
|
||
}
|
||
PSG.oper[i1].eg_sh_d1r = FM.eg_rate_shift[PSG.oper[i1].d1r + v];
|
||
PSG.oper[i1].eg_sel_d1r = FM.eg_rate_select[PSG.oper[i1].d1r + v];
|
||
PSG.oper[i1].eg_sh_d2r = FM.eg_rate_shift[PSG.oper[i1].d2r + v];
|
||
PSG.oper[i1].eg_sel_d2r = FM.eg_rate_select[PSG.oper[i1].d2r + v];
|
||
PSG.oper[i1].eg_sh_rr = FM.eg_rate_shift[PSG.oper[i1].rr + v];
|
||
PSG.oper[i1].eg_sel_rr = FM.eg_rate_select[PSG.oper[i1].rr + v];
|
||
}
|
||
private static void ym2151_write_reg(int r, int v)
|
||
{
|
||
int opIndex = (r & 0x07) * 4 + ((r & 0x18) >> 3);
|
||
/* adjust bus to 8 bits */
|
||
r &= 0xff;
|
||
v &= 0xff;
|
||
switch (r & 0xe0)
|
||
{
|
||
case 0x00:
|
||
switch (r)
|
||
{
|
||
case 0x01: /* LFO reset(bit 1), Test Register (other bits) */
|
||
PSG.test = (byte)v;
|
||
if ((v & 2) != 0)
|
||
{
|
||
PSG.lfo_phase = 0;
|
||
}
|
||
break;
|
||
case 0x08:
|
||
envelope_KONKOFF((uint)((v & 7) * 4), v);
|
||
break;
|
||
case 0x0f: /* noise mode enable, noise period */
|
||
PSG.noise = (uint)v;
|
||
PSG.noise_f = PSG.noise_tab[v & 0x1f];
|
||
break;
|
||
case 0x10: /* timer A hi */
|
||
PSG.timer_A_index = (PSG.timer_A_index & 0x003) | (uint)(v << 2);
|
||
break;
|
||
case 0x11: /* timer A low */
|
||
PSG.timer_A_index = (PSG.timer_A_index & 0x3fc) | (uint)(v & 3);
|
||
break;
|
||
case 0x12: /* timer B */
|
||
PSG.timer_B_index = (uint)v;
|
||
break;
|
||
case 0x14: /* CSM, irq flag reset, irq enable, timer start/stop */
|
||
PSG.irq_enable = (uint)v; /* bit 3-timer B, bit 2-timer A, bit 7 - CSM */
|
||
if ((v & 0x10) != 0) /* reset timer A irq flag */
|
||
{
|
||
PSG.status &= 0xfffffffe;
|
||
EmuTimer.timer_set_internal(EmuTimer.TIME_ACT.YM2151_irqAoff_callback);
|
||
}
|
||
if ((v & 0x20) != 0) /* reset timer B irq flag */
|
||
{
|
||
PSG.status &= 0xfffffffd;
|
||
EmuTimer.timer_set_internal(EmuTimer.TIME_ACT.YM2151_irqBoff_callback);
|
||
}
|
||
if ((v & 0x02) != 0)
|
||
{ /* load and start timer B */
|
||
/* ASG 980324: added a real timer */
|
||
/* start timer _only_ if it wasn't already started (it will reload time value next round) */
|
||
if (!EmuTimer.timer_enable(PSG.timer_B, true))
|
||
{
|
||
EmuTimer.timer_adjust_periodic(PSG.timer_B, PSG.timer_B_time[PSG.timer_B_index], Attotime.ATTOTIME_NEVER);
|
||
PSG.timer_B_index_old = PSG.timer_B_index;
|
||
}
|
||
}
|
||
else
|
||
{ /* stop timer B */
|
||
/* ASG 980324: added a real timer */
|
||
EmuTimer.timer_enable(PSG.timer_B, false);
|
||
}
|
||
if ((v & 0x01) != 0)
|
||
{ /* load and start timer A */
|
||
/* ASG 980324: added a real timer */
|
||
/* start timer _only_ if it wasn't already started (it will reload time value next round) */
|
||
if (!EmuTimer.timer_enable(PSG.timer_A, true))
|
||
{
|
||
EmuTimer.timer_adjust_periodic(PSG.timer_A, PSG.timer_A_time[PSG.timer_A_index], Attotime.ATTOTIME_NEVER);
|
||
PSG.timer_A_index_old = PSG.timer_A_index;
|
||
}
|
||
}
|
||
else
|
||
{ /* stop timer A */
|
||
/* ASG 980324: added a real timer */
|
||
EmuTimer.timer_enable(PSG.timer_A, false);
|
||
}
|
||
break;
|
||
case 0x18: /* LFO frequency */
|
||
{
|
||
PSG.lfo_overflow = (uint)((1 << ((15 - (v >> 4)) + 3)) * (1 << 10));
|
||
PSG.lfo_counter_add = (uint)(0x10 + (v & 0x0f));
|
||
}
|
||
break;
|
||
case 0x19: /* PMD (bit 7==1) or AMD (bit 7==0) */
|
||
if ((v & 0x80) != 0)
|
||
PSG.pmd = (sbyte)(v & 0x7f);
|
||
else
|
||
PSG.amd = (byte)(v & 0x7f);
|
||
break;
|
||
case 0x1b: /* CT2, CT1, LFO waveform */
|
||
PSG.ct = (byte)(v >> 6);
|
||
PSG.lfo_wsel = (byte)(v & 3);
|
||
if (PSG.porthandler != null)
|
||
{
|
||
PSG.porthandler(0, PSG.ct);
|
||
}
|
||
break;
|
||
default:
|
||
//logerror("YM2151 Write %02x to undocumented register #%02x\n", v, r);
|
||
break;
|
||
}
|
||
break;
|
||
case 0x20:
|
||
int op1 = (r & 7) * 4;
|
||
//op = PSG.oper[(r & 7) * 4];
|
||
switch (r & 0x18)
|
||
{
|
||
case 0x00: /* RL enable, Feedback, Connection */
|
||
PSG.oper[op1].fb_shift = (uint)((((v >> 3) & 7) != 0) ? ((v >> 3) & 7) + 6 : 0);
|
||
PSG.pan[(r & 7) * 2] = (uint)(((v & 0x40) != 0) ? ~0 : 0);
|
||
PSG.pan[(r & 7) * 2 + 1] = (uint)(((v & 0x80) != 0) ? ~0 : 0);
|
||
PSG.connect[r & 7] = (byte)(v & 7);
|
||
set_connect(r & 7, v & 7);
|
||
break;
|
||
case 0x08: /* Key Code */
|
||
v &= 0x7f;
|
||
if (v != PSG.oper[op1].kc)
|
||
{
|
||
uint kc, kc_channel;
|
||
kc_channel = (uint)((v - (v >> 2)) * 64);
|
||
kc_channel += 768;
|
||
kc_channel |= (PSG.oper[op1].kc_i & 63);
|
||
PSG.oper[(r & 7) * 4].kc = (uint)v;
|
||
PSG.oper[(r & 7) * 4].kc_i = kc_channel;
|
||
PSG.oper[(r & 7) * 4 + 1].kc = (uint)v;
|
||
PSG.oper[(r & 7) * 4 + 1].kc_i = kc_channel;
|
||
PSG.oper[(r & 7) * 4 + 2].kc = (uint)v;
|
||
PSG.oper[(r & 7) * 4 + 2].kc_i = kc_channel;
|
||
PSG.oper[(r & 7) * 4 + 3].kc = (uint)v;
|
||
PSG.oper[(r & 7) * 4 + 3].kc_i = kc_channel;
|
||
kc = (uint)(v >> 2);
|
||
PSG.oper[(r & 7) * 4].dt1 = PSG.dt1_freq[PSG.oper[(r & 7) * 4].dt1_i + kc];
|
||
PSG.oper[(r & 7) * 4].freq = (uint)(((PSG.freq[kc_channel + PSG.oper[(r & 7) * 4].dt2] + PSG.oper[(r & 7) * 4].dt1) * PSG.oper[(r & 7) * 4].mul) >> 1);
|
||
PSG.oper[(r & 7) * 4 + 1].dt1 = PSG.dt1_freq[PSG.oper[(r & 7) * 4 + 1].dt1_i + kc];
|
||
PSG.oper[(r & 7) * 4 + 1].freq = (uint)(((PSG.freq[kc_channel + PSG.oper[(r & 7) * 4 + 1].dt2] + PSG.oper[(r & 7) * 4 + 1].dt1) * PSG.oper[(r & 7) * 4 + 1].mul) >> 1);
|
||
PSG.oper[(r & 7) * 4 + 2].dt1 = PSG.dt1_freq[PSG.oper[(r & 7) * 4 + 2].dt1_i + kc];
|
||
PSG.oper[(r & 7) * 4 + 2].freq = (uint)(((PSG.freq[kc_channel + PSG.oper[(r & 7) * 4 + 2].dt2] + PSG.oper[(r & 7) * 4 + 2].dt1) * PSG.oper[(r & 7) * 4 + 2].mul) >> 1);
|
||
PSG.oper[(r & 7) * 4 + 3].dt1 = PSG.dt1_freq[PSG.oper[(r & 7) * 4 + 3].dt1_i + kc];
|
||
PSG.oper[(r & 7) * 4 + 3].freq = (uint)(((PSG.freq[kc_channel + PSG.oper[(r & 7) * 4 + 3].dt2] + PSG.oper[(r & 7) * 4 + 3].dt1) * PSG.oper[(r & 7) * 4 + 3].mul) >> 1);
|
||
refresh_EG(op1);
|
||
}
|
||
break;
|
||
case 0x10: /* Key Fraction */
|
||
v >>= 2;
|
||
if (v != (PSG.oper[(r & 7) * 4].kc_i & 63))
|
||
{
|
||
uint kc_channel;
|
||
kc_channel = (uint)v;
|
||
kc_channel |= (uint)(PSG.oper[(r & 7) * 4].kc_i & ~63);
|
||
PSG.oper[(r & 7) * 4].kc_i = kc_channel;
|
||
PSG.oper[(r & 7) * 4 + 1].kc_i = kc_channel;
|
||
PSG.oper[(r & 7) * 4 + 2].kc_i = kc_channel;
|
||
PSG.oper[(r & 7) * 4 + 3].kc_i = kc_channel;
|
||
PSG.oper[(r & 7) * 4].freq = (uint)(((PSG.freq[kc_channel + PSG.oper[(r & 7) * 4].dt2] + PSG.oper[(r & 7) * 4].dt1) * PSG.oper[(r & 7) * 4].mul) >> 1);
|
||
PSG.oper[(r & 7) * 4 + 1].freq = (uint)(((PSG.freq[kc_channel + PSG.oper[(r & 7) * 4 + 1].dt2] + PSG.oper[(r & 7) * 4 + 1].dt1) * PSG.oper[(r & 7) * 4 + 1].mul) >> 1);
|
||
PSG.oper[(r & 7) * 4 + 2].freq = (uint)(((PSG.freq[kc_channel + PSG.oper[(r & 7) * 4 + 2].dt2] + PSG.oper[(r & 7) * 4 + 2].dt1) * PSG.oper[(r & 7) * 4 + 2].mul) >> 1);
|
||
PSG.oper[(r & 7) * 4 + 3].freq = (uint)(((PSG.freq[kc_channel + PSG.oper[(r & 7) * 4 + 3].dt2] + PSG.oper[(r & 7) * 4 + 3].dt1) * PSG.oper[(r & 7) * 4 + 3].mul) >> 1);
|
||
}
|
||
break;
|
||
case 0x18: /* PMS, AMS */
|
||
PSG.oper[op1].pms = (uint)((v >> 4) & 7);
|
||
PSG.oper[op1].ams = (uint)(v & 3);
|
||
break;
|
||
}
|
||
break;
|
||
case 0x40: /* DT1, MUL */
|
||
{
|
||
uint olddt1_i = PSG.oper[opIndex].dt1_i;
|
||
uint oldmul = PSG.oper[opIndex].mul;
|
||
PSG.oper[opIndex].dt1_i = (uint)((v & 0x70) << 1);
|
||
PSG.oper[opIndex].mul = (uint)(((v & 0x0f) != 0) ? (v & 0x0f) << 1 : 1);
|
||
if (olddt1_i != PSG.oper[opIndex].dt1_i)
|
||
PSG.oper[opIndex].dt1 = PSG.dt1_freq[PSG.oper[opIndex].dt1_i + (PSG.oper[opIndex].kc >> 2)];
|
||
if ((olddt1_i != PSG.oper[opIndex].dt1_i) || (oldmul != PSG.oper[opIndex].mul))
|
||
PSG.oper[opIndex].freq = (uint)(((PSG.freq[PSG.oper[opIndex].kc_i + PSG.oper[opIndex].dt2] + PSG.oper[opIndex].dt1) * PSG.oper[opIndex].mul) >> 1);
|
||
}
|
||
break;
|
||
case 0x60: /* TL */
|
||
PSG.oper[opIndex].tl = (uint)((v & 0x7f) << 3); /* 7bit TL */
|
||
break;
|
||
case 0x80: /* KS, AR */
|
||
{
|
||
uint oldks = PSG.oper[opIndex].ks;
|
||
uint oldar = PSG.oper[opIndex].ar;
|
||
PSG.oper[opIndex].ks = (uint)(5 - (v >> 6));
|
||
PSG.oper[opIndex].ar = (uint)(((v & 0x1f) != 0) ? 32 + ((v & 0x1f) << 1) : 0);
|
||
if ((PSG.oper[opIndex].ar != oldar) || (PSG.oper[opIndex].ks != oldks))
|
||
{
|
||
if ((PSG.oper[opIndex].ar + (PSG.oper[opIndex].kc >> (int)PSG.oper[opIndex].ks)) < 32 + 62)
|
||
{
|
||
PSG.oper[opIndex].eg_sh_ar = FM.eg_rate_shift[PSG.oper[opIndex].ar + (PSG.oper[opIndex].kc >> (int)PSG.oper[opIndex].ks)];
|
||
PSG.oper[opIndex].eg_sel_ar = FM.eg_rate_select[PSG.oper[opIndex].ar + (PSG.oper[opIndex].kc >> (int)PSG.oper[opIndex].ks)];
|
||
}
|
||
else
|
||
{
|
||
PSG.oper[opIndex].eg_sh_ar = 0;
|
||
PSG.oper[opIndex].eg_sel_ar = 17 * 8;
|
||
}
|
||
}
|
||
if (PSG.oper[opIndex].ks != oldks)
|
||
{
|
||
PSG.oper[opIndex].eg_sh_d1r = FM.eg_rate_shift[PSG.oper[opIndex].d1r + (PSG.oper[opIndex].kc >> (int)PSG.oper[opIndex].ks)];
|
||
PSG.oper[opIndex].eg_sel_d1r = FM.eg_rate_select[PSG.oper[opIndex].d1r + (PSG.oper[opIndex].kc >> (int)PSG.oper[opIndex].ks)];
|
||
PSG.oper[opIndex].eg_sh_d2r = FM.eg_rate_shift[PSG.oper[opIndex].d2r + (PSG.oper[opIndex].kc >> (int)PSG.oper[opIndex].ks)];
|
||
PSG.oper[opIndex].eg_sel_d2r = FM.eg_rate_select[PSG.oper[opIndex].d2r + (PSG.oper[opIndex].kc >> (int)PSG.oper[opIndex].ks)];
|
||
PSG.oper[opIndex].eg_sh_rr = FM.eg_rate_shift[PSG.oper[opIndex].rr + (PSG.oper[opIndex].kc >> (int)PSG.oper[opIndex].ks)];
|
||
PSG.oper[opIndex].eg_sel_rr = FM.eg_rate_select[PSG.oper[opIndex].rr + (PSG.oper[opIndex].kc >> (int)PSG.oper[opIndex].ks)];
|
||
}
|
||
}
|
||
break;
|
||
case 0xa0: /* LFO AM enable, D1R */
|
||
PSG.oper[opIndex].AMmask = (uint)(((v & 0x80) != 0) ? ~0 : 0);
|
||
PSG.oper[opIndex].d1r = (uint)(((v & 0x1f) != 0) ? 32 + ((v & 0x1f) << 1) : 0);
|
||
PSG.oper[opIndex].eg_sh_d1r = FM.eg_rate_shift[PSG.oper[opIndex].d1r + (PSG.oper[opIndex].kc >> (int)PSG.oper[opIndex].ks)];
|
||
PSG.oper[opIndex].eg_sel_d1r = FM.eg_rate_select[PSG.oper[opIndex].d1r + (PSG.oper[opIndex].kc >> (int)PSG.oper[opIndex].ks)];
|
||
break;
|
||
case 0xc0: /* DT2, D2R */
|
||
{
|
||
uint olddt2 = PSG.oper[opIndex].dt2;
|
||
PSG.oper[opIndex].dt2 = dt2_tab[v >> 6];
|
||
if (PSG.oper[opIndex].dt2 != olddt2)
|
||
PSG.oper[opIndex].freq = (uint)(((PSG.freq[PSG.oper[opIndex].kc_i + PSG.oper[opIndex].dt2] + PSG.oper[opIndex].dt1) * PSG.oper[opIndex].mul) >> 1);
|
||
}
|
||
PSG.oper[opIndex].d2r = (uint)(((v & 0x1f) != 0) ? 32 + ((v & 0x1f) << 1) : 0);
|
||
PSG.oper[opIndex].eg_sh_d2r = FM.eg_rate_shift[PSG.oper[opIndex].d2r + (PSG.oper[opIndex].kc >> (int)PSG.oper[opIndex].ks)];
|
||
PSG.oper[opIndex].eg_sel_d2r = FM.eg_rate_select[PSG.oper[opIndex].d2r + (PSG.oper[opIndex].kc >> (int)PSG.oper[opIndex].ks)];
|
||
break;
|
||
case 0xe0: /* D1L, RR */
|
||
PSG.oper[opIndex].d1l = d1l_tab[v >> 4];
|
||
PSG.oper[opIndex].rr = (uint)(34 + ((v & 0x0f) << 2));
|
||
PSG.oper[opIndex].eg_sh_rr = FM.eg_rate_shift[PSG.oper[opIndex].rr + (PSG.oper[opIndex].kc >> (int)PSG.oper[opIndex].ks)];
|
||
PSG.oper[opIndex].eg_sel_rr = FM.eg_rate_select[PSG.oper[opIndex].rr + (PSG.oper[opIndex].kc >> (int)PSG.oper[opIndex].ks)];
|
||
break;
|
||
}
|
||
}
|
||
public static void ym2151_postload()
|
||
{
|
||
int j;
|
||
for (j = 0; j < 8; j++)
|
||
{
|
||
set_connect(j, PSG.connect[j]);
|
||
}
|
||
}
|
||
public static void ym2151_init(int clock)
|
||
{
|
||
PSG.connect = new byte[8];
|
||
PSG.dt1_freq = new int[256];
|
||
PSG.freq = new uint[11 * 768];
|
||
PSG.noise_tab = new uint[32];
|
||
PSG.oper = new YM2151Operator[32];
|
||
PSG.pan = new uint[16];
|
||
PSG.timer_A_time = new Atime[1024];
|
||
PSG.timer_B_time = new Atime[256];
|
||
for (int i1 = 0; i1 < 32; i1++)
|
||
{
|
||
iconnect[i1] = 12;
|
||
}
|
||
init_tables();
|
||
PSG.clock = clock;//rate = clock/64
|
||
PSG.sampfreq = clock / 64;
|
||
PSG.irqhandler = null;
|
||
PSG.porthandler = null;
|
||
init_chip_tables();
|
||
PSG.lfo_timer_add = (uint)(0x400 * (clock / 64.0) / PSG.sampfreq);
|
||
PSG.eg_timer_add = (uint)(0x10000 * (clock / 64.0) / PSG.sampfreq);
|
||
PSG.eg_timer_overflow = 0x30000;
|
||
/* this must be done _before_ a call to ym2151_reset_chip() */
|
||
PSG.timer_A = EmuTimer.timer_alloc_common(EmuTimer.TIME_ACT.YM2151_timer_callback_a, false);
|
||
PSG.timer_B = EmuTimer.timer_alloc_common(EmuTimer.TIME_ACT.YM2151_timer_callback_b, false);
|
||
ym2151_reset_chip();
|
||
switch (Machine.sBoard)
|
||
{
|
||
case "CPS-1":
|
||
PSG.irqhandler = Cpuint.cps1_irq_handler_mus;
|
||
break;
|
||
case "Namco System 1":
|
||
PSG.irqhandler = Cpuint.namcos1_sound_interrupt;
|
||
break;
|
||
case "M72":
|
||
PSG.irqhandler = M72.m72_ym2151_irq_handler;
|
||
break;
|
||
case "M92":
|
||
PSG.irqhandler = M92.sound_irq;
|
||
break;
|
||
case "Taito":
|
||
switch (Machine.sName)
|
||
{
|
||
case "opwolf":
|
||
case "opwolfa":
|
||
case "opwolfj":
|
||
case "opwolfu":
|
||
case "opwolfb":
|
||
case "opwolfp":
|
||
PSG.irqhandler = Taito.irq_handler;
|
||
PSG.porthandler = Taito.sound_bankswitch_w;
|
||
break;
|
||
}
|
||
break;
|
||
case "Konami 68000":
|
||
switch (Machine.sName)
|
||
{
|
||
case "cuebrick":
|
||
PSG.irqhandler = Konami68000.cuebrick_irq_handler;
|
||
break;
|
||
default:
|
||
PSG.irqhandler = Konami68000.konami68000_ym2151_irq_handler;
|
||
break;
|
||
}
|
||
break;
|
||
case "Capcom":
|
||
switch (Machine.sName)
|
||
{
|
||
case "sf":
|
||
case "sfua":
|
||
case "sfj":
|
||
case "sfjan":
|
||
case "sfan":
|
||
case "sfp":
|
||
PSG.irqhandler = Capcom.irq_handler;
|
||
break;
|
||
}
|
||
break;
|
||
}
|
||
}
|
||
public static void ym2151_reset_chip()
|
||
{
|
||
int i;
|
||
/* initialize hardware registers */
|
||
for (i = 0; i < 32; i++)
|
||
{
|
||
PSG.oper[i].volume = 0x3ff;
|
||
PSG.oper[i].kc_i = 768; /* min kc_i value */
|
||
}
|
||
PSG.eg_timer = 0;
|
||
PSG.eg_cnt = 0;
|
||
PSG.lfo_timer = 0;
|
||
PSG.lfo_counter = 0;
|
||
PSG.lfo_phase = 0;
|
||
PSG.lfo_wsel = 0;
|
||
PSG.pmd = 0;
|
||
PSG.amd = 0;
|
||
PSG.lfa = 0;
|
||
PSG.lfp = 0;
|
||
PSG.test = 0;
|
||
PSG.irq_enable = 0;
|
||
/* ASG 980324 -- reset the timers before writing to the registers */
|
||
EmuTimer.timer_enable(PSG.timer_A, false);
|
||
EmuTimer.timer_enable(PSG.timer_B, false);
|
||
PSG.timer_A_index = 0;
|
||
PSG.timer_B_index = 0;
|
||
PSG.timer_A_index_old = 0;
|
||
PSG.timer_B_index_old = 0;
|
||
PSG.noise = 0;
|
||
PSG.noise_rng = 0;
|
||
PSG.noise_p = 0;
|
||
PSG.noise_f = PSG.noise_tab[0];
|
||
PSG.csm_req = 0;
|
||
PSG.status = 0;
|
||
ym2151_write_reg(0x1b, 0); /* only because of CT1, CT2 output pins */
|
||
ym2151_write_reg(0x18, 0); /* set LFO frequency */
|
||
for (i = 0x20; i < 0x100; i++) /* set the operators */
|
||
{
|
||
ym2151_write_reg(i, 0);
|
||
}
|
||
}
|
||
|
||
unsafe static int op_calc(YM2151Operator* PSGoper, int i1, uint env, int pm)
|
||
{
|
||
uint p;
|
||
p = (env << 3) + sin_tab[(((int)((PSGoper[i1].phase & 0xffff0000) + (pm << 15))) >> 16) & 0x3ff];
|
||
if (p >= 13 * 2 * 0x100)
|
||
{
|
||
return 0;
|
||
}
|
||
return tl_tab[p];
|
||
}
|
||
|
||
//private static int op_calc(int i1, uint env, int pm)
|
||
//{
|
||
// uint p;
|
||
// p = (env << 3) + sin_tab[(((int)((PSG.oper[i1].phase & 0xffff0000) + (pm << 15))) >> 16) & 0x3ff];
|
||
// if (p >= 13 * 2 * 0x100)
|
||
// {
|
||
// return 0;
|
||
// }
|
||
// return tl_tab[p];
|
||
//}
|
||
|
||
|
||
unsafe static int op_calc1(YM2151Operator* PSGoper, int i1, uint env, int pm)
|
||
{
|
||
uint p;
|
||
int i;
|
||
i = (int)((PSGoper[i1].phase & 0xffff0000) + pm);
|
||
p = (env << 3) + sin_tab[(i >> 16) & 0x3ff];
|
||
if (p >= 13 * 2 * 0x100)
|
||
{
|
||
return 0;
|
||
}
|
||
return tl_tab[p];
|
||
}
|
||
|
||
//private static int op_calc1_src(int i1, uint env, int pm)
|
||
//{
|
||
// uint p;
|
||
// int i;
|
||
// i = (int)((PSG.oper[i1].phase & 0xffff0000) + pm);
|
||
// p = (env << 3) + sin_tab[(i >> 16) & 0x3ff];
|
||
// if (p >= 13 * 2 * 0x100)
|
||
// {
|
||
// return 0;
|
||
// }
|
||
// return tl_tab[p];
|
||
//}
|
||
|
||
unsafe static uint volume_calc(YM2151Operator* PSGoper, int i1, uint AM)
|
||
{
|
||
uint i11;
|
||
i11 = PSGoper[i1].tl + ((uint)PSGoper[i1].volume) + (AM & PSGoper[i1].AMmask);
|
||
return i11;
|
||
}
|
||
//private static uint volume_calc_old(int i1, uint AM)
|
||
//{
|
||
// uint i11;
|
||
// i11 = PSG.oper[i1].tl + ((uint)PSG.oper[i1].volume) + (AM & PSG.oper[i1].AMmask);
|
||
// return i11;
|
||
//}
|
||
|
||
//chan_calc高频调用 单次Update 5467次 左右，下级堆栈volume_calc 20000+次 op_calc 10000+次
|
||
|
||
unsafe static void chan_calc(YM2151Operator* PSGoper, int* chanout, int* imem, int chan)
|
||
{
|
||
|
||
//fixed (YM2151Operator* PSGoperPtr = &PSG.oper[0])
|
||
{
|
||
//YM2151Operator* PSGoper = PSGoperPtr;
|
||
uint env;
|
||
uint AM = 0;
|
||
//m2 = c1 = c2 = mem = 0;
|
||
chanout[8] = chanout[9] = chanout[10] = chanout[11] = 0;
|
||
//op = PSGoper[chan * 4]; /* M1 */
|
||
//op.mem_connect = op.mem_value; /* restore delayed sample (MEM) value to m2 or c2 */
|
||
set_mem(PSGoper, chanout, imem, chan * 4);
|
||
if (PSGoper[chan * 4].ams != 0)
|
||
{
|
||
AM = PSG.lfa << (int)(PSGoper[chan * 4].ams - 1);
|
||
}
|
||
|
||
env = volume_calc(PSGoper, (chan * 4), AM);
|
||
//env = volume_calc_planB(PSGoper[chan * 4], AM);
|
||
{
|
||
int iout = PSGoper[chan * 4].fb_out_prev + PSGoper[chan * 4].fb_out_curr;
|
||
PSGoper[chan * 4].fb_out_prev = PSGoper[chan * 4].fb_out_curr;
|
||
|
||
set_value1(chanout, PSGoper, chan * 4);
|
||
|
||
PSGoper[chan * 4].fb_out_curr = 0;
|
||
if (env < 13 * 64)
|
||
{
|
||
if (PSGoper[chan * 4].fb_shift == 0)
|
||
{
|
||
iout = 0;
|
||
}
|
||
PSGoper[chan * 4].fb_out_curr = op_calc1(PSGoper, (chan * 4), env, (iout << (int)PSGoper[chan * 4].fb_shift));
|
||
}
|
||
}
|
||
env = volume_calc(PSGoper, (chan * 4 + 1), AM); /* M2 */
|
||
//env = volume_calc_planB(PSGoper[chan * 4 + 1], AM);/* M2 */
|
||
if (env < 13 * 64)
|
||
{
|
||
//PSGoper[chan * 4 + 1].connect += op_calc((int)(chan * 4 + 1), env, m2);
|
||
set_value2(chanout, chan * 4 + 1, op_calc(PSGoper, (chan * 4 + 1), env, chanout[8]));// m2));
|
||
}
|
||
env = volume_calc(PSGoper, (chan * 4 + 2), AM); /* C1 */
|
||
//env = volume_calc_planB(PSGoper[chan * 4 + 2], AM); /* C1 */
|
||
if (env < 13 * 64)
|
||
{
|
||
//PSGoper[chan * 4 + 2].connect += op_calc((int)(chan * 4 + 2), env, c1);
|
||
set_value2(chanout, chan * 4 + 2, op_calc(PSGoper, (chan * 4 + 2), env, chanout[9]));// c1));
|
||
}
|
||
env = volume_calc(PSGoper, (chan * 4 + 3), AM); /* C2 */
|
||
//env = volume_calc_planB(PSGoper[chan * 4 + 3], AM); /* C2 */
|
||
if (env < 13 * 64)
|
||
{
|
||
chanout[chan] += op_calc(PSGoper, (chan * 4 + 3), env, chanout[10]);// c2);
|
||
}
|
||
/* M1 */
|
||
PSGoper[chan * 4].mem_value = chanout[11];//mem;
|
||
}
|
||
|
||
}
|
||
|
||
//private static void chan_calc_src(int chan)
|
||
//{
|
||
// uint env;
|
||
// uint AM = 0;
|
||
// //m2 = c1 = c2 = mem = 0;
|
||
// chanout[8] = chanout[9] = chanout[10] = chanout[11] = 0;
|
||
// //op = PSG.oper[chan * 4]; /* M1 */
|
||
// //op.mem_connect = op.mem_value; /* restore delayed sample (MEM) value to m2 or c2 */
|
||
// set_mem(chan * 4);
|
||
// if (PSG.oper[chan * 4].ams != 0)
|
||
// {
|
||
// AM = PSG.lfa << (int)(PSG.oper[chan * 4].ams - 1);
|
||
// }
|
||
|
||
|
||
// env = volume_calc((int)(chan * 4), AM);
|
||
// //env = volume_calc_planB(PSG.oper[chan * 4], AM);
|
||
// {
|
||
// int iout = PSG.oper[chan * 4].fb_out_prev + PSG.oper[chan * 4].fb_out_curr;
|
||
// PSG.oper[chan * 4].fb_out_prev = PSG.oper[chan * 4].fb_out_curr;
|
||
|
||
// set_value1(chan * 4);
|
||
|
||
// PSG.oper[chan * 4].fb_out_curr = 0;
|
||
// if (env < 13 * 64)
|
||
// {
|
||
// if (PSG.oper[chan * 4].fb_shift == 0)
|
||
// {
|
||
// iout = 0;
|
||
// }
|
||
// PSG.oper[chan * 4].fb_out_curr = op_calc1((int)(chan * 4), env, (int)(iout << (int)PSG.oper[chan * 4].fb_shift));
|
||
// }
|
||
// }
|
||
// env = volume_calc((int)(chan * 4 + 1), AM); /* M2 */
|
||
// //env = volume_calc_planB(PSG.oper[chan * 4 + 1], AM);/* M2 */
|
||
// if (env < 13 * 64)
|
||
// {
|
||
// //PSG.oper[chan * 4 + 1].connect += op_calc((int)(chan * 4 + 1), env, m2);
|
||
// set_value2(chan * 4 + 1, op_calc((int)(chan * 4 + 1), env, chanout[8]));// m2));
|
||
// }
|
||
// env = volume_calc((int)(chan * 4 + 2), AM); /* C1 */
|
||
// //env = volume_calc_planB(PSG.oper[chan * 4 + 2], AM); /* C1 */
|
||
// if (env < 13 * 64)
|
||
// {
|
||
// //PSG.oper[chan * 4 + 2].connect += op_calc((int)(chan * 4 + 2), env, c1);
|
||
// set_value2(chan * 4 + 2, op_calc((int)(chan * 4 + 2), env, chanout[9]));// c1));
|
||
// }
|
||
// env = volume_calc((int)(chan * 4 + 3), AM); /* C2 */
|
||
// //env = volume_calc_planB(PSG.oper[chan * 4 + 3], AM); /* C2 */
|
||
// if (env < 13 * 64)
|
||
// {
|
||
// chanout[chan] += op_calc((int)(chan * 4 + 3), env, chanout[10]);// c2);
|
||
// }
|
||
// /* M1 */
|
||
// PSG.oper[chan * 4].mem_value = chanout[11];//mem;
|
||
//}
|
||
|
||
unsafe static void chan7_calc(YM2151Operator* PSGoper, int* chanout, int* imem)
|
||
{
|
||
uint env;
|
||
uint AM = 0;
|
||
//m2 = c1 = c2 = mem = 0;
|
||
chanout[8] = chanout[9] = chanout[10] = chanout[11] = 0;
|
||
//op = PSG.oper[7 * 4]; /* M1 */
|
||
//op.mem_connect = op.mem_value; /* restore delayed sample (MEM) value to m2 or c2 */
|
||
set_mem(PSGoper, chanout, imem, 7 * 4);
|
||
if (PSGoper[7 * 4].ams != 0)
|
||
{
|
||
AM = PSG.lfa << (int)(PSGoper[7 * 4].ams - 1);
|
||
}
|
||
env = volume_calc(PSGoper, 7 * 4, AM);
|
||
//env = volume_calc_planB(PSGoper[7*4], AM);
|
||
int iout = PSGoper[7 * 4].fb_out_prev + PSGoper[7 * 4].fb_out_curr;
|
||
PSGoper[7 * 4].fb_out_prev = PSGoper[7 * 4].fb_out_curr;
|
||
set_value1(chanout, PSGoper, 7 * 4);
|
||
PSGoper[7 * 4].fb_out_curr = 0;
|
||
if (env < 13 * 64)
|
||
{
|
||
if (PSGoper[7 * 4].fb_shift == 0)
|
||
{
|
||
iout = 0;
|
||
}
|
||
PSGoper[7 * 4].fb_out_curr = op_calc1(PSGoper, 7 * 4, env, (iout << (int)PSGoper[7 * 4].fb_shift));
|
||
}
|
||
env = volume_calc(PSGoper, 7 * 4 + 1, AM); /* M2 */
|
||
//env = volume_calc_planB(PSGoper[7 * 4 + 1], AM);/* M2 */
|
||
if (env < 13 * 64)
|
||
{
|
||
//PSGoper[7 * 4 + 1].connect += op_calc(7 * 4 + 1, env, m2);
|
||
set_value2(chanout, 7 * 4 + 1, op_calc(PSGoper, 7 * 4 + 1, env, chanout[8]));// m2));
|
||
}
|
||
env = volume_calc(PSGoper, 7 * 4 + 2, AM); /* C1 */
|
||
//env = volume_calc_planB(PSGoper[7 * 4 + 2], AM);/* C1 */
|
||
if (env < 13 * 64)
|
||
{
|
||
//PSGoper[7 * 4 + 2].connect += op_calc(7 * 4 + 2, env, c1);
|
||
set_value2(chanout, 7 * 4 + 2, op_calc(PSGoper, 7 * 4 + 2, env, chanout[9]));// c1));
|
||
}
|
||
env = volume_calc(PSGoper, 7 * 4 + 3, AM); /* C2 */
|
||
//env = volume_calc_planB(PSGoper[7 * 4 + 3], AM);/* C2 */
|
||
if ((PSG.noise & 0x80) != 0)
|
||
{
|
||
uint noiseout;
|
||
|
||
noiseout = 0;
|
||
if (env < 0x3ff)
|
||
noiseout = (env ^ 0x3ff) * 2; /* range of the YM2151 noise output is -2044 to 2040 */
|
||
chanout[7] += (int)(((PSG.noise_rng & 0x10000) != 0) ? noiseout : -noiseout); /* bit 16 -> output */
|
||
}
|
||
else
|
||
{
|
||
if (env < 13 * 64)
|
||
chanout[7] += op_calc(PSGoper, 7 * 4 + 3, env, chanout[10]);// c2);
|
||
}
|
||
/* M1 */
|
||
PSGoper[7 * 4].mem_value = chanout[11];//mem;
|
||
}
|
||
|
||
//private static void chan7_calc_src()
|
||
//{
|
||
// uint env;
|
||
// uint AM = 0;
|
||
// //m2 = c1 = c2 = mem = 0;
|
||
// chanout[8] = chanout[9] = chanout[10] = chanout[11] = 0;
|
||
// //op = PSG.oper[7 * 4]; /* M1 */
|
||
// //op.mem_connect = op.mem_value; /* restore delayed sample (MEM) value to m2 or c2 */
|
||
// set_mem(7 * 4);
|
||
// if (PSG.oper[7 * 4].ams != 0)
|
||
// {
|
||
// AM = PSG.lfa << (int)(PSG.oper[7 * 4].ams - 1);
|
||
// }
|
||
// env = volume_calc(7 * 4, AM);
|
||
// //env = volume_calc_planB(PSG.oper[7*4], AM);
|
||
// int iout = PSG.oper[7 * 4].fb_out_prev + PSG.oper[7 * 4].fb_out_curr;
|
||
// PSG.oper[7 * 4].fb_out_prev = PSG.oper[7 * 4].fb_out_curr;
|
||
// set_value1(7 * 4);
|
||
// PSG.oper[7 * 4].fb_out_curr = 0;
|
||
// if (env < 13 * 64)
|
||
// {
|
||
// if (PSG.oper[7 * 4].fb_shift == 0)
|
||
// {
|
||
// iout = 0;
|
||
// }
|
||
// PSG.oper[7 * 4].fb_out_curr = op_calc1(7 * 4, env, (iout << (int)PSG.oper[7 * 4].fb_shift));
|
||
// }
|
||
// env = volume_calc(7 * 4 + 1, AM); /* M2 */
|
||
// //env = volume_calc_planB(PSG.oper[7 * 4 + 1], AM);/* M2 */
|
||
// if (env < 13 * 64)
|
||
// {
|
||
// //PSG.oper[7 * 4 + 1].connect += op_calc(7 * 4 + 1, env, m2);
|
||
// set_value2(7 * 4 + 1, op_calc(7 * 4 + 1, env, chanout[8]));// m2));
|
||
// }
|
||
// env = volume_calc(7 * 4 + 2, AM); /* C1 */
|
||
// //env = volume_calc_planB(PSG.oper[7 * 4 + 2], AM);/* C1 */
|
||
// if (env < 13 * 64)
|
||
// {
|
||
// //PSG.oper[7 * 4 + 2].connect += op_calc(7 * 4 + 2, env, c1);
|
||
// set_value2(7 * 4 + 2, op_calc(7 * 4 + 2, env, chanout[9]));// c1));
|
||
// }
|
||
// env = volume_calc(7 * 4 + 3, AM); /* C2 */
|
||
// //env = volume_calc_planB(PSG.oper[7 * 4 + 3], AM);/* C2 */
|
||
// if ((PSG.noise & 0x80) != 0)
|
||
// {
|
||
// uint noiseout;
|
||
|
||
// noiseout = 0;
|
||
// if (env < 0x3ff)
|
||
// noiseout = (env ^ 0x3ff) * 2; /* range of the YM2151 noise output is -2044 to 2040 */
|
||
// chanout[7] += (int)(((PSG.noise_rng & 0x10000) != 0) ? noiseout : -noiseout); /* bit 16 -> output */
|
||
// }
|
||
// else
|
||
// {
|
||
// if (env < 13 * 64)
|
||
// chanout[7] += op_calc(7 * 4 + 3, env, chanout[10]);// c2);
|
||
// }
|
||
// /* M1 */
|
||
// PSG.oper[7 * 4].mem_value = chanout[11];//mem;
|
||
//}
|
||
|
||
unsafe static void advance_eg(YM2151Operator* PSGoper)
|
||
{
|
||
uint i;
|
||
int i1 = 0;
|
||
PSG.eg_timer += PSG.eg_timer_add;
|
||
while (PSG.eg_timer >= PSG.eg_timer_overflow)
|
||
{
|
||
PSG.eg_timer -= PSG.eg_timer_overflow;
|
||
PSG.eg_cnt++;
|
||
/* envelope generator */
|
||
//op = PSGoper[i1]; /* CH 0 M1 */
|
||
i = 32;
|
||
do
|
||
{
|
||
switch (PSGoper[i1].state)
|
||
{
|
||
case 4: /* attack phase */
|
||
if ((PSG.eg_cnt & ((1 << PSGoper[i1].eg_sh_ar) - 1)) == 0)
|
||
{
|
||
PSGoper[i1].volume += (~PSGoper[i1].volume *
|
||
(eg_inc[PSGoper[i1].eg_sel_ar + ((PSG.eg_cnt >> PSGoper[i1].eg_sh_ar) & 7)])
|
||
) >> 4;
|
||
|
||
if (PSGoper[i1].volume <= 0)
|
||
{
|
||
PSGoper[i1].volume = 0;
|
||
PSGoper[i1].state = 3;
|
||
}
|
||
}
|
||
break;
|
||
case 3: /* decay phase */
|
||
if ((PSG.eg_cnt & ((1 << PSGoper[i1].eg_sh_d1r) - 1)) == 0)
|
||
{
|
||
PSGoper[i1].volume += eg_inc[PSGoper[i1].eg_sel_d1r + ((PSG.eg_cnt >> PSGoper[i1].eg_sh_d1r) & 7)];
|
||
if (PSGoper[i1].volume >= PSGoper[i1].d1l)
|
||
PSGoper[i1].state = 2;
|
||
}
|
||
break;
|
||
case 2: /* sustain phase */
|
||
if ((PSG.eg_cnt & ((1 << PSGoper[i1].eg_sh_d2r) - 1)) == 0)
|
||
{
|
||
PSGoper[i1].volume += eg_inc[PSGoper[i1].eg_sel_d2r + ((PSG.eg_cnt >> PSGoper[i1].eg_sh_d2r) & 7)];
|
||
if (PSGoper[i1].volume >= 0x3ff)
|
||
{
|
||
PSGoper[i1].volume = 0x3ff;
|
||
PSGoper[i1].state = 0;
|
||
}
|
||
}
|
||
break;
|
||
case 1: /* release phase */
|
||
if ((PSG.eg_cnt & ((1 << PSGoper[i1].eg_sh_rr) - 1)) == 0)
|
||
{
|
||
PSGoper[i1].volume += eg_inc[PSGoper[i1].eg_sel_rr + ((PSG.eg_cnt >> PSGoper[i1].eg_sh_rr) & 7)];
|
||
if (PSGoper[i1].volume >= 0x3ff)
|
||
{
|
||
PSGoper[i1].volume = 0x3ff;
|
||
PSGoper[i1].state = 0;
|
||
}
|
||
}
|
||
break;
|
||
}
|
||
i1++;
|
||
i--;
|
||
} while (i != 0);
|
||
}
|
||
}
|
||
|
||
//private static void advance_eg()
|
||
//{
|
||
// uint i;
|
||
// int i1 = 0;
|
||
// PSG.eg_timer += PSG.eg_timer_add;
|
||
// while (PSG.eg_timer >= PSG.eg_timer_overflow)
|
||
// {
|
||
// PSG.eg_timer -= PSG.eg_timer_overflow;
|
||
// PSG.eg_cnt++;
|
||
// /* envelope generator */
|
||
// //op = PSG.oper[i1]; /* CH 0 M1 */
|
||
// i = 32;
|
||
// do
|
||
// {
|
||
// switch (PSG.oper[i1].state)
|
||
// {
|
||
// case 4: /* attack phase */
|
||
// if ((PSG.eg_cnt & ((1 << PSG.oper[i1].eg_sh_ar) - 1)) == 0)
|
||
// {
|
||
// PSG.oper[i1].volume += (~PSG.oper[i1].volume *
|
||
// (eg_inc[PSG.oper[i1].eg_sel_ar + ((PSG.eg_cnt >> PSG.oper[i1].eg_sh_ar) & 7)])
|
||
// ) >> 4;
|
||
|
||
// if (PSG.oper[i1].volume <= 0)
|
||
// {
|
||
// PSG.oper[i1].volume = 0;
|
||
// PSG.oper[i1].state = 3;
|
||
// }
|
||
// }
|
||
// break;
|
||
// case 3: /* decay phase */
|
||
// if ((PSG.eg_cnt & ((1 << PSG.oper[i1].eg_sh_d1r) - 1)) == 0)
|
||
// {
|
||
// PSG.oper[i1].volume += eg_inc[PSG.oper[i1].eg_sel_d1r + ((PSG.eg_cnt >> PSG.oper[i1].eg_sh_d1r) & 7)];
|
||
// if (PSG.oper[i1].volume >= PSG.oper[i1].d1l)
|
||
// PSG.oper[i1].state = 2;
|
||
// }
|
||
// break;
|
||
// case 2: /* sustain phase */
|
||
// if ((PSG.eg_cnt & ((1 << PSG.oper[i1].eg_sh_d2r) - 1)) == 0)
|
||
// {
|
||
// PSG.oper[i1].volume += eg_inc[PSG.oper[i1].eg_sel_d2r + ((PSG.eg_cnt >> PSG.oper[i1].eg_sh_d2r) & 7)];
|
||
// if (PSG.oper[i1].volume >= 0x3ff)
|
||
// {
|
||
// PSG.oper[i1].volume = 0x3ff;
|
||
// PSG.oper[i1].state = 0;
|
||
// }
|
||
// }
|
||
// break;
|
||
// case 1: /* release phase */
|
||
// if ((PSG.eg_cnt & ((1 << PSG.oper[i1].eg_sh_rr) - 1)) == 0)
|
||
// {
|
||
// PSG.oper[i1].volume += eg_inc[PSG.oper[i1].eg_sel_rr + ((PSG.eg_cnt >> PSG.oper[i1].eg_sh_rr) & 7)];
|
||
// if (PSG.oper[i1].volume >= 0x3ff)
|
||
// {
|
||
// PSG.oper[i1].volume = 0x3ff;
|
||
// PSG.oper[i1].state = 0;
|
||
// }
|
||
// }
|
||
// break;
|
||
// }
|
||
// i1++;
|
||
// i--;
|
||
// } while (i != 0);
|
||
// }
|
||
//}
|
||
unsafe static void advance(YM2151Operator* PSGoper, uint* PSGfreq)
|
||
{
|
||
uint i;
|
||
int a, p;
|
||
/* LFO */
|
||
if ((PSG.test & 2) != 0)
|
||
{
|
||
PSG.lfo_phase = 0;
|
||
}
|
||
else
|
||
{
|
||
PSG.lfo_timer += PSG.lfo_timer_add;
|
||
if (PSG.lfo_timer >= PSG.lfo_overflow)
|
||
{
|
||
PSG.lfo_timer -= PSG.lfo_overflow;
|
||
PSG.lfo_counter += PSG.lfo_counter_add;
|
||
PSG.lfo_phase += (PSG.lfo_counter >> 4);
|
||
PSG.lfo_phase &= 255;
|
||
PSG.lfo_counter &= 15;
|
||
}
|
||
}
|
||
i = PSG.lfo_phase;
|
||
/* calculate LFO AM and PM waveform value (all verified on real chip, except for noise algorithm which is impossible to analyse)*/
|
||
switch (PSG.lfo_wsel)
|
||
{
|
||
case 0:
|
||
/* saw */
|
||
/* AM: 255 down to 0 */
|
||
/* PM: 0 to 127, -127 to 0 (at PMD=127: LFP = 0 to 126, -126 to 0) */
|
||
a = (int)(255 - i);
|
||
if (i < 128)
|
||
p = (int)i;
|
||
else
|
||
p = (int)(i - 255);
|
||
break;
|
||
case 1:
|
||
/* square */
|
||
/* AM: 255, 0 */
|
||
/* PM: 128,-128 (LFP = exactly +PMD, -PMD) */
|
||
if (i < 128)
|
||
{
|
||
a = 255;
|
||
p = 128;
|
||
}
|
||
else
|
||
{
|
||
a = 0;
|
||
p = -128;
|
||
}
|
||
break;
|
||
case 2:
|
||
/* triangle */
|
||
/* AM: 255 down to 1 step -2; 0 up to 254 step +2 */
|
||
/* PM: 0 to 126 step +2, 127 to 1 step -2, 0 to -126 step -2, -127 to -1 step +2*/
|
||
if (i < 128)
|
||
a = (int)(255 - (i * 2));
|
||
else
|
||
a = (int)((i * 2) - 256);
|
||
if (i < 64) /* i = 0..63 */
|
||
p = (int)(i * 2); /* 0 to 126 step +2 */
|
||
else if (i < 128) /* i = 64..127 */
|
||
p = (int)(255 - i * 2); /* 127 to 1 step -2 */
|
||
else if (i < 192) /* i = 128..191 */
|
||
p = (int)(256 - i * 2); /* 0 to -126 step -2*/
|
||
else /* i = 192..255 */
|
||
p = (int)(i * 2 - 511); /*-127 to -1 step +2*/
|
||
break;
|
||
case 3:
|
||
default: /*keep the compiler happy*/
|
||
a = lfo_noise_waveform[i];
|
||
p = a - 128;
|
||
break;
|
||
}
|
||
PSG.lfa = (uint)(a * PSG.amd / 128);
|
||
PSG.lfp = p * PSG.pmd / 128;
|
||
PSG.noise_p += PSG.noise_f;
|
||
i = (PSG.noise_p >> 16); /* number of events (shifts of the shift register) */
|
||
PSG.noise_p &= 0xffff;
|
||
while (i != 0)
|
||
{
|
||
uint j;
|
||
j = ((PSG.noise_rng ^ (PSG.noise_rng >> 3)) & 1) ^ 1;
|
||
PSG.noise_rng = (j << 16) | (PSG.noise_rng >> 1);
|
||
i--;
|
||
}
|
||
/* phase generator */
|
||
uint i1 = 0;
|
||
//op = PSGoper[i1]; /* CH 0 M1 */
|
||
i = 8;
|
||
do
|
||
{
|
||
if (PSGoper[i1].pms != 0) /* only when phase modulation from LFO is enabled for this channel */
|
||
{
|
||
int mod_ind = PSG.lfp; /* -128..+127 (8bits signed) */
|
||
if (PSGoper[i1].pms < 6)
|
||
mod_ind >>= (int)(6 - PSGoper[i1].pms);
|
||
else
|
||
mod_ind <<= (int)(PSGoper[i1].pms - 5);
|
||
if (mod_ind != 0)
|
||
{
|
||
uint kc_channel = (uint)(PSGoper[i1].kc_i + mod_ind);
|
||
PSGoper[i1].phase += (uint)(((PSGfreq[kc_channel + PSGoper[i1].dt2] + PSGoper[i1].dt1) * PSGoper[i1].mul) >> 1);
|
||
PSGoper[i1 + 1].phase += (uint)(((PSGfreq[kc_channel + PSGoper[i1 + 1].dt2] + PSGoper[i1 + 1].dt1) * PSGoper[i1 + 1].mul) >> 1);
|
||
PSGoper[i1 + 2].phase += (uint)(((PSGfreq[kc_channel + PSGoper[i1 + 2].dt2] + PSGoper[i1 + 2].dt1) * PSGoper[i1 + 2].mul) >> 1);
|
||
PSGoper[i1 + 3].phase += (uint)(((PSGfreq[kc_channel + PSGoper[i1 + 3].dt2] + PSGoper[i1 + 3].dt1) * PSGoper[i1 + 3].mul) >> 1);
|
||
}
|
||
else /* phase modulation from LFO is equal to zero */
|
||
{
|
||
PSGoper[i1].phase += PSGoper[i1].freq;
|
||
PSGoper[i1 + 1].phase += PSGoper[i1 + 1].freq;
|
||
PSGoper[i1 + 2].phase += PSGoper[i1 + 2].freq;
|
||
PSGoper[i1 + 3].phase += PSGoper[i1 + 3].freq;
|
||
}
|
||
}
|
||
else /* phase modulation from LFO is disabled */
|
||
{
|
||
PSGoper[i1].phase += PSGoper[i1].freq;
|
||
PSGoper[i1 + 1].phase += PSGoper[i1 + 1].freq;
|
||
PSGoper[i1 + 2].phase += PSGoper[i1 + 2].freq;
|
||
PSGoper[i1 + 3].phase += PSGoper[i1 + 3].freq;
|
||
}
|
||
i1 += 4;
|
||
i--;
|
||
} while (i != 0);
|
||
if (PSG.csm_req != 0) /* CSM KEYON/KEYOFF seqeunce request */
|
||
{
|
||
if (PSG.csm_req == 2) /* KEY ON */
|
||
{
|
||
i1 = 0;
|
||
PSGoper[i1] = PSGoper[i1]; /* CH 0 M1 */
|
||
i = 32;
|
||
do
|
||
{
|
||
KEY_ON(i1, 2);
|
||
i1++;
|
||
i--;
|
||
} while (i != 0);
|
||
PSG.csm_req = 1;
|
||
}
|
||
else /* KEY OFF */
|
||
{
|
||
i1 = 0;
|
||
PSGoper[i1] = PSGoper[i1]; /* CH 0 M1 */
|
||
i = 32;
|
||
do
|
||
{
|
||
KEY_OFF(i1, 0xfffffffe);
|
||
i1++;
|
||
i--;
|
||
} while (i != 0);
|
||
PSG.csm_req = 0;
|
||
}
|
||
}
|
||
}
|
||
//private static void advance()
|
||
//{
|
||
// uint i;
|
||
// int a, p;
|
||
// /* LFO */
|
||
// if ((PSG.test & 2) != 0)
|
||
// {
|
||
// PSG.lfo_phase = 0;
|
||
// }
|
||
// else
|
||
// {
|
||
// PSG.lfo_timer += PSG.lfo_timer_add;
|
||
// if (PSG.lfo_timer >= PSG.lfo_overflow)
|
||
// {
|
||
// PSG.lfo_timer -= PSG.lfo_overflow;
|
||
// PSG.lfo_counter += PSG.lfo_counter_add;
|
||
// PSG.lfo_phase += (PSG.lfo_counter >> 4);
|
||
// PSG.lfo_phase &= 255;
|
||
// PSG.lfo_counter &= 15;
|
||
// }
|
||
// }
|
||
// i = PSG.lfo_phase;
|
||
// /* calculate LFO AM and PM waveform value (all verified on real chip, except for noise algorithm which is impossible to analyse)*/
|
||
// switch (PSG.lfo_wsel)
|
||
// {
|
||
// case 0:
|
||
// /* saw */
|
||
// /* AM: 255 down to 0 */
|
||
// /* PM: 0 to 127, -127 to 0 (at PMD=127: LFP = 0 to 126, -126 to 0) */
|
||
// a = (int)(255 - i);
|
||
// if (i < 128)
|
||
// p = (int)i;
|
||
// else
|
||
// p = (int)(i - 255);
|
||
// break;
|
||
// case 1:
|
||
// /* square */
|
||
// /* AM: 255, 0 */
|
||
// /* PM: 128,-128 (LFP = exactly +PMD, -PMD) */
|
||
// if (i < 128)
|
||
// {
|
||
// a = 255;
|
||
// p = 128;
|
||
// }
|
||
// else
|
||
// {
|
||
// a = 0;
|
||
// p = -128;
|
||
// }
|
||
// break;
|
||
// case 2:
|
||
// /* triangle */
|
||
// /* AM: 255 down to 1 step -2; 0 up to 254 step +2 */
|
||
// /* PM: 0 to 126 step +2, 127 to 1 step -2, 0 to -126 step -2, -127 to -1 step +2*/
|
||
// if (i < 128)
|
||
// a = (int)(255 - (i * 2));
|
||
// else
|
||
// a = (int)((i * 2) - 256);
|
||
// if (i < 64) /* i = 0..63 */
|
||
// p = (int)(i * 2); /* 0 to 126 step +2 */
|
||
// else if (i < 128) /* i = 64..127 */
|
||
// p = (int)(255 - i * 2); /* 127 to 1 step -2 */
|
||
// else if (i < 192) /* i = 128..191 */
|
||
// p = (int)(256 - i * 2); /* 0 to -126 step -2*/
|
||
// else /* i = 192..255 */
|
||
// p = (int)(i * 2 - 511); /*-127 to -1 step +2*/
|
||
// break;
|
||
// case 3:
|
||
// default: /*keep the compiler happy*/
|
||
// a = lfo_noise_waveform[i];
|
||
// p = a - 128;
|
||
// break;
|
||
// }
|
||
// PSG.lfa = (uint)(a * PSG.amd / 128);
|
||
// PSG.lfp = p * PSG.pmd / 128;
|
||
// PSG.noise_p += PSG.noise_f;
|
||
// i = (PSG.noise_p >> 16); /* number of events (shifts of the shift register) */
|
||
// PSG.noise_p &= 0xffff;
|
||
// while (i != 0)
|
||
// {
|
||
// uint j;
|
||
// j = ((PSG.noise_rng ^ (PSG.noise_rng >> 3)) & 1) ^ 1;
|
||
// PSG.noise_rng = (j << 16) | (PSG.noise_rng >> 1);
|
||
// i--;
|
||
// }
|
||
// /* phase generator */
|
||
// uint i1 = 0;
|
||
// //op = PSG.oper[i1]; /* CH 0 M1 */
|
||
// i = 8;
|
||
// do
|
||
// {
|
||
// if (PSG.oper[i1].pms != 0) /* only when phase modulation from LFO is enabled for this channel */
|
||
// {
|
||
// int mod_ind = PSG.lfp; /* -128..+127 (8bits signed) */
|
||
// if (PSG.oper[i1].pms < 6)
|
||
// mod_ind >>= (int)(6 - PSG.oper[i1].pms);
|
||
// else
|
||
// mod_ind <<= (int)(PSG.oper[i1].pms - 5);
|
||
// if (mod_ind != 0)
|
||
// {
|
||
// uint kc_channel = (uint)(PSG.oper[i1].kc_i + mod_ind);
|
||
// PSG.oper[i1].phase += (uint)(((PSG.freq[kc_channel + PSG.oper[i1].dt2] + PSG.oper[i1].dt1) * PSG.oper[i1].mul) >> 1);
|
||
// PSG.oper[i1 + 1].phase += (uint)(((PSG.freq[kc_channel + PSG.oper[i1 + 1].dt2] + PSG.oper[i1 + 1].dt1) * PSG.oper[i1 + 1].mul) >> 1);
|
||
// PSG.oper[i1 + 2].phase += (uint)(((PSG.freq[kc_channel + PSG.oper[i1 + 2].dt2] + PSG.oper[i1 + 2].dt1) * PSG.oper[i1 + 2].mul) >> 1);
|
||
// PSG.oper[i1 + 3].phase += (uint)(((PSG.freq[kc_channel + PSG.oper[i1 + 3].dt2] + PSG.oper[i1 + 3].dt1) * PSG.oper[i1 + 3].mul) >> 1);
|
||
// }
|
||
// else /* phase modulation from LFO is equal to zero */
|
||
// {
|
||
// PSG.oper[i1].phase += PSG.oper[i1].freq;
|
||
// PSG.oper[i1 + 1].phase += PSG.oper[i1 + 1].freq;
|
||
// PSG.oper[i1 + 2].phase += PSG.oper[i1 + 2].freq;
|
||
// PSG.oper[i1 + 3].phase += PSG.oper[i1 + 3].freq;
|
||
// }
|
||
// }
|
||
// else /* phase modulation from LFO is disabled */
|
||
// {
|
||
// PSG.oper[i1].phase += PSG.oper[i1].freq;
|
||
// PSG.oper[i1 + 1].phase += PSG.oper[i1 + 1].freq;
|
||
// PSG.oper[i1 + 2].phase += PSG.oper[i1 + 2].freq;
|
||
// PSG.oper[i1 + 3].phase += PSG.oper[i1 + 3].freq;
|
||
// }
|
||
// i1 += 4;
|
||
// i--;
|
||
// } while (i != 0);
|
||
// if (PSG.csm_req != 0) /* CSM KEYON/KEYOFF seqeunce request */
|
||
// {
|
||
// if (PSG.csm_req == 2) /* KEY ON */
|
||
// {
|
||
// i1 = 0;
|
||
// PSG.oper[i1] = PSG.oper[i1]; /* CH 0 M1 */
|
||
// i = 32;
|
||
// do
|
||
// {
|
||
// KEY_ON(i1, 2);
|
||
// i1++;
|
||
// i--;
|
||
// } while (i != 0);
|
||
// PSG.csm_req = 1;
|
||
// }
|
||
// else /* KEY OFF */
|
||
// {
|
||
// i1 = 0;
|
||
// PSG.oper[i1] = PSG.oper[i1]; /* CH 0 M1 */
|
||
// i = 32;
|
||
// do
|
||
// {
|
||
// KEY_OFF(i1, 0xfffffffe);
|
||
// i1++;
|
||
// i--;
|
||
// } while (i != 0);
|
||
// PSG.csm_req = 0;
|
||
// }
|
||
// }
|
||
//}
|
||
|
||
static bool skiprun_update_one;
|
||
static int run_update_one_Index;
|
||
public unsafe static void ym2151_update_one(int offset, int length)
|
||
{
|
||
fixed (uint* PSGpanPtr = &PSG.pan[0])
|
||
fixed (uint* PSGfreqPtr = &PSG.freq[0])
|
||
fixed (YM2151Operator* PSGoperPtr = &PSG.oper[0])
|
||
fixed (int* chanoutPtr = &chanout[0])
|
||
//fixed (int* streamoutput0Ptr = &Sound.ym2151stream.streamoutput_Ptrs[0][0])
|
||
//fixed (int* streamoutput1Ptr = &Sound.ym2151stream.streamoutput_Ptrs[0][1])
|
||
fixed (int* imemPtr = &imem[0])
|
||
{
|
||
YM2151Operator* PSGoper = PSGoperPtr;
|
||
uint* PSGpan = PSGpanPtr;
|
||
uint* PSGfreq = PSGfreqPtr;
|
||
int* chanout = chanoutPtr;
|
||
//int* streamoutput0 = streamoutput0Ptr;
|
||
//int* streamoutput1 = streamoutput1Ptr;
|
||
int* streamoutput0 = &Sound.ym2151stream.streamoutput_Ptrs[0][0];
|
||
int* streamoutput1 = &Sound.ym2151stream.streamoutput_Ptrs[0][1];
|
||
int* imem = imemPtr;
|
||
|
||
int i;
|
||
int outl, outr;
|
||
for (i = 0; i < length; i++)
|
||
{
|
||
advance_eg(PSGoper);
|
||
chanout[0] = 0;
|
||
chanout[1] = 0;
|
||
chanout[2] = 0;
|
||
chanout[3] = 0;
|
||
chanout[4] = 0;
|
||
chanout[5] = 0;
|
||
chanout[6] = 0;
|
||
chanout[7] = 0;
|
||
|
||
//二分交替混音
|
||
//skiprun_update_one = !skiprun_update_one;
|
||
//if (!skiprun_update_one)
|
||
//{
|
||
// chan_calc(PSGoper, chanout, imem, 0);
|
||
// chan_calc(PSGoper, chanout, imem, 2);
|
||
// chan_calc(PSGoper, chanout, imem, 4);
|
||
// chan_calc(PSGoper, chanout, imem, 6);
|
||
//}
|
||
//else
|
||
//{
|
||
// chan_calc(PSGoper, chanout, imem, 1);
|
||
// chan_calc(PSGoper, chanout, imem, 3);
|
||
// chan_calc(PSGoper, chanout, imem, 5);
|
||
// chan7_calc(PSGoper, chanout, imem);
|
||
//}
|
||
|
||
//三分交替混音
|
||
//run_update_one_Index++;
|
||
//if (run_update_one_Index > 2)
|
||
// run_update_one_Index = 0;
|
||
//switch (run_update_one_Index)
|
||
//{
|
||
// case 0:
|
||
// chan_calc(PSGoper, chanout, imem, 0);
|
||
// chan_calc(PSGoper, chanout, imem, 2);
|
||
// chan_calc(PSGoper, chanout, imem, 4);
|
||
// break;
|
||
// case 1:
|
||
// chan_calc(PSGoper, chanout, imem, 1);
|
||
// chan_calc(PSGoper, chanout, imem, 3);
|
||
// chan7_calc(PSGoper, chanout, imem);
|
||
// break;
|
||
// case 2:
|
||
// chan_calc(PSGoper, chanout, imem, 0);
|
||
// chan_calc(PSGoper, chanout, imem, 5);
|
||
// chan_calc(PSGoper, chanout, imem, 6);
|
||
// break;
|
||
//}
|
||
|
||
//完全渲染混音
|
||
chan_calc(PSGoper, chanout, imem, 0);
|
||
chan_calc(PSGoper, chanout, imem, 1);
|
||
chan_calc(PSGoper, chanout, imem, 2);
|
||
chan_calc(PSGoper, chanout, imem, 3);
|
||
chan_calc(PSGoper, chanout, imem, 4);
|
||
chan_calc(PSGoper, chanout, imem, 5);
|
||
chan_calc(PSGoper, chanout, imem, 6);
|
||
chan7_calc(PSGoper, chanout, imem);
|
||
|
||
outl = (int)(chanout[0] & PSGpan[0]);
|
||
outr = (int)(chanout[0] & PSGpan[1]);
|
||
outl += (int)(chanout[1] & PSGpan[2]);
|
||
outr += (int)(chanout[1] & PSGpan[3]);
|
||
outl += (int)(chanout[2] & PSGpan[4]);
|
||
outr += (int)(chanout[2] & PSGpan[5]);
|
||
outl += (int)(chanout[3] & PSGpan[6]);
|
||
outr += (int)(chanout[3] & PSGpan[7]);
|
||
outl += (int)(chanout[4] & PSGpan[8]);
|
||
outr += (int)(chanout[4] & PSGpan[9]);
|
||
outl += (int)(chanout[5] & PSGpan[10]);
|
||
outr += (int)(chanout[5] & PSGpan[11]);
|
||
outl += (int)(chanout[6] & PSGpan[12]);
|
||
outr += (int)(chanout[6] & PSGpan[13]);
|
||
outl += (int)(chanout[7] & PSGpan[14]);
|
||
outr += (int)(chanout[7] & PSGpan[15]);
|
||
if (outl > 32767)
|
||
{
|
||
outl = 32767;
|
||
}
|
||
else if (outl < -32768)
|
||
{
|
||
outl = -32768;
|
||
}
|
||
if (outr > 32767)
|
||
{
|
||
outr = 32767;
|
||
}
|
||
else if (outr < -32768)
|
||
{
|
||
outr = -32768;
|
||
}
|
||
streamoutput0[offset + i] = outl;
|
||
streamoutput1[offset + i] = outr;
|
||
advance(PSGoper, PSGfreq);
|
||
}
|
||
}
|
||
}
|
||
//public static void ym2151_update_one(int offset, int length)
|
||
//{
|
||
// int i;
|
||
// int outl, outr;
|
||
// for (i = 0; i < length; i++)
|
||
// {
|
||
// advance_eg();
|
||
// chanout[0] = 0;
|
||
// chanout[1] = 0;
|
||
// chanout[2] = 0;
|
||
// chanout[3] = 0;
|
||
// chanout[4] = 0;
|
||
// chanout[5] = 0;
|
||
// chanout[6] = 0;
|
||
// chanout[7] = 0;
|
||
// chan_calc(0);
|
||
// chan_calc(1);
|
||
// chan_calc(2);
|
||
// chan_calc(3);
|
||
// chan_calc(4);
|
||
// chan_calc(5);
|
||
// chan_calc(6);
|
||
// chan7_calc();
|
||
// outl = (int)(chanout[0] & PSG.pan[0]);
|
||
// outr = (int)(chanout[0] & PSG.pan[1]);
|
||
// outl += (int)(chanout[1] & PSG.pan[2]);
|
||
// outr += (int)(chanout[1] & PSG.pan[3]);
|
||
// outl += (int)(chanout[2] & PSG.pan[4]);
|
||
// outr += (int)(chanout[2] & PSG.pan[5]);
|
||
// outl += (int)(chanout[3] & PSG.pan[6]);
|
||
// outr += (int)(chanout[3] & PSG.pan[7]);
|
||
// outl += (int)(chanout[4] & PSG.pan[8]);
|
||
// outr += (int)(chanout[4] & PSG.pan[9]);
|
||
// outl += (int)(chanout[5] & PSG.pan[10]);
|
||
// outr += (int)(chanout[5] & PSG.pan[11]);
|
||
// outl += (int)(chanout[6] & PSG.pan[12]);
|
||
// outr += (int)(chanout[6] & PSG.pan[13]);
|
||
// outl += (int)(chanout[7] & PSG.pan[14]);
|
||
// outr += (int)(chanout[7] & PSG.pan[15]);
|
||
// if (outl > 32767)
|
||
// {
|
||
// outl = 32767;
|
||
// }
|
||
// else if (outl < -32768)
|
||
// {
|
||
// outl = -32768;
|
||
// }
|
||
// if (outr > 32767)
|
||
// {
|
||
// outr = 32767;
|
||
// }
|
||
// else if (outr < -32768)
|
||
// {
|
||
// outr = -32768;
|
||
// }
|
||
// Sound.ym2151stream.streamoutput_Ptrs[0][offset + i] = outl;
|
||
// Sound.ym2151stream.streamoutput_Ptrs[1][offset + i] = outr;
|
||
// advance();
|
||
// }
|
||
//}
|
||
public static byte ym2151_status_port_0_r()
|
||
{
|
||
Sound.ym2151stream.stream_update();
|
||
return (byte)PSG.status;
|
||
}
|
||
public static void ym2151_register_port_0_w(byte data)
|
||
{
|
||
PSG.lastreg0 = data;
|
||
}
|
||
public static void ym2151_data_port_0_w(byte data)
|
||
{
|
||
Sound.ym2151stream.stream_update();
|
||
ym2151_write_reg(PSG.lastreg0, data);
|
||
}
|
||
|
||
unsafe static void set_value1(int* chanout, YM2151Operator* PSGoper, int op1)
|
||
{
|
||
if (iconnect[op1] == 12)
|
||
{
|
||
chanout[9] = chanout[10] = chanout[11] = PSGoper[op1].fb_out_prev;
|
||
}
|
||
else
|
||
{
|
||
chanout[iconnect[op1]] = PSGoper[op1].fb_out_prev;
|
||
}
|
||
}
|
||
//private static void set_value1(int op1)
|
||
//{
|
||
// if (iconnect[op1] == 12)
|
||
// {
|
||
// chanout[9] = chanout[10] = chanout[11] = PSG.oper[op1].fb_out_prev;
|
||
// }
|
||
// else
|
||
// {
|
||
// chanout[iconnect[op1]] = PSG.oper[op1].fb_out_prev;
|
||
// }
|
||
//}
|
||
unsafe static void set_value2(int* chanout, int op1, int i)
|
||
{
|
||
if (iconnect[op1] == 12)
|
||
{
|
||
return;
|
||
}
|
||
else
|
||
{
|
||
chanout[iconnect[op1]] += i;
|
||
}
|
||
}
|
||
|
||
//private static void set_value2(int op1, int i)
|
||
//{
|
||
// if (iconnect[op1] == 12)
|
||
// {
|
||
// return;
|
||
// }
|
||
// else
|
||
// {
|
||
// chanout[iconnect[op1]] += i;
|
||
// }
|
||
//}
|
||
unsafe static void set_mem(YM2151Operator* PSGoper, int* chanout, int* imem, int op1)
|
||
{
|
||
if (imem[op1] == 8 || imem[op1] == 10 || imem[op1] == 11)
|
||
{
|
||
chanout[imem[op1]] = PSGoper[op1].mem_value;
|
||
}
|
||
}
|
||
//private static void set_mem(int op1)
|
||
//{
|
||
// if (imem[op1] == 8 || imem[op1] == 10 || imem[op1] == 11)
|
||
// {
|
||
// chanout[imem[op1]] = PSG.oper[op1].mem_value;
|
||
// }
|
||
//}
|
||
public static void SaveStateBinary(BinaryWriter writer)
|
||
{
|
||
int i;
|
||
for (i = 0; i < 32; i++)
|
||
{
|
||
writer.Write(PSG.oper[i].phase);
|
||
writer.Write(PSG.oper[i].freq);
|
||
writer.Write(PSG.oper[i].dt1);
|
||
writer.Write(PSG.oper[i].mul);
|
||
writer.Write(PSG.oper[i].dt1_i);
|
||
writer.Write(PSG.oper[i].dt2);
|
||
writer.Write(PSG.oper[i].mem_value);
|
||
writer.Write(PSG.oper[i].fb_shift);
|
||
writer.Write(PSG.oper[i].fb_out_curr);
|
||
writer.Write(PSG.oper[i].fb_out_prev);
|
||
writer.Write(PSG.oper[i].kc);
|
||
writer.Write(PSG.oper[i].kc_i);
|
||
writer.Write(PSG.oper[i].pms);
|
||
writer.Write(PSG.oper[i].ams);
|
||
writer.Write(PSG.oper[i].AMmask);
|
||
writer.Write(PSG.oper[i].state);
|
||
writer.Write(PSG.oper[i].eg_sh_ar);
|
||
writer.Write(PSG.oper[i].eg_sel_ar);
|
||
writer.Write(PSG.oper[i].tl);
|
||
writer.Write(PSG.oper[i].volume);
|
||
writer.Write(PSG.oper[i].eg_sh_d1r);
|
||
writer.Write(PSG.oper[i].eg_sel_d1r);
|
||
writer.Write(PSG.oper[i].d1l);
|
||
writer.Write(PSG.oper[i].eg_sh_d2r);
|
||
writer.Write(PSG.oper[i].eg_sel_d2r);
|
||
writer.Write(PSG.oper[i].eg_sh_rr);
|
||
writer.Write(PSG.oper[i].eg_sel_rr);
|
||
writer.Write(PSG.oper[i].key);
|
||
writer.Write(PSG.oper[i].ks);
|
||
writer.Write(PSG.oper[i].ar);
|
||
writer.Write(PSG.oper[i].d1r);
|
||
writer.Write(PSG.oper[i].d2r);
|
||
writer.Write(PSG.oper[i].rr);
|
||
writer.Write(PSG.oper[i].reserved0);
|
||
writer.Write(PSG.oper[i].reserved1);
|
||
}
|
||
for (i = 0; i < 16; i++)
|
||
{
|
||
writer.Write(PSG.pan[i]);
|
||
}
|
||
writer.Write(PSG.lastreg0);
|
||
writer.Write(PSG.eg_cnt);
|
||
writer.Write(PSG.eg_timer);
|
||
writer.Write(PSG.eg_timer_add);
|
||
writer.Write(PSG.eg_timer_overflow);
|
||
writer.Write(PSG.lfo_phase);
|
||
writer.Write(PSG.lfo_timer);
|
||
writer.Write(PSG.lfo_timer_add);
|
||
writer.Write(PSG.lfo_overflow);
|
||
writer.Write(PSG.lfo_counter);
|
||
writer.Write(PSG.lfo_counter_add);
|
||
writer.Write(PSG.lfo_wsel);
|
||
writer.Write(PSG.amd);
|
||
writer.Write(PSG.pmd);
|
||
writer.Write(PSG.lfa);
|
||
writer.Write(PSG.lfp);
|
||
writer.Write(PSG.test);
|
||
writer.Write(PSG.ct);
|
||
writer.Write(PSG.noise);
|
||
writer.Write(PSG.noise_rng);
|
||
writer.Write(PSG.noise_p);
|
||
writer.Write(PSG.noise_f);
|
||
writer.Write(PSG.csm_req);
|
||
writer.Write(PSG.irq_enable);
|
||
writer.Write(PSG.status);
|
||
writer.Write(PSG.timer_A_index);
|
||
writer.Write(PSG.timer_B_index);
|
||
writer.Write(PSG.timer_A_index_old);
|
||
writer.Write(PSG.timer_B_index_old);
|
||
writer.Write(PSG.irqlinestate);
|
||
writer.Write(PSG.connect);
|
||
}
|
||
public static void LoadStateBinary(BinaryReader reader)
|
||
{
|
||
int i;
|
||
for (i = 0; i < 32; i++)
|
||
{
|
||
PSG.oper[i].phase = reader.ReadUInt32();
|
||
PSG.oper[i].freq = reader.ReadUInt32();
|
||
PSG.oper[i].dt1 = reader.ReadInt32();
|
||
PSG.oper[i].mul = reader.ReadUInt32();
|
||
PSG.oper[i].dt1_i = reader.ReadUInt32();
|
||
PSG.oper[i].dt2 = reader.ReadUInt32();
|
||
PSG.oper[i].mem_value = reader.ReadInt32();
|
||
PSG.oper[i].fb_shift = reader.ReadUInt32();
|
||
PSG.oper[i].fb_out_curr = reader.ReadInt32();
|
||
PSG.oper[i].fb_out_prev = reader.ReadInt32();
|
||
PSG.oper[i].kc = reader.ReadUInt32();
|
||
PSG.oper[i].kc_i = reader.ReadUInt32();
|
||
PSG.oper[i].pms = reader.ReadUInt32();
|
||
PSG.oper[i].ams = reader.ReadUInt32();
|
||
PSG.oper[i].AMmask = reader.ReadUInt32();
|
||
PSG.oper[i].state = reader.ReadUInt32();
|
||
PSG.oper[i].eg_sh_ar = reader.ReadByte();
|
||
PSG.oper[i].eg_sel_ar = reader.ReadByte();
|
||
PSG.oper[i].tl = reader.ReadUInt32();
|
||
PSG.oper[i].volume = reader.ReadInt32();
|
||
PSG.oper[i].eg_sh_d1r = reader.ReadByte();
|
||
PSG.oper[i].eg_sel_d1r = reader.ReadByte();
|
||
PSG.oper[i].d1l = reader.ReadUInt32();
|
||
PSG.oper[i].eg_sh_d2r = reader.ReadByte();
|
||
PSG.oper[i].eg_sel_d2r = reader.ReadByte();
|
||
PSG.oper[i].eg_sh_rr = reader.ReadByte();
|
||
PSG.oper[i].eg_sel_rr = reader.ReadByte();
|
||
PSG.oper[i].key = reader.ReadUInt32();
|
||
PSG.oper[i].ks = reader.ReadUInt32();
|
||
PSG.oper[i].ar = reader.ReadUInt32();
|
||
PSG.oper[i].d1r = reader.ReadUInt32();
|
||
PSG.oper[i].d2r = reader.ReadUInt32();
|
||
PSG.oper[i].rr = reader.ReadUInt32();
|
||
PSG.oper[i].reserved0 = reader.ReadUInt32();
|
||
PSG.oper[i].reserved1 = reader.ReadUInt32();
|
||
}
|
||
for (i = 0; i < 16; i++)
|
||
{
|
||
PSG.pan[i] = reader.ReadUInt32();
|
||
}
|
||
PSG.lastreg0 = reader.ReadInt32();
|
||
PSG.eg_cnt = reader.ReadUInt32();
|
||
PSG.eg_timer = reader.ReadUInt32();
|
||
PSG.eg_timer_add = reader.ReadUInt32();
|
||
PSG.eg_timer_overflow = reader.ReadUInt32();
|
||
PSG.lfo_phase = reader.ReadUInt32();
|
||
PSG.lfo_timer = reader.ReadUInt32();
|
||
PSG.lfo_timer_add = reader.ReadUInt32();
|
||
PSG.lfo_overflow = reader.ReadUInt32();
|
||
PSG.lfo_counter = reader.ReadUInt32();
|
||
PSG.lfo_counter_add = reader.ReadUInt32();
|
||
PSG.lfo_wsel = reader.ReadByte();
|
||
PSG.amd = reader.ReadByte();
|
||
PSG.pmd = reader.ReadSByte();
|
||
PSG.lfa = reader.ReadUInt32();
|
||
PSG.lfp = reader.ReadInt32();
|
||
PSG.test = reader.ReadByte();
|
||
PSG.ct = reader.ReadByte();
|
||
PSG.noise = reader.ReadUInt32();
|
||
PSG.noise_rng = reader.ReadUInt32();
|
||
PSG.noise_p = reader.ReadUInt32();
|
||
PSG.noise_f = reader.ReadUInt32();
|
||
PSG.csm_req = reader.ReadUInt32();
|
||
PSG.irq_enable = reader.ReadUInt32();
|
||
PSG.status = reader.ReadUInt32();
|
||
PSG.timer_A_index = reader.ReadUInt32();
|
||
PSG.timer_B_index = reader.ReadUInt32();
|
||
PSG.timer_A_index_old = reader.ReadUInt32();
|
||
PSG.timer_B_index_old = reader.ReadUInt32();
|
||
PSG.irqlinestate = reader.ReadInt32();
|
||
PSG.connect = reader.ReadBytes(8);
|
||
}
|
||
}
|
||
} |