Subversion Repositories pentevo

Rev

Rev 1099 | Blame | Compare with Previous | Last modification | View Log | Download | RSS feed | ?url?

  1. // This file is taken from the openMSX project.
  2. // The file has been modified to be built in the blueMSX environment.
  3.  
  4. // $Id: OpenMsxYMF262.cpp,v 1.4 2005/09/24 00:09:50 dvik Exp $
  5.  
  6. /*
  7.  *
  8.  * File: ymf262.c - software implementation of YMF262
  9.  *                  FM sound generator type OPL3
  10.  *
  11.  * Copyright (C) 2003 Jarek Burczynski
  12.  *
  13.  * Version 0.1
  14.  *
  15.  *
  16.  * Revision History:
  17.  *
  18.  * 03-03-2003: initial release
  19.  *  - thanks to Olivier Galibert and Chris Hardy for YMF262 and YAC512 chips
  20.  *  - thanks to Stiletto for the datasheets
  21.  *
  22.  *
  23.  *
  24.  * differences between OPL2 and OPL3 not documented in Yamaha datahasheets:
  25.  * - sinus table is a little different: the negative part is off by one...
  26.  *
  27.  * - in order to enable selection of four different waveforms on OPL2
  28.  *   one must set bit 5 in register 0x01(test).
  29.  *   on OPL3 this bit is ignored and 4-waveform select works *always*.
  30.  *   (Don't confuse this with OPL3's 8-waveform select.)
  31.  *
  32.  * - Envelope Generator: all 15 x rates take zero time on OPL3
  33.  *   (on OPL2 15 0 and 15 1 rates take some time while 15 2 and 15 3 rates
  34.  *   take zero time)
  35.  *
  36.  * - channel calculations: output of operator 1 is in perfect sync with
  37.  *   output of operator 2 on OPL3; on OPL and OPL2 output of operator 1
  38.  *   is always delayed by one sample compared to output of operator 2
  39.  *
  40.  *
  41.  * differences between OPL2 and OPL3 shown in datasheets:
  42.  * - YMF262 does not support CSM mode
  43.  */
  44.  
  45. #include "../std.h"
  46.  
  47. #include "ymf262.h"
  48. #include <cmath>
  49.  
  50. #ifdef _MSC_VER
  51. #pragma warning( disable : 4355 )
  52. #endif
  53.  
  54. const double PI = 3.14159265358979323846;
  55.  
  56. const int FREQ_SH   = 16;  // 16.16 fixed point (frequency calculations)
  57. const int EG_SH     = 16;  // 16.16 fixed point (EG timing)
  58. const int LFO_SH    = 24;  //  8.24 fixed point (LFO calculations)
  59. const int TIMER_SH  = 16;  // 16.16 fixed point (timers calculations)
  60. const int FREQ_MASK = (1 << FREQ_SH) - 1;
  61. const unsigned int EG_TIMER_OVERFLOW = 1 << EG_SH;
  62.  
  63. // envelope output entries
  64. const int ENV_BITS    = 10;
  65. const int ENV_LEN     = 1 << ENV_BITS;
  66. const double ENV_STEP = 128.0 / ENV_LEN;
  67.  
  68. const int MAX_ATT_INDEX = (1 << (ENV_BITS - 1)) - 1; //511
  69. const int MIN_ATT_INDEX = 0;
  70.  
  71. // sinwave entries
  72. const int SIN_BITS = 10;
  73. const int SIN_LEN  = 1 << SIN_BITS;
  74. const int SIN_MASK = SIN_LEN - 1;
  75.  
  76. const int TL_RES_LEN = 256;     // 8 bits addressing (real chip)
  77.  
  78. // register number to channel number , slot offset
  79. const u8 SLOT1 = 0;
  80. const u8 SLOT2 = 1;
  81.  
  82. // Envelope Generator phases
  83. const int EG_ATT = 4;
  84. const int EG_DEC = 3;
  85. const int EG_SUS = 2;
  86. const int EG_REL = 1;
  87. const int EG_OFF = 0;
  88.  
  89.  
  90. // mapping of register number (offset) to slot number used by the emulator
  91. const int slot_array[32] =
  92. {
  93.          0,  2,  4,  1,  3,  5, -1, -1,
  94.          6,  8, 10,  7,  9, 11, -1, -1,
  95.         12, 14, 16, 13, 15, 17, -1, -1,
  96.         -1, -1, -1, -1, -1, -1, -1, -1
  97. };
  98.  
  99. // key scale level
  100. // table is 3dB/octave , DV converts this into 6dB/octave
  101. // 0.1875 is bit 0 weight of the envelope counter (volume) expressed in the 'decibel' scale
  102. #define DV(x) (int)(x / (0.1875/2.0))
  103. const unsigned ksl_tab[8 * 16] =
  104. {
  105.         // OCT 0
  106.         DV( 0.000), DV( 0.000), DV( 0.000), DV( 0.000),
  107.         DV( 0.000), DV( 0.000), DV( 0.000), DV( 0.000),
  108.         DV( 0.000), DV( 0.000), DV( 0.000), DV( 0.000),
  109.         DV( 0.000), DV( 0.000), DV( 0.000), DV( 0.000),
  110.         // OCT 1
  111.         DV( 0.000), DV( 0.000), DV( 0.000), DV( 0.000),
  112.         DV( 0.000), DV( 0.000), DV( 0.000), DV( 0.000),
  113.         DV( 0.000), DV( 0.750), DV( 1.125), DV( 1.500),
  114.         DV( 1.875), DV( 2.250), DV( 2.625), DV( 3.000),
  115.         // OCT 2
  116.         DV( 0.000), DV( 0.000), DV( 0.000), DV( 0.000),
  117.         DV( 0.000), DV( 1.125), DV( 1.875), DV( 2.625),
  118.         DV( 3.000), DV( 3.750), DV( 4.125), DV( 4.500),
  119.         DV( 4.875), DV( 5.250), DV( 5.625), DV( 6.000),
  120.         // OCT 3
  121.         DV( 0.000), DV( 0.000), DV( 0.000), DV( 1.875),
  122.         DV( 3.000), DV( 4.125), DV( 4.875), DV( 5.625),
  123.         DV( 6.000), DV( 6.750), DV( 7.125), DV( 7.500),
  124.         DV( 7.875), DV( 8.250), DV( 8.625), DV( 9.000),
  125.         // OCT 4
  126.         DV( 0.000), DV( 0.000), DV( 3.000), DV( 4.875),
  127.         DV( 6.000), DV( 7.125), DV( 7.875), DV( 8.625),
  128.         DV( 9.000), DV( 9.750), DV(10.125), DV(10.500),
  129.         DV(10.875), DV(11.250), DV(11.625), DV(12.000),
  130.         // OCT 5
  131.         DV( 0.000), DV( 3.000), DV( 6.000), DV( 7.875),
  132.         DV( 9.000), DV(10.125), DV(10.875), DV(11.625),
  133.         DV(12.000), DV(12.750), DV(13.125), DV(13.500),
  134.         DV(13.875), DV(14.250), DV(14.625), DV(15.000),
  135.         // OCT 6
  136.         DV( 0.000), DV( 6.000), DV( 9.000), DV(10.875),
  137.         DV(12.000), DV(13.125), DV(13.875), DV(14.625),
  138.         DV(15.000), DV(15.750), DV(16.125), DV(16.500),
  139.         DV(16.875), DV(17.250), DV(17.625), DV(18.000),
  140.         // OCT 7
  141.         DV( 0.000), DV( 9.000), DV(12.000), DV(13.875),
  142.         DV(15.000), DV(16.125), DV(16.875), DV(17.625),
  143.         DV(18.000), DV(18.750), DV(19.125), DV(19.500),
  144.         DV(19.875), DV(20.250), DV(20.625), DV(21.000)
  145. };
  146. #undef DV
  147.  
  148. // sustain level table (3dB per step)
  149. // 0 - 15: 0, 3, 6, 9,12,15,18,21,24,27,30,33,36,39,42,93 (dB)
  150. #define SC(db) (unsigned) (db * (2.0/ENV_STEP))
  151. const unsigned sl_tab[16] = {
  152.  SC( 0), SC( 1), SC( 2), SC(3 ), SC(4 ), SC(5 ), SC(6 ), SC( 7),
  153.  SC( 8), SC( 9), SC(10), SC(11), SC(12), SC(13), SC(14), SC(31)
  154. };
  155. #undef SC
  156.  
  157.  
  158. const u8 RATE_STEPS = 8;
  159. const u8 eg_inc[15 * RATE_STEPS] =
  160. {
  161. //cycle:0 1  2 3  4 5  6 7
  162.                 0,1, 0,1, 0,1, 0,1, //  0  rates 00..12 0 (increment by 0 or 1)
  163.                 0,1, 0,1, 1,1, 0,1, //  1  rates 00..12 1
  164.                 0,1, 1,1, 0,1, 1,1, //  2  rates 00..12 2
  165.                 0,1, 1,1, 1,1, 1,1, //  3  rates 00..12 3
  166.  
  167.                 1,1, 1,1, 1,1, 1,1, //  4  rate 13 0 (increment by 1)
  168.                 1,1, 1,2, 1,1, 1,2, //  5  rate 13 1
  169.                 1,2, 1,2, 1,2, 1,2, //  6  rate 13 2
  170.                 1,2, 2,2, 1,2, 2,2, //  7  rate 13 3
  171.  
  172.                 2,2, 2,2, 2,2, 2,2, //  8  rate 14 0 (increment by 2)
  173.                 2,2, 2,4, 2,2, 2,4, //  9  rate 14 1
  174.                 2,4, 2,4, 2,4, 2,4, // 10  rate 14 2
  175.                 2,4, 4,4, 2,4, 4,4, // 11  rate 14 3
  176.  
  177.                 4,4, 4,4, 4,4, 4,4, // 12  rates 15 0, 15 1, 15 2, 15 3 for decay
  178.                 8,8, 8,8, 8,8, 8,8, // 13  rates 15 0, 15 1, 15 2, 15 3 for attack (zero time)
  179.                 0,0, 0,0, 0,0, 0,0, // 14  infinity rates for attack and decay(s)
  180. };
  181.  
  182.  
  183. #define O(a) (a*RATE_STEPS)
  184. // note that there is no O(13) in this table - it's directly in the code
  185. const u8 eg_rate_select[16 + 64 + 16] =
  186. {
  187.         // Envelope Generator rates (16 + 64 rates + 16 RKS)
  188.         // 16 infinite time rates
  189.         O(14),O(14),O(14),O(14),O(14),O(14),O(14),O(14),
  190.         O(14),O(14),O(14),O(14),O(14),O(14),O(14),O(14),
  191.  
  192.         // rates 00-12
  193.         O( 0),O( 1),O( 2),O( 3),
  194.         O( 0),O( 1),O( 2),O( 3),
  195.         O( 0),O( 1),O( 2),O( 3),
  196.         O( 0),O( 1),O( 2),O( 3),
  197.         O( 0),O( 1),O( 2),O( 3),
  198.         O( 0),O( 1),O( 2),O( 3),
  199.         O( 0),O( 1),O( 2),O( 3),
  200.         O( 0),O( 1),O( 2),O( 3),
  201.         O( 0),O( 1),O( 2),O( 3),
  202.         O( 0),O( 1),O( 2),O( 3),
  203.         O( 0),O( 1),O( 2),O( 3),
  204.         O( 0),O( 1),O( 2),O( 3),
  205.         O( 0),O( 1),O( 2),O( 3),
  206.  
  207.         // rate 13
  208.         O( 4),O( 5),O( 6),O( 7),
  209.  
  210.         // rate 14
  211.         O( 8),O( 9),O(10),O(11),
  212.  
  213.         // rate 15
  214.         O(12),O(12),O(12),O(12),
  215.  
  216.         // 16 dummy rates (same as 15 3)
  217.         O(12),O(12),O(12),O(12),O(12),O(12),O(12),O(12),
  218.         O(12),O(12),O(12),O(12),O(12),O(12),O(12),O(12),
  219. };
  220. #undef O
  221.  
  222. //rate  0,    1,    2,    3,   4,   5,   6,  7,  8,  9,  10, 11, 12, 13, 14, 15
  223. //shift 12,   11,   10,   9,   8,   7,   6,  5,  4,  3,  2,  1,  0,  0,  0,  0  
  224. //mask  4095, 2047, 1023, 511, 255, 127, 63, 31, 15, 7,  3,  1,  0,  0,  0,  0  
  225. #define O(a) (a*1)
  226. const u8 eg_rate_shift[16 + 64 + 16] =
  227. {
  228.         // Envelope Generator counter shifts (16 + 64 rates + 16 RKS)
  229.         // 16 infinite time rates
  230.         O(0),O(0),O(0),O(0),O(0),O(0),O(0),O(0),
  231.         O(0),O(0),O(0),O(0),O(0),O(0),O(0),O(0),
  232.  
  233.         // rates 00-15
  234.         O(12),O(12),O(12),O(12),
  235.         O(11),O(11),O(11),O(11),
  236.         O(10),O(10),O(10),O(10),
  237.         O( 9),O( 9),O( 9),O( 9),
  238.         O( 8),O( 8),O( 8),O( 8),
  239.         O( 7),O( 7),O( 7),O( 7),
  240.         O( 6),O( 6),O( 6),O( 6),
  241.         O( 5),O( 5),O( 5),O( 5),
  242.         O( 4),O( 4),O( 4),O( 4),
  243.         O( 3),O( 3),O( 3),O( 3),
  244.         O( 2),O( 2),O( 2),O( 2),
  245.         O( 1),O( 1),O( 1),O( 1),
  246.         O( 0),O( 0),O( 0),O( 0),
  247.         O( 0),O( 0),O( 0),O( 0),
  248.         O( 0),O( 0),O( 0),O( 0),
  249.         O( 0),O( 0),O( 0),O( 0),
  250.  
  251.         // 16 dummy rates (same as 15 3)
  252.         O( 0),O( 0),O( 0),O( 0),O( 0),O( 0),O( 0),O( 0),
  253.         O( 0),O( 0),O( 0),O( 0),O( 0),O( 0),O( 0),O( 0),
  254. };
  255. #undef O
  256.  
  257.  
  258. // multiple table
  259. #define ML(x) (u8)(2 * x)
  260. const u8 mul_tab[16] =
  261. {
  262.         // 1/2, 1, 2, 3, 4, 5, 6, 7, 8, 9,10,10,12,12,15,15
  263.         ML( 0.5),ML( 1.0),ML( 2.0),ML( 3.0),ML( 4.0),ML( 5.0),ML( 6.0),ML( 7.0),
  264.         ML( 8.0),ML( 9.0),ML(10.0),ML(10.0),ML(12.0),ML(12.0),ML(15.0),ML(15.0)
  265. };
  266. #undef ML
  267.  
  268. // TL_TAB_LEN is calculated as:
  269. //  (12+1)=13 - sinus amplitude bits     (Y axis)
  270. //  additional 1: to compensate for calculations of negative part of waveform
  271. //  (if we don't add it then the greatest possible _negative_ value would be -2
  272. //  and we really need -1 for waveform #7)
  273. //  2  - sinus sign bit           (Y axis)
  274. //  TL_RES_LEN - sinus resolution (X axis)
  275.  
  276. const int TL_TAB_LEN = 13 * 2 * TL_RES_LEN;
  277. static int tl_tab[TL_TAB_LEN];
  278. const int ENV_QUIET = TL_TAB_LEN >> 4;
  279.  
  280. // sin waveform table in 'decibel' scale
  281. // there are eight waveforms on OPL3 chips
  282. static unsigned int sin_tab[SIN_LEN * 8];
  283.  
  284.  
  285. // LFO Amplitude Modulation table (verified on real YM3812)
  286. //  27 output levels (triangle waveform); 1 level takes one of: 192, 256 or 448 samples
  287. //
  288. // Length: 210 elements
  289. //
  290. // Each of the elements has to be repeated
  291. // exactly 64 times (on 64 consecutive samples).
  292. // The whole table takes: 64 * 210 = 13440 samples.
  293. //
  294. // When AM = 1 data is used directly
  295. // When AM = 0 data is divided by 4 before being used (loosing precision is important)
  296.  
  297. const unsigned int LFO_AM_TAB_ELEMENTS = 210;
  298. const u8 lfo_am_table[LFO_AM_TAB_ELEMENTS] =
  299. {
  300.         0,0,0,0,0,0,0,
  301.         1,1,1,1,
  302.         2,2,2,2,
  303.         3,3,3,3,
  304.         4,4,4,4,
  305.         5,5,5,5,
  306.         6,6,6,6,
  307.         7,7,7,7,
  308.         8,8,8,8,
  309.         9,9,9,9,
  310.         10,10,10,10,
  311.         11,11,11,11,
  312.         12,12,12,12,
  313.         13,13,13,13,
  314.         14,14,14,14,
  315.         15,15,15,15,
  316.         16,16,16,16,
  317.         17,17,17,17,
  318.         18,18,18,18,
  319.         19,19,19,19,
  320.         20,20,20,20,
  321.         21,21,21,21,
  322.         22,22,22,22,
  323.         23,23,23,23,
  324.         24,24,24,24,
  325.         25,25,25,25,
  326.         26,26,26,
  327.         25,25,25,25,
  328.         24,24,24,24,
  329.         23,23,23,23,
  330.         22,22,22,22,
  331.         21,21,21,21,
  332.         20,20,20,20,
  333.         19,19,19,19,
  334.         18,18,18,18,
  335.         17,17,17,17,
  336.         16,16,16,16,
  337.         15,15,15,15,
  338.         14,14,14,14,
  339.         13,13,13,13,
  340.         12,12,12,12,
  341.         11,11,11,11,
  342.         10,10,10,10,
  343.         9,9,9,9,
  344.         8,8,8,8,
  345.         7,7,7,7,
  346.         6,6,6,6,
  347.         5,5,5,5,
  348.         4,4,4,4,
  349.         3,3,3,3,
  350.         2,2,2,2,
  351.         1,1,1,1
  352. };
  353.  
  354. // LFO Phase Modulation table (verified on real YM3812)
  355. const char lfo_pm_table[8 * 8 * 2] =
  356. {
  357.         // FNUM2/FNUM = 00 0xxxxxxx (0x0000)
  358.         0, 0, 0, 0, 0, 0, 0, 0, //LFO PM depth = 0
  359.         0, 0, 0, 0, 0, 0, 0, 0, //LFO PM depth = 1
  360.  
  361.         // FNUM2/FNUM = 00 1xxxxxxx (0x0080)
  362.         0, 0, 0, 0, 0, 0, 0, 0, //LFO PM depth = 0
  363.         1, 0, 0, 0,-1, 0, 0, 0, //LFO PM depth = 1
  364.  
  365.         // FNUM2/FNUM = 01 0xxxxxxx (0x0100)
  366.         1, 0, 0, 0,-1, 0, 0, 0, //LFO PM depth = 0
  367.         2, 1, 0,-1,-2,-1, 0, 1, //LFO PM depth = 1
  368.  
  369.         // FNUM2/FNUM = 01 1xxxxxxx (0x0180)
  370.         1, 0, 0, 0,-1, 0, 0, 0, //LFO PM depth = 0
  371.         3, 1, 0,-1,-3,-1, 0, 1, //LFO PM depth = 1
  372.  
  373.         // FNUM2/FNUM = 10 0xxxxxxx (0x0200)
  374.         2, 1, 0,-1,-2,-1, 0, 1, //LFO PM depth = 0
  375.         4, 2, 0,-2,-4,-2, 0, 2, //LFO PM depth = 1
  376.  
  377.         // FNUM2/FNUM = 10 1xxxxxxx (0x0280)
  378.         2, 1, 0,-1,-2,-1, 0, 1, //LFO PM depth = 0
  379.         5, 2, 0,-2,-5,-2, 0, 2, //LFO PM depth = 1
  380.  
  381.         // FNUM2/FNUM = 11 0xxxxxxx (0x0300)
  382.         3, 1, 0,-1,-3,-1, 0, 1, //LFO PM depth = 0
  383.         6, 3, 0,-3,-6,-3, 0, 3, //LFO PM depth = 1
  384.  
  385.         // FNUM2/FNUM = 11 1xxxxxxx (0x0380)
  386.         3, 1, 0,-1,-3,-1, 0, 1, //LFO PM depth = 0
  387.         7, 3, 0,-3,-7,-3, 0, 3  //LFO PM depth = 1
  388. };
  389.  
  390.  
  391. static int* chanOut;
  392. #define PHASE_MOD1 18
  393. #define PHASE_MOD2 19
  394.  
  395.  
  396.  
  397. YMF262Slot::YMF262Slot()
  398. {
  399.         ar = dr = rr = KSR = ksl = ksr = mul = 0;
  400.         Cnt = Incr = FB = op1_out[0] = op1_out[1] = CON = 0;
  401.         connect = 0;
  402.         eg_type = state = TL = TLL = volume = sl = 0;
  403.         eg_m_ar = eg_sh_ar = eg_sel_ar = eg_m_dr = eg_sh_dr = 0;
  404.         eg_sel_dr = eg_m_rr = eg_sh_rr = eg_sel_rr = 0;
  405.         key = AMmask = vib = waveform_number = wavetable = 0;
  406. }
  407.  
  408. YMF262Channel::YMF262Channel()
  409. {
  410.         block_fnum = fc = ksl_base = kcode = extended = 0;
  411. }
  412.  
  413.  
  414. void YMF262::callback(u8 flag)
  415. {
  416.         setStatus(flag);
  417. }
  418.  
  419. // status set and IRQ handling
  420. void YMF262::setStatus(u8 flag)
  421. {
  422.         // set status flag masking out disabled IRQs
  423.         status |= flag;
  424.         if (status & statusMask) {
  425.                 status |= 0x80;
  426. //              IRQHelper::set();
  427.         }
  428. }
  429.  
  430. // status reset and IRQ handling
  431. void YMF262::resetStatus(u8 flag)
  432. {
  433.         // reset status flag
  434.         status &= ~flag;
  435.         if (!(status & statusMask)) {
  436.                 status &= 0x7F;
  437. //              IRQHelper::reset();
  438.         }
  439. }
  440.  
  441. // IRQ mask set
  442. void YMF262::changeStatusMask(u8 flag)
  443. {
  444.         statusMask = flag;
  445.         status &= statusMask;
  446.         if (status) {
  447.                 status |= 0x80;
  448. //              IRQHelper::set();
  449.         } else {
  450.                 status &= 0x7F;
  451. //              IRQHelper::reset();
  452.         }
  453. }
  454.  
  455.  
  456. // advance LFO to next sample
  457. void YMF262::advance_lfo()
  458. {
  459.         // LFO
  460.         lfo_am_cnt += lfo_am_inc;
  461.         if (lfo_am_cnt >= (LFO_AM_TAB_ELEMENTS << LFO_SH)) {
  462.                 // lfo_am_table is 210 elements long
  463.                 lfo_am_cnt -= (LFO_AM_TAB_ELEMENTS << LFO_SH);
  464.         }
  465.  
  466.         u8 tmp = lfo_am_table[lfo_am_cnt >> LFO_SH];
  467.         if (lfo_am_depth) {
  468.                 LFO_AM = tmp;
  469.         } else {
  470.                 LFO_AM = tmp >> 2;
  471.         }
  472.         lfo_pm_cnt += lfo_pm_inc;
  473.         LFO_PM = ((lfo_pm_cnt >> LFO_SH) & 7) | lfo_pm_depth_range;
  474. }
  475.  
  476. // advance to next sample
  477. void YMF262::advance()
  478. {
  479.         eg_timer += eg_timer_add;
  480.  
  481.     if (eg_timer > 4 * EG_TIMER_OVERFLOW) {
  482.         eg_timer = EG_TIMER_OVERFLOW;
  483.     }
  484.         while (eg_timer >= EG_TIMER_OVERFLOW) {
  485.                 eg_timer -= EG_TIMER_OVERFLOW;
  486.                 eg_cnt++;
  487.  
  488.                 for (int i = 0; i < 18 * 2; i++) {
  489.                         YMF262Channel &ch = channels[i / 2];
  490.                         YMF262Slot &op = ch.slots[i & 1];
  491.                         // Envelope Generator
  492.                         switch(op.state) {
  493.                         case EG_ATT:    // attack phase
  494.                                 if (!(eg_cnt & op.eg_m_ar)) {
  495.                                         op.volume += (~op.volume * eg_inc[op.eg_sel_ar + ((eg_cnt >> op.eg_sh_ar) & 7)]) >> 3;
  496.                                         if (op.volume <= MIN_ATT_INDEX) {
  497.                                                 op.volume = MIN_ATT_INDEX;
  498.                                                 op.state = EG_DEC;
  499.                                         }
  500.                                 }
  501.                                 break;
  502.  
  503.                         case EG_DEC:    // decay phase
  504.                                 if (!(eg_cnt & op.eg_m_dr)) {
  505.                                         op.volume += eg_inc[op.eg_sel_dr + ((eg_cnt >> op.eg_sh_dr) & 7)];
  506.                                         if (op.volume >= op.sl) {
  507.                                                 op.state = EG_SUS;
  508.                                         }
  509.                                 }
  510.                                 break;
  511.  
  512.                         case EG_SUS:    // sustain phase
  513.                                 // this is important behaviour:
  514.                                 // one can change percusive/non-percussive
  515.                                 // modes on the fly and the chip will remain
  516.                                 // in sustain phase - verified on real YM3812
  517.                                 if (op.eg_type) {
  518.                                         // non-percussive mode
  519.                                         // do nothing
  520.                                 } else {
  521.                                         // percussive mode
  522.                                         // during sustain phase chip adds Release Rate (in percussive mode)
  523.                                         if (!(eg_cnt & op.eg_m_rr)) {
  524.                                                 op.volume += eg_inc[op.eg_sel_rr + ((eg_cnt>>op.eg_sh_rr) & 7)];
  525.                                                 if (op.volume >= MAX_ATT_INDEX) {
  526.                                                         op.volume = MAX_ATT_INDEX;
  527.                                                 }
  528.                                         } else {
  529.                                                 // do nothing in sustain phase
  530.                                         }
  531.                                 }
  532.                                 break;
  533.  
  534.                         case EG_REL:    // release phase
  535.                                 if (!(eg_cnt & op.eg_m_rr)) {
  536.                                         op.volume += eg_inc[op.eg_sel_rr + ((eg_cnt>>op.eg_sh_rr) & 7)];
  537.                                         if (op.volume >= MAX_ATT_INDEX) {
  538.                                                 op.volume = MAX_ATT_INDEX;
  539.                                                 op.state = EG_OFF;
  540.                                         }
  541.                                 }
  542.                         break;
  543.  
  544.                         default:
  545.                                 break;
  546.                         }
  547.                 }
  548.         }
  549.  
  550.     int i;
  551.         for (i = 0; i < 18 * 2; i++) {
  552.                 YMF262Channel &ch = channels[i / 2];
  553.                 YMF262Slot &op = ch.slots[i & 1];
  554.  
  555.                 // Phase Generator
  556.                 if (op.vib) {
  557.                         u8 block;
  558.                         unsigned int block_fnum = ch.block_fnum;
  559.                         unsigned int fnum_lfo   = (block_fnum & 0x0380) >> 7;
  560.                         signed int lfo_fn_table_index_offset = lfo_pm_table[LFO_PM + 16 * fnum_lfo];
  561.  
  562.                         if (lfo_fn_table_index_offset) {
  563.                                 // LFO phase modulation active
  564.                                 block_fnum += lfo_fn_table_index_offset;
  565.                                 block = (block_fnum & 0x1c00) >> 10;
  566.                                 op.Cnt += (fn_tab[block_fnum & 0x03ff] >> (7 - block)) * op.mul;
  567.                         } else {
  568.                                 // LFO phase modulation  = zero
  569.                                 op.Cnt += op.Incr;
  570.                         }
  571.                 } else {
  572.                         // LFO phase modulation disabled for this operator
  573.                         op.Cnt += op.Incr;
  574.                 }
  575.         }
  576.  
  577.         // The Noise Generator of the YM3812 is 23-bit shift register.
  578.         // Period is equal to 2^23-2 samples.
  579.         // Register works at sampling frequency of the chip, so output
  580.         // can change on every sample.
  581.         //
  582.         // Output of the register and input to the bit 22 is:
  583.         // bit0 XOR bit14 XOR bit15 XOR bit22
  584.         //
  585.         // Simply use bit 22 as the noise output.
  586.         noise_p += noise_f;
  587.     i = (noise_p >> FREQ_SH) & 0x1f;            // number of events (shifts of the shift register)
  588.         noise_p &= FREQ_MASK;
  589.         while (i--) {
  590.                 // unsigned j = ( (noise_rng) ^ (noise_rng>>14) ^ (noise_rng>>15) ^ (noise_rng>>22) ) & 1;
  591.                 // noise_rng = (j<<22) | (noise_rng>>1);
  592.                 //
  593.                 // Instead of doing all the logic operations above, we
  594.                 // use a trick here (and use bit 0 as the noise output).
  595.                 // The difference is only that the noise bit changes one
  596.                 // step ahead. This doesn't matter since we don't know
  597.                 // what is real state of the noise_rng after the reset.
  598.  
  599.                 if (noise_rng & 1) {
  600.                         noise_rng ^= 0x800302;
  601.                 }
  602.                 noise_rng >>= 1;
  603.         }
  604. }
  605.  
  606.  
  607. signed int op_calc(unsigned phase, unsigned env, signed int pm, unsigned int wave_tab)
  608. {
  609.         int i = (phase & ~FREQ_MASK) + (pm << 16);
  610.         int p = (env << 4) + sin_tab[wave_tab + ((i >> FREQ_SH ) & SIN_MASK)];
  611.         if (p >= TL_TAB_LEN) {
  612.                 return 0;
  613.         }
  614.         return tl_tab[p];
  615. }
  616.  
  617. signed int op_calc1(unsigned phase, unsigned int env, signed int pm, unsigned int wave_tab)
  618. {
  619.         int i = (phase & ~FREQ_MASK) + pm;
  620.         int p = (env << 4) + sin_tab[wave_tab + ((i >> FREQ_SH) & SIN_MASK)];
  621.         if (p >= TL_TAB_LEN) {
  622.                 return 0;
  623.         }
  624.         return tl_tab[p];
  625. }
  626.  
  627. inline int YMF262Slot::volume_calc(u8 LFO_AM)
  628. {
  629.         return TLL + volume + (LFO_AM & AMmask);
  630. }
  631.  
  632. // calculate output of a standard 2 operator channel
  633. // (or 1st part of a 4-op channel)
  634. void YMF262Channel::chan_calc(u8 LFO_AM)
  635. {
  636.     chanOut[PHASE_MOD1] = 0;
  637.     chanOut[PHASE_MOD2] = 0;
  638.         chanOut[PHASE_MOD1]  = 0;
  639.         chanOut[PHASE_MOD2] = 0;
  640.  
  641.         // SLOT 1
  642.         int env = slots[SLOT1].volume_calc(LFO_AM);
  643.         int out = slots[SLOT1].op1_out[0] + slots[SLOT1].op1_out[1];
  644.         slots[SLOT1].op1_out[0] = slots[SLOT1].op1_out[1];
  645.         slots[SLOT1].op1_out[1] = 0;
  646.         if (env < ENV_QUIET) {
  647.                 if (!slots[SLOT1].FB) {
  648.                         out = 0;
  649.                 }
  650.                 slots[SLOT1].op1_out[1] = op_calc1(slots[SLOT1].Cnt, env, (out<<slots[SLOT1].FB), slots[SLOT1].wavetable);
  651.         }
  652.         chanOut[slots[SLOT1].connect] += slots[SLOT1].op1_out[1];
  653.  
  654.         // SLOT 2
  655.         env = slots[SLOT2].volume_calc(LFO_AM);
  656.         if (env < ENV_QUIET) {
  657.                 chanOut[slots[SLOT2].connect] += op_calc(slots[SLOT2].Cnt, env, chanOut[PHASE_MOD1], slots[SLOT2].wavetable);
  658.         }
  659. }
  660.  
  661. // calculate output of a 2nd part of 4-op channel
  662. void YMF262Channel::chan_calc_ext(u8 LFO_AM)
  663. {
  664.         chanOut[PHASE_MOD1] = 0;
  665.  
  666.         // SLOT 1
  667.         int env  = slots[SLOT1].volume_calc(LFO_AM);
  668.         if (env < ENV_QUIET) {
  669.                 chanOut[slots[SLOT1].connect] += op_calc(slots[SLOT1].Cnt, env, chanOut[PHASE_MOD2], slots[SLOT1].wavetable );
  670.         }
  671.  
  672.         // SLOT 2
  673.         env = slots[SLOT2].volume_calc(LFO_AM);
  674.         if (env < ENV_QUIET) {
  675.                 chanOut[slots[SLOT2].connect] += op_calc(slots[SLOT2].Cnt, env, chanOut[PHASE_MOD1], slots[SLOT2].wavetable);
  676.         }
  677. }
  678.  
  679. // operators used in the rhythm sounds generation process:
  680. //
  681. // Envelope Generator:
  682. //
  683. // channel  operator  register number   Bass  High  Snare Tom  Top
  684. // / slot   number    TL ARDR SLRR Wave Drum  Hat   Drum  Tom  Cymbal
  685. //  6 / 0   12        50  70   90   f0  +
  686. //  6 / 1   15        53  73   93   f3  +
  687. //  7 / 0   13        51  71   91   f1        +
  688. //  7 / 1   16        54  74   94   f4              +
  689. //  8 / 0   14        52  72   92   f2                    +
  690. //  8 / 1   17        55  75   95   f5                          +
  691. //
  692. // Phase Generator:
  693. //
  694. // channel  operator  register number   Bass  High  Snare Tom  Top
  695. // / slot   number    MULTIPLE          Drum  Hat   Drum  Tom  Cymbal
  696. //  6 / 0   12        30                +
  697. //  6 / 1   15        33                +
  698. //  7 / 0   13        31                      +     +           +
  699. //  7 / 1   16        34                -----  n o t  u s e d -----
  700. //  8 / 0   14        32                                  +
  701. //  8 / 1   17        35                      +                 +
  702. //
  703. // channel  operator  register number   Bass  High  Snare Tom  Top
  704. // number   number    BLK/FNUM2 FNUM    Drum  Hat   Drum  Tom  Cymbal
  705. //    6     12,15     B6        A6      +
  706. //
  707. //    7     13,16     B7        A7            +     +           +
  708. //
  709. //    8     14,17     B8        A8            +           +     +
  710.  
  711. // calculate rhythm
  712. void YMF262::chan_calc_rhythm(bool noise)
  713. {
  714.         YMF262Slot& SLOT6_1 = channels[6].slots[SLOT1];
  715.         YMF262Slot& SLOT6_2 = channels[6].slots[SLOT2];
  716.         YMF262Slot& SLOT7_1 = channels[7].slots[SLOT1];
  717.         YMF262Slot& SLOT7_2 = channels[7].slots[SLOT2];
  718.         YMF262Slot& SLOT8_1 = channels[8].slots[SLOT1];
  719.         YMF262Slot& SLOT8_2 = channels[8].slots[SLOT2];
  720.  
  721.         // Bass Drum (verified on real YM3812):
  722.         //  - depends on the channel 6 'connect' register:
  723.         //      when connect = 0 it works the same as in normal (non-rhythm) mode (op1->op2->out)
  724.         //      when connect = 1 _only_ operator 2 is present on output (op2->out), operator 1 is ignored
  725.         //  - output sample always is multiplied by 2
  726.  
  727.         chanOut[PHASE_MOD1] = 0;
  728.  
  729.         // SLOT 1
  730.         int env = SLOT6_1.volume_calc(LFO_AM);
  731.         int out = SLOT6_1.op1_out[0] + SLOT6_1.op1_out[1];
  732.         SLOT6_1.op1_out[0] = SLOT6_1.op1_out[1];
  733.  
  734.         if (!SLOT6_1.CON) {
  735.                 chanOut[PHASE_MOD1] = SLOT6_1.op1_out[0];
  736.         } else {
  737.                 // ignore output of operator 1
  738.         }
  739.  
  740.         SLOT6_1.op1_out[1] = 0;
  741.         if (env < ENV_QUIET) {
  742.                 if (!SLOT6_1.FB) {
  743.                         out = 0;
  744.                 }
  745.                 SLOT6_1.op1_out[1] = op_calc1(SLOT6_1.Cnt, env, (out << SLOT6_1.FB), SLOT6_1.wavetable);
  746.         }
  747.  
  748.         // SLOT 2
  749.         env = SLOT6_2.volume_calc(LFO_AM);
  750.         if (env < ENV_QUIET) {
  751.                 chanout[6] += op_calc(SLOT6_2.Cnt, env, chanOut[PHASE_MOD1], SLOT6_2.wavetable) * 2;
  752.         }
  753.  
  754.         // Phase generation is based on:
  755.         // HH  (13) channel 7->slot 1 combined with channel 8->slot 2 (same combination as TOP CYMBAL but different output phases)
  756.         // SD  (16) channel 7->slot 1
  757.         // TOM (14) channel 8->slot 1
  758.         // TOP (17) channel 7->slot 1 combined with channel 8->slot 2 (same combination as HIGH HAT but different output phases)
  759.  
  760.         // Envelope generation based on:
  761.         // HH  channel 7->slot1
  762.         // SD  channel 7->slot2
  763.         // TOM channel 8->slot1
  764.         // TOP channel 8->slot2
  765.  
  766.         // The following formulas can be well optimized.
  767.         // I leave them in direct form for now (in case I've missed something).
  768.  
  769.         // High Hat (verified on real YM3812)
  770.         env = SLOT7_1.volume_calc(LFO_AM);
  771.         if (env < ENV_QUIET) {
  772.                 // high hat phase generation:
  773.                 // phase = d0 or 234 (based on frequency only)
  774.                 // phase = 34 or 2d0 (based on noise)
  775.  
  776.                 // base frequency derived from operator 1 in channel 7
  777.                 bool bit7 = ((SLOT7_1.Cnt >> FREQ_SH) & 0x80) != 0;
  778.                 bool bit3 = ((SLOT7_1.Cnt >> FREQ_SH) & 0x08) != 0;
  779.                 bool bit2 = ((SLOT7_1.Cnt >> FREQ_SH) & 0x04) != 0;
  780.                 bool res1 = ((bit2 ^ bit7) | bit3) != 0;
  781.                 // when res1 = 0 phase = 0x000 | 0xd0;
  782.                 // when res1 = 1 phase = 0x200 | (0xd0>>2);
  783.                 unsigned phase = res1 ? (0x200|(0xd0>>2)) : 0xd0;
  784.  
  785.                 // enable gate based on frequency of operator 2 in channel 8
  786.                 bool bit5e= ((SLOT8_2.Cnt>>FREQ_SH) & 0x20) != 0;
  787.                 bool bit3e= ((SLOT8_2.Cnt>>FREQ_SH) & 0x08) != 0;
  788.                 bool res2 = (bit3e ^ bit5e) != 0;
  789.                 // when res2 = 0 pass the phase from calculation above (res1);
  790.                 // when res2 = 1 phase = 0x200 | (0xd0>>2);
  791.                 if (res2) {
  792.                         phase = (0x200|(0xd0>>2));
  793.                 }
  794.  
  795.                 // when phase & 0x200 is set and noise=1 then phase = 0x200|0xd0
  796.                 // when phase & 0x200 is set and noise=0 then phase = 0x200|(0xd0>>2), ie no change
  797.                 if (phase&0x200) {
  798.                         if (noise) {
  799.                                 phase = 0x200|0xd0;
  800.                         }
  801.                 } else {
  802.                 // when phase & 0x200 is clear and noise=1 then phase = 0xd0>>2
  803.                 // when phase & 0x200 is clear and noise=0 then phase = 0xd0, ie no change
  804.                         if (noise) {
  805.                                 phase = 0xd0>>2;
  806.                         }
  807.                 }
  808.                 chanout[7] += op_calc(phase<<FREQ_SH, env, 0, SLOT7_1.wavetable) * 2;
  809.         }
  810.  
  811.         // Snare Drum (verified on real YM3812)
  812.         env = SLOT7_2.volume_calc(LFO_AM);
  813.         if (env < ENV_QUIET) {
  814.                 // base frequency derived from operator 1 in channel 7
  815.                 bool bit8 = ((SLOT7_1.Cnt>>FREQ_SH) & 0x100) != 0;
  816.                 // when bit8 = 0 phase = 0x100;
  817.                 // when bit8 = 1 phase = 0x200;
  818.                 unsigned phase = bit8 ? 0x200 : 0x100;
  819.  
  820.                 // Noise bit XOR'es phase by 0x100
  821.                 // when noisebit = 0 pass the phase from calculation above
  822.                 // when noisebit = 1 phase ^= 0x100;
  823.                 // in other words: phase ^= (noisebit<<8);
  824.                 if (noise) {
  825.                         phase ^= 0x100;
  826.                 }
  827.                 chanout[7] += op_calc(phase<<FREQ_SH, env, 0, SLOT7_2.wavetable) * 2;
  828.         }
  829.  
  830.         // Tom Tom (verified on real YM3812)
  831.         env = SLOT8_1.volume_calc(LFO_AM);
  832.         if (env < ENV_QUIET) {
  833.                 chanout[8] += op_calc(SLOT8_1.Cnt, env, 0, SLOT8_1.wavetable) * 2;
  834.         }
  835.  
  836.         // Top Cymbal (verified on real YM3812)
  837.         env = SLOT8_2.volume_calc(LFO_AM);
  838.         if (env < ENV_QUIET) {
  839.                 // base frequency derived from operator 1 in channel 7
  840.                 bool bit7 = ((SLOT7_1.Cnt>>FREQ_SH) & 0x80) != 0;
  841.                 bool bit3 = ((SLOT7_1.Cnt>>FREQ_SH) & 0x08) != 0;
  842.                 bool bit2 = ((SLOT7_1.Cnt>>FREQ_SH) & 0x04) != 0;
  843.                 bool res1 = ((bit2 ^ bit7) | bit3) != 0;
  844.                 // when res1 = 0 phase = 0x000 | 0x100;
  845.                 // when res1 = 1 phase = 0x200 | 0x100;
  846.                 unsigned phase = res1 ? 0x300 : 0x100;
  847.  
  848.                 // enable gate based on frequency of operator 2 in channel 8
  849.                 bool bit5e= ((SLOT8_2.Cnt>>FREQ_SH) & 0x20) != 0;
  850.                 bool bit3e= ((SLOT8_2.Cnt>>FREQ_SH) & 0x08) != 0;
  851.                 bool res2 = (bit3e ^ bit5e) != 0;
  852.                 // when res2 = 0 pass the phase from calculation above (res1);
  853.                 // when res2 = 1 phase = 0x200 | 0x100;
  854.                 if (res2) {
  855.                         phase = 0x300;
  856.                 }
  857.                 chanout[8] += op_calc(phase<<FREQ_SH, env, 0, SLOT8_2.wavetable) * 2;
  858.         }
  859. }
  860.  
  861.  
  862. // generic table initialize
  863. void YMF262::init_tables(void)
  864. {
  865.     int i;
  866.         static bool alreadyInit = false;
  867.         if (alreadyInit) {
  868.                 return;
  869.         }
  870.         alreadyInit = true;
  871.  
  872.         for (int x = 0; x < TL_RES_LEN; x++) {
  873.                 double m = (1 << 16) / pow((double)2, (x + 1) * (ENV_STEP / 4.0) / 8.0);
  874.                 m = floor(m);
  875.  
  876.                 // we never reach (1<<16) here due to the (x+1)
  877.                 // result fits within 16 bits at maximum
  878.                 int n = (int)m;         // 16 bits here
  879.                 n >>= 4;                // 12 bits here
  880.                 if (n & 1) {            // round to nearest
  881.                         n = (n >> 1) + 1;
  882.                 } else {
  883.                         n = n >> 1;
  884.                 }
  885.                 // 11 bits here (rounded)
  886.                 n <<= 1;                // 12 bits here (as in real chip)
  887.                 tl_tab[x * 2 + 0] = n;
  888.                 tl_tab[x * 2 + 1] = ~tl_tab[x * 2 + 0]; // this _is_ different from OPL2 (verified on real YMF262)
  889.  
  890.                 for (i = 1; i < 13; i++) {
  891.                         tl_tab[x * 2 + 0 + i * 2 * TL_RES_LEN] =  tl_tab[x * 2 + 0] >> i;
  892.                         tl_tab[x * 2 + 1 + i * 2 * TL_RES_LEN] = ~tl_tab[x * 2 + 0 + i * 2 * TL_RES_LEN];  // this _is_ different from OPL2 (verified on real YMF262)
  893.                 }
  894.         }
  895.  
  896.         const double LOG2 = ::log((double)2);
  897.         for (i = 0; i < SIN_LEN; i++) {
  898.                 // non-standard sinus
  899.                 double m = sin(((i * 2) + 1) * PI / SIN_LEN); // checked against the real chip
  900.                 // we never reach zero here due to ((i * 2) + 1)
  901.                 double o = (m > 0.0) ?
  902.                         8 * ::log( 1.0 / m) / LOG2:     // convert to 'decibels'
  903.                         8 * ::log(-1.0 / m) / LOG2;     // convert to 'decibels'
  904.                 o = o / (ENV_STEP / 4);
  905.  
  906.                 int n = (int)(2 * o);
  907.                 if (n & 1) {// round to nearest
  908.                         n = (n>>1)+1;
  909.                 } else {
  910.                         n = n>>1;
  911.                 }
  912.                 sin_tab[i] = n * 2 + (m >=0.0 ? 0 : 1);
  913.         }
  914.  
  915.         for (i = 0; i < SIN_LEN; i++) {
  916.                 // these 'pictures' represent _two_ cycles
  917.                 // waveform 1:  __      __    
  918.                 //             /  \____/  \____
  919.                 // output only first half of the sinus waveform (positive one)
  920.                 if (i & (1 << (SIN_BITS - 1))) {
  921.                         sin_tab[1*SIN_LEN+i] = TL_TAB_LEN;
  922.                 } else {
  923.                         sin_tab[1*SIN_LEN+i] = sin_tab[i];
  924.                 }
  925.                
  926.                 // waveform 2:  __  __  __  __
  927.                 //             /  \/  \/  \/  \.
  928.                 // abs(sin)
  929.                 sin_tab[2 * SIN_LEN + i] = sin_tab[i & (SIN_MASK >> 1)];
  930.  
  931.                 // waveform 3:  _   _   _   _  
  932.                 //             / |_/ |_/ |_/ |_
  933.                 // abs(output only first quarter of the sinus waveform)
  934.                 if (i & (1<<(SIN_BITS-2))) {
  935.                         sin_tab[3*SIN_LEN+i] = TL_TAB_LEN;
  936.                 } else {
  937.                         sin_tab[3*SIN_LEN+i] = sin_tab[i & (SIN_MASK>>2)];
  938.                 }
  939.  
  940.                 // waveform 4:                
  941.                 //             /\  ____/\  ____
  942.                 //               \/      \/    
  943.                 // output whole sinus waveform in half the cycle(step=2) and output 0 on the other half of cycle
  944.                 if (i & (1 << (SIN_BITS-1))) {
  945.                         sin_tab[4*SIN_LEN+i] = TL_TAB_LEN;
  946.                 } else {
  947.                         sin_tab[4*SIN_LEN+i] = sin_tab[i*2];
  948.                 }
  949.  
  950.                 // waveform 5:                
  951.                 //             /\/\____/\/\____
  952.                 //                            
  953.                 // output abs(whole sinus) waveform in half the cycle(step=2) and output 0 on the other half of cycle
  954.                 if (i & (1 << (SIN_BITS-1))) {
  955.                         sin_tab[5*SIN_LEN+i] = TL_TAB_LEN;
  956.                 } else {
  957.                         sin_tab[5*SIN_LEN+i] = sin_tab[(i*2) & (SIN_MASK>>1)];
  958.                 }
  959.  
  960.                 // waveform 6: ____    ____    
  961.                 //                            
  962.                 //                 ____    ____
  963.                 // output maximum in half the cycle and output minimum on the other half of cycle
  964.                 if (i & (1 << (SIN_BITS - 1))) {
  965.                         sin_tab[6*SIN_LEN+i] = 1;       // negative
  966.                 } else {
  967.                         sin_tab[6*SIN_LEN+i] = 0;       // positive
  968.                 }
  969.  
  970.                 // waveform 7:                
  971.                 //             |\____  |\____  
  972.                 //                   \|      \|
  973.                 // output sawtooth waveform    
  974.                 int x = (i & (1 << (SIN_BITS - 1))) ?
  975.                         ((SIN_LEN - 1) - i) * 16 + 1 : // negative: from 8177 to 1
  976.                         i * 16;                        //positive: from 0 to 8176
  977.                 if (x > TL_TAB_LEN) {
  978.                         x = TL_TAB_LEN; // clip to the allowed range
  979.                 }
  980.                 sin_tab[7 * SIN_LEN+i] = x;
  981.         }
  982. }
  983.  
  984.  
  985. void YMF262::setSampleRate(int sampleRate, int Oversampling)
  986. {
  987.     oplOversampling = Oversampling;
  988.         const int CLCK_FREQ = 14318180;
  989.         double freqbase  = ((double)CLCK_FREQ / (8.0 * 36)) / (double)(sampleRate * oplOversampling);
  990.  
  991.         // make fnumber -> increment counter table
  992.         for (int i = 0; i < 1024; i++) {
  993.                 // opn phase increment counter = 20bit
  994.                 // -10 because chip works with 10.10 fixed point, while we use 16.16
  995.                 fn_tab[i] = (unsigned)( (double)i * 64 * freqbase * (1<<(FREQ_SH - 10)));
  996.         }
  997.  
  998.         // Amplitude modulation: 27 output levels (triangle waveform);
  999.         // 1 level takes one of: 192, 256 or 448 samples
  1000.         // One entry from LFO_AM_TABLE lasts for 64 samples
  1001.         lfo_am_inc = (unsigned)((1 << LFO_SH) * freqbase / 64.0);
  1002.  
  1003.         // Vibrato: 8 output levels (triangle waveform); 1 level takes 1024 samples
  1004.         lfo_pm_inc = (unsigned)((1 << LFO_SH) * freqbase / 1024.0);
  1005.  
  1006.         // Noise generator: a step takes 1 sample
  1007.         noise_f = (unsigned)((1 << FREQ_SH) * freqbase);
  1008.  
  1009.         eg_timer_add  = (unsigned)((1 << EG_SH) * freqbase);
  1010. }
  1011.  
  1012. void YMF262Slot::FM_KEYON(u8 key_set)
  1013. {
  1014.         if (!key) {
  1015.                 // restart Phase Generator
  1016.                 Cnt = 0;
  1017.                 // phase -> Attack
  1018.                 state = EG_ATT;
  1019.         }
  1020.         key |= key_set;
  1021. }
  1022.  
  1023. void YMF262Slot::FM_KEYOFF(u8 key_clr)
  1024. {
  1025.         if (key) {
  1026.                 key &= key_clr;
  1027.                 if (!key) {
  1028.                         // phase -> Release
  1029.                         if (state > EG_REL) {
  1030.                                 state = EG_REL;
  1031.                         }
  1032.                 }
  1033.         }
  1034. }
  1035.  
  1036. // update phase increment counter of operator (also update the EG rates if necessary)
  1037. void YMF262Channel::CALC_FCSLOT(YMF262Slot &slot)
  1038. {
  1039.         // (frequency) phase increment counter
  1040.         slot.Incr = fc * slot.mul;
  1041.         int ksr = kcode >> slot.KSR;
  1042.  
  1043.         if (slot.ksr != ksr) {
  1044.                 slot.ksr = ksr;
  1045.  
  1046.                 // calculate envelope generator rates
  1047.                 if ((slot.ar + slot.ksr) < 16+60) {
  1048.                         slot.eg_sh_ar  = eg_rate_shift [slot.ar + slot.ksr ];
  1049.                         slot.eg_m_ar   = (1 << slot.eg_sh_ar) - 1;
  1050.                         slot.eg_sel_ar = eg_rate_select[slot.ar + slot.ksr ];
  1051.                 } else {
  1052.                         slot.eg_sh_ar  = 0;
  1053.                         slot.eg_m_ar   = (1 << slot.eg_sh_ar) - 1;
  1054.                         slot.eg_sel_ar = 13 * RATE_STEPS;
  1055.                 }
  1056.                 slot.eg_sh_dr  = eg_rate_shift [slot.dr + slot.ksr ];
  1057.                 slot.eg_m_dr   = (1 << slot.eg_sh_dr) - 1;
  1058.                 slot.eg_sel_dr = eg_rate_select[slot.dr + slot.ksr ];
  1059.                 slot.eg_sh_rr  = eg_rate_shift [slot.rr + slot.ksr ];
  1060.                 slot.eg_m_rr   = (1 << slot.eg_sh_rr) - 1;
  1061.                 slot.eg_sel_rr = eg_rate_select[slot.rr + slot.ksr ];
  1062.         }
  1063. }
  1064.  
  1065. // set multi,am,vib,EG-TYP,KSR,mul
  1066. void YMF262::set_mul(u8 sl, u8 v)
  1067. {
  1068.         int chan_no = sl / 2;
  1069.         YMF262Channel &ch  = channels[chan_no];
  1070.         YMF262Slot &slot = ch.slots[sl & 1];
  1071.  
  1072.         slot.mul     = mul_tab[v & 0x0f];
  1073.         slot.KSR     = (v & 0x10) ? 0 : 2;
  1074.         slot.eg_type = (v & 0x20);
  1075.         slot.vib     = (v & 0x40);
  1076.         slot.AMmask  = (v & 0x80) ? ~0 : 0;
  1077.  
  1078.         if (OPL3_mode) {
  1079.                 // in OPL3 mode
  1080.                 // DO THIS:
  1081.                 //  if this is one of the slots of 1st channel forming up a 4-op channel
  1082.                 //  do normal operation
  1083.                 //  else normal 2 operator function
  1084.                 // OR THIS:
  1085.                 //  if this is one of the slots of 2nd channel forming up a 4-op channel
  1086.                 //  update it using channel data of 1st channel of a pair
  1087.                 //  else normal 2 operator function
  1088.                 switch(chan_no) {
  1089.                 case 0: case 1: case 2:
  1090.                 case 9: case 10: case 11:
  1091.                         if (ch.extended) {
  1092.                                 // normal
  1093.                                 ch.CALC_FCSLOT(slot);
  1094.                         } else {
  1095.                                 // normal
  1096.                                 ch.CALC_FCSLOT(slot);
  1097.                         }
  1098.                         break;
  1099.                 case 3: case 4: case 5:
  1100.                 case 12: case 13: case 14: {
  1101.                         YMF262Channel &ch3 = channels[chan_no - 3];
  1102.                         if (ch3.extended) {
  1103.                                 // update this slot using frequency data for 1st channel of a pair
  1104.                                 ch3.CALC_FCSLOT(slot);
  1105.                         } else {
  1106.                                 // normal
  1107.                                 ch.CALC_FCSLOT(slot);
  1108.                         }
  1109.                         break;
  1110.                 }
  1111.                 default:
  1112.                         // normal
  1113.                         ch.CALC_FCSLOT(slot);
  1114.                         break;
  1115.                 }
  1116.         } else {
  1117.                 // in OPL2 mode
  1118.                 ch.CALC_FCSLOT(slot);
  1119.         }
  1120. }
  1121.  
  1122. // set ksl & tl
  1123. void YMF262::set_ksl_tl(u8 sl, u8 v)
  1124. {
  1125.         int chan_no = sl/2;
  1126.         YMF262Channel &ch = channels[chan_no];
  1127.         YMF262Slot &slot = ch.slots[sl & 1];
  1128.  
  1129.         int ksl = v >> 6; // 0 / 1.5 / 3.0 / 6.0 dB/OCT
  1130.  
  1131.         slot.ksl = ksl ? 3 - ksl : 31;
  1132.         slot.TL  = (v & 0x3F) << (ENV_BITS - 1 - 7); // 7 bits TL (bit 6 = always 0)
  1133.  
  1134.         if (OPL3_mode) {
  1135.  
  1136.                 // in OPL3 mode
  1137.                 //DO THIS:
  1138.                 //if this is one of the slots of 1st channel forming up a 4-op channel
  1139.                 //do normal operation
  1140.                 //else normal 2 operator function
  1141.                 //OR THIS:
  1142.                 //if this is one of the slots of 2nd channel forming up a 4-op channel
  1143.                 //update it using channel data of 1st channel of a pair
  1144.                 //else normal 2 operator function
  1145.                 switch(chan_no) {
  1146.                 case 0: case 1: case 2:
  1147.                 case 9: case 10: case 11:
  1148.                         if (ch.extended) {
  1149.                                 // normal
  1150.                                 slot.TLL = slot.TL + (ch.ksl_base >> slot.ksl);
  1151.                         } else {
  1152.                                 // normal
  1153.                                 slot.TLL = slot.TL + (ch.ksl_base >> slot.ksl);
  1154.                         }
  1155.                         break;
  1156.                 case 3: case 4: case 5:
  1157.                 case 12: case 13: case 14: {
  1158.                         YMF262Channel &ch3 = channels[chan_no - 3];
  1159.                         if (ch3.extended) {
  1160.                                 // update this slot using frequency data for 1st channel of a pair
  1161.                                 slot.TLL = slot.TL + (ch3.ksl_base >> slot.ksl);
  1162.                         } else {
  1163.                                 // normal
  1164.                                 slot.TLL = slot.TL + (ch.ksl_base >> slot.ksl);
  1165.                         }
  1166.                         break;
  1167.                 }
  1168.                 default:
  1169.                         // normal
  1170.                         slot.TLL = slot.TL + (ch.ksl_base >> slot.ksl);
  1171.                         break;
  1172.                 }
  1173.         } else {
  1174.                 // in OPL2 mode
  1175.                 slot.TLL = slot.TL + (ch.ksl_base >> slot.ksl);
  1176.         }
  1177. }
  1178.  
  1179. // set attack rate & decay rate  
  1180. void YMF262::set_ar_dr(u8 sl, u8 v)
  1181. {
  1182.         YMF262Channel &ch = channels[sl / 2];
  1183.         YMF262Slot &slot = ch.slots[sl & 1];
  1184.  
  1185.         slot.ar = (v >> 4) ? 16 + ((v >> 4) << 2) : 0;
  1186.  
  1187.         if ((slot.ar + slot.ksr) < 16 + 60) {
  1188.                 // verified on real YMF262 - all 15 x rates take "zero" time
  1189.                 slot.eg_sh_ar  = eg_rate_shift [slot.ar + slot.ksr];
  1190.                 slot.eg_m_ar   = (1 << slot.eg_sh_ar) - 1;
  1191.                 slot.eg_sel_ar = eg_rate_select[slot.ar + slot.ksr];
  1192.         } else {
  1193.                 slot.eg_sh_ar  = 0;
  1194.                 slot.eg_m_ar   = (1 << slot.eg_sh_ar) - 1;
  1195.                 slot.eg_sel_ar = 13 * RATE_STEPS;
  1196.         }
  1197.  
  1198.         slot.dr    = (v & 0x0F) ? 16 + ((v & 0x0F) << 2) : 0;
  1199.         slot.eg_sh_dr  = eg_rate_shift [slot.dr + slot.ksr];
  1200.         slot.eg_m_dr   = (1 << slot.eg_sh_dr) - 1;
  1201.         slot.eg_sel_dr = eg_rate_select[slot.dr + slot.ksr];
  1202. }
  1203.  
  1204. // set sustain level & release rate
  1205. void YMF262::set_sl_rr(u8 sl, u8 v)
  1206. {
  1207.         YMF262Channel &ch = channels[sl / 2];
  1208.         YMF262Slot &slot = ch.slots[sl & 1];
  1209.  
  1210.         slot.sl  = sl_tab[v >> 4];
  1211.         slot.rr  = (v & 0x0F) ? 16 + ((v & 0x0F) << 2) : 0;
  1212.         slot.eg_sh_rr  = eg_rate_shift [slot.rr + slot.ksr];
  1213.         slot.eg_m_rr   = (1 << slot.eg_sh_rr) - 1;
  1214.         slot.eg_sel_rr = eg_rate_select[slot.rr + slot.ksr];
  1215. }
  1216.  
  1217. void YMF262::update_channels(YMF262Channel &ch)
  1218. {
  1219.         // update channel passed as a parameter and a channel at CH+=3;
  1220.         if (ch.extended) {
  1221.                 // we've just switched to combined 4 operator mode
  1222.         } else {
  1223.                 // we've just switched to normal 2 operator mode
  1224.         }
  1225. }
  1226.  
  1227. u8 YMF262::peekReg(int r)
  1228. {
  1229.         return reg[r];
  1230. }
  1231.  
  1232. u8 YMF262::readReg(int r)
  1233. {
  1234.         return reg[r];
  1235. }
  1236.  
  1237. void YMF262::writeReg(int r, u8 v, const EmuTime &time)
  1238. {
  1239.         if (!OPL3_mode && (r != 0x105)) {
  1240.                 // in OPL2 mode the only accessible in set #2 is register 0x05
  1241.                 r &= ~0x100;
  1242.         }
  1243.         writeRegForce(r, v, time);
  1244.         checkMute();
  1245. }
  1246. void YMF262::writeRegForce(int r, u8 v, const EmuTime &time)
  1247. {
  1248.         reg[r] = v;
  1249.  
  1250.         u8 ch_offset = 0;
  1251.         if (r & 0x100) {
  1252.                 switch(r) {
  1253.                 case 0x101:     // test register
  1254.                         return;
  1255.                
  1256.                 case 0x104: { // 6 channels enable
  1257.                         YMF262Channel &ch0 = channels[0];
  1258.                         u8 prev = ch0.extended;
  1259.                         ch0.extended = (v >> 0) & 1;
  1260.                         if (prev != ch0.extended) {
  1261.                                 update_channels(ch0);
  1262.                         }
  1263.                         YMF262Channel &ch1 = channels[1];
  1264.                         prev = ch1.extended;
  1265.                         ch1.extended = (v >> 1) & 1;
  1266.                         if (prev != ch1.extended) {
  1267.                                 update_channels(ch1);
  1268.                         }
  1269.                         YMF262Channel &ch2 = channels[2];
  1270.                         prev = ch2.extended;
  1271.                         ch2.extended = (v >> 2) & 1;
  1272.                         if (prev != ch2.extended) {
  1273.                                 update_channels(ch2);
  1274.                         }
  1275.                         YMF262Channel &ch9 = channels[9];
  1276.                         prev = ch9.extended;
  1277.                         ch9.extended = (v >> 3) & 1;
  1278.                         if (prev != ch9.extended) {
  1279.                                 update_channels(ch9);
  1280.                         }
  1281.                         YMF262Channel &ch10 = channels[10];
  1282.                         prev = ch10.extended;
  1283.                         ch10.extended = (v >> 4) & 1;
  1284.                         if (prev != ch10.extended) {
  1285.                                 update_channels(ch10);
  1286.                         }
  1287.                         YMF262Channel &ch11 = channels[11];
  1288.                         prev = ch11.extended;
  1289.                         ch11.extended = (v >> 5) & 1;
  1290.                         if (prev != ch11.extended) {
  1291.                                 update_channels(ch11);
  1292.                         }
  1293.                         return;
  1294.                 }
  1295.                 case 0x105:     // OPL3 extensions enable register
  1296.                         // OPL3 mode when bit0=1 otherwise it is OPL2 mode
  1297.                         OPL3_mode = v & 0x01;
  1298.                         if (OPL3_mode) {
  1299.                                 status2 = 0x02;
  1300.                         }
  1301.                        
  1302.                         // following behaviour was tested on real YMF262,
  1303.                         // switching OPL3/OPL2 modes on the fly:
  1304.                         //  - does not change the waveform previously selected
  1305.                         //    (unless when ....)
  1306.                         //  - does not update CH.A, CH.B, CH.C and CH.D output
  1307.                         //    selectors (registers c0-c8) (unless when ....)
  1308.                         //  - does not disable channels 9-17 on OPL3->OPL2 switch
  1309.                         //  - does not switch 4 operator channels back to 2
  1310.                         //    operator channels
  1311.                         return;
  1312.  
  1313.                 default:
  1314.                         break;
  1315.                 }
  1316.                 ch_offset = 9;  // register page #2 starts from channel 9
  1317.         }
  1318.  
  1319.         r &= 0xFF;
  1320.         switch(r & 0xE0) {
  1321.         case 0x00: // 00-1F:control
  1322.                 switch(r & 0x1F) {
  1323.                 case 0x01: // test register
  1324.                         break;
  1325.                        
  1326.                 case 0x02: // Timer 1
  1327.                         timer1.setValue(v);
  1328.                         break;
  1329.  
  1330.                 case 0x03: // Timer 2
  1331.                         timer2.setValue(v);
  1332.                         break;
  1333.  
  1334.                 case 0x04: // IRQ clear / mask and Timer enable
  1335.                         if (v & 0x80) {
  1336.                                 // IRQ flags clear
  1337.                                 resetStatus(0x60);
  1338.                                 timer1.resetFlags();
  1339.                                 timer2.resetFlags();
  1340.                         } else {
  1341.                                 changeStatusMask((~v) & 0x60);
  1342.                                 timer1.setStart((v & R04_ST1) != 0, time);
  1343.                                 timer2.setStart((v & R04_ST2) != 0, time);
  1344.                         }
  1345.                         break;
  1346.                        
  1347.                 case 0x08: // x,NTS,x,x, x,x,x,x
  1348.                         nts = v;
  1349.                         break;
  1350.                        
  1351.                 default:
  1352.                         break;
  1353.                 }
  1354.                 break;
  1355.        
  1356.         case 0x20: { // am ON, vib ON, ksr, eg_type, mul
  1357.                 int slot = slot_array[r & 0x1F];
  1358.                 if (slot < 0) return;
  1359.                 set_mul(slot + ch_offset * 2, v);
  1360.                 break;
  1361.         }
  1362.         case 0x40: {
  1363.                 int slot = slot_array[r & 0x1F];
  1364.                 if (slot < 0) return;
  1365.                 set_ksl_tl(slot + ch_offset * 2, v);
  1366.                 break;
  1367.         }
  1368.         case 0x60: {
  1369.                 int slot = slot_array[r & 0x1F];
  1370.                 if (slot < 0) return;
  1371.                 set_ar_dr(slot + ch_offset * 2, v);
  1372.                 break;
  1373.         }
  1374.         case 0x80: {
  1375.                 int slot = slot_array[r & 0x1F];
  1376.                 if (slot < 0) return;
  1377.                 set_sl_rr(slot + ch_offset * 2, v);
  1378.                 break;
  1379.         }
  1380.         case 0xA0: {
  1381.                 if (r == 0xBD) {
  1382.                         // am depth, vibrato depth, r,bd,sd,tom,tc,hh
  1383.                         if (ch_offset != 0) {
  1384.                                 // 0xbd register is present in set #1 only
  1385.                                 return;
  1386.                         }
  1387.                         lfo_am_depth = v & 0x80;
  1388.                         lfo_pm_depth_range = (v & 0x40) ? 8 : 0;
  1389.                         rhythm = v & 0x3F;
  1390.  
  1391.                         if (rhythm & 0x20) {
  1392.                                 // BD key on/off
  1393.                                 if (v & 0x10) {
  1394.                                         channels[6].slots[SLOT1].FM_KEYON ( 2);
  1395.                                         channels[6].slots[SLOT2].FM_KEYON ( 2);
  1396.                                 } else {
  1397.                                         channels[6].slots[SLOT1].FM_KEYOFF(~2);
  1398.                                         channels[6].slots[SLOT2].FM_KEYOFF(~2);
  1399.                                 }
  1400.                                 // HH key on/off
  1401.                                 if (v & 0x01) {
  1402.                                         channels[7].slots[SLOT1].FM_KEYON ( 2);
  1403.                                 } else {
  1404.                                         channels[7].slots[SLOT1].FM_KEYOFF(~2);
  1405.                                 }
  1406.                                 // SD key on/off
  1407.                                 if (v & 0x08) {
  1408.                                         channels[7].slots[SLOT2].FM_KEYON ( 2);
  1409.                                 } else {
  1410.                                         channels[7].slots[SLOT2].FM_KEYOFF(~2);
  1411.                                 }
  1412.                                 // TOM key on/off
  1413.                                 if (v & 0x04) {
  1414.                                         channels[8].slots[SLOT1].FM_KEYON ( 2);
  1415.                                 } else {
  1416.                                         channels[8].slots[SLOT1].FM_KEYOFF(~2);
  1417.                                 }
  1418.                                 // TOP-CY key on/off
  1419.                                 if (v & 0x02) {
  1420.                                         channels[8].slots[SLOT2].FM_KEYON ( 2);
  1421.                                 } else {
  1422.                                         channels[8].slots[SLOT2].FM_KEYOFF(~2);
  1423.                                 }
  1424.                         } else {
  1425.                                 // BD key off
  1426.                                 channels[6].slots[SLOT1].FM_KEYOFF(~2);
  1427.                                 channels[6].slots[SLOT2].FM_KEYOFF(~2);
  1428.                                 // HH key off
  1429.                                 channels[7].slots[SLOT1].FM_KEYOFF(~2);
  1430.                                 // SD key off
  1431.                                 channels[7].slots[SLOT2].FM_KEYOFF(~2);
  1432.                                 // TOM key off
  1433.                                 channels[8].slots[SLOT1].FM_KEYOFF(~2);
  1434.                                 // TOP-CY off
  1435.                                 channels[8].slots[SLOT2].FM_KEYOFF(~2);
  1436.                         }
  1437.                         return;
  1438.                 }
  1439.  
  1440.                 // keyon,block,fnum
  1441.                 if ((r & 0x0F) > 8) {
  1442.                         return;
  1443.                 }
  1444.                 int chan_no = (r & 0x0F) + ch_offset;
  1445.                 YMF262Channel &ch  = channels[chan_no];
  1446.                 YMF262Channel &ch3 = channels[chan_no + 3];
  1447.                 int block_fnum;
  1448.                 if (!(r & 0x10)) {
  1449.                         // a0-a8
  1450.                         block_fnum  = (ch.block_fnum&0x1F00) | v;
  1451.                 } else {
  1452.                         // b0-b8
  1453.                         block_fnum = ((v & 0x1F) << 8) | (ch.block_fnum & 0xFF);
  1454.                         if (OPL3_mode) {
  1455.                                 // in OPL3 mode
  1456.                                 // DO THIS:
  1457.                                 // if this is 1st channel forming up a 4-op channel
  1458.                                 // ALSO keyon/off slots of 2nd channel forming up 4-op channel
  1459.                                 // else normal 2 operator function keyon/off
  1460.                                 // OR THIS:
  1461.                                 // if this is 2nd channel forming up 4-op channel just do nothing
  1462.                                 // else normal 2 operator function keyon/off
  1463.                                 switch(chan_no) {
  1464.                                 case 0: case 1: case 2:
  1465.                                 case 9: case 10: case 11:
  1466.                                         if (ch.extended) {
  1467.                                                 //if this is 1st channel forming up a 4-op channel
  1468.                                                 //ALSO keyon/off slots of 2nd channel forming up 4-op channel
  1469.                                                 if (v & 0x20) {
  1470.                                                         ch.slots[SLOT1].FM_KEYON ( 1);
  1471.                                                         ch.slots[SLOT2].FM_KEYON ( 1);
  1472.                                                         ch3.slots[SLOT1].FM_KEYON( 1);
  1473.                                                         ch3.slots[SLOT2].FM_KEYON( 1);
  1474.                                                 } else {
  1475.                                                         ch.slots[SLOT1].FM_KEYOFF (~1);
  1476.                                                         ch.slots[SLOT2].FM_KEYOFF (~1);
  1477.                                                         ch3.slots[SLOT1].FM_KEYOFF(~1);
  1478.                                                         ch3.slots[SLOT2].FM_KEYOFF(~1);
  1479.                                                 }
  1480.                                         } else {
  1481.                                                 //else normal 2 operator function keyon/off
  1482.                                                 if (v & 0x20) {
  1483.                                                         ch.slots[SLOT1].FM_KEYON ( 1);
  1484.                                                         ch.slots[SLOT2].FM_KEYON ( 1);
  1485.                                                 } else {
  1486.                                                         ch.slots[SLOT1].FM_KEYOFF(~1);
  1487.                                                         ch.slots[SLOT2].FM_KEYOFF(~1);
  1488.                                                 }
  1489.                                         }
  1490.                                         break;
  1491.  
  1492.                                 case 3: case 4: case 5:
  1493.                                 case 12: case 13: case 14: {
  1494.                                         YMF262Channel &ch_3 = channels[chan_no - 3];
  1495.                                         if (ch_3.extended) {
  1496.                                                 //if this is 2nd channel forming up 4-op channel just do nothing
  1497.                                         } else {
  1498.                                                 //else normal 2 operator function keyon/off
  1499.                                                 if (v & 0x20) {
  1500.                                                         ch.slots[SLOT1].FM_KEYON ( 1);
  1501.                                                         ch.slots[SLOT2].FM_KEYON ( 1);
  1502.                                                 } else {
  1503.                                                         ch.slots[SLOT1].FM_KEYOFF(~1);
  1504.                                                         ch.slots[SLOT2].FM_KEYOFF(~1);
  1505.                                                 }
  1506.                                         }
  1507.                                         break;
  1508.                                 }
  1509.                                 default:
  1510.                                         if (v & 0x20) {
  1511.                                                 ch.slots[SLOT1].FM_KEYON ( 1);
  1512.                                                 ch.slots[SLOT2].FM_KEYON ( 1);
  1513.                                         } else {
  1514.                                                 ch.slots[SLOT1].FM_KEYOFF(~1);
  1515.                                                 ch.slots[SLOT2].FM_KEYOFF(~1);
  1516.                                         }
  1517.                                         break;
  1518.                                 }
  1519.                         } else {
  1520.                                 if (v & 0x20) {
  1521.                                         ch.slots[SLOT1].FM_KEYON ( 1);
  1522.                                         ch.slots[SLOT2].FM_KEYON ( 1);
  1523.                                 } else {
  1524.                                         ch.slots[SLOT1].FM_KEYOFF(~1);
  1525.                                         ch.slots[SLOT2].FM_KEYOFF(~1);
  1526.                                 }
  1527.                         }
  1528.                 }
  1529.                 // update
  1530.                 if (ch.block_fnum != block_fnum) {
  1531.                         u8 block  = block_fnum >> 10;
  1532.                         ch.block_fnum = block_fnum;
  1533.                         ch.ksl_base = ksl_tab[block_fnum >> 6];
  1534.                         ch.fc       = fn_tab[block_fnum & 0x03FF] >> (7 - block);
  1535.  
  1536.                         // BLK 2,1,0 bits -> bits 3,2,1 of kcode
  1537.                         ch.kcode = (ch.block_fnum & 0x1C00) >> 9;
  1538.  
  1539.                         // the info below is actually opposite to what is stated
  1540.                         // in the Manuals (verifed on real YMF262)
  1541.                         // if notesel == 0 -> lsb of kcode is bit 10 (MSB) of fnum  
  1542.                         // if notesel == 1 -> lsb of kcode is bit 9 (MSB-1) of fnum
  1543.                         if (nts & 0x40) {
  1544.                                 ch.kcode |= (ch.block_fnum & 0x100) >> 8;       // notesel == 1
  1545.                         } else {
  1546.                                 ch.kcode |= (ch.block_fnum & 0x200) >> 9;       // notesel == 0
  1547.                         }
  1548.                         if (OPL3_mode) {
  1549.                                 int chan_no = (r & 0x0F) + ch_offset;
  1550.                                 // in OPL3 mode
  1551.                                 //DO THIS:
  1552.                                 //if this is 1st channel forming up a 4-op channel
  1553.                                 //ALSO update slots of 2nd channel forming up 4-op channel
  1554.                                 //else normal 2 operator function keyon/off
  1555.                                 //OR THIS:
  1556.                                 //if this is 2nd channel forming up 4-op channel just do nothing
  1557.                                 //else normal 2 operator function keyon/off
  1558.                                 switch(chan_no) {
  1559.                                 case 0: case 1: case 2:
  1560.                                 case 9: case 10: case 11:
  1561.                                         if (ch.extended) {
  1562.                                                 //if this is 1st channel forming up a 4-op channel
  1563.                                                 //ALSO update slots of 2nd channel forming up 4-op channel
  1564.  
  1565.                                                 // refresh Total Level in FOUR SLOTs of this channel and channel+3 using data from THIS channel
  1566.                                                 ch.slots[SLOT1].TLL = ch.slots[SLOT1].TL + (ch.ksl_base >> ch.slots[SLOT1].ksl);
  1567.                                                 ch.slots[SLOT2].TLL = ch.slots[SLOT2].TL + (ch.ksl_base >> ch.slots[SLOT2].ksl);
  1568.                                                 ch3.slots[SLOT1].TLL = ch3.slots[SLOT1].TL + (ch.ksl_base >> ch3.slots[SLOT1].ksl);
  1569.                                                 ch3.slots[SLOT2].TLL = ch3.slots[SLOT2].TL + (ch.ksl_base >> ch3.slots[SLOT2].ksl);
  1570.  
  1571.                                                 // refresh frequency counter in FOUR SLOTs of this channel and channel+3 using data from THIS channel
  1572.                                                 ch.CALC_FCSLOT(ch.slots[SLOT1]);
  1573.                                                 ch.CALC_FCSLOT(ch.slots[SLOT2]);
  1574.                                                 ch.CALC_FCSLOT(ch3.slots[SLOT1]);
  1575.                                                 ch.CALC_FCSLOT(ch3.slots[SLOT2]);
  1576.                                         } else {
  1577.                                                 //else normal 2 operator function
  1578.                                                 // refresh Total Level in both SLOTs of this channel
  1579.                                                 ch.slots[SLOT1].TLL = ch.slots[SLOT1].TL + (ch.ksl_base >> ch.slots[SLOT1].ksl);
  1580.                                                 ch.slots[SLOT2].TLL = ch.slots[SLOT2].TL + (ch.ksl_base >> ch.slots[SLOT2].ksl);
  1581.  
  1582.                                                 // refresh frequency counter in both SLOTs of this channel
  1583.                                                 ch.CALC_FCSLOT(ch.slots[SLOT1]);
  1584.                                                 ch.CALC_FCSLOT(ch.slots[SLOT2]);
  1585.                                         }
  1586.                                         break;
  1587.  
  1588.                                 case 3: case 4: case 5:
  1589.                                 case 12: case 13: case 14: {
  1590.                                         YMF262Channel &ch_3 = channels[chan_no - 3];
  1591.                                         if (ch_3.extended) {
  1592.                                                 //if this is 2nd channel forming up 4-op channel just do nothing
  1593.                                         } else {
  1594.                                                 //else normal 2 operator function
  1595.                                                 // refresh Total Level in both SLOTs of this channel
  1596.                                                 ch.slots[SLOT1].TLL = ch.slots[SLOT1].TL + (ch.ksl_base >> ch.slots[SLOT1].ksl);
  1597.                                                 ch.slots[SLOT2].TLL = ch.slots[SLOT2].TL + (ch.ksl_base >> ch.slots[SLOT2].ksl);
  1598.  
  1599.                                                 // refresh frequency counter in both SLOTs of this channel
  1600.                                                 ch.CALC_FCSLOT(ch.slots[SLOT1]);
  1601.                                                 ch.CALC_FCSLOT(ch.slots[SLOT2]);
  1602.                                         }
  1603.                                         break;
  1604.                                 }
  1605.                                 default:
  1606.                                         // refresh Total Level in both SLOTs of this channel
  1607.                                         ch.slots[SLOT1].TLL = ch.slots[SLOT1].TL + (ch.ksl_base >> ch.slots[SLOT1].ksl);
  1608.                                         ch.slots[SLOT2].TLL = ch.slots[SLOT2].TL + (ch.ksl_base >> ch.slots[SLOT2].ksl);
  1609.  
  1610.                                         // refresh frequency counter in both SLOTs of this channel
  1611.                                         ch.CALC_FCSLOT(ch.slots[SLOT1]);
  1612.                                         ch.CALC_FCSLOT(ch.slots[SLOT2]);
  1613.                                         break;
  1614.                                 }
  1615.                         } else {
  1616.                                 // in OPL2 mode
  1617.                                 // refresh Total Level in both SLOTs of this channel
  1618.                                 ch.slots[SLOT1].TLL = ch.slots[SLOT1].TL + (ch.ksl_base >> ch.slots[SLOT1].ksl);
  1619.                                 ch.slots[SLOT2].TLL = ch.slots[SLOT2].TL + (ch.ksl_base >> ch.slots[SLOT2].ksl);
  1620.  
  1621.                                 // refresh frequency counter in both SLOTs of this channel
  1622.                                 ch.CALC_FCSLOT(ch.slots[SLOT1]);
  1623.                                 ch.CALC_FCSLOT(ch.slots[SLOT2]);
  1624.                         }
  1625.                 }
  1626.                 break;
  1627.         }
  1628.         case 0xC0: {
  1629.                 // CH.D, CH.C, CH.B, CH.A, FB(3bits), C
  1630.                 if ((r & 0xF) > 8) {
  1631.                         return;
  1632.                 }
  1633.                 int chan_no = (r & 0x0F) + ch_offset;
  1634.                 YMF262Channel &ch = channels[chan_no];
  1635.  
  1636.                 int base = chan_no * 4;
  1637.                 if (OPL3_mode) {
  1638.                         // OPL3 mode
  1639.                         pan[base + 0] = (v & 0x10) ? ~0 : 0;    // ch.A
  1640.                         pan[base + 1] = (v & 0x20) ? ~0 : 0;    // ch.B
  1641.                         pan[base + 2] = (v & 0x40) ? ~0 : 0;    // ch.C
  1642.                         pan[base + 3] = (v & 0x80) ? ~0 : 0;    // ch.D
  1643.                 } else {
  1644.                         // OPL2 mode - always enabled
  1645.                         pan[base + 0] = ~0;     // ch.A
  1646.                         pan[base + 1] = ~0;     // ch.B
  1647.                         pan[base + 2] = ~0;     // ch.C
  1648.                         pan[base + 3] = ~0;     // ch.D
  1649.                 }
  1650.  
  1651.                 ch.slots[SLOT1].FB  = (v >> 1) & 7 ? ((v >> 1) & 7) + 7 : 0;
  1652.                 ch.slots[SLOT1].CON = v & 1;
  1653.  
  1654.                 if (OPL3_mode) {
  1655.                         switch(chan_no) {
  1656.                         case 0: case 1: case 2:
  1657.                         case 9: case 10: case 11:
  1658.                                 if (ch.extended) {
  1659.                                         YMF262Channel &ch3 = channels[chan_no + 3];
  1660.                                         u8 conn = (ch.slots[SLOT1].CON << 1) || (ch3.slots[SLOT1].CON);
  1661.                                         switch(conn) {
  1662.                                         case 0:
  1663.                                                 // 1 -> 2 -> 3 -> 4 - out
  1664.                                                 ch.slots[SLOT1].connect = PHASE_MOD1;
  1665.                                                 ch.slots[SLOT2].connect = PHASE_MOD2;
  1666.                                                 ch3.slots[SLOT1].connect = PHASE_MOD1;
  1667.                                                 ch3.slots[SLOT2].connect = chan_no + 3;
  1668.                                                 break;
  1669.                                                
  1670.                                         case 1:
  1671.                                                 // 1 -> 2 -\.
  1672.                                                 // 3 -> 4 -+- out
  1673.                                                 ch.slots[SLOT1].connect = PHASE_MOD1;
  1674.                                                 ch.slots[SLOT2].connect = chan_no;
  1675.                                                 ch3.slots[SLOT1].connect = PHASE_MOD1;
  1676.                                                 ch3.slots[SLOT2].connect = chan_no + 3;
  1677.                                                 break;
  1678.                                                
  1679.                                         case 2:
  1680.                                                 // 1 -----------\.
  1681.                                                 // 2 -> 3 -> 4 -+- out
  1682.                                                 ch.slots[SLOT1].connect = chan_no;
  1683.                                                 ch.slots[SLOT2].connect = PHASE_MOD2;
  1684.                                                 ch3.slots[SLOT1].connect = PHASE_MOD1;
  1685.                                                 ch3.slots[SLOT2].connect = chan_no + 3;
  1686.                                                 break;
  1687.  
  1688.                                         case 3:
  1689.                                                 // 1 ------\.
  1690.                                                 // 2 -> 3 -+- out
  1691.                                                 // 4 ------/    
  1692.                                                 ch.slots[SLOT1].connect = chan_no;
  1693.                                                 ch.slots[SLOT2].connect = PHASE_MOD2;
  1694.                                                 ch3.slots[SLOT1].connect = chan_no + 3;
  1695.                                                 ch3.slots[SLOT2].connect = chan_no + 3;
  1696.                                                 break;
  1697.                                         }
  1698.                                 } else {
  1699.                                         // 2 operators mode
  1700.                                         ch.slots[SLOT1].connect = ch.slots[SLOT1].CON ? chan_no : PHASE_MOD1;
  1701.                                         ch.slots[SLOT2].connect = chan_no;
  1702.                                 }
  1703.                                 break;
  1704.  
  1705.                         case 3: case 4: case 5:
  1706.                         case 12: case 13: case 14: {
  1707.                                 YMF262Channel &ch3 = channels[chan_no - 3];
  1708.                                 if (ch3.extended) {
  1709.                                         u8 conn = (ch3.slots[SLOT1].CON << 1) || (ch.slots[SLOT1].CON);
  1710.                                         switch(conn) {
  1711.                                         case 0:
  1712.                                                 // 1 -> 2 -> 3 -> 4 - out
  1713.                                                 ch3.slots[SLOT1].connect = PHASE_MOD1;
  1714.                                                 ch3.slots[SLOT2].connect = PHASE_MOD2;
  1715.                                                 ch.slots[SLOT1].connect = PHASE_MOD1;
  1716.                                                 ch.slots[SLOT2].connect = chan_no;
  1717.                                                 break;
  1718.  
  1719.                                         case 1:
  1720.                                                 // 1 -> 2 -\.
  1721.                                                 // 3 -> 4 -+- out
  1722.                                                 ch3.slots[SLOT1].connect = PHASE_MOD1;
  1723.                                                 ch3.slots[SLOT2].connect = chan_no - 3;
  1724.                                                 ch.slots[SLOT1].connect = PHASE_MOD1;
  1725.                                                 ch.slots[SLOT2].connect = chan_no;
  1726.                                                 break;
  1727.                                                
  1728.                                         case 2:
  1729.                                                 // 1 -----------\.
  1730.                                                 // 2 -> 3 -> 4 -+- out
  1731.                                                 ch3.slots[SLOT1].connect = chan_no - 3;
  1732.                                                 ch3.slots[SLOT2].connect = PHASE_MOD2;
  1733.                                                 ch.slots[SLOT1].connect = PHASE_MOD1;
  1734.                                                 ch.slots[SLOT2].connect = chan_no;
  1735.                                                 break;
  1736.                                                
  1737.                                         case 3:
  1738.                                                 // 1 ------\.
  1739.                                                 // 2 -> 3 -+- out
  1740.                                                 // 4 ------/    
  1741.                                                 ch3.slots[SLOT1].connect = chan_no - 3;
  1742.                                                 ch3.slots[SLOT2].connect = PHASE_MOD2;
  1743.                                                 ch.slots[SLOT1].connect = chan_no;
  1744.                                                 ch.slots[SLOT2].connect = chan_no;
  1745.                                                 break;
  1746.                                         }
  1747.                                 } else {
  1748.                                         // 2 operators mode
  1749.                                         ch.slots[SLOT1].connect = ch.slots[SLOT1].CON ? chan_no : PHASE_MOD1;
  1750.                                         ch.slots[SLOT2].connect = chan_no;
  1751.                                 }
  1752.                                 break;
  1753.                         }
  1754.                         default:
  1755.                                 // 2 operators mode
  1756.                                 ch.slots[SLOT1].connect = ch.slots[SLOT1].CON ? chan_no : PHASE_MOD1;
  1757.                                 ch.slots[SLOT2].connect = chan_no;
  1758.                                 break;
  1759.                         }
  1760.                 } else {
  1761.                         // OPL2 mode - always 2 operators mode
  1762.                         ch.slots[SLOT1].connect = ch.slots[SLOT1].CON ? chan_no : PHASE_MOD1;
  1763.                         ch.slots[SLOT2].connect = chan_no;
  1764.                 }
  1765.                 break;
  1766.         }
  1767.         case 0xE0: {
  1768.                 // waveform select
  1769.                 int slot = slot_array[r & 0x1f];
  1770.                 if (slot < 0) return;
  1771.                 slot += ch_offset * 2;
  1772.                 YMF262Channel &ch = channels[slot / 2];
  1773.  
  1774.                 // store 3-bit value written regardless of current OPL2 or OPL3
  1775.                 // mode... (verified on real YMF262)
  1776.                 v &= 7;
  1777.                 ch.slots[slot & 1].waveform_number = v;
  1778.                 // ... but select only waveforms 0-3 in OPL2 mode
  1779.                 if (!OPL3_mode) {
  1780.                         v &= 3;
  1781.                 }
  1782.                 ch.slots[slot & 1].wavetable = v * SIN_LEN;
  1783.                 break;
  1784.         }
  1785.         }
  1786. }
  1787.  
  1788.  
  1789. void YMF262::reset(const EmuTime &time, unsigned tStatesPerSecond)
  1790. {
  1791.         timer1.init(tStatesPerSecond);
  1792.         timer2.init(tStatesPerSecond);
  1793.  
  1794.         eg_timer = 0;
  1795.         eg_cnt   = 0;
  1796.  
  1797.         noise_rng = 1;  // noise shift register
  1798.         nts       = 0;  // note split
  1799.         resetStatus(0x60);
  1800.  
  1801.         // reset with register write
  1802.         writeRegForce(0x01, 0, time); // test register
  1803.         writeRegForce(0x02, 0, time); // Timer1
  1804.         writeRegForce(0x03, 0, time); // Timer2
  1805.         writeRegForce(0x04, 0, time); // IRQ mask clear
  1806.  
  1807.         //FIX IT  registers 101, 104 and 105
  1808.         //FIX IT (dont change CH.D, CH.C, CH.B and CH.A in C0-C8 registers)
  1809.     int c;
  1810.         for (c = 0xFF; c >= 0x20; c--) {
  1811.                 writeRegForce(c, 0, time);
  1812.         }
  1813.         //FIX IT (dont change CH.D, CH.C, CH.B and CH.A in C0-C8 registers)
  1814.         for (c = 0x1FF; c >= 0x120; c--) {
  1815.                 writeRegForce(c, 0, time);
  1816.         }
  1817.  
  1818.         // reset operator parameters
  1819.         for (c = 0; c < 9 * 2; c++) {
  1820.                 YMF262Channel &ch = channels[c];
  1821.                 for (int s = 0; s < 2; s++) {
  1822.                         ch.slots[s].state  = EG_OFF;
  1823.                         ch.slots[s].volume = MAX_ATT_INDEX;
  1824.                 }
  1825.         }
  1826.         setInternalMute(true);
  1827. }
  1828.  
  1829. YMF262::YMF262(short volume, const EmuTime &time)
  1830. {
  1831.     chanOut = chanout;
  1832.  
  1833.         LFO_AM = LFO_PM = 0;
  1834.         lfo_am_depth = lfo_pm_depth_range = lfo_am_cnt = lfo_pm_cnt = 0;
  1835.         noise_rng = noise_p = 0;
  1836.         rhythm = nts = 0;
  1837.         OPL3_mode = false;
  1838.         status = status2 = statusMask = 0;
  1839.        
  1840.     oplOversampling = 1;
  1841.  
  1842.         init_tables();
  1843.  
  1844.         reset(time, 0);
  1845. }
  1846.  
  1847. YMF262::~YMF262()
  1848. {
  1849. }
  1850.  
  1851. u8 YMF262::peekStatus(const EmuTime& time)
  1852. {
  1853.         return status | status2 | timer1.poll(time) | timer2.poll(time);
  1854. }
  1855.  
  1856. u8 YMF262::readStatus(const EmuTime& time)
  1857. {
  1858.         u8 result = peekStatus(time);
  1859.         status2 = 0;
  1860.         return result;
  1861. }
  1862.  
  1863. void YMF262::checkMute()
  1864. {
  1865.         bool mute = checkMuteHelper();
  1866.         //PRT_DEBUG("YMF262: muted " << mute);
  1867.         setInternalMute(mute);
  1868. }
  1869. bool YMF262::checkMuteHelper()
  1870. {
  1871.         // TODO this doesn't always mute when possible
  1872.         for (int i = 0; i < 18; i++) {
  1873.                 for (int j = 0; j < 2; j++) {
  1874.                         YMF262Slot &sl = channels[i].slots[j];
  1875.                         if (!((sl.state == EG_OFF) ||
  1876.                               ((sl.state == EG_REL) &&
  1877.                                ((sl.TLL + sl.volume) >= ENV_QUIET)))) {
  1878.                                 return false;
  1879.                         }
  1880.                 }
  1881.         }
  1882.         return true;
  1883. }
  1884.  
  1885. int* YMF262::updateBuffer(int length)
  1886. {
  1887.         if (isInternalMuted()) {
  1888.                 return NULL;
  1889.         }
  1890.        
  1891.         bool rhythmEnabled = (rhythm & 0x20) != 0;
  1892.  
  1893.         int* buf = buffer;
  1894.         while (length--) {
  1895.                 int a = 0;
  1896.                 int b = 0;
  1897.                 int c = 0;
  1898.                 int d = 0;
  1899.         int count = oplOversampling;
  1900.         while (count--) {
  1901.                     advance_lfo();
  1902.  
  1903.                     // clear channel outputs
  1904.                     memset(chanout, 0, sizeof(int) * 18);
  1905.  
  1906.                     // register set #1
  1907.                     // extended 4op ch#0 part 1 or 2op ch#0
  1908.                     channels[0].chan_calc(LFO_AM);
  1909.                     if (channels[0].extended) {
  1910.                             // extended 4op ch#0 part 2
  1911.                             channels[3].chan_calc_ext(LFO_AM);
  1912.                     } else {
  1913.                             // standard 2op ch#3
  1914.                             channels[3].chan_calc(LFO_AM);
  1915.                     }
  1916.  
  1917.                     // extended 4op ch#1 part 1 or 2op ch#1
  1918.                     channels[1].chan_calc(LFO_AM);
  1919.                     if (channels[1].extended) {
  1920.                             // extended 4op ch#1 part 2
  1921.                             channels[5].chan_calc_ext(LFO_AM);
  1922.                     } else {
  1923.                             // standard 2op ch#4
  1924.                             channels[4].chan_calc(LFO_AM);
  1925.                     }
  1926.  
  1927.                     // extended 4op ch#2 part 1 or 2op ch#2
  1928.                     channels[2].chan_calc(LFO_AM);
  1929.                     if (channels[2].extended) {
  1930.                             // extended 4op ch#2 part 2
  1931.                             channels[5].chan_calc_ext(LFO_AM);
  1932.                     } else {
  1933.                             // standard 2op ch#5
  1934.                             channels[5].chan_calc(LFO_AM);
  1935.                     }
  1936.  
  1937.                     if (!rhythmEnabled) {
  1938.                             channels[6].chan_calc(LFO_AM);
  1939.                             channels[7].chan_calc(LFO_AM);
  1940.                             channels[8].chan_calc(LFO_AM);
  1941.                     } else {
  1942.                             // Rhythm part
  1943.                             chan_calc_rhythm(noise_rng & 1);
  1944.                     }
  1945.  
  1946.                     // register set #2
  1947.                     channels[9].chan_calc(LFO_AM);
  1948.                     if (channels[9].extended) {
  1949.                             channels[12].chan_calc_ext(LFO_AM);
  1950.                     } else {
  1951.                             channels[12].chan_calc(LFO_AM);
  1952.                     }
  1953.  
  1954.                     channels[10].chan_calc(LFO_AM);
  1955.                     if (channels[10].extended) {
  1956.                             channels[13].chan_calc_ext(LFO_AM);
  1957.                     } else {
  1958.                             channels[13].chan_calc(LFO_AM);
  1959.                     }
  1960.  
  1961.                     channels[11].chan_calc(LFO_AM);
  1962.                     if (channels[11].extended) {
  1963.                             channels[14].chan_calc_ext(LFO_AM);
  1964.                     } else {
  1965.                             channels[14].chan_calc(LFO_AM);
  1966.                     }
  1967.  
  1968.                     // channels 15,16,17 are fixed 2-operator channels only
  1969.                     channels[15].chan_calc(LFO_AM);
  1970.                     channels[16].chan_calc(LFO_AM);
  1971.                     channels[17].chan_calc(LFO_AM);
  1972.  
  1973.                     for (int i = 0; i < 18; i++) {
  1974.                             a += chanout[i] & pan[4 * i + 0];
  1975.                             b += chanout[i] & pan[4 * i + 1];
  1976.                             c += chanout[i] & pan[4 * i + 2];
  1977.                             d += chanout[i] & pan[4 * i + 3];
  1978.                     }
  1979.                     advance();
  1980.         }
  1981.                 *(buf++) = (a << 3) / oplOversampling;
  1982.                 *(buf++) = (b << 3) / oplOversampling;
  1983.         }
  1984.  
  1985.         checkMute();
  1986.         return buffer;
  1987. }
  1988.  
  1989. void YMF262::setInternalVolume(short newVolume)
  1990. {
  1991.         maxVolume = newVolume;
  1992. }
  1993.