Subversion Repositories pentevo

Rev

Rev 1134 | 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: OpenMsxYMF278.cpp,v 1.3 2005/09/24 00:09:50 dvik Exp $
  5.  
  6. #include "../std.h"
  7.  
  8. #include "ymf278.h"
  9. #include <cmath>
  10.  
  11. const int EG_SH = 16;   // 16.16 fixed point (EG timing)
  12. const unsigned int EG_TIMER_OVERFLOW = 1 << EG_SH;
  13.  
  14. // envelope output entries
  15. const int ENV_BITS      = 10;
  16. const int ENV_LEN       = 1 << ENV_BITS;
  17. const double ENV_STEP   = 128.0 / ENV_LEN;
  18. const int MAX_ATT_INDEX = (1 << (ENV_BITS - 1)) - 1; //511
  19. const int MIN_ATT_INDEX = 0;
  20.  
  21. // Envelope Generator phases
  22. const int EG_ATT = 4;
  23. const int EG_DEC = 3;
  24. const int EG_SUS = 2;
  25. const int EG_REL = 1;
  26. const int EG_OFF = 0;
  27.  
  28. const int EG_REV = 5;   //pseudo reverb
  29. const int EG_DMP = 6;   //damp
  30.  
  31. // Pan values, units are -3dB, i.e. 8.
  32. const int pan_left[16]  = {
  33.         0, 8, 16, 24, 32, 40, 48, 256, 256,   0,  0,  0,  0,  0,  0, 0
  34. };
  35. const int pan_right[16] = {
  36.         0, 0,  0,  0,  0,  0,  0,   0, 256, 256, 48, 40, 32, 24, 16, 8
  37. };
  38.  
  39. // Mixing levels, units are -3dB, and add some marging to avoid clipping
  40. const int mix_level[8] = {
  41.         8, 16, 24, 32, 40, 48, 56, 256
  42. };
  43.  
  44. // decay level table (3dB per step)
  45. // 0 - 15: 0, 3, 6, 9,12,15,18,21,24,27,30,33,36,39,42,93 (dB)
  46. #define SC(db) (unsigned int)(db * (2.0 / ENV_STEP))
  47. const unsigned int dl_tab[16] = {
  48.  SC( 0), SC( 1), SC( 2), SC(3 ), SC(4 ), SC(5 ), SC(6 ), SC( 7),
  49.  SC( 8), SC( 9), SC(10), SC(11), SC(12), SC(13), SC(14), SC(31)
  50. };
  51. #undef SC
  52.  
  53. const u8 RATE_STEPS = 8;
  54. const u8 eg_inc[15 * RATE_STEPS] = {
  55. //cycle:0 1  2 3  4 5  6 7
  56.         0, 1,  0, 1,  0, 1,  0, 1, //  0  rates 00..12 0 (increment by 0 or 1)
  57.         0, 1,  0, 1,  1, 1,  0, 1, //  1  rates 00..12 1
  58.         0, 1,  1, 1,  0, 1,  1, 1, //  2  rates 00..12 2
  59.         0, 1,  1, 1,  1, 1,  1, 1, //  3  rates 00..12 3
  60.  
  61.         1, 1,  1, 1,  1, 1,  1, 1, //  4  rate 13 0 (increment by 1)
  62.         1, 1,  1, 2,  1, 1,  1, 2, //  5  rate 13 1
  63.         1, 2,  1, 2,  1, 2,  1, 2, //  6  rate 13 2
  64.         1, 2,  2, 2,  1, 2,  2, 2, //  7  rate 13 3
  65.  
  66.         2, 2,  2, 2,  2, 2,  2, 2, //  8  rate 14 0 (increment by 2)
  67.         2, 2,  2, 4,  2, 2,  2, 4, //  9  rate 14 1
  68.         2, 4,  2, 4,  2, 4,  2, 4, // 10  rate 14 2
  69.         2, 4,  4, 4,  2, 4,  4, 4, // 11  rate 14 3
  70.  
  71.         4, 4,  4, 4,  4, 4,  4, 4, // 12  rates 15 0, 15 1, 15 2, 15 3 for decay
  72.         8, 8,  8, 8,  8, 8,  8, 8, // 13  rates 15 0, 15 1, 15 2, 15 3 for attack (zero time)
  73.         0, 0,  0, 0,  0, 0,  0, 0, // 14  infinity rates for attack and decay(s)
  74. };
  75.  
  76. #define O(a) (a * RATE_STEPS)
  77. const u8 eg_rate_select[64] = {
  78.         O( 0),O( 1),O( 2),O( 3),
  79.         O( 0),O( 1),O( 2),O( 3),
  80.         O( 0),O( 1),O( 2),O( 3),
  81.         O( 0),O( 1),O( 2),O( 3),
  82.         O( 0),O( 1),O( 2),O( 3),
  83.         O( 0),O( 1),O( 2),O( 3),
  84.         O( 0),O( 1),O( 2),O( 3),
  85.         O( 0),O( 1),O( 2),O( 3),
  86.         O( 0),O( 1),O( 2),O( 3),
  87.         O( 0),O( 1),O( 2),O( 3),
  88.         O( 0),O( 1),O( 2),O( 3),
  89.         O( 0),O( 1),O( 2),O( 3),
  90.         O( 0),O( 1),O( 2),O( 3),
  91.         O( 4),O( 5),O( 6),O( 7),
  92.         O( 8),O( 9),O(10),O(11),
  93.         O(12),O(12),O(12),O(12),
  94. };
  95. #undef O
  96.  
  97. //rate  0,    1,    2,    3,   4,   5,   6,  7,  8,  9,  10, 11, 12, 13, 14, 15
  98. //shift 12,   11,   10,   9,   8,   7,   6,  5,  4,  3,  2,  1,  0,  0,  0,  0
  99. //mask  4095, 2047, 1023, 511, 255, 127, 63, 31, 15, 7,  3,  1,  0,  0,  0,  0
  100. #define O(a) (a)
  101. const u8 eg_rate_shift[64] = {
  102.         O(12),O(12),O(12),O(12),
  103.         O(11),O(11),O(11),O(11),
  104.         O(10),O(10),O(10),O(10),
  105.         O( 9),O( 9),O( 9),O( 9),
  106.         O( 8),O( 8),O( 8),O( 8),
  107.         O( 7),O( 7),O( 7),O( 7),
  108.         O( 6),O( 6),O( 6),O( 6),
  109.         O( 5),O( 5),O( 5),O( 5),
  110.         O( 4),O( 4),O( 4),O( 4),
  111.         O( 3),O( 3),O( 3),O( 3),
  112.         O( 2),O( 2),O( 2),O( 2),
  113.         O( 1),O( 1),O( 1),O( 1),
  114.         O( 0),O( 0),O( 0),O( 0),
  115.         O( 0),O( 0),O( 0),O( 0),
  116.         O( 0),O( 0),O( 0),O( 0),
  117.         O( 0),O( 0),O( 0),O( 0),
  118. };
  119. #undef O
  120.  
  121.  
  122. //number of steps to take in quarter of lfo frequency
  123. //TODO check if frequency matches real chip
  124. #define O(a) ((int)((EG_TIMER_OVERFLOW / a) / 6))
  125. const int lfo_period[8] = {
  126.         O(0.168), O(2.019), O(3.196), O(4.206),
  127.         O(5.215), O(5.888), O(6.224), O(7.066)
  128. };
  129. #undef O
  130.  
  131.  
  132. #define O(a) ((int)(a * 65536))
  133. const int vib_depth[8] = {
  134.         O(0),      O(3.378),  O(5.065),  O(6.750),
  135.         O(10.114), O(20.170), O(40.106), O(79.307)
  136. };
  137. #undef O
  138.  
  139.  
  140. #define SC(db) (unsigned int) (db * (2.0 / ENV_STEP))
  141. const int am_depth[8] = {
  142.         SC(0),     SC(1.781), SC(2.906), SC(3.656),
  143.         SC(4.406), SC(5.906), SC(7.406), SC(11.91)
  144. };
  145. #undef SC
  146.  
  147.  
  148. YMF278Slot::YMF278Slot()
  149. {
  150.         reset();
  151. }
  152.  
  153. void YMF278Slot::reset()
  154. {
  155.         wave = FN = OCT = PRVB = LD = TL = pan = lfo = vib = AM = 0;
  156.         AR = D1R = DL = D2R = RC = RR = 0;
  157.         step = stepptr = 0;
  158.         bits = startaddr = loopaddr = endaddr = 0;
  159.         env_vol = MAX_ATT_INDEX;
  160.         //env_vol_step = env_vol_lim = 0;
  161.  
  162.         lfo_active = false;
  163.         lfo_cnt = lfo_step = 0;
  164.         lfo_max = lfo_period[0];
  165.  
  166.         state = EG_OFF;
  167.         active = false;
  168. }
  169.  
  170. int YMF278Slot::compute_rate(int val)
  171. {
  172.         if (val == 0) {
  173.                 return 0;
  174.         } else if (val == 15) {
  175.                 return 63;
  176.         }
  177.         int res;
  178.         if (RC != 15) {
  179.                 int oct = OCT;
  180.                 if (oct & 8) {
  181.                         oct |= -8;
  182.                 }
  183.                 res = (oct + RC) * 2 + (FN & 0x200 ? 1 : 0) + val * 4;
  184.         } else {
  185.                 res = val * 4;
  186.         }
  187.         if (res < 0) {
  188.                 res = 0;
  189.         } else if (res > 63) {
  190.                 res = 63;
  191.         }
  192.         return res;
  193. }
  194.  
  195. int YMF278Slot::compute_vib()
  196. {
  197.         return (((lfo_step << 8) / lfo_max) * vib_depth[(int)vib]) >> 24;
  198. }
  199.  
  200.  
  201. int YMF278Slot::compute_am()
  202. {
  203.         if (lfo_active && AM) {
  204.                 return (((lfo_step << 8) / lfo_max) * am_depth[(int)AM]) >> 12;
  205.         } else {
  206.                 return 0;
  207.         }
  208. }
  209.  
  210. void YMF278Slot::set_lfo(int newlfo)
  211. {
  212.         lfo_step = (((lfo_step << 8) / lfo_max) * newlfo) >> 8;
  213.         lfo_cnt  = (((lfo_cnt  << 8) / lfo_max) * newlfo) >> 8;
  214.  
  215.         lfo = newlfo;
  216.         lfo_max = lfo_period[(int)lfo];
  217. }
  218.  
  219.  
  220. void YMF278::advance()
  221. {
  222.         eg_timer += eg_timer_add;
  223.    
  224.     if (eg_timer > 4 * EG_TIMER_OVERFLOW) {
  225.         eg_timer = EG_TIMER_OVERFLOW;
  226.     }
  227.  
  228.         while (eg_timer >= EG_TIMER_OVERFLOW) {
  229.                 eg_timer -= EG_TIMER_OVERFLOW;
  230.                 eg_cnt++;
  231.                
  232.                 for (int i = 0; i < 24; i++) {
  233.                         YMF278Slot &op = slots[i];
  234.                        
  235.                         if (op.lfo_active) {
  236.                                 op.lfo_cnt++;
  237.                                 if (op.lfo_cnt < op.lfo_max) {
  238.                                         op.lfo_step++;
  239.                                 } else if (op.lfo_cnt < (op.lfo_max * 3)) {
  240.                                         op.lfo_step--;
  241.                                 } else {
  242.                                         op.lfo_step++;
  243.                                         if (op.lfo_cnt == (op.lfo_max * 4)) {
  244.                                                 op.lfo_cnt = 0;
  245.                                         }
  246.                                 }
  247.                         }
  248.                        
  249.                         // Envelope Generator
  250.                         switch(op.state) {
  251.                         case EG_ATT: {  // attack phase
  252.                                 u8 rate = op.compute_rate(op.AR);
  253.                                 if (rate < 4) {
  254.                                         break;
  255.                                 }
  256.                                 u8 shift = eg_rate_shift[rate];
  257.                                 if (!(eg_cnt & ((1 << shift) -1))) {
  258.                                         u8 select = eg_rate_select[rate];
  259.                                         op.env_vol += (~op.env_vol * eg_inc[select + ((eg_cnt >> shift) & 7)]) >> 3;
  260.                                         if (op.env_vol <= MIN_ATT_INDEX) {
  261.                                                 op.env_vol = MIN_ATT_INDEX;
  262.                         if (op.DL == 0) {
  263.                                                 op.state = EG_SUS;
  264.                         }
  265.                         else {
  266.                                                 op.state = EG_DEC;
  267.                         }
  268.                                         }
  269.                                 }
  270.                                 break;
  271.                         }
  272.                         case EG_DEC: {  // decay phase
  273.                                 u8 rate = op.compute_rate(op.D1R);
  274.                                 if (rate < 4) {
  275.                                         break;
  276.                                 }
  277.                                 u8 shift = eg_rate_shift[rate];
  278.                                 if (!(eg_cnt & ((1 << shift) -1))) {
  279.                                         u8 select = eg_rate_select[rate];
  280.                                         op.env_vol += eg_inc[select + ((eg_cnt >> shift) & 7)];
  281.                                        
  282.                                         if (((unsigned int)op.env_vol > dl_tab[6]) && op.PRVB) {
  283.                                                 op.state = EG_REV;
  284.                                         } else {
  285.                                                 if (op.env_vol >= op.DL) {
  286.                                                         op.state = EG_SUS;
  287.                                                 }
  288.                                         }
  289.                                 }
  290.                                 break;
  291.                         }
  292.                         case EG_SUS: {  // sustain phase
  293.                                 u8 rate = op.compute_rate(op.D2R);
  294.                                 if (rate < 4) {
  295.                                         break;
  296.                                 }
  297.                                 u8 shift = eg_rate_shift[rate];
  298.                                 if (!(eg_cnt & ((1 << shift) -1))) {
  299.                                         u8 select = eg_rate_select[rate];
  300.                                         op.env_vol += eg_inc[select + ((eg_cnt >> shift) & 7)];
  301.                                        
  302.                                         if (((unsigned int)op.env_vol > dl_tab[6]) && op.PRVB) {
  303.                                                 op.state = EG_REV;
  304.                                         } else {
  305.                                                 if (op.env_vol >= MAX_ATT_INDEX) {
  306.                                                         op.env_vol = MAX_ATT_INDEX;
  307.                                                         op.active = false;
  308.                                                         checkMute();
  309.                                                 }
  310.                                         }
  311.                                 }
  312.                                 break;
  313.                         }
  314.                         case EG_REL: {  // release phase
  315.                                 u8 rate = op.compute_rate(op.RR);
  316.                                 if (rate < 4) {
  317.                                         break;
  318.                                 }
  319.                                 u8 shift = eg_rate_shift[rate];
  320.                                 if (!(eg_cnt & ((1 << shift) -1))) {
  321.                                         u8 select = eg_rate_select[rate];
  322.                                         op.env_vol += eg_inc[select + ((eg_cnt >> shift) & 7)];
  323.                                        
  324.                                         if (((unsigned int)op.env_vol > dl_tab[6]) && op.PRVB) {
  325.                                                 op.state = EG_REV;
  326.                                         } else {
  327.                                                 if (op.env_vol >= MAX_ATT_INDEX) {
  328.                                                         op.env_vol = MAX_ATT_INDEX;
  329.                                                         op.active = false;
  330.                                                         checkMute();
  331.                                                 }
  332.                                         }
  333.                                 }
  334.                                 break;
  335.                         }
  336.                         case EG_REV: {  //pseudo reverb
  337.                                 //TODO improve env_vol update
  338.                                 u8 rate = op.compute_rate(5);
  339.                                 //if (rate < 4) {
  340.                                 //      break;
  341.                                 //}
  342.                                 u8 shift = eg_rate_shift[rate];
  343.                                 if (!(eg_cnt & ((1 << shift) - 1))) {
  344.                                         u8 select = eg_rate_select[rate];
  345.                                         op.env_vol += eg_inc[select + ((eg_cnt >> shift) & 7)];
  346.                                        
  347.                                         if (op.env_vol >= MAX_ATT_INDEX) {
  348.                                                 op.env_vol = MAX_ATT_INDEX;
  349.                                                 op.active = false;
  350.                                                 checkMute();
  351.                                         }
  352.                                 }
  353.                                 break;
  354.                         }
  355.                         case EG_DMP: {  //damping
  356.                                 //TODO improve env_vol update, damp is just fastest decay now
  357.                                 u8 rate = 56;
  358.                                 u8 shift = eg_rate_shift[rate];
  359.                                 if (!(eg_cnt & ((1 << shift) - 1))) {
  360.                                         u8 select = eg_rate_select[rate];
  361.                                         op.env_vol += eg_inc[select + ((eg_cnt >> shift) & 7)];
  362.                                        
  363.                                         if (op.env_vol >= MAX_ATT_INDEX) {
  364.                                                 op.env_vol = MAX_ATT_INDEX;
  365.                                                 op.active = false;
  366.                                                 checkMute();
  367.                                         }
  368.                                 }
  369.                                 break;
  370.                         }
  371.                         case EG_OFF:
  372.                                 // nothing
  373.                                 break;
  374.                        
  375.                         default:
  376.                                 break;
  377.                         }
  378.                 }
  379.         }
  380. }
  381.  
  382. short YMF278::getSample(YMF278Slot &op)
  383. {
  384.         short sample;
  385.         switch (op.bits) {
  386.         case 0: {
  387.                 // 8 bit
  388.                 sample = readMem(op.startaddr + op.pos) << 8;
  389.                 break;
  390.         }
  391.         case 1: {
  392.                 // 12 bit
  393.                 int addr = op.startaddr + ((op.pos / 2) * 3);
  394.                 if (op.pos & 1) {
  395.                         sample = readMem(addr + 2) << 8 |
  396.                                  ((readMem(addr + 1) << 4) & 0xF0);
  397.                 } else {
  398.                         sample = readMem(addr + 0) << 8 |
  399.                                  (readMem(addr + 1) & 0xF0);
  400.                 }
  401.                 break;
  402.         }
  403.         case 2: {
  404.                 // 16 bit
  405.                 int addr = op.startaddr + (op.pos * 2);
  406.                 sample = (readMem(addr + 0) << 8) |
  407.                          (readMem(addr + 1));
  408.                 break;
  409.         }
  410.         default:
  411.                 // TODO unspecified
  412.                 sample = 0;
  413.         }
  414.         return sample;
  415. }
  416.  
  417. void YMF278::checkMute()
  418. {
  419.         setInternalMute(!anyActive());
  420. }
  421.  
  422. bool YMF278::anyActive()
  423. {
  424.         for (int i = 0; i < 24; i++) {
  425.                 if (slots[i].active) {
  426.                         return true;
  427.                 }
  428.         }
  429.         return false;
  430. }
  431.  
  432. int* YMF278::updateBuffer(int length)
  433. {
  434.         if (isInternalMuted()) {
  435.                 return NULL;
  436.         }
  437.  
  438.         int vl = mix_level[pcm_l];
  439.         int vr = mix_level[pcm_r];
  440.         int *buf = buffer;
  441.         while (length--) {
  442.                 int left = 0;
  443.                 int right = 0;
  444.         int cnt = oplOversampling;
  445.         while (cnt--) {
  446.                     for (int i = 0; i < 24; i++) {
  447.                             YMF278Slot &sl = slots[i];
  448.                             if (!sl.active) {
  449.                                     continue;
  450.                             }
  451.  
  452.                             short sample = (sl.sample1 * (0x10000 - sl.stepptr) +
  453.                                             sl.sample2 * sl.stepptr) >> 16;
  454.                             int vol = sl.TL + (sl.env_vol >> 2) + sl.compute_am();
  455.  
  456.                             int volLeft  = vol + pan_left [(int)sl.pan] + vl;
  457.                             int volRight = vol + pan_right[(int)sl.pan] + vr;
  458.  
  459.                             // TODO prob doesn't happen in real chip
  460.                             if (volLeft < 0) {
  461.                                     volLeft = 0;
  462.                             }
  463.                             if (volRight < 0) {
  464.                                     volRight = 0;
  465.                             }
  466.  
  467.                             left  += (sample * volume[volLeft] ) >> 10;
  468.                             right += (sample * volume[volRight]) >> 10;
  469.                        
  470.                             if (sl.lfo_active && sl.vib) {
  471.                                     int oct = sl.OCT;
  472.                                     if (oct & 8) {
  473.                                             oct |= -8;
  474.                                     }
  475.                                     oct += 5;
  476.                                     sl.stepptr += (oct >= 0 ? ((sl.FN | 1024) + sl.compute_vib()) << oct
  477.                                                        : ((sl.FN | 1024) + sl.compute_vib()) >> -oct) / oplOversampling;
  478.                             } else {
  479.                                     sl.stepptr += sl.step / oplOversampling;
  480.                             }
  481.  
  482.                 int count = (sl.stepptr >> 16) & 0x0f;
  483.                 sl.stepptr &= 0xffff;
  484.                             while (count--) {
  485.                                     sl.sample1 = sl.sample2;
  486.                                     sl.pos++;
  487.                                     if (sl.pos >= sl.endaddr) {
  488.                                             sl.pos = sl.loopaddr;
  489.                                     }
  490.                                     sl.sample2 = getSample(sl);
  491.                             }          
  492.                     }
  493.                     advance();
  494.         }
  495.                 *buf++ = left / oplOversampling;
  496.                 *buf++ = right / oplOversampling;
  497.         }
  498.         return buffer;
  499. }
  500.  
  501. void YMF278::keyOnHelper(YMF278Slot& slot)
  502. {
  503.         slot.active = true;
  504.         setInternalMute(false);
  505.        
  506.         int oct = slot.OCT;
  507.         if (oct & 8) {
  508.                 oct |= -8;
  509.         }
  510.         oct += 5;
  511.         slot.step = oct >= 0 ? (slot.FN | 1024) << oct : (slot.FN | 1024) >> -oct;
  512.         slot.state = EG_ATT;
  513.         slot.stepptr = 0;
  514.         slot.pos = 0;
  515.         slot.sample1 = getSample(slot);
  516.         slot.pos = 1;
  517.         slot.sample2 = getSample(slot);
  518. }
  519.  
  520. void YMF278::writeRegOPL4(u8 reg, u8 data, const EmuTime &time)
  521. {
  522.         BUSY_Time = time + 88 * 6 / 9;
  523.        
  524.         // Handle slot registers specifically
  525.         if (reg >= 0x08 && reg <= 0xF7) {
  526.                 int snum = (reg - 8) % 24;
  527.                 YMF278Slot& slot = slots[snum];
  528.                 switch ((reg - 8) / 24) {
  529.                 case 0: {
  530.                         LD_Time = time;
  531.                         slot.wave = (slot.wave & 0x100) | data;
  532.                         int base = (slot.wave < 384 || !wavetblhdr) ?
  533.                                    (slot.wave * 12) :
  534.                                    (wavetblhdr * 0x80000 + ((slot.wave - 384) * 12));
  535.                         u8 buf[12];
  536.                         for (int i = 0; i < 12; i++) {
  537.                                 buf[i] = readMem(base + i);
  538.                         }
  539.                         slot.bits = (buf[0] & 0xC0) >> 6;
  540.                         slot.set_lfo((buf[7] >> 3) & 7);
  541.                         slot.vib  = buf[7] & 7;
  542.                         slot.AR   = buf[8] >> 4;
  543.                         slot.D1R  = buf[8] & 0xF;
  544.                         slot.DL   = dl_tab[buf[9] >> 4];
  545.                         slot.D2R  = buf[9] & 0xF;
  546.                         slot.RC   = buf[10] >> 4;
  547.                         slot.RR   = buf[10] & 0xF;
  548.                         slot.AM   = buf[11] & 7;
  549.                         slot.startaddr = buf[2] | (buf[1] << 8) |
  550.                                          ((buf[0] & 0x3F) << 16);
  551.                         slot.loopaddr = buf[4] + (buf[3] << 8);
  552.                         slot.endaddr  = (((buf[6] + (buf[5] << 8)) ^ 0xFFFF) + 1);
  553.                         if ((regs[reg + 4] & 0x080)) {
  554.                                 keyOnHelper(slot);
  555.                         }
  556.                         break;
  557.                 }
  558.                 case 1: {
  559.                         slot.wave = (slot.wave & 0xFF) | ((data & 0x1) << 8);
  560.                         slot.FN = (slot.FN & 0x380) | (data >> 1);
  561.                         int oct = slot.OCT;
  562.                         if (oct & 8) {
  563.                                 oct |= -8;
  564.                         }
  565.                 oct += 5;
  566.                 slot.step = oct >= 0 ? (slot.FN | 1024) << oct : (slot.FN | 1024) >> -oct;
  567.                         break;
  568.                 }
  569.                 case 2: {
  570.                         slot.FN = (slot.FN & 0x07F) | ((data & 0x07) << 7);
  571.                         slot.PRVB = ((data & 0x08) >> 3);
  572.                         slot.OCT =  ((data & 0xF0) >> 4);
  573.                         int oct = slot.OCT;
  574.                         if (oct & 8) {
  575.                                 oct |= -8;
  576.                         }
  577.                 oct += 5;
  578.                 slot.step = oct >= 0 ? (slot.FN | 1024) << oct : (slot.FN | 1024) >> -oct;
  579.             break;
  580.                 }
  581.                 case 3:
  582.                         slot.TL = data >> 1;
  583.                         slot.LD = data & 0x1;
  584.  
  585.                         // TODO
  586.                         if (slot.LD) {
  587.                                 // directly change volume
  588.                         } else {
  589.                                 // interpolate volume
  590.                         }
  591.                         break;
  592.                 case 4:
  593.                         slot.pan = data & 0x0F;
  594.  
  595.                         if (data & 0x020) {
  596.                                 // LFO reset
  597.                                 slot.lfo_active = false;
  598.                                 slot.lfo_cnt = 0;
  599.                                 slot.lfo_max = lfo_period[(int)slot.vib];
  600.                                 slot.lfo_step = 0;
  601.                         } else {
  602.                                 // LFO activate
  603.                                 slot.lfo_active = true;
  604.                         }
  605.  
  606.                         switch (data >> 6) {
  607.                         case 0: //tone off, no damp
  608.                                 if (slot.active && (slot.state != EG_REV) ) {
  609.                                         slot.state = EG_REL;
  610.                                 }
  611.                                 break;
  612.                         case 1: //tone off, damp
  613.                                 slot.state = EG_DMP;
  614.                                 break;
  615.                         case 2: //tone on, no damp
  616.                                 if (!(regs[reg] & 0x080)) {
  617.                                         keyOnHelper(slot);
  618.                                 }
  619.                                 break;
  620.                         case 3: //tone on, damp
  621.                                 slot.state = EG_DMP;
  622.                                 break;
  623.                         }
  624.                         break;
  625.                 case 5:
  626.                         slot.vib = data & 0x7;
  627.                         slot.set_lfo((data >> 3) & 0x7);
  628.                         break;
  629.                 case 6:
  630.                         slot.AR  = data >> 4;
  631.                         slot.D1R = data & 0xF;
  632.                         break;
  633.                 case 7:
  634.                         slot.DL  = dl_tab[data >> 4];
  635.                         slot.D2R = data & 0xF;
  636.                         break;
  637.                 case 8:
  638.                         slot.RC = data >> 4;
  639.                         slot.RR = data & 0xF;
  640.                         break;
  641.                 case 9:
  642.                         slot.AM = data & 0x7;
  643.                         break;
  644.                 }
  645.         } else {
  646.                 // All non-slot registers
  647.                 switch (reg) {
  648.                 case 0x00:      // TEST
  649.                 case 0x01:
  650.                         break;
  651.  
  652.                 case 0x02:
  653.                         wavetblhdr = (data >> 2) & 0x7;
  654.                         memmode = data & 1;
  655.                         break;
  656.  
  657.                 case 0x03:
  658.                         memadr = (memadr & 0x00FFFF) | (data << 16);
  659.                         break;
  660.  
  661.                 case 0x04:
  662.                         memadr = (memadr & 0xFF00FF) | (data << 8);
  663.                         break;
  664.  
  665.                 case 0x05:
  666.                         memadr = (memadr & 0xFFFF00) | data;
  667.                         break;
  668.  
  669.                 case 0x06:  // memory data
  670.                         BUSY_Time += 28 * 6 / 9;
  671.                         writeMem(memadr, data);
  672.                         memadr = (memadr + 1) & 0xFFFFFF;
  673.                         break;
  674.                
  675.                 case 0xF8:
  676.                         // TODO use these
  677.                         fm_l = data & 0x7;
  678.                         fm_r = (data >> 3) & 0x7;
  679.                         break;
  680.  
  681.                 case 0xF9:
  682.                         pcm_l = data & 0x7;
  683.                         pcm_r = (data >> 3) & 0x7;
  684.                         break;
  685.                 }
  686.         }
  687.        
  688.         regs[reg] = data;
  689. }
  690.  
  691. u8 YMF278::peekRegOPL4(u8 reg, const EmuTime &time)
  692. {
  693.         BUSY_Time = time;
  694.        
  695.         u8 result;
  696.         switch(reg) {
  697.                 case 2: // 3 upper bits are device ID
  698.                         result = (regs[2] & 0x1F) | 0x20;
  699.                         break;
  700.                        
  701.                 case 6: // Memory Data Register
  702.                         result = readMem(memadr);
  703.                         break;
  704.  
  705.                 default:
  706.                         result = regs[reg];
  707.                         break;
  708.         }
  709.         return result;
  710. }
  711.  
  712. u8 YMF278::readRegOPL4(u8 reg, const EmuTime &time)
  713. {
  714.         BUSY_Time = time;
  715.        
  716.         u8 result;
  717.         switch(reg) {
  718.                 case 2: // 3 upper bits are device ID
  719.                         result = (regs[2] & 0x1F) | 0x20;
  720.                         break;
  721.                        
  722.                 case 6: // Memory Data Register
  723.                         BUSY_Time += 38 * 6 / 9;
  724.                         result = readMem(memadr);
  725.                         memadr = (memadr + 1) & 0xFFFFFF;
  726.                         break;
  727.  
  728.                 default:
  729.                         result = regs[reg];
  730.                         break;
  731.         }
  732.         return result;
  733. }
  734.  
  735. u8 YMF278::peekStatus(const EmuTime &time)
  736. {
  737.         u8 result = 0;
  738.         if (time - BUSY_Time < 88 * 6 / 9) {
  739.                 result |= 0x01;
  740.         }
  741.         if (time - LD_Time < 10000 * 6 / 9) {
  742.                 result |= 0x02;
  743.         }
  744.         return result;
  745. }
  746.  
  747. u8 YMF278::readStatus(const EmuTime &time)
  748. {
  749.         u8 result = 0;
  750.         if (time - BUSY_Time < 88 * 6 / 9) {
  751.                 result |= 0x01;
  752.         }
  753.         if (time - LD_Time < 10000 * 6 / 9) {
  754.                 result |= 0x02;
  755.         }
  756.         return result;
  757. }
  758.  
  759. YMF278::YMF278(short volume, int ramSize, int romSize,
  760.                const EmuTime &time)
  761. {
  762.     LD_Time = 0;
  763.     BUSY_Time = 0;
  764.         memadr = 0;     // avoid UMR
  765.         endRom = romSize;
  766.         ramSize *= 1024;        // in kb
  767.  
  768.     this->ramSize = ramSize;
  769.  
  770. //      rom = new u8[romSize];
  771. //    ram = new u8[4096 * 1024];
  772.  
  773.         rom = (u8 *)malloc(romSize);
  774.         ram = (u8 *)malloc(4096*1024); // NULL-checking is elsewhere
  775.  
  776.  
  777.     oplOversampling = 1;
  778.  
  779.         endRam = endRom + ramSize;
  780.        
  781.         reset(time);
  782. }
  783.  
  784. YMF278::~YMF278()
  785. {
  786. //      delete[] ram;
  787. //      delete[] rom;
  788.         if(ram)
  789.                 free(ram);
  790.         if(rom)
  791.                 free(rom);
  792. }
  793.  
  794. void YMF278::reset(const EmuTime &time)
  795. {
  796.         eg_timer = 0;
  797.         eg_cnt   = 0;
  798.  
  799.     int i;
  800.         for (i = 0; i < 24; i++) {
  801.                 slots[i].reset();
  802.         }
  803.         for (i = 255; i >= 0; i--) { // reverse order to avoid UMR
  804.                 writeRegOPL4(i, 0, time);
  805.         }
  806.         setInternalMute(true);
  807.         wavetblhdr = memmode = memadr = 0;
  808.         fm_l = fm_r = pcm_l = pcm_r = 0;
  809.         BUSY_Time = time;
  810.         LD_Time = time;
  811. }
  812.  
  813. void YMF278::setSampleRate(int sampleRate, int Oversampling)
  814. {
  815.     oplOversampling = Oversampling;
  816.         eg_timer_add = (unsigned int)((1 << EG_SH) / oplOversampling);
  817. }
  818.  
  819. void YMF278::setInternalVolume(short newVolume)
  820. {
  821.     newVolume /= 32;
  822.         // Volume table, 1 = -0.375dB, 8 = -3dB, 256 = -96dB
  823.     int i;
  824.         for (i = 0; i < 256; i++) {
  825.                 volume[i] = (int)(4.0 * (double)newVolume * pow(2.0, (-0.375 / 6) * i));
  826.         }
  827.         for (i = 256; i < 256 * 4; i++) {
  828.                 volume[i] = 0;
  829.         }
  830. }
  831.  
  832. u8 YMF278::readMem(unsigned int address)
  833. {
  834.         if (rom && address < endRom) {
  835.                 return rom[address];
  836.         } else if (ram && address < endRam) {
  837.                 return ram[address - endRom];
  838.         } else {
  839.                 return 255;     // TODO check
  840.         }
  841. }
  842.  
  843. void YMF278::writeMem(unsigned int address, u8 value)
  844. {
  845.         if (address < endRom) {
  846.                 // can't write to ROM
  847.         } else if (ram && address < endRam) {
  848.                 ram[address - endRom] = value;
  849.         } else {
  850.                 // can't write to unmapped memory
  851.         }
  852. }
  853.