Subversion Repositories pentevo

Rev

Rev 797 | Blame | Compare with Previous | Last modification | View Log | Download | RSS feed

  1. /*
  2. **
  3. ** File: fm.c -- software implementation of Yamaha FM sound generator
  4. **
  5. ** Copyright (C) 2001, 2002, 2003 Jarek Burczynski (bujar at mame dot net)
  6. ** Copyright (C) 1998 Tatsuyuki Satoh , MultiArcadeMachineEmulator development
  7. **
  8. ** Version 1.4A (final beta)
  9. **
  10. */
  11.  
  12. /*
  13. ** History:
  14. **
  15. ** 14-02-2006 Alone Coder:
  16. **  - fixed YM2203 stop volume (511 instead of MAX_ATT_INDEX) - verified on real chip
  17. **  - fixed YM2203 SSG-EG=#0a key off (inversion disabled) - verified on real chip
  18. **  - uncommented sine generator in SSG-EG reinit - verified on real chip
  19. **
  20. ** 03-08-2003 Jarek Burczynski:
  21. **  - fixed YM2608 initial values (after the reset)
  22. **  - fixed flag and irqmask handling (YM2608)
  23. **  - fixed BUFRDY flag handling (YM2608)
  24. **
  25. ** 14-06-2003 Jarek Burczynski:
  26. **  - implemented all of the YM2608 status register flags
  27. **  - implemented support for external memory read/write via YM2608
  28. **  - implemented support for deltat memory limit register in YM2608 emulation
  29. **
  30. ** 22-05-2003 Jarek Burczynski:
  31. **  - fixed LFO PM calculations (copy&paste bugfix)
  32. **
  33. ** 08-05-2003 Jarek Burczynski:
  34. **  - fixed SSG support
  35. **
  36. ** 22-04-2003 Jarek Burczynski:
  37. **  - implemented 100% correct LFO generator (verified on real YM2610 and YM2608)
  38. **
  39. ** 15-04-2003 Jarek Burczynski:
  40. **  - added support for YM2608's register 0x110 - status mask
  41. **
  42. ** 01-12-2002 Jarek Burczynski:
  43. **  - fixed register addressing in YM2608, YM2610, YM2610B chips. (verified on real YM2608)
  44. **    The addressing patch used for early Neo-Geo games can be removed now.
  45. **
  46. ** 26-11-2002 Jarek Burczynski, Nicola Salmoria:
  47. **  - recreated YM2608 ADPCM ROM using data from real YM2608's output which leads to:
  48. **  - added emulation of YM2608 drums.
  49. **  - output of YM2608 is two times lower now - same as YM2610 (verified on real YM2608)
  50. **
  51. ** 16-08-2002 Jarek Burczynski:
  52. **  - binary exact Envelope Generator (verified on real YM2203);
  53. **    identical to YM2151
  54. **  - corrected 'off by one' error in feedback calculations (when feedback is off)
  55. **  - corrected connection (algorithm) calculation (verified on real YM2203 and YM2610)
  56. **
  57. ** 18-12-2001 Jarek Burczynski:
  58. **  - added SSG-EG support (verified on real YM2203)
  59. **
  60. ** 12-08-2001 Jarek Burczynski:
  61. **  - corrected sin_tab and tl_tab data (verified on real chip)
  62. **  - corrected feedback calculations (verified on real chip)
  63. **  - corrected phase generator calculations (verified on real chip)
  64. **  - corrected envelope generator calculations (verified on real chip)
  65. **  - corrected FM volume level (YM2610 and YM2610B).
  66. **  - changed YMxxxUpdateOne() functions (YM2203, YM2608, YM2610, YM2610B, YM2612) :
  67. **    this was needed to calculate YM2610 FM channels output correctly.
  68. **    (Each FM channel is calculated as in other chips, but the output of the channel
  69. **    gets shifted right by one *before* sending to accumulator. That was impossible to do
  70. **    with previous implementation).
  71. **
  72. ** 23-07-2001 Jarek Burczynski, Nicola Salmoria:
  73. **  - corrected YM2610 ADPCM type A algorithm and tables (verified on real chip)
  74. **
  75. ** 11-06-2001 Jarek Burczynski:
  76. **  - corrected end of sample bug in ADPCMA_calc_cha().
  77. **    Real YM2610 checks for equality between current and end addresses (only 20 LSB bits).
  78. **
  79. ** 08-12-98 hiro-shi:
  80. ** rename ADPCMA -> ADPCMB, ADPCMB -> ADPCMA
  81. ** move ROM limit check.(CALC_CH? -> 2610Write1/2)
  82. ** test program (ADPCMB_TEST)
  83. ** move ADPCM A/B end check.
  84. ** ADPCMB repeat flag(no check)
  85. ** change ADPCM volume rate (8->16) (32->48).
  86. **
  87. ** 09-12-98 hiro-shi:
  88. ** change ADPCM volume. (8->16, 48->64)
  89. ** replace ym2610 ch0/3 (YM-2610B)
  90. ** change ADPCM_SHIFT (10->8) missing bank change 0x4000-0xffff.
  91. ** add ADPCM_SHIFT_MASK
  92. ** change ADPCMA_DECODE_MIN/MAX.
  93. */
  94.  
  95.  
  96.  
  97.  
  98. /************************************************************************/
  99. /*    comment of hiro-shi(Hiromitsu Shioya)                             */
  100. /*    YM2610(B) = OPN-B                                                 */
  101. /*    YM2610  : PSG:3ch FM:4ch ADPCM(18.5KHz):6ch DeltaT ADPCM:1ch      */
  102. /*    YM2610B : PSG:3ch FM:6ch ADPCM(18.5KHz):6ch DeltaT ADPCM:1ch      */
  103. /************************************************************************/
  104.  
  105. //fnum= fq*2.3575
  106. /* globals */
  107. #include "../std.h"
  108. #include "../sysdefs.h"
  109. #include "emul_2203.h"
  110.  
  111. #define TYPE_SSG    0x01    /* SSG support          */
  112. #define TYPE_LFOPAN 0x02    /* OPN type LFO and PAN */
  113. #define TYPE_6CH    0x04    /* FM 6CH / 3CH         */
  114. #define TYPE_DAC    0x08    /* YM2612's DAC device  */
  115. #define TYPE_ADPCM  0x10    /* two ADPCM units      */
  116.  
  117. #define TYPE_YM2203 (TYPE_SSG)
  118. #define TYPE_YM2608 (TYPE_SSG |TYPE_LFOPAN |TYPE_6CH |TYPE_ADPCM)
  119. #define TYPE_YM2610 (TYPE_SSG |TYPE_LFOPAN |TYPE_6CH |TYPE_ADPCM)
  120. #define TYPE_YM2612 (TYPE_DAC |TYPE_LFOPAN |TYPE_6CH)
  121.  
  122. #define FREQ_SH                 16U  /* 16.16 fixed point (frequency calculations) */
  123. #define EG_SH                   16  /* 16.16 fixed point (envelope generator timing) */
  124. #define LFO_SH                  24  /*  8.24 fixed point (LFO calculations)       */
  125. #define TIMER_SH                16  /* 16.16 fixed point (timers calculations)    */
  126.  
  127. #define FREQ_MASK               ((1U<<FREQ_SH)-1U)
  128.  
  129. #define ENV_BITS                10
  130. #define ENV_LEN                 (1<<ENV_BITS)
  131. #define ENV_STEP                (128.0/ENV_LEN)
  132.  
  133. #define MAX_ATT_INDEX   (ENV_LEN-1) /* 1023 */
  134. #define MIN_ATT_INDEX   (0)                     /* 0 */
  135.  
  136. #define EG_ATT                  4
  137. #define EG_DEC                  3
  138. #define EG_SUS                  2
  139. #define EG_REL                  1
  140. #define EG_OFF                  0
  141.  
  142. #define SIN_BITS                10
  143. #define SIN_LEN                 (1<<SIN_BITS)
  144. #define SIN_MASK                (SIN_LEN-1)
  145.  
  146. #define TL_RES_LEN              (256) /* 8 bits addressing (real chip) */
  147.  
  148. #if (FM_SAMPLE_BITS==16)
  149.         #define FINAL_SH        (0)
  150.         #define MAXOUT          (+32767)
  151.         #define MINOUT          (-32768)
  152. #else
  153.         #define FINAL_SH        (8)
  154.         #define MAXOUT          (+127)
  155.         #define MINOUT          (-128)
  156. #endif
  157.  
  158. /*  TL_TAB_LEN is calculated as:
  159. *   13 - sinus amplitude bits     (Y axis)
  160. *   2  - sinus sign bit           (Y axis)
  161. *   TL_RES_LEN - sinus resolution (X axis)
  162. */
  163. #define TL_TAB_LEN (13*2*TL_RES_LEN)
  164.  
  165. #define ENV_QUIET               (TL_TAB_LEN>>3)
  166.  
  167. #define RATE_STEPS (8)
  168.  
  169. #define INTERNAL_TIMER_A(ST,CSM_CH)
  170. #define INTERNAL_TIMER_B(ST,step)
  171.  
  172. #define logerror(a,b,c,d,e)
  173.  
  174. #define SC(db) (UINT32) ( db * (4.0/ENV_STEP) )
  175. static const UINT32 sl_table[16]={
  176.  SC( 0),SC( 1),SC( 2),SC(3 ),SC(4 ),SC(5 ),SC(6 ),SC( 7),
  177.  SC( 8),SC( 9),SC(10),SC(11),SC(12),SC(13),SC(14),SC(31)
  178. };
  179. #undef SC
  180.  
  181. static const UINT8 eg_inc[19*RATE_STEPS]={
  182.  
  183. /*cycle:0 1  2 3  4 5  6 7*/
  184.  
  185. /* 0 */ 0,1, 0,1, 0,1, 0,1, /* rates 00..11 0 (increment by 0 or 1) */
  186. /* 1 */ 0,1, 0,1, 1,1, 0,1, /* rates 00..11 1 */
  187. /* 2 */ 0,1, 1,1, 0,1, 1,1, /* rates 00..11 2 */
  188. /* 3 */ 0,1, 1,1, 1,1, 1,1, /* rates 00..11 3 */
  189.  
  190. /* 4 */ 1,1, 1,1, 1,1, 1,1, /* rate 12 0 (increment by 1) */
  191. /* 5 */ 1,1, 1,2, 1,1, 1,2, /* rate 12 1 */
  192. /* 6 */ 1,2, 1,2, 1,2, 1,2, /* rate 12 2 */
  193. /* 7 */ 1,2, 2,2, 1,2, 2,2, /* rate 12 3 */
  194.  
  195. /* 8 */ 2,2, 2,2, 2,2, 2,2, /* rate 13 0 (increment by 2) */
  196. /* 9 */ 2,2, 2,4, 2,2, 2,4, /* rate 13 1 */
  197. /*10 */ 2,4, 2,4, 2,4, 2,4, /* rate 13 2 */
  198. /*11 */ 2,4, 4,4, 2,4, 4,4, /* rate 13 3 */
  199.  
  200. /*12 */ 4,4, 4,4, 4,4, 4,4, /* rate 14 0 (increment by 4) */
  201. /*13 */ 4,4, 4,8, 4,4, 4,8, /* rate 14 1 */
  202. /*14 */ 4,8, 4,8, 4,8, 4,8, /* rate 14 2 */
  203. /*15 */ 4,8, 8,8, 4,8, 8,8, /* rate 14 3 */
  204.  
  205. /*16 */ 8,8, 8,8, 8,8, 8,8, /* rates 15 0, 15 1, 15 2, 15 3 (increment by 8) */
  206. /*17 */ 16,16,16,16,16,16,16,16, /* rates 15 2, 15 3 for attack */
  207. /*18 */ 0,0, 0,0, 0,0, 0,0, /* infinity rates for attack and decay(s) */
  208. };
  209.  
  210. #define O(a) (a*RATE_STEPS)
  211.  
  212. /*note that there is no O(17) in this table - it's directly in the code */
  213. static const UINT8 eg_rate_select[32+64+32]={   /* Envelope Generator rates (32 + 64 rates + 32 RKS) */
  214. /* 32 infinite time rates */
  215. O(18),O(18),O(18),O(18),O(18),O(18),O(18),O(18),
  216. O(18),O(18),O(18),O(18),O(18),O(18),O(18),O(18),
  217. O(18),O(18),O(18),O(18),O(18),O(18),O(18),O(18),
  218. O(18),O(18),O(18),O(18),O(18),O(18),O(18),O(18),
  219.  
  220. /* rates 00-11 */
  221. O( 0),O( 1),O( 2),O( 3),
  222. O( 0),O( 1),O( 2),O( 3),
  223. O( 0),O( 1),O( 2),O( 3),
  224. O( 0),O( 1),O( 2),O( 3),
  225. O( 0),O( 1),O( 2),O( 3),
  226. O( 0),O( 1),O( 2),O( 3),
  227. O( 0),O( 1),O( 2),O( 3),
  228. O( 0),O( 1),O( 2),O( 3),
  229. O( 0),O( 1),O( 2),O( 3),
  230. O( 0),O( 1),O( 2),O( 3),
  231. O( 0),O( 1),O( 2),O( 3),
  232. O( 0),O( 1),O( 2),O( 3),
  233.  
  234. /* rate 12 */
  235. O( 4),O( 5),O( 6),O( 7),
  236.  
  237. /* rate 13 */
  238. O( 8),O( 9),O(10),O(11),
  239.  
  240. /* rate 14 */
  241. O(12),O(13),O(14),O(15),
  242.  
  243. /* rate 15 */
  244. O(16),O(16),O(16),O(16),
  245.  
  246. /* 32 dummy rates (same as 15 3) */
  247. O(16),O(16),O(16),O(16),O(16),O(16),O(16),O(16),
  248. O(16),O(16),O(16),O(16),O(16),O(16),O(16),O(16),
  249. O(16),O(16),O(16),O(16),O(16),O(16),O(16),O(16),
  250. O(16),O(16),O(16),O(16),O(16),O(16),O(16),O(16)
  251.  
  252. };
  253. #undef O
  254.  
  255. #define O(a) (a*1)
  256. static const UINT8 eg_rate_shift[32+64+32]={    /* Envelope Generator counter shifts (32 + 64 rates + 32 RKS) */
  257. /* 32 infinite time rates */
  258. O(0),O(0),O(0),O(0),O(0),O(0),O(0),O(0),
  259. O(0),O(0),O(0),O(0),O(0),O(0),O(0),O(0),
  260. O(0),O(0),O(0),O(0),O(0),O(0),O(0),O(0),
  261. O(0),O(0),O(0),O(0),O(0),O(0),O(0),O(0),
  262.  
  263. /* rates 00-11 */
  264. O(11),O(11),O(11),O(11),
  265. O(10),O(10),O(10),O(10),
  266. O( 9),O( 9),O( 9),O( 9),
  267. O( 8),O( 8),O( 8),O( 8),
  268. O( 7),O( 7),O( 7),O( 7),
  269. O( 6),O( 6),O( 6),O( 6),
  270. O( 5),O( 5),O( 5),O( 5),
  271. O( 4),O( 4),O( 4),O( 4),
  272. O( 3),O( 3),O( 3),O( 3),
  273. O( 2),O( 2),O( 2),O( 2),
  274. O( 1),O( 1),O( 1),O( 1),
  275. O( 0),O( 0),O( 0),O( 0),
  276.  
  277. /* rate 12 */
  278. O( 0),O( 0),O( 0),O( 0),
  279.  
  280. /* rate 13 */
  281. O( 0),O( 0),O( 0),O( 0),
  282.  
  283. /* rate 14 */
  284. O( 0),O( 0),O( 0),O( 0),
  285.  
  286. /* rate 15 */
  287. O( 0),O( 0),O( 0),O( 0),
  288.  
  289. /* 32 dummy rates (same as 15 3) */
  290. O( 0),O( 0),O( 0),O( 0),O( 0),O( 0),O( 0),O( 0),
  291. O( 0),O( 0),O( 0),O( 0),O( 0),O( 0),O( 0),O( 0),
  292. O( 0),O( 0),O( 0),O( 0),O( 0),O( 0),O( 0),O( 0),
  293. O( 0),O( 0),O( 0),O( 0),O( 0),O( 0),O( 0),O( 0)
  294. };
  295. #undef O
  296.  
  297. static const UINT8 dt_tab[4 * 32]={
  298. /* this is YM2151 and YM2612 phase increment data (in 10.10 fixed point format)*/
  299. /* FD=0 */
  300.         0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
  301.         0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
  302. /* FD=1 */
  303.         0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2,
  304.         2, 3, 3, 3, 4, 4, 4, 5, 5, 6, 6, 7, 8, 8, 8, 8,
  305. /* FD=2 */
  306.         1, 1, 1, 1, 2, 2, 2, 2, 2, 3, 3, 3, 4, 4, 4, 5,
  307.         5, 6, 6, 7, 8, 8, 9,10,11,12,13,14,16,16,16,16,
  308. /* FD=3 */
  309.         2, 2, 2, 2, 2, 3, 3, 3, 4, 4, 4, 5, 5, 6, 6, 7,
  310.         8 , 8, 9,10,11,12,13,14,16,17,19,20,22,22,22,22
  311. };
  312.  
  313. /* register number to channel number , slot offset */
  314. #define OPN_CHAN(N) (N&3)
  315. #define OPN_SLOT(N) ((N>>2)&3)
  316.  
  317. /* slot number */
  318. #define SLOT1 0
  319. #define SLOT2 2
  320. #define SLOT3 1
  321. #define SLOT4 3
  322.  
  323. /* OPN key frequency number -> key code follow table */
  324. /* fnum higher 4bit -> keycode lower 2bit */
  325. static const UINT8 opn_fktable[16] = {0,0,0,0,0,0,0,1,2,3,3,3,3,3,3,3};
  326.  
  327. static INT16/*signed int*/ tl_tab[TL_TAB_LEN];
  328.  
  329. /* sin waveform table in 'decibel' scale */
  330. static UINT16/*unsigned int*/ sin_tab[SIN_LEN];
  331.  
  332. /* current chip state */
  333. static void     *_cur_chip = nullptr;   /* pointer of current chip struct */
  334. static FM_ST    *_State;                        /* basic status */
  335. static FM_CH    *_cch[3];               /* pointer of FM channels */
  336.  
  337.  
  338. static INT32    _m2,_c1,_c2;            /* Phase Modulation input for operators 2,3,4 */
  339. static INT32    _mem;                   /* one sample delay memory */
  340.  
  341. static INT32    _out_fm[3];             /* outputs of working channels */
  342.  
  343. /* limitter */
  344.  
  345. #define Limit(val, max,min) { \
  346.         if ( val > max )      val = max; \
  347.         else if ( val < min ) val = min; \
  348. }
  349.  
  350. /* status set and IRQ handling */
  351. static void FM_STATUS_SET(FM_ST *ST,int flag)
  352. {
  353.         /* set status flag */
  354.         ST->status |= flag;
  355.         if ( !(ST->irq) && (ST->status & ST->irqmask) )
  356.         {
  357.                 ST->irq = 1;
  358.                 /* callback user interrupt handler (IRQ is OFF to ON) */
  359. //              if(ST->IRQ_Handler) (ST->IRQ_Handler)(ST->param,1);
  360.         }
  361. }
  362.  
  363. /* status reset and IRQ handling */
  364. static void FM_STATUS_RESET(FM_ST *ST,int flag)
  365. {
  366.         /* reset status flag */
  367.         ST->status &=~flag;
  368.         if ( (ST->irq) && !(ST->status & ST->irqmask) )
  369.         {
  370.                 ST->irq = 0;
  371.                 /* callback user interrupt handler (IRQ is ON to OFF) */
  372. //              if(ST->IRQ_Handler) (ST->IRQ_Handler)(ST->param,0);
  373.         }
  374. }
  375.  
  376. /* IRQ mask set */
  377. static void FM_IRQMASK_SET(FM_ST *ST,int flag)
  378. {
  379.         ST->irqmask = UINT8(flag);
  380.         /* IRQ handling check */
  381.         FM_STATUS_SET(ST,0);
  382.         FM_STATUS_RESET(ST,0);
  383. }
  384.  
  385.  
  386. /* OPN Mode Register Write */
  387. static void set_timers( FM_ST *ST, void *n, int v )
  388. {
  389.     (void)n;
  390.  
  391.         /* b7 = CSM MODE */
  392.         /* b6 = 3 slot mode */
  393.         /* b5 = reset b */
  394.         /* b4 = reset a */
  395.         /* b3 = timer enable b */
  396.         /* b2 = timer enable a */
  397.         /* b1 = load b */
  398.         /* b0 = load a */
  399.         ST->mode = UINT32(v);
  400.  
  401.         /* reset Timer b flag */
  402.         if( v & 0x20 )
  403.                 FM_STATUS_RESET(ST,0x02);
  404.         /* reset Timer a flag */
  405.         if( v & 0x10 )
  406.                 FM_STATUS_RESET(ST,0x01);
  407.         /* load b */
  408.         if( v & 0x02 )
  409.         {
  410.                 if( ST->TBC == 0 )
  411.                 {
  412.                         ST->TBC = ( 256-ST->TB)<<4;
  413.                         /* External timer handler */
  414. //                      if (ST->Timer_Handler) (ST->Timer_Handler)(n,1,ST->TBC,ST->TimerBase);
  415.                 }
  416.         }
  417.         else
  418.         {       /* stop timer b */
  419.                 if( ST->TBC != 0 )
  420.                 {
  421.                         ST->TBC = 0;
  422. //                      if (ST->Timer_Handler) (ST->Timer_Handler)(n,1,0,ST->TimerBase);
  423.                 }
  424.         }
  425.         /* load a */
  426.         if( v & 0x01 )
  427.         {
  428.                 if( ST->TAC == 0 )
  429.                 {
  430.                         ST->TAC = (1024-ST->TA);
  431.                         /* External timer handler */
  432. //                      if (ST->Timer_Handler) (ST->Timer_Handler)(n,0,ST->TAC,ST->TimerBase);
  433.                 }
  434.         }
  435.         else
  436.         {       /* stop timer a */
  437.                 if( ST->TAC != 0 )
  438.                 {
  439.                         ST->TAC = 0;
  440. //                      if (ST->Timer_Handler) (ST->Timer_Handler)(n,0,0,ST->TimerBase);
  441.                 }
  442.         }
  443. }
  444.  
  445. /* Timer A Overflow */
  446. static void TimerAOver(FM_ST *ST)
  447. {
  448.         /* set status (if enabled) */
  449.         if(ST->mode & 0x04) FM_STATUS_SET(ST,0x01);
  450.         /* clear or reload the counter */
  451.         ST->TAC = (1024-ST->TA);
  452. //      if (ST->Timer_Handler) (ST->Timer_Handler)(ST->param,0,ST->TAC,ST->TimerBase);
  453. }
  454. /* Timer B Overflow */
  455. static void TimerBOver(FM_ST *ST)
  456. {
  457.         /* set status (if enabled) */
  458.         if(ST->mode & 0x08) FM_STATUS_SET(ST,0x02);
  459.         /* clear or reload the counter */
  460.         ST->TBC = ( 256-ST->TB)<<4;
  461. //      if (ST->Timer_Handler) (ST->Timer_Handler)(ST->param,1,ST->TBC,ST->TimerBase);
  462. }
  463.  
  464.  
  465. #if FM_BUSY_FLAG_SUPPORT
  466. static UINT8 FM_STATUS_FLAG(FM_ST *ST)
  467. {
  468.         if( ST->BusyExpire > 0)
  469.         {
  470.                 if( (ST->BusyExpire - FM_GET_TIME_NOW()) > 0)
  471.                         return ST->status | 0x80;       /* with busy */
  472.                 /* expire */
  473.                 ST->BusyExpire = 0;
  474.         }
  475.         return ST->status;
  476. }
  477. static void FM_BUSY_SET(FM_ST *ST,int busyclock )
  478. {
  479.         ST->BusyExpire = FM_GET_TIME_NOW() + (ST->TimerBase * busyclock);
  480. }
  481. #define FM_BUSY_CLEAR(ST) ((ST)->BusyExpire = 0)
  482. #else
  483. #define FM_STATUS_FLAG(ST) ((ST)->status)
  484. #define FM_BUSY_SET(ST,bclock) {}
  485. #define FM_BUSY_CLEAR(ST) {}
  486. #endif
  487.  
  488.  
  489. static void FM_KEYON(FM_CH *CH , int s )
  490. {
  491.         FM_SLOT *SLOT = &CH->SLOT[s];
  492.         if( !SLOT->key )
  493.         {
  494.                 SLOT->key = 1;
  495.                 SLOT->phase = 0;                /* restart Phase Generator */ //restored by Alone Coder
  496.                 SLOT->state = EG_ATT;   /* phase -> Attack */
  497.                 if ( SLOT->volume >= MAX_ATT_INDEX )SLOT->volume = 511; /* Alone Coder */
  498.         }
  499. }
  500.  
  501. static void FM_KEYOFF(FM_CH *CH , int s )
  502. {
  503.         FM_SLOT *SLOT = &CH->SLOT[s];
  504.         if( SLOT->key )
  505.         {
  506.                 SLOT->key = 0;
  507.                 if (SLOT->state>EG_REL)
  508.                         SLOT->state = EG_REL;/* phase -> Release */
  509.         }
  510. }
  511.  
  512. /* set algorithm connection */
  513. static void setup_connection( FM_CH *CH, int ch )
  514. {
  515.         INT32 *carrier = &_out_fm[ch];
  516.  
  517.         INT32 **om1 = &CH->connect1;
  518.         INT32 **oc1 = &CH->connect2;
  519.         INT32 **om2 = &CH->connect3;
  520.         INT32 **memc = &CH->mem_connect;
  521.  
  522.         switch( CH->ALGO ){
  523.         case 0:
  524.                 /* M1---C1---MEM---M2---C2---OUT */
  525.                 *om1 = &_c1;
  526.                 *oc1 = &_mem;
  527.                 *om2 = &_c2;
  528.                 *memc= &_m2;
  529.                 break;
  530.         case 1:
  531.                 /* M1------+-MEM---M2---C2---OUT */
  532.                 /*      C1-+                     */
  533.                 *om1 = &_mem;
  534.                 *oc1 = &_mem;
  535.                 *om2 = &_c2;
  536.                 *memc= &_m2;
  537.                 break;
  538.         case 2:
  539.                 /* M1-----------------+-C2---OUT */
  540.                 /*      C1---MEM---M2-+          */
  541.                 *om1 = &_c2;
  542.                 *oc1 = &_mem;
  543.                 *om2 = &_c2;
  544.                 *memc= &_m2;
  545.                 break;
  546.         case 3:
  547.                 /* M1---C1---MEM------+-C2---OUT */
  548.                 /*                 M2-+          */
  549.                 *om1 = &_c1;
  550.                 *oc1 = &_mem;
  551.                 *om2 = &_c2;
  552.                 *memc= &_c2;
  553.                 break;
  554.         case 4:
  555.                 /* M1---C1-+-OUT */
  556.                 /* M2---C2-+     */
  557.                 /* MEM: not used */
  558.                 *om1 = &_c1;
  559.                 *oc1 = carrier;
  560.                 *om2 = &_c2;
  561.                 *memc= &_mem;   /* store it anywhere where it will not be used */
  562.                 break;
  563.         case 5:
  564.                 /*    +----C1----+     */
  565.                 /* M1-+-MEM---M2-+-OUT */
  566.                 /*    +----C2----+     */
  567.                 *om1 = nullptr; /* special mark */
  568.                 *oc1 = carrier;
  569.                 *om2 = carrier;
  570.                 *memc= &_m2;
  571.                 break;
  572.         case 6:
  573.                 /* M1---C1-+     */
  574.                 /*      M2-+-OUT */
  575.                 /*      C2-+     */
  576.                 /* MEM: not used */
  577.                 *om1 = &_c1;
  578.                 *oc1 = carrier;
  579.                 *om2 = carrier;
  580.                 *memc= &_mem;   /* store it anywhere where it will not be used */
  581.                 break;
  582.         case 7:
  583.                 /* M1-+     */
  584.                 /* C1-+-OUT */
  585.                 /* M2-+     */
  586.                 /* C2-+     */
  587.                 /* MEM: not used*/
  588.                 *om1 = carrier;
  589.                 *oc1 = carrier;
  590.                 *om2 = carrier;
  591.                 *memc= &_mem;   /* store it anywhere where it will not be used */
  592.                 break;
  593.         }
  594.  
  595.         CH->connect4 = carrier;
  596. }
  597.  
  598. /* set detune & multiple #3x */
  599. static void set_det_mul(FM_ST *ST,FM_CH *CH,FM_SLOT *SLOT,int v)
  600. {
  601.         SLOT->mul = (v&0x0f)? (v&0x0f)*2 : 1;
  602.         SLOT->DT  = ST->dt_tab[(v>>4)&7];
  603.         CH->SLOT[SLOT1].Incr=-1U;
  604. }
  605.  
  606. /* set total level #4x*/
  607. static void set_tl(FM_CH *CH,FM_SLOT *SLOT , int v)
  608. {
  609.     (void)CH;
  610.  
  611.     SLOT->tl = UINT32((v&0x7f)<<(ENV_BITS-7)); /* 7bit TL */
  612. }
  613.  
  614. /* set attack rate & key scale #5x */
  615. static void set_ar_ksr(FM_CH *CH,FM_SLOT *SLOT,int v)
  616. {
  617.         UINT8 old_KSR = SLOT->KSR;
  618.  
  619.         SLOT->ar = UINT32((v&0x1f) ? 32 + ((v&0x1f)<<1) : 0);
  620.  
  621.         SLOT->KSR = UINT8(3-(v>>6));
  622.         if (SLOT->KSR != old_KSR)
  623.         {
  624.                 CH->SLOT[SLOT1].Incr=-1U;
  625.         }
  626.         else
  627.         {
  628.                 /* refresh Attack rate */
  629.                 if ((SLOT->ar + SLOT->ksr) < 32+62)
  630.                 {
  631.                         SLOT->eg_sh_ar  = eg_rate_shift [SLOT->ar  + SLOT->ksr ];
  632.                         SLOT->eg_sel_ar = eg_rate_select[SLOT->ar  + SLOT->ksr ];
  633.                 }
  634.                 else
  635.                 {
  636.                         SLOT->eg_sh_ar  = 0;
  637.                         SLOT->eg_sel_ar = 17*RATE_STEPS;
  638.                 }
  639.         }
  640. }
  641.  
  642. /* set decay rate  #6x*/
  643. static void set_dr(FM_SLOT *SLOT,int v)
  644. {
  645.         SLOT->d1r = UINT32((v&0x1f) ? 32 + ((v&0x1f)<<1) : 0);
  646.  
  647.         SLOT->eg_sh_d1r = eg_rate_shift [SLOT->d1r + SLOT->ksr];
  648.         SLOT->eg_sel_d1r= eg_rate_select[SLOT->d1r + SLOT->ksr];
  649.  
  650. }
  651.  
  652. /* set sustain rate  #7x*/
  653. static void set_sr(FM_SLOT *SLOT,int v)
  654. {
  655.         SLOT->d2r = UINT32((v&0x1f) ? 32 + ((v&0x1f)<<1) : 0);
  656.  
  657.         SLOT->eg_sh_d2r = eg_rate_shift [SLOT->d2r + SLOT->ksr];
  658.         SLOT->eg_sel_d2r= eg_rate_select[SLOT->d2r + SLOT->ksr];
  659. }
  660.  
  661. /* set release rate  #8x*/
  662. static void set_sl_rr(FM_SLOT *SLOT,int v)
  663. {
  664.         SLOT->sl = sl_table[ v>>4 ];
  665.  
  666.         SLOT->rr  = UINT32(34 + ((v&0x0f)<<2));
  667.  
  668.         SLOT->eg_sh_rr  = eg_rate_shift [SLOT->rr  + SLOT->ksr];
  669.         SLOT->eg_sel_rr = eg_rate_select[SLOT->rr  + SLOT->ksr];
  670. }
  671.  
  672. static signed int op_calc(UINT32 phase, unsigned int env, signed int pm)
  673. {
  674.         UINT32 p;
  675.  
  676.         p = (env<<3) + sin_tab[ ( ((signed int)(int(phase & ~FREQ_MASK) + int(pm<<15))) >> FREQ_SH ) & SIN_MASK ];
  677.  
  678.         if (p >= TL_TAB_LEN)
  679.                 return 0;
  680.         return tl_tab[p];
  681. }
  682.  
  683. static signed int op_calc1(UINT32 phase, unsigned int env, signed int pm)
  684. {
  685.         UINT32 p;
  686.  
  687.         p = (env<<3) + sin_tab[ ( ((signed int)(int(phase & ~FREQ_MASK) + pm      )) >> FREQ_SH ) & SIN_MASK ];
  688.  
  689.         if (p >= TL_TAB_LEN)
  690.                 return 0;
  691.         return tl_tab[p];
  692. }
  693.  
  694.  
  695. static void chan_calc(FM_OPN *OPN, FM_CH *CH)
  696. {
  697.     (void)OPN;
  698.     (void)CH;
  699.  
  700.     unsigned int eg_out;
  701.  
  702. //      UINT32 AM = 0;//LFO_AM >> CH->ams;
  703.  
  704.         _m2 = _c1 = _c2 = _mem = 0;
  705.  
  706.         *CH->mem_connect = CH->mem_value;       /* restore delayed sample (MEM) value to _m2 or _c2 */
  707.  
  708.         eg_out = CH->SLOT[SLOT1].vol_out;
  709.         {
  710.                 INT32 out = CH->op1_out[0] + CH->op1_out[1];
  711.                 CH->op1_out[0] = CH->op1_out[1];
  712.  
  713.                 if( !CH->connect1 ){
  714.                         /* algorithm 5  */
  715.                         _mem = _c1 = _c2 = CH->op1_out[0];
  716.                 }else{
  717.                         /* other algorithms */
  718.                         *CH->connect1 += CH->op1_out[0];
  719.                 }
  720.  
  721.                 CH->op1_out[1] = 0;
  722.                 if( eg_out < ENV_QUIET )        /* SLOT 1 */
  723.                 {
  724.                         if (!CH->FB)
  725.                                 out=0;
  726.  
  727.                         CH->op1_out[1] = op_calc1(CH->SLOT[SLOT1].phase, eg_out, (out<<CH->FB) );
  728.                 }
  729.         }
  730.  
  731.         eg_out = CH->SLOT[SLOT3].vol_out;
  732.         if( eg_out < ENV_QUIET )                /* SLOT 3 */
  733.                 *CH->connect3 += op_calc(CH->SLOT[SLOT3].phase, eg_out, _m2);
  734.  
  735.         eg_out = CH->SLOT[SLOT2].vol_out;
  736.         if( eg_out < ENV_QUIET )                /* SLOT 2 */
  737.                 *CH->connect2 += op_calc(CH->SLOT[SLOT2].phase, eg_out, _c1);
  738.  
  739.         eg_out = CH->SLOT[SLOT4].vol_out;
  740.         if( eg_out < ENV_QUIET )                /* SLOT 4 */
  741.                 *CH->connect4 += op_calc(CH->SLOT[SLOT4].phase, eg_out, _c2);
  742.  
  743.  
  744.         /* store current MEM */
  745.         CH->mem_value = _mem;
  746.  
  747.         /* update phase counters AFTER output calculations */
  748.         CH->SLOT[SLOT1].phase += CH->SLOT[SLOT1].Incr;
  749.         CH->SLOT[SLOT2].phase += CH->SLOT[SLOT2].Incr;
  750.         CH->SLOT[SLOT3].phase += CH->SLOT[SLOT3].Incr;
  751.         CH->SLOT[SLOT4].phase += CH->SLOT[SLOT4].Incr;
  752. }
  753.  
  754.  
  755. /* update phase increment and envelope generator */
  756. static void refresh_fc_eg_slot(FM_SLOT *SLOT , int fc , int kc )
  757. {
  758.         int ksr;
  759.  
  760.         /* (frequency) phase increment counter */
  761.         SLOT->Incr = (UINT32(fc+SLOT->DT[kc])*SLOT->mul) >> 1;
  762.  
  763.         ksr = kc >> SLOT->KSR;
  764.         if( SLOT->ksr != ksr )
  765.         {
  766.                 SLOT->ksr = UINT8(ksr);
  767.  
  768.                 /* calculate envelope generator rates */
  769.                 if ((SLOT->ar + SLOT->ksr) < 32+62)
  770.                 {
  771.                         SLOT->eg_sh_ar  = eg_rate_shift [SLOT->ar  + SLOT->ksr ];
  772.                         SLOT->eg_sel_ar = eg_rate_select[SLOT->ar  + SLOT->ksr ];
  773.                 }
  774.                 else
  775.                 {
  776.                         SLOT->eg_sh_ar  = 0;
  777.                         SLOT->eg_sel_ar = 17*RATE_STEPS;
  778.                 }
  779.  
  780.                 SLOT->eg_sh_d1r = eg_rate_shift [SLOT->d1r + SLOT->ksr];
  781.                 SLOT->eg_sel_d1r= eg_rate_select[SLOT->d1r + SLOT->ksr];
  782.  
  783.                 SLOT->eg_sh_d2r = eg_rate_shift [SLOT->d2r + SLOT->ksr];
  784.                 SLOT->eg_sel_d2r= eg_rate_select[SLOT->d2r + SLOT->ksr];
  785.  
  786.                 SLOT->eg_sh_rr  = eg_rate_shift [SLOT->rr  + SLOT->ksr];
  787.                 SLOT->eg_sel_rr = eg_rate_select[SLOT->rr  + SLOT->ksr];
  788.         }
  789. }
  790.  
  791. /* update phase increment counters */
  792. static void refresh_fc_eg_chan(FM_CH *CH )
  793. {
  794.         if( CH->SLOT[SLOT1].Incr==-1U){
  795.                 int fc = int(CH->fc);
  796.                 int kc = CH->kcode;
  797.                 refresh_fc_eg_slot(&CH->SLOT[SLOT1] , fc , kc );
  798.                 refresh_fc_eg_slot(&CH->SLOT[SLOT2] , fc , kc );
  799.                 refresh_fc_eg_slot(&CH->SLOT[SLOT3] , fc , kc );
  800.                 refresh_fc_eg_slot(&CH->SLOT[SLOT4] , fc , kc );
  801.         }
  802. }
  803.  
  804. /* initialize time tables */
  805. static void init_timetables( FM_ST *ST , const UINT8 *dttable )
  806. {
  807.         int i,d;
  808.         double rate;
  809.  
  810. #if 0
  811.         logerror("FM.C: samplerate=%8i chip clock=%8i  freqbase=%f  \n",
  812.                          ST->rate, ST->clock, ST->freqbase );
  813. #endif
  814.  
  815.         /* DeTune table */
  816.         for (d = 0;d <= 3;d++){
  817.                 for (i = 0;i <= 31;i++){
  818.                         rate = ((double)dttable[d*32 + i]) * SIN_LEN  * ST->freqbase  * (1<<FREQ_SH) / ((double)(1<<20));
  819.                         ST->dt_tab[d][i]   = (INT32) rate;
  820.                         ST->dt_tab[d+4][i] = -(INT32) rate;
  821. #if 0
  822.                         logerror("FM.C: DT [%2i %2i] = %8x  \n", d, i, ST->dt_tab[d][i] );
  823. #endif
  824.                 }
  825.         }
  826.  
  827. }
  828.  
  829. static void reset_channels( FM_ST *ST , FM_CH *CH , int num )
  830. {
  831.         int c,s;
  832.  
  833.         ST->mode   = 0; /* normal mode */
  834.         ST->TA     = 0;
  835.         ST->TAC    = 0;
  836.         ST->TB     = 0;
  837.         ST->TBC    = 0;
  838.  
  839.         for( c = 0 ; c < num ; c++ )
  840.         {
  841.                 CH[c].fc = 0;
  842.                 for(s = 0 ; s < 4 ; s++ )
  843.                 {
  844.                         CH[c].SLOT[s].ssg = 0;
  845.                         CH[c].SLOT[s].ssgn = 0;
  846.                         CH[c].SLOT[s].state= EG_OFF;
  847.                         CH[c].SLOT[s].volume = MAX_ATT_INDEX;
  848.                         CH[c].SLOT[s].vol_out= MAX_ATT_INDEX;
  849.                 }
  850.         }
  851. }
  852.  
  853. /* initialize generic tables */
  854. static int init_tables(void)
  855. {
  856.         signed int i,x;
  857.         signed int n;
  858.         double o,m;
  859.  
  860.         for (x=0; x<TL_RES_LEN; x++)
  861.         {
  862.                 m = (1<<16) / pow((double)2, (double)((x+1) * (ENV_STEP/4.0) / 8.0));
  863.                 m = floor(m);
  864.  
  865.                 /* we never reach (1<<16) here due to the (x+1) */
  866.                 /* result fits within 16 bits at maximum */
  867.  
  868.                 n = (int)m;             /* 16 bits here */
  869.                 n >>= 4;                /* 12 bits here */
  870.                 if (n&1)                /* round to nearest */
  871.                         n = (n>>1)+1;
  872.                 else
  873.                         n = n>>1;
  874.                                                 /* 11 bits here (rounded) */
  875.                 n <<= 2;                /* 13 bits here (as in real chip) */
  876.                 tl_tab[ x*2 + 0 ] = INT16(n);
  877.                 tl_tab[ x*2 + 1 ] = INT16(-n);
  878.  
  879.                 for (i=1; i<13; i++)
  880.                 {
  881.                         tl_tab[ x*2+0 + i*2*TL_RES_LEN ] =  INT16(n>>i);
  882.                         tl_tab[ x*2+1 + i*2*TL_RES_LEN ] = INT16(-(n>>i));
  883.                 }
  884.         }
  885.         /*logerror("FM.C: TL_TAB_LEN = %i elements (%i bytes)\n",TL_TAB_LEN, (int)sizeof(tl_tab));*/
  886.  
  887.  
  888.         for (i=0; i<SIN_LEN; i++)
  889.         {
  890.                 /* non-standard sinus */
  891.                 m = sin( ((i*2)+1) * PI / SIN_LEN ); /* checked against the real chip */
  892.  
  893.                 /* we never reach zero here due to ((i*2)+1) */
  894.                 if (m>0.0)
  895.                         o = 8*(double)log(1.0/m)/log((double)2);        /* convert to 'decibels' */
  896.                 else
  897.                         o = 8*(double)log(-1.0/m)/log((double)2);       /* convert to 'decibels' */
  898.  
  899.                 o = o / (ENV_STEP/4);
  900.  
  901.                 n = (int)(2.0*o);
  902.                 if (n&1)                                                /* round to nearest */
  903.                         n = (n>>1)+1;
  904.                 else
  905.                         n = n>>1;
  906.  
  907.                 sin_tab[ i ] = UINT16(n*2 + (m>=0.0? 0: 1 ));
  908. //              printf("FM.C: sin [%4i]= %4i (tl_tab value=%5i)\n", i, sin_tab[i],tl_tab[sin_tab[i]]);
  909.         }
  910.  
  911.         /*logerror("FM.C: ENV_QUIET= %08x\n",ENV_QUIET );*/
  912.  
  913.         return 1;
  914. }
  915.  
  916. static void FMCloseTable( void )
  917. {
  918. #ifdef SAVE_SAMPLE
  919. //      fclose(sample[0]);
  920. #endif
  921.         return;
  922. }
  923.  
  924. /* CSM Key Controll */
  925. static void CSMKeyControll(FM_CH *CH)
  926. {
  927.         /* this is wrong, atm */
  928.  
  929.         /* all key on */
  930.         FM_KEYON(CH,SLOT1);
  931.         FM_KEYON(CH,SLOT2);
  932.         FM_KEYON(CH,SLOT3);
  933.         FM_KEYON(CH,SLOT4);
  934. }
  935.  
  936.  
  937. __inline void advance_eg_channel(FM_OPN *OPN, FM_SLOT *SLOT)
  938. {
  939.         unsigned int out;
  940.         unsigned int swap_flag = 0;
  941.         unsigned int i;
  942.  
  943.  
  944.         i = 4; /* four operators per channel */
  945.         do
  946.         {
  947.                 switch(SLOT->state)
  948.                 {
  949.                 case EG_ATT:            /* attack phase */
  950.                         if ( !(OPN->eg_cnt & ((1<<SLOT->eg_sh_ar)-1) ) )
  951.                         {
  952.                                 SLOT->volume += (~SLOT->volume *
  953.                                   (eg_inc[SLOT->eg_sel_ar + ((OPN->eg_cnt>>SLOT->eg_sh_ar)&7)])
  954.                                 ) >>4;
  955.  
  956.                                 if (SLOT->volume <= MIN_ATT_INDEX)
  957.                                 {
  958.                                         SLOT->volume = MIN_ATT_INDEX;
  959.                                         SLOT->state = EG_DEC;
  960.                                 }
  961.                         }
  962.                 break;
  963.  
  964.                 case EG_DEC:    /* decay phase */
  965.                         if (SLOT->ssg&0x08)     /* SSG EG type envelope selected */
  966.                         {
  967.                                 if ( !(OPN->eg_cnt & ((1<<SLOT->eg_sh_d1r)-1) ) )
  968.                                 {
  969.                                         SLOT->volume += 4 * eg_inc[SLOT->eg_sel_d1r + ((OPN->eg_cnt>>SLOT->eg_sh_d1r)&7)];
  970.  
  971.                                         if ( (UINT32)SLOT->volume >= SLOT->sl )
  972.                                                 SLOT->state = EG_SUS;
  973.                                 }
  974.                         }
  975.                         else
  976.                         {
  977.                                 if ( !(OPN->eg_cnt & ((1<<SLOT->eg_sh_d1r)-1) ) )
  978.                                 {
  979.                                         SLOT->volume += eg_inc[SLOT->eg_sel_d1r + ((OPN->eg_cnt>>SLOT->eg_sh_d1r)&7)];
  980.  
  981.                                         if ( (UINT32)SLOT->volume >= SLOT->sl )
  982.                                                 SLOT->state = EG_SUS;
  983.                                 }
  984.                         }
  985.                 break;
  986.  
  987.                 case EG_SUS:    /* sustain phase */
  988.                         if (SLOT->ssg&0x08)     /* SSG EG type envelope selected */
  989.                         {
  990.                                 if ( !(OPN->eg_cnt & ((1<<SLOT->eg_sh_d2r)-1) ) )
  991.                                 {
  992.                                         SLOT->volume += 4 * eg_inc[SLOT->eg_sel_d2r + ((OPN->eg_cnt>>SLOT->eg_sh_d2r)&7)];
  993.  
  994.                                         if ( SLOT->volume >= 512 /* с√ыю MAX_ATT_INDEX */ ) //Alone Coder
  995.                                         {
  996.                                                 SLOT->volume = MAX_ATT_INDEX;
  997.  
  998.                                                 if (SLOT->ssg&0x01)     /* bit 0 = hold */
  999.                                                 {
  1000.                                                         if (SLOT->ssgn&1)       /* have we swapped once ??? */
  1001.                                                         {
  1002.                                                                 /* yes, so do nothing, just hold current level */
  1003.                                                         }
  1004.                                                         else
  1005.                                                                 swap_flag = (SLOT->ssg&0x02) | 1 ; /* bit 1 = alternate */
  1006.  
  1007.                                                 }
  1008.                                                 else
  1009.                                                 {
  1010.                                                         /* same as KEY-ON operation */
  1011.  
  1012.                                                         /* restart of the Phase Generator should be here,
  1013.                                 only if AR is not maximum ??? ALWAYS! */
  1014.                                                         SLOT->phase = 0; //Alone Coder
  1015.  
  1016.                                                         /* phase -> Attack */
  1017.                                                    SLOT->volume = 511; //Alone Coder
  1018.                                                         SLOT->state = EG_ATT;
  1019.  
  1020.                                                         swap_flag = (SLOT->ssg&0x02); /* bit 1 = alternate */
  1021.                                                 }
  1022.                                         }
  1023.                                 }
  1024.                         }
  1025.                         else
  1026.                         {
  1027.                                 if ( !(OPN->eg_cnt & ((1<<SLOT->eg_sh_d2r)-1) ) )
  1028.                                 {
  1029.                                         SLOT->volume += eg_inc[SLOT->eg_sel_d2r + ((OPN->eg_cnt>>SLOT->eg_sh_d2r)&7)];
  1030.  
  1031.                                         if ( SLOT->volume >= MAX_ATT_INDEX )
  1032.                                         {
  1033.                                                 SLOT->volume = MAX_ATT_INDEX;
  1034.                                                 /* do not change SLOT->state (verified on real chip) */
  1035.                                         }
  1036.                                 }
  1037.  
  1038.                         }
  1039.                 break;
  1040.  
  1041.                 case EG_REL:    /* release phase */
  1042.                                 if ( !(OPN->eg_cnt & ((1<<SLOT->eg_sh_rr)-1) ) )
  1043.                                 {
  1044.                                         SLOT->volume += eg_inc[SLOT->eg_sel_rr + ((OPN->eg_cnt>>SLOT->eg_sh_rr)&7)];
  1045.  
  1046.                                         if ( SLOT->volume >= MAX_ATT_INDEX )
  1047.                                         {
  1048.                                                 SLOT->volume = MAX_ATT_INDEX;
  1049.                                                 SLOT->state = EG_OFF;
  1050.                                         }
  1051.                                 }
  1052.                 break;
  1053.  
  1054.                 }
  1055.  
  1056.                 out = SLOT->tl + ((UINT32)SLOT->volume);
  1057.  
  1058.                 if ((SLOT->ssg&0x08) && (SLOT->ssgn&2) && (SLOT->state != EG_OFF/*Alone Coder*/))       /* negate output (changes come from alternate bit, init comes from attack bit) */
  1059.                         out ^= 511/*Alone Coder*/; //((1<<ENV_BITS)-1); /* 1023 */
  1060.  
  1061.                 /* we need to store the result here because we are going to change ssgn
  1062.             in next instruction */
  1063.                 SLOT->vol_out = out;
  1064.  
  1065.                 SLOT->ssgn ^= swap_flag;
  1066.  
  1067.                 SLOT++;
  1068.                 i--;
  1069.         }while (i);
  1070.  
  1071. }
  1072.  
  1073. #ifdef _STATE_H
  1074.  
  1075. enum { SS_INT8, SS_UINT8, SS_INT16, SS_UINT16, SS_INT32, SS_UINT32, SS_INT, SS_DOUBLE, SS_FLOAT};
  1076.  
  1077. static void ss_register_entry(const char *module, int instance, const char *name, int type, void *data, unsigned int size)
  1078. {
  1079.         int i;
  1080.         FILE* logfile=fopen("logfile.log", "a+");
  1081.         if(!logfile)
  1082.                 return;
  1083.  
  1084.         fprintf(logfile,"%20s:%3d [%10s]: ",module,instance,name);
  1085.  
  1086.         if (type==SS_INT8) { fprintf(logfile,"INT8   "); for (i=0;i<(int)size;i++) fprintf(logfile,"[%2x]#%+02x ",i,((signed char*)data)[i]); }
  1087.         if (type==SS_INT16) { fprintf(logfile,"INT16  "); for (i=0;i<(int)size;i++) fprintf(logfile,"[%2x]#%+04x ",i,((signed short*)data)[i]); }
  1088.         if (type==SS_INT32) { fprintf(logfile,"INT32  "); for (i=0;i<(int)size;i++) fprintf(logfile,"[%2x]#%+08x ",i,((signed int*)data)[i]); }
  1089.         if (type==SS_UINT8&&size==256) {
  1090.                 fprintf(logfile,"UINT8  ");
  1091.                 for (i=0;i<(int)size;i++) {
  1092.                         if (i%16==0) fprintf(logfile,"\n");
  1093.                         fprintf(logfile,"[%02x]#%02x ",i,((unsigned char*)data)[i]);
  1094.                 }
  1095.         }
  1096.         else if (type==SS_UINT8) { fprintf(logfile,"UINT8  "); for (i=0;i<(int)size;i++) fprintf(logfile,"[%2x]#%02x ",i,((unsigned char*)data)[i]); }
  1097.         if (type==SS_UINT16) { fprintf(logfile,"UINT16 "); for (i=0;i<(int)size;i++) fprintf(logfile,"[%2x]#%04x ",i,((unsigned short*)data)[i]); }
  1098.         if (type==SS_UINT32) { fprintf(logfile,"UINT32 "); for (i=0;i<(int)size;i++) fprintf(logfile,"[%2x]#%08x ",i,((unsigned int*)data)[i]); }
  1099.  
  1100.         if (type==SS_INT) { fprintf(logfile,"INT    "); fprintf(logfile,"    %d ",((int*)data)[0]); }
  1101.         if (type==SS_DOUBLE) { fprintf(logfile,"DOUBLE "); for (i=0;i<(int)size;i++) fprintf(logfile,"[%d]%f ",i,((double*)data)[i]); }
  1102.         if (type==SS_FLOAT) { fprintf(logfile,"FLOAT  "); for (i=0;i<(int)size;i++) fprintf(logfile,"[%d]%f ",i, (double)((float*)data)[i]); }
  1103.  
  1104.         fprintf(logfile,"\n");
  1105.  
  1106.         fclose(logfile);
  1107.         return;
  1108. }
  1109.  
  1110. static void state_save_register_UINT8 (const char *module, int instance, const char *name, UINT8 *val, unsigned size)
  1111. { ss_register_entry(module, instance, name, SS_UINT8, val, size); }
  1112.  
  1113. static void state_save_register_INT8  (const char *module, int instance, const char *name, INT8 *val, unsigned size)
  1114. { ss_register_entry(module, instance, name, SS_INT8, val, size); }
  1115.  
  1116. static void state_save_register_UINT16(const char *module, int instance, const char *name, UINT16 *val, unsigned size)
  1117. { ss_register_entry(module, instance, name, SS_UINT16, val, size); }
  1118.  
  1119. static void state_save_register_INT16 (const char *module, int instance, const char *name, INT16 *val, unsigned size)
  1120. { ss_register_entry(module, instance, name, SS_INT16, val, size); }
  1121.  
  1122. static void state_save_register_UINT32(const char *module, int instance, const char *name, UINT32 *val, unsigned size)
  1123. { ss_register_entry(module, instance, name, SS_UINT32, val, size); }
  1124.  
  1125. static void state_save_register_INT32 (const char *module, int instance, const char *name, INT32 *val, unsigned size)
  1126. { ss_register_entry(module, instance, name, SS_INT32, val, size); }
  1127.  
  1128. static void state_save_register_int   (const char *module, int instance, const char *name, int *val)
  1129. { ss_register_entry(module, instance, name, SS_INT, val, 1); }
  1130.  
  1131. static void state_save_register_double(const char *module, int instance, const char *name, double *val, unsigned size)
  1132. { ss_register_entry(module, instance, name, SS_DOUBLE, val, size); }
  1133.  
  1134. static void state_save_register_float(const char *module, int instance, const char *name, float *val, unsigned size)
  1135. { ss_register_entry(module, instance, name, SS_FLOAT, val, size); }
  1136.  
  1137.  
  1138. /* FM channel save , internal state only */
  1139. static void FMsave_state_channel(const char *name,int num,FM_CH *CH,int num_ch)
  1140. {
  1141.         int slot , ch;
  1142.         char state_name[20];
  1143.         const char slot_array[4] = { 1 , 3 , 2 , 4 };
  1144.  
  1145.         for(ch=0;ch<num_ch;ch++,CH++)
  1146.         {
  1147.                 /* channel */
  1148.                 sprintf(state_name,"%s.CH%d",name,ch);
  1149.                 state_save_register_INT32(state_name, num, "feedback" , CH->op1_out , 2);
  1150.                 state_save_register_UINT32(state_name, num, "phasestep"   , &CH->fc , 1);
  1151.                 state_save_register_UINT32(state_name, num, "block_fnum"   , &CH->block_fnum , 1);
  1152.                 /* slots */
  1153.                 for(slot=0;slot<4;slot++)
  1154.                 {
  1155.                         FM_SLOT *SLOT = &CH->SLOT[slot];
  1156.  
  1157.                         sprintf(state_name,"%s.CH%d.SLOT%d",name,ch,slot_array[slot]);
  1158.                         state_save_register_UINT32(state_name, num, "phasecount" , &SLOT->phase, 1);
  1159.                         state_save_register_UINT8 (state_name, num, "state"      , &SLOT->state, 1);
  1160.                         state_save_register_INT32 (state_name, num, "volume"     , &SLOT->volume, 1);
  1161.                 }
  1162.         }
  1163. }
  1164.  
  1165. static void FMsave_state_st(const char *state_name,int num,FM_ST *ST)
  1166. {
  1167. #if FM_BUSY_FLAG_SUPPORT
  1168.         state_save_register_double(state_name, num, "BusyExpire", &ST->BusyExpire , 1);
  1169. #endif
  1170.         state_save_register_UINT8 (state_name, num, "address"   , &ST->address , 1);
  1171.         state_save_register_UINT8 (state_name, num, "IRQ"       , &ST->irq     , 1);
  1172.         state_save_register_UINT8 (state_name, num, "IRQ MASK"  , &ST->irqmask , 1);
  1173.         state_save_register_UINT8 (state_name, num, "status"    , &ST->status  , 1);
  1174.         state_save_register_UINT32(state_name, num, "mode"      , &ST->mode    , 1);
  1175.         state_save_register_UINT8 (state_name, num, "prescaler" , &ST->prescaler_sel , 1);
  1176.         state_save_register_UINT8 (state_name, num, "freq latch", &ST->fn_h , 1);
  1177.         state_save_register_int   (state_name, num, "TIMER A"   , &ST->TA   );
  1178.         state_save_register_int   (state_name, num, "TIMER Acnt", &ST->TAC  );
  1179.         state_save_register_UINT8 (state_name, num, "TIMER B"   , &ST->TB   , 1);
  1180.         state_save_register_int   (state_name, num, "TIMER Bcnt", &ST->TBC  );
  1181.  
  1182.         state_save_register_int  (state_name, num, "clock"     , &ST->clock );
  1183.         state_save_register_int  (state_name, num, "rate"      , &ST->rate );
  1184. }
  1185.  
  1186. #endif // _STATE_H
  1187.  
  1188. /* prescaler set (and make time tables) */
  1189. static void OPNSetPres(FM_OPN *OPN , int pres , int TimerPres, int SSGpres)
  1190. {
  1191.         int i;
  1192.  
  1193.         /* frequency base */
  1194.         OPN->ST.freqbase = (OPN->ST.rate) ? ((double)OPN->ST.clock / OPN->ST.rate) / pres : 0;
  1195.  
  1196. #if 0
  1197.         OPN->ST.rate = (double)OPN->ST.clock / pres;
  1198.         OPN->ST.freqbase = 1.0;
  1199. #endif
  1200.  
  1201.         OPN->eg_timer_add  = (UINT32)((1<<EG_SH)  *  OPN->ST.freqbase);
  1202.         OPN->eg_timer_overflow = (UINT32)(( 3 ) * (1<<EG_SH));
  1203.  
  1204.         /* Timer base time */
  1205.         OPN->ST.TimerBase = 1.0/((double)OPN->ST.clock / (double)TimerPres);
  1206.  
  1207.         /* SSG part  prescaler set */
  1208. //      if( SSGpres ) (*OPN->ST.SSG->set_clock)( OPN->ST.param, OPN->ST.clock * 2 / SSGpres );
  1209.         OPN->ST.SSGclock = OPN->ST.clock * 2 / SSGpres;
  1210.  
  1211.         /* make time tables */
  1212.         init_timetables( &OPN->ST, dt_tab );
  1213.  
  1214.         /* there are 2048 FNUMs that can be generated using FNUM/BLK registers*/
  1215.         /* calculate fnumber -> increment counter table */
  1216.         for(i = 0; i < 2048; i++)
  1217.         {
  1218.                 /* freq table for octave 7 */
  1219.                 /* OPN phase increment counter = 20bit */
  1220.                 OPN->fn_table[i] = (UINT32)( (double)i * 64 * OPN->ST.freqbase * (1<<(FREQ_SH-10)) );
  1221.                 /* -10 because chip works with 10.10 fixed point, while we use 16.16 */
  1222.         }
  1223.  
  1224. }
  1225.  
  1226. /* write a OPN mode register 0x20-0x2f */
  1227. static void OPNWriteMode(FM_OPN *OPN, int r, int v)
  1228. {
  1229.         UINT8 c;
  1230.         FM_CH *CH;
  1231.  
  1232.         switch(r){
  1233.         case 0x21:      /* Test */
  1234.                 break;
  1235.         case 0x22:      /* LFO FREQ (YM2608/YM2610/YM2610B/YM2612) */
  1236.                 break;
  1237.         case 0x24:      /* timer A High 8*/
  1238.                 OPN->ST.TA = (OPN->ST.TA & 0x03)|(((int)v)<<2);
  1239.                 break;
  1240.         case 0x25:      /* timer A Low 2*/
  1241.                 OPN->ST.TA = (OPN->ST.TA & 0x3fc)|(v&3);
  1242.                 break;
  1243.         case 0x26:      /* timer B */
  1244.                 OPN->ST.TB = UINT8(v);
  1245.                 break;
  1246.         case 0x27:      /* mode, timer control */
  1247.                 set_timers( &(OPN->ST),OPN->ST.param,v );
  1248.                 break;
  1249.         case 0x28:      /* key on / off */
  1250.                 c = v & 0x03;
  1251.                 if( c == 3 ) break;
  1252.                 CH = OPN->P_CH;
  1253.                 CH = &CH[c];
  1254.                 if(v&0x10) FM_KEYON(CH,SLOT1); else FM_KEYOFF(CH,SLOT1);
  1255.                 if(v&0x20) FM_KEYON(CH,SLOT2); else FM_KEYOFF(CH,SLOT2);
  1256.                 if(v&0x40) FM_KEYON(CH,SLOT3); else FM_KEYOFF(CH,SLOT3);
  1257.                 if(v&0x80) FM_KEYON(CH,SLOT4); else FM_KEYOFF(CH,SLOT4);
  1258.                 break;
  1259.         }
  1260. }
  1261.  
  1262. /* write a OPN register (0x30-0xff) */
  1263. static void OPNWriteReg(FM_OPN *OPN, int r, int v)
  1264. {
  1265.         FM_CH *CH;
  1266.         FM_SLOT *SLOT;
  1267.  
  1268.         UINT8 c = OPN_CHAN(r);
  1269.  
  1270.         if (c == 3) return; /* 0xX3,0xX7,0xXB,0xXF */
  1271.  
  1272.         CH = OPN->P_CH;
  1273.         CH = &CH[c];
  1274.  
  1275.         SLOT = &(CH->SLOT[OPN_SLOT(r)]);
  1276.  
  1277.         switch( r & 0xf0 ) {
  1278.         case 0x30:      /* DET , MUL */
  1279.                 set_det_mul(&OPN->ST,CH,SLOT,v);
  1280.                 break;
  1281.  
  1282.         case 0x40:      /* TL */
  1283.                 set_tl(CH,SLOT,v);
  1284.                 break;
  1285.  
  1286.         case 0x50:      /* KS, AR */
  1287.                 set_ar_ksr(CH,SLOT,v);
  1288.                 break;
  1289.  
  1290.         case 0x60:      /*     DR */
  1291.                 set_dr(SLOT,v);
  1292.                 break;
  1293.  
  1294.         case 0x70:      /*     SR */
  1295.                 set_sr(SLOT,v);
  1296.                 break;
  1297.  
  1298.         case 0x80:      /* SL, RR */
  1299.                 set_sl_rr(SLOT,v);
  1300.                 break;
  1301.  
  1302.         case 0x90:      /* SSG-EG */
  1303.  
  1304.                 SLOT->ssg  =  v&0x0f;
  1305.                 SLOT->ssgn = (v&0x04)>>1; /* bit 1 in ssgn = attack */
  1306.  
  1307.                 /* SSG-EG envelope shapes :
  1308.  
  1309.         E AtAlH
  1310.         1 0 0 0  \\\\
  1311.  
  1312.         1 0 0 1  \___
  1313.  
  1314.         1 0 1 0  \/\/
  1315.                   ___
  1316.         1 0 1 1  \
  1317.  
  1318.         1 1 0 0  ////
  1319.                   ___
  1320.         1 1 0 1  /
  1321.  
  1322.         1 1 1 0  /\/\
  1323.  
  1324.         1 1 1 1  /___
  1325.  
  1326.  
  1327.         E = SSG-EG enable
  1328.  
  1329.         The shapes are generated using Attack, Decay and Sustain phases.
  1330.  
  1331.         Each single character in the diagrams above represents this whole
  1332.         sequence:
  1333.  
  1334.         - when KEY-ON = 1, normal Attack phase is generated (*without* any
  1335.           difference when compared to normal mode),
  1336.  
  1337.         - later, when envelope level reaches minimum level (max volume),
  1338.           the EG switches to Decay phase (which works with bigger steps
  1339.           when compared to normal mode - see below),
  1340.  
  1341.         - later when envelope level passes the SL level,
  1342.           the EG switches to Sustain phase (which works with bigger steps
  1343.           when compared to normal mode - see below),
  1344.  
  1345.         - finally when envelope level reaches maximum level (min volume),
  1346.           the EG switches to Attack phase again (depends on actual waveform).
  1347.  
  1348.         Important is that when switch to Attack phase occurs, the phase counter
  1349.         of that operator will be zeroed-out (as in normal KEY-ON) but not always.
  1350.         (I havent found the rule for that - perhaps only when the output level is low)
  1351.  
  1352.         The difference (when compared to normal Envelope Generator mode) is
  1353.         that the resolution in Decay and Sustain phases is 4 times lower;
  1354.         this results in only 256 steps instead of normal 1024.
  1355.         In other words:
  1356.         when SSG-EG is disabled, the step inside of the EG is one,
  1357.         when SSG-EG is enabled, the step is four (in Decay and Sustain phases).
  1358.  
  1359.         Times between the level changes are the same in both modes.
  1360.  
  1361.  
  1362.         Important:
  1363.         Decay 1 Level (so called SL) is compared to actual SSG-EG output, so
  1364.         it is the same in both SSG and no-SSG modes, with this exception:
  1365.  
  1366.         when the SSG-EG is enabled and is generating raising levels
  1367.         (when the EG output is inverted) the SL will be found at wrong level !!!
  1368.         For example, when SL=02:
  1369.             0 -6 = -6dB in non-inverted EG output
  1370.             96-6 = -90dB in inverted EG output
  1371.         Which means that EG compares its level to SL as usual, and that the
  1372.         output is simply inverted afterall.
  1373.  
  1374.  
  1375.         The Yamaha's manuals say that AR should be set to 0x1f (max speed).
  1376.         That is not necessary, but then EG will be generating Attack phase.
  1377.  
  1378.         */
  1379.  
  1380.  
  1381.                 break;
  1382.  
  1383.         case 0xa0:
  1384.                 switch( OPN_SLOT(r) ){
  1385.                 case 0:         /* 0xa0-0xa2 : FNUM1 */
  1386.                         {
  1387.                                 UINT32 fn = (((UINT32)( (OPN->ST.fn_h)&7))<<8) + UINT32(v);
  1388.                                 UINT8 blk = OPN->ST.fn_h>>3;
  1389.                                 /* keyscale code */
  1390.                                 CH->kcode = UINT8((blk<<2) | opn_fktable[fn >> 7]);
  1391.                                 /* phase increment counter */
  1392.                                 CH->fc = OPN->fn_table[fn]>>(7-blk);
  1393.  
  1394.                                 /* store fnum in clear form for LFO PM calculations */
  1395.                                 CH->block_fnum = UINT32(blk<<11U) | fn;
  1396.  
  1397.                                 CH->SLOT[SLOT1].Incr=-1U;
  1398.                         }
  1399.                         break;
  1400.                 case 1:         /* 0xa4-0xa6 : FNUM2,BLK */
  1401.                         OPN->ST.fn_h = v&0x3f;
  1402.                         break;
  1403.                 case 2:         /* 0xa8-0xaa : 3CH FNUM1 */
  1404.                         if(r < 0x100)
  1405.                         {
  1406.                                 UINT32 fn = (((UINT32)(OPN->SL3.fn_h&7))<<8) + UINT32(v);
  1407.                                 UINT8 blk = OPN->SL3.fn_h>>3;
  1408.                                 /* keyscale code */
  1409.                                 OPN->SL3.kcode[c]= UINT8((blk<<2) | opn_fktable[fn >> 7]);
  1410.                                 /* phase increment counter */
  1411.                                 OPN->SL3.fc[c] = OPN->fn_table[fn]>>(7-blk);
  1412.                                 OPN->SL3.block_fnum[c] = fn;
  1413.                                 (OPN->P_CH)[2].SLOT[SLOT1].Incr=-1U;
  1414.                         }
  1415.                         break;
  1416.                 case 3:         /* 0xac-0xae : 3CH FNUM2,BLK */
  1417.                         if(r < 0x100)
  1418.                                 OPN->SL3.fn_h = v&0x3f;
  1419.                         break;
  1420.                 }
  1421.                 break;
  1422.  
  1423.         case 0xb0:
  1424.                 switch( OPN_SLOT(r) ){
  1425.                 case 0:         /* 0xb0-0xb2 : FB,ALGO */
  1426.                         {
  1427.                                 int feedback = (v>>3)&7;
  1428.                                 CH->ALGO = v&7;
  1429.                                 CH->FB   = UINT8(feedback ? feedback+6 : 0);
  1430.                                 setup_connection( CH, c );
  1431.                         }
  1432.                         break;
  1433.                 }
  1434.                 break;
  1435.         }
  1436. }
  1437.  
  1438.  
  1439. /*
  1440.   prescaler circuit (best guess to verified chip behaviour)
  1441.  
  1442.                +--------------+  +-sel2-+
  1443.                |              +--|in20  |
  1444.          +---+ |  +-sel1-+       |      |
  1445. M-CLK -+-|1/2|-+--|in10  | +---+ |   out|--INT_CLOCK
  1446.        | +---+    |   out|-|1/3|-|in21  |
  1447.        +----------|in11  | +---+ +------+
  1448.                   +------+
  1449.  
  1450. reg.2d : sel2 = in21 (select sel2)
  1451. reg.2e : sel1 = in11 (select sel1)
  1452. reg.2f : sel1 = in10 , sel2 = in20 (clear selector)
  1453. reset  : sel1 = in11 , sel2 = in21 (clear both)
  1454.  
  1455. */
  1456. void OPNPrescaler_w(FM_OPN *OPN , int addr, int pre_divider)
  1457. {
  1458.         static const int opn_pres[4] = { 2*12 , 2*12 , 6*12 , 3*12 };
  1459.         static const int ssg_pres[4] = {    1 ,    1 ,    4 ,    2 };
  1460.         int sel;
  1461.  
  1462.         switch(addr)
  1463.         {
  1464.         case 0:         /* when reset */
  1465.                 OPN->ST.prescaler_sel = 2;
  1466.                 break;
  1467.         case 1:         /* when postload */
  1468.                 break;
  1469.         case 0x2d:      /* divider sel : select 1/1 for 1/3line    */
  1470.                 OPN->ST.prescaler_sel |= 0x02;
  1471.                 break;
  1472.         case 0x2e:      /* divider sel , select 1/3line for output */
  1473.                 OPN->ST.prescaler_sel |= 0x01;
  1474.                 break;
  1475.         case 0x2f:      /* divider sel , clear both selector to 1/2,1/2 */
  1476.                 OPN->ST.prescaler_sel = 0;
  1477.                 break;
  1478.         }
  1479.         sel = OPN->ST.prescaler_sel & 3;
  1480.         /* update prescaler */
  1481.         OPNSetPres( OPN,        opn_pres[sel]*pre_divider,
  1482.                                                 opn_pres[sel]*pre_divider,
  1483.                                                 ssg_pres[sel]*pre_divider );
  1484. }
  1485.  
  1486. /*****************************************************************************/
  1487. /*      YM2203 local section                                                 */
  1488. /*****************************************************************************/
  1489.  
  1490. /* Generate samples for one of the YM2203s */
  1491. void YM2203UpdateOne(void *chip, FMSAMPLE *buffer, int length)
  1492. {
  1493.         YM2203 *F2203 = (YM2203 *)chip;
  1494.         FM_OPN *OPN =   &F2203->OPN;
  1495.         int i;
  1496.         FMSAMPLE *buf = buffer;
  1497.  
  1498.         _cur_chip = (void *)F2203;
  1499.         _State    = &F2203->OPN.ST;
  1500.         _cch[0]   = &F2203->CH[0];
  1501.         _cch[1]   = &F2203->CH[1];
  1502.         _cch[2]   = &F2203->CH[2];
  1503.  
  1504.         /* refresh PG and EG */
  1505.         refresh_fc_eg_chan( _cch[0] );
  1506.         refresh_fc_eg_chan( _cch[1] );
  1507.         if( ((_State->mode & 0xc0) == 0x40) )
  1508.         {
  1509.                 // 3SLOT MODE
  1510.                 if( _cch[2]->SLOT[SLOT1].Incr==-1U)
  1511.                 {
  1512.                         refresh_fc_eg_slot(&_cch[2]->SLOT[SLOT1] , int(OPN->SL3.fc[1]) , OPN->SL3.kcode[1] );
  1513.                         refresh_fc_eg_slot(&_cch[2]->SLOT[SLOT2] , int(OPN->SL3.fc[2]) , OPN->SL3.kcode[2] );
  1514.                         refresh_fc_eg_slot(&_cch[2]->SLOT[SLOT3] , int(OPN->SL3.fc[0]) , OPN->SL3.kcode[0] );
  1515.                         refresh_fc_eg_slot(&_cch[2]->SLOT[SLOT4] , int(_cch[2]->fc) , _cch[2]->kcode );
  1516.                 }
  1517.         }else
  1518.         refresh_fc_eg_chan( _cch[2] );
  1519.  
  1520.  
  1521.         /* buffering */
  1522.         for (i=0; i < length ; i++)
  1523.         {
  1524.                 /* clear outputs */
  1525.                 _out_fm[0] = 0;
  1526.                 _out_fm[1] = 0;
  1527.                 _out_fm[2] = 0;
  1528.  
  1529.                 /* advance envelope generator */
  1530.                 OPN->eg_timer += OPN->eg_timer_add;
  1531.                 while (OPN->eg_timer >= OPN->eg_timer_overflow)
  1532.                 {
  1533.                         OPN->eg_timer -= OPN->eg_timer_overflow;
  1534.                         OPN->eg_cnt++;
  1535.  
  1536.                         advance_eg_channel(OPN, &_cch[0]->SLOT[SLOT1]);
  1537.                         advance_eg_channel(OPN, &_cch[1]->SLOT[SLOT1]);
  1538.                         advance_eg_channel(OPN, &_cch[2]->SLOT[SLOT1]);
  1539.                 }
  1540.  
  1541.                 /* calculate FM */
  1542.                 chan_calc(OPN, _cch[0] );
  1543.                 chan_calc(OPN, _cch[1] );
  1544.                 chan_calc(OPN, _cch[2] );
  1545.  
  1546.                 /* buffering */
  1547.                 {
  1548.                         int lt;
  1549.                         lt = _out_fm[0] + _out_fm[1] + _out_fm[2];
  1550.                         lt >>= FINAL_SH;
  1551.                         Limit( lt , MAXOUT, MINOUT );
  1552. //                      #ifdef SAVE_SAMPLE
  1553. //                              SAVE_ALL_CHANNELS
  1554. //                      #endif
  1555.  
  1556.                         /* buffering */
  1557.                         buf[i] = FMSAMPLE(lt);
  1558.                 }
  1559.  
  1560.                 /* timer A control */
  1561.                 INTERNAL_TIMER_A( _State , _cch[2] )
  1562.         }
  1563.         INTERNAL_TIMER_B(_State,length)
  1564. }
  1565.  
  1566. /* ---------- reset one of chip ---------- */
  1567. void YM2203ResetChip(void *chip)
  1568. {
  1569.         int i;
  1570.         YM2203 *F2203 = (YM2203 *)chip;
  1571.         FM_OPN *OPN = &F2203->OPN;
  1572.  
  1573.         /* Reset Prescaler */
  1574.         OPNPrescaler_w(OPN, 0 , 1 );
  1575.         /* reset SSG section */
  1576. //      (*OPN->ST.SSG->reset)(OPN->ST.param);
  1577.         /* status clear */
  1578.         FM_IRQMASK_SET(&OPN->ST,0x03);
  1579.         FM_BUSY_CLEAR(&OPN->ST);
  1580.         OPNWriteMode(OPN,0x27,0x30); /* mode 0 , timer reset */
  1581.  
  1582.         OPN->eg_timer = 0;
  1583.         OPN->eg_cnt   = 0;
  1584.  
  1585.         FM_STATUS_RESET(&OPN->ST, 0xff);
  1586.  
  1587.         reset_channels( &OPN->ST , F2203->CH , 3 );
  1588.         /* reset OPerator paramater */
  1589.         for(i = 0xb2 ; i >= 0x30 ; i-- ) OPNWriteReg(OPN,i,0);
  1590.         for(i = 0x26 ; i >= 0x20 ; i-- ) OPNWriteReg(OPN,i,0);
  1591. }
  1592.  
  1593. #ifdef _STATE_H
  1594. void YM2203Postload(void *chip)
  1595. {
  1596.         if (chip)
  1597.         {
  1598.                 YM2203 *F2203 = (YM2203 *)chip;
  1599.                 int r;
  1600.  
  1601.                 /* prescaler */
  1602.                 OPNPrescaler_w(&F2203->OPN,1,1);
  1603.  
  1604.                 /* SSG registers */
  1605.                 for(r=0;r<16;r++)
  1606.                 {
  1607. //                      (*F2203->OPN.ST.SSG->write)(F2203->OPN.ST.param,0,r);
  1608. //                      (*F2203->OPN.ST.SSG->write)(F2203->OPN.ST.param,1,F2203->REGS[r]);
  1609.                 }
  1610.  
  1611.                 /* OPN registers */
  1612.                 /* DT / MULTI , TL , KS / AR , AMON / DR , SR , SL / RR , SSG-EG */
  1613.                 for(r=0x30;r<0x9e;r++)
  1614.                         if((r&3) != 3)
  1615.                                 OPNWriteReg(&F2203->OPN,r,F2203->REGS[r]);
  1616.                 /* FB / CONNECT , L / R / AMS / PMS */
  1617.                 for(r=0xb0;r<0xb6;r++)
  1618.                         if((r&3) != 3)
  1619.                                 OPNWriteReg(&F2203->OPN,r,F2203->REGS[r]);
  1620.  
  1621.                 /* channels */
  1622.                 /*FM_channel_postload(F2203->CH,3);*/
  1623.         }
  1624.         _cur_chip = nullptr;
  1625. }
  1626.  
  1627. void YM2203_save_state(void *chip, int index)
  1628. {
  1629.         if (chip)
  1630.         {
  1631.                 YM2203 *F2203 = (YM2203 *)chip;
  1632.                 const char statename[] = "YM2203";
  1633.  
  1634.                 state_save_register_UINT8 (statename, index, "regs"   , F2203->REGS   , 256);
  1635.                 FMsave_state_st(statename,index,&F2203->OPN.ST);
  1636.                 FMsave_state_channel(statename,index,F2203->CH,3);
  1637.                 /* 3slots */
  1638.                 state_save_register_UINT32 (statename, index, "slot3fc" , F2203->OPN.SL3.fc , 3);
  1639.                 state_save_register_UINT8  (statename, index, "slot3fh" , &F2203->OPN.SL3.fn_h , 1);
  1640.                 state_save_register_UINT8  (statename, index, "slot3kc" , F2203->OPN.SL3.kcode , 3);
  1641.         }
  1642. }
  1643. #endif /* _STATE_H */
  1644.  
  1645. /* ----------  Initialize YM2203 emulator(s) ----------
  1646.    'num' is the number of virtual YM2203s to allocate
  1647.    'clock' is the chip clock in Hz
  1648.    'rate' is sampling rate
  1649. */
  1650. void * YM2203Init(void *param, int index, int clock, int rate
  1651. //                              ,FM_TIMERHANDLER TimerHandler,FM_IRQHANDLER IRQHandler,
  1652. //               const struct ssg_callbacks *ssg
  1653.                )
  1654. {
  1655.     (void)index;
  1656.  
  1657.         YM2203 *F2203;
  1658.  
  1659.         _cur_chip = nullptr;    /* hiro-shi!! */
  1660.  
  1661.         /* allocate ym2203 state space */
  1662.         if( (F2203 = (YM2203 *)malloc(sizeof(YM2203)))==nullptr)
  1663.                 return nullptr;
  1664.         /* clear */
  1665.         memset(F2203,0,sizeof(YM2203));
  1666.  
  1667.         if( !init_tables() )
  1668.         {
  1669.                 free( F2203 );
  1670.                 return nullptr;
  1671.         }
  1672.  
  1673.         F2203->OPN.ST.param = param;
  1674.         F2203->OPN.type = TYPE_YM2203;
  1675.         F2203->OPN.P_CH = F2203->CH;
  1676.         F2203->OPN.ST.clock = clock;
  1677.         F2203->OPN.ST.rate = rate;
  1678.  
  1679. //      F2203->OPN.ST.Timer_Handler = TimerHandler;
  1680. //      F2203->OPN.ST.IRQ_Handler   = IRQHandler;
  1681. //      F2203->OPN.ST.SSG           = ssg;
  1682.         YM2203ResetChip(F2203);
  1683.  
  1684. #ifdef _STATE_H
  1685.         YM2203_save_state(F2203, index);
  1686. #endif
  1687.         return F2203;
  1688. }
  1689.  
  1690. /* shut down emulator */
  1691. void YM2203Shutdown(void *chip)
  1692. {
  1693.         YM2203 *FM2203 = (YM2203 *)chip;
  1694.  
  1695.         FMCloseTable();
  1696.         free(FM2203);
  1697.         chip=nullptr;
  1698. }
  1699.  
  1700. /* YM2203 I/O interface */
  1701. int YM2203Write(void *chip,int a,UINT8 v)
  1702. {
  1703.         YM2203 *F2203 = (YM2203 *)chip;
  1704.         FM_OPN *OPN = &F2203->OPN;
  1705.  
  1706.         if( !(a&1) )
  1707.         {       // address port
  1708.                 OPN->ST.address = (v &= 0xff);
  1709.  
  1710.                 // Write register to SSG emulator
  1711. //              if( v < 16 ) (*OPN->ST.SSG->write)(OPN->ST.param,0,v);
  1712.  
  1713.         }
  1714.         else
  1715.         {       // data port
  1716.                 int addr = OPN->ST.address;
  1717.                 // prescaler select : 2d,2e,2f
  1718.                 if( addr >= 0x2d && addr <= 0x2f )
  1719.                         OPNPrescaler_w(OPN , addr , 1);
  1720.                 else {
  1721. //#ifdef _STATE_H
  1722.                         F2203->REGS[addr] = v;
  1723. //#endif
  1724.                         switch( addr & 0xf0 )
  1725.                         {
  1726.                         case 0x00:      /* 0x00-0x0f : SSG section */
  1727.                                 /* Write data to SSG emulator */
  1728. //                              (*OPN->ST.SSG->write)(OPN->ST.param,a,v);
  1729.                                 break;
  1730.                         case 0x20:      /* 0x20-0x2f : Mode section */
  1731. //                              YM2203UpdateReq(OPN->ST.param);
  1732.                                 /* write register */
  1733.                                 OPNWriteMode(OPN,addr,v);
  1734.                                 break;
  1735.                         default:        /* 0x30-0xff : OPN section */
  1736. //                              YM2203UpdateReq(OPN->ST.param);
  1737.                                 /* write register */
  1738.                                 OPNWriteReg(OPN,addr,v);
  1739.                         }
  1740.                         FM_BUSY_SET(&OPN->ST,1);
  1741.                 }
  1742.         }
  1743.         return OPN->ST.irq;
  1744. }
  1745.  
  1746. UINT8 YM2203Read(void *chip,int a)
  1747. {
  1748.         YM2203 *F2203 = (YM2203 *)chip;
  1749. //      int addr = F2203->OPN.ST.address;
  1750.         UINT8 ret = 0;
  1751.  
  1752.         if( !(a&1) )
  1753.         {       /* status port */
  1754.                 ret = FM_STATUS_FLAG(&F2203->OPN.ST);
  1755.         }
  1756.         else
  1757.         {       /* data port (only SSG) */
  1758. //              if( addr < 16 ) ret = (*F2203->OPN.ST.SSG->read)(F2203->OPN.ST.param);
  1759.         }
  1760.         return ret;
  1761. }
  1762.  
  1763. int YM2203TimerOver(void *chip,int c)
  1764. {
  1765.         YM2203 *F2203 = (YM2203 *)chip;
  1766.  
  1767.         if( c )
  1768.         {       /* Timer B */
  1769.                 TimerBOver( &(F2203->OPN.ST) );
  1770.         }
  1771.         else
  1772.         {       /* Timer A */
  1773. //              YM2203UpdateReq(F2203->OPN.ST.param);
  1774.                 /* timer update */
  1775.                 TimerAOver( &(F2203->OPN.ST) );
  1776.                 /* CSM mode key,TL control */
  1777.                 if( F2203->OPN.ST.mode & 0x80 )
  1778.                 {       /* CSM mode auto key on */
  1779.                         CSMKeyControll( &(F2203->CH[2]) );
  1780.                 }
  1781.         }
  1782.         return F2203->OPN.ST.irq;
  1783. }
  1784.