16/vgmsnd/vgmSndDrv.c

   1 // vgmSndDrv.c - VGM Sound Driver for OPL2\r
   2 // Valley Bell, 2015-07-27\r
   3 \r
   4 // Note: This uses quite a few optimizations that assume that your\r
   5 //       machine is Little Endian.\r
   6 \r
   7 #include <stdio.h>\r
   8 #include <stdlib.h>\r
   9 #include <string.h>\r
  10 \r
  11 #include <common.h>\r
  12 #include "vgmSndDrv.h"\r
  13 \r
  14 \r
  15 #define QUICK_READ\r
  16 \r
  17 \r
  18 \r
  19 #define FCC_VGM 0x206D6756      // 'Vgm '\r
  20 #define FCC_GD3 0x20336447      // 'Gd3 '\r
  21 \r
  22 typedef struct _vgm_file_header_base\r
  23 {\r
  24         UINT32 fccVGM;                  // 00\r
  25         UINT32 lngEOFOffset;    // 04\r
  26         UINT32 lngVersion;              // 08\r
  27         UINT32 lngSkip1[2];             // 0C\r
  28         UINT32 lngGD3Offset;    // 14\r
  29         UINT32 lngTotalSamples; // 18\r
  30         UINT32 lngLoopOffset;   // 1C\r
  31         UINT32 lngLoopSamples;  // 20\r
  32         UINT32 lngRate;                 // 24\r
  33         UINT32 lngSkip2[3];             // 28\r
  34         UINT32 lngDataOffset;   // 34\r
  35         UINT32 lngSkip3[2];             // 38\r
  36 } VGM_BASE_HDR;\r
  37 \r
  38 #define PBMODE_MUSIC    0x00\r
  39 #define PBMODE_SFX              0x01\r
  40 typedef struct _vgm_playback\r
  41 {\r
  42         UINT8 pbMode;\r
  43         UINT8 vgmEnd;   // 00 - running, 01 - finished, FF - not loaded\r
  44         UINT16 curLoopCnt;\r
  45         UINT32 vgmPos;\r
  46         UINT32 vgmSmplPos;\r
  47         UINT32 pbSmplPos;\r
  48         VGM_FILE* file;\r
  49         \r
  50         // oplChnMask:\r
  51         //      Music: mask of channels used/overridden by SFX\r
  52         //      SFX:   ID of channel used by SFX (all commands are forces to it)\r
  53         UINT16 oplChnMask;\r
  54         UINT8* oplRegCache;\r
  55         UINT8 workRAM[0x04];\r
  56 } VGM_PBK;\r
  57 \r
  58 \r
  59 \r
  60 INLINE UINT16 ReadLE16(const UINT8* buffer)\r
  61 {\r
  62 #ifdef QUICK_READ\r
  63         return *(UINT16*)buffer;\r
  64 #else\r
  65         return (buffer[0x00] << 0) | (buffer[0x01] << 8);\r
  66 #endif\r
  67 }\r
  68 \r
  69 INLINE UINT32 ReadLE32(const UINT8* buffer)\r
  70 {\r
  71 #ifdef QUICK_READ\r
  72         return *(UINT32*)buffer;\r
  73 #else\r
  74         return  (buffer[0x00] <<  0) | (buffer[0x01] <<  8) |\r
  75                         (buffer[0x02] << 16) | (buffer[0x03] << 24);\r
  76 #endif\r
  77 }\r
  78 \r
  79 \r
  80 // Function Prototypes\r
  81 //UINT8 OpenVGMFile(const char* FileName, VGM_FILE* vgmFile);\r
  82 //void FreeVGMFile(VGM_FILE* vgmFile);\r
  83 \r
  84 static bool DoVgmLoop(VGM_PBK* vgmPlay);\r
  85 static void UpdateVGM(VGM_PBK* vgmPlay, UINT16 Samples);\r
  86 \r
  87 //void InitEngine(void);\r
  88 //void DeinitEngine(void);\r
  89 \r
  90 //UINT8 PlayMusic(VGM_FILE* vgmFile);\r
  91 //UINT8 PlaySFX(VGM_FILE* vgmFile, UINT8 sfxChnID);\r
  92 //UINT8 StopMusic(void);\r
  93 //UINT8 StopSFX(UINT8 sfxChnID);        // Note: sfxChnID == 0xFF -> stop all SFX\r
  94 //UINT8 PauseMusic(void);\r
  95 //UINT8 ResumeMusic(void);\r
  96 static void StartPlayback(VGM_PBK* vgmPb);\r
  97 static void StopPlayback(VGM_PBK* vgmPb);\r
  98 \r
  99 static void ym2413_write(VGM_PBK* vgmPb, UINT8 reg, UINT8 data);\r
 100 static void ym3812_write(VGM_PBK* vgmPb, UINT8 reg, UINT8 data);\r
 101 static void ym3512_write(VGM_PBK* vgmPb, UINT8 reg, UINT8 data);\r
 102 static void ymf262_write(VGM_PBK* vgmPb, UINT8 port, UINT8 reg, UINT8 data);\r
 103 \r
 104 //void UpdateSoundEngine(void);\r
 105 \r
 106 \r
 107 // Functions that must be supplied by external library\r
 108 extern void OPL2_Write(UINT8 reg, UINT8 data);\r
 109 extern UINT8 OPL2_ReadStatus(void);\r
 110 \r
 111 \r
 112 \r
 113 \r
 114 #define SFX_CHN_COUNT   6\r
 115 \r
 116 #define TIMER1_RATE             7       // 256-7 = 248; (3579545/72/4) / 248 = 50.12 Hz ~ 50 Hz\r
 117 #define VGM_UPD_RATE    880     // 880 samples (44.1 KHz) = 50.11 Hz\r
 118 \r
 119 static VGM_PBK vgmPbMusic;\r
 120 static VGM_PBK vgmPbSFX[SFX_CHN_COUNT];\r
 121 \r
 122 static UINT8 oplRegs_Music[0x100];\r
 123 static UINT8 oplRegs_SFX[SFX_CHN_COUNT][0x0D];  // 20 23 40 43 60 63 80 83 E0 E3 C0 A0 B0\r
 124 \r
 125 static const UINT8 SFX_REGS[0x0D] =\r
 126 {       0x20, 0x23, 0x40, 0x43, 0x60, 0x63, 0x80, 0x83,\r
 127         0xE0, 0xE3, 0xC0, 0xA0, 0xB0};\r
 128 static const UINT8 SFX_REGS_REV[0x10] = // 20/30 -> 0, 40/50 -> 2, ...\r
 129 {       0xFF, 0xFF, 0x00, 0x00, 0x02, 0x02, 0x04, 0x04,\r
 130         0x06, 0x06, 0x0B, 0x0C, 0x0A, 0xFF, 0x08, 0x08};\r
 131 static const UINT8 CHN_OPMASK[0x09] =\r
 132 {       0x00, 0x01, 0x02, 0x08, 0x09, 0x0A, 0x10, 0x11, 0x12};\r
 133 static const UINT8 CHN_OPMASK_REV[0x20] =\r
 134 {       0x00, 0x01, 0x02, 0x80, 0x81, 0x82, 0xFF, 0xFF,\r
 135         0x03, 0x04, 0x05, 0x83, 0x84, 0x85, 0xFF, 0xFF,\r
 136         0x06, 0x07, 0x08, 0x86, 0x87, 0x88, 0xFF, 0xFF,\r
 137         0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF};\r
 138 \r
 139 \r
 140 UINT8 OpenVGMFile(const char* FileName, VGM_FILE* vgmFile)\r
 141 {\r
 142         size_t hdrSize;\r
 143         size_t readEl;  // 'elements' read from file\r
 144         size_t bytesToRead;\r
 145         VGM_BASE_HDR vgmBaseHdr;\r
 146         FILE* hFile;\r
 147         UINT32 CurPos;\r
 148         \r
 149         memset(vgmFile, 0x00, sizeof(VGM_FILE));\r
 150         \r
 151         hFile = fopen(FileName, "rb");\r
 152         if (hFile == NULL)\r
 153                 return 0xFF;\r
 154         \r
 155         hdrSize = sizeof(VGM_BASE_HDR);\r
 156         readEl = fread(&vgmBaseHdr, hdrSize, 0x01, hFile);\r
 157         if (readEl <= 0)\r
 158         {\r
 159                 fclose(hFile);\r
 160                 return 0xFE;    // read error\r
 161         }\r
 162         if (vgmBaseHdr.fccVGM != FCC_VGM)\r
 163         {\r
 164                 fclose(hFile);\r
 165                 return 0x80;    // bad signature\r
 166         }\r
 167         if (vgmBaseHdr.lngVersion < 0x0150)\r
 168         {\r
 169                 fclose(hFile);\r
 170                 return 0x81;    // We don't support VGM v1.10 and earlier\r
 171         }\r
 172         \r
 173         vgmFile->dataLen = vgmBaseHdr.lngEOFOffset + 0x04;\r
 174         vgmFile->data = (UINT8*)malloc(vgmFile->dataLen);\r
 175         if (vgmFile->data == NULL)\r
 176         {\r
 177                 fclose(hFile);\r
 178                 return 0xF0;    // malloc error\r
 179         }\r
 180         memcpy(vgmFile->data, &vgmBaseHdr, hdrSize);\r
 181         bytesToRead = vgmFile->dataLen - hdrSize;\r
 182         readEl = fread(vgmFile->data + hdrSize, 0x01, bytesToRead, hFile);\r
 183         if (readEl < bytesToRead)\r
 184         {\r
 185                 //fclose(hFile);\r
 186                 //return 0xFE;  // read error\r
 187                 vgmFile->dataLen = hdrSize + readEl;\r
 188         }\r
 189         \r
 190         fclose(hFile);\r
 191         \r
 192         memcpy(&vgmFile->header, vgmFile->data, sizeof(VGM_HEADER));\r
 193         \r
 194         // relative -> absolute addresses\r
 195         vgmFile->header.lngEOFOffset += 0x04;\r
 196         if (vgmFile->header.lngGD3Offset)\r
 197                 vgmFile->header.lngGD3Offset += 0x14;\r
 198         if (vgmFile->header.lngLoopOffset)\r
 199                 vgmFile->header.lngLoopOffset += 0x1C;\r
 200         if (! vgmFile->header.lngDataOffset)\r
 201                 vgmFile->header.lngDataOffset = 0x0C;\r
 202         vgmFile->header.lngDataOffset += 0x34;\r
 203         \r
 204         CurPos = vgmFile->header.lngDataOffset;\r
 205         if (vgmFile->header.lngVersion < 0x0150)\r
 206                 CurPos = 0x40;\r
 207         hdrSize = sizeof(VGM_HEADER);\r
 208         if (hdrSize > CurPos)\r
 209                 memset((UINT8*)&vgmFile->header + CurPos, 0x00, hdrSize - CurPos);\r
 210         \r
 211         fclose(hFile);\r
 212         return 0x00;\r
 213 }\r
 214 \r
 215 void FreeVGMFile(VGM_FILE* vgmFile)\r
 216 {\r
 217         free(vgmFile->data);    vgmFile->data = NULL;\r
 218         vgmFile->dataLen = 0;\r
 219         \r
 220         return;\r
 221 }\r
 222 \r
 223 \r
 224 static bool DoVgmLoop(VGM_PBK* vgmPlay)\r
 225 {\r
 226         const VGM_HEADER* vgmHdr = &vgmPlay->file->header;\r
 227         \r
 228         if (! vgmHdr->lngLoopOffset)\r
 229                 return false;\r
 230         \r
 231         vgmPlay->curLoopCnt ++;\r
 232         \r
 233         vgmPlay->vgmPos = vgmHdr->lngLoopOffset;\r
 234         vgmPlay->vgmSmplPos -= vgmHdr->lngLoopSamples;\r
 235         vgmPlay->pbSmplPos -= vgmHdr->lngLoopSamples;\r
 236         \r
 237         return true;\r
 238 }\r
 239 \r
 240 static void UpdateVGM(VGM_PBK* vgmPlay, UINT16 Samples)\r
 241 {\r
 242         const UINT32 vgmLen = vgmPlay->file->dataLen;\r
 243         const UINT8* vgmData = vgmPlay->file->data;\r
 244         const UINT8* VGMPnt;\r
 245         UINT32 VGMPos;\r
 246         UINT32 VGMSmplPos;\r
 247         UINT8 Command;\r
 248         UINT8 blockType;\r
 249         UINT32 blockLen;\r
 250         \r
 251         vgmPlay->pbSmplPos += Samples;\r
 252         VGMPos = vgmPlay->vgmPos;\r
 253         VGMSmplPos = vgmPlay->vgmSmplPos;\r
 254         while(VGMSmplPos < vgmPlay->pbSmplPos && ! vgmPlay->vgmEnd)\r
 255         {\r
 256                 VGMPnt = &vgmData[VGMPos];\r
 257                 Command = VGMPnt[0x00];\r
 258                 switch(Command & 0xF0)\r
 259                 {\r
 260                 case 0x70:      // small delay (1-16 samples)\r
 261                         VGMSmplPos += (Command & 0x0F) + 0x01;\r
 262                         VGMPos += 0x01;\r
 263                         break;\r
 264                 case 0x80:      // DAC write + small delay (0-15 samples)\r
 265                         VGMSmplPos += (Command & 0x0F);\r
 266                         VGMPos += 0x01;\r
 267                         break;\r
 268                 case 0x60:\r
 269                         switch(Command)\r
 270                         {\r
 271                         case 0x66:      // End Of File\r
 272                                 vgmPlay->vgmPos = VGMPos;\r
 273                                 vgmPlay->vgmSmplPos = VGMSmplPos;\r
 274                                 if (! DoVgmLoop(vgmPlay))\r
 275                                         vgmPlay->vgmEnd = 0x01;\r
 276                                 VGMPos = vgmPlay->vgmPos;\r
 277                                 VGMSmplPos = vgmPlay->vgmSmplPos;\r
 278                                 break;\r
 279                         case 0x62:      // 1/60s delay\r
 280                                 VGMSmplPos += 735;\r
 281                                 VGMPos += 0x01;\r
 282                                 break;\r
 283                         case 0x63:      // 1/50s delay\r
 284                                 VGMSmplPos += 882;\r
 285                                 VGMPos += 0x01;\r
 286                                 break;\r
 287                         case 0x61:      // xx Sample Delay\r
 288                                 VGMSmplPos += ReadLE16(&VGMPnt[0x01]);\r
 289                                 VGMPos += 0x03;\r
 290                                 break;\r
 291                         case 0x67:      // Data Block (PCM Data Stream)\r
 292                                 blockType = VGMPnt[0x02];\r
 293                                 blockLen = ReadLE32(&VGMPnt[0x03]);\r
 294                                 blockLen &= 0x7FFFFFFF;\r
 295                                 VGMPos += 0x07 + blockLen;\r
 296                                 break;\r
 297                         case 0x68:      // PCM RAM write\r
 298                                 VGMPos += 0x0C;\r
 299                                 break;\r
 300                         default:\r
 301                                 vgmPlay->vgmEnd = 0x01;\r
 302                                 break;\r
 303                         }\r
 304                         break;\r
 305                 case 0x50:\r
 306                         if (Command == 0x50)\r
 307                         {\r
 308                                 VGMPos += 0x02; // SN76496 write\r
 309                                 break;\r
 310                         }\r
 311                         switch(Command)\r
 312                         {\r
 313                         case 0x51:      // YM2413 write\r
 314                                 ym2413_write(vgmPlay, VGMPnt[0x01], VGMPnt[0x02]);\r
 315                                 break;\r
 316                         case 0x5A:      // YM3812 write\r
 317                                 ym3812_write(vgmPlay, VGMPnt[0x01], VGMPnt[0x02]);\r
 318                                 break;\r
 319                         case 0x5B:      // YM3526 write\r
 320                         case 0x5C:      // Y8950 write\r
 321                                 ym3512_write(vgmPlay, VGMPnt[0x01], VGMPnt[0x02]);\r
 322                                 break;\r
 323                         case 0x5E:      // YMF262 write, port 0\r
 324                         case 0x5F:      // YMF262 write, port 1\r
 325                                 ymf262_write(vgmPlay, Command & 0x01, VGMPnt[0x01], VGMPnt[0x02]);\r
 326                                 break;\r
 327                         }\r
 328                         VGMPos += 0x03;\r
 329                         break;\r
 330                 case 0x30:\r
 331                         VGMPos += 0x02;\r
 332                         break;\r
 333                 case 0x40:\r
 334                 case 0xA0:\r
 335                 case 0xB0:\r
 336                         VGMPos += 0x03;\r
 337                         break;\r
 338                 case 0xC0:\r
 339                 case 0xD0:\r
 340                         VGMPos += 0x04;\r
 341                         break;\r
 342                 case 0xE0:\r
 343                 case 0xF0:\r
 344                         VGMPos += 0x05;\r
 345                         break;\r
 346                 case 0x90:\r
 347                         switch(Command)\r
 348                         {\r
 349                         case 0x90:      // DAC Ctrl: Setup Chip\r
 350                                 VGMPos += 0x05;\r
 351                                 break;\r
 352                         case 0x91:      // DAC Ctrl: Set Data\r
 353                                 VGMPos += 0x05;\r
 354                                 break;\r
 355                         case 0x92:      // DAC Ctrl: Set Freq\r
 356                                 VGMPos += 0x06;\r
 357                                 break;\r
 358                         case 0x93:      // DAC Ctrl: Play from Start Pos\r
 359                                 VGMPos += 0x0B;\r
 360                                 break;\r
 361                         case 0x94:      // DAC Ctrl: Stop immediately\r
 362                                 VGMPos += 0x02;\r
 363                                 break;\r
 364                         case 0x95:      // DAC Ctrl: Play Block (small)\r
 365                                 VGMPos += 0x05;\r
 366                                 break;\r
 367                         default:\r
 368                                 vgmPlay->vgmEnd = 0x01;\r
 369                                 break;\r
 370                         }\r
 371                         break;\r
 372                 default:\r
 373                         vgmPlay->vgmEnd = 0x01;\r
 374                         return;\r
 375                 }\r
 376                 \r
 377                 if (VGMPos >= vgmLen)\r
 378                         vgmPlay->vgmEnd = 0x01;\r
 379         }\r
 380         vgmPlay->vgmPos = VGMPos;\r
 381         vgmPlay->vgmSmplPos = VGMSmplPos;\r
 382         if (vgmPlay->vgmEnd)\r
 383                 StopPlayback(vgmPlay);\r
 384         \r
 385         return;\r
 386 }\r
 387 \r
 388 \r
 389 \r
 390 \r
 391 void InitEngine(void)\r
 392 {\r
 393         UINT8 curSFX;\r
 394         UINT8 curReg;\r
 395         \r
 396         memset(oplRegs_Music, 0x00, 0x100);\r
 397         memset(&vgmPbMusic, 0x00, sizeof(VGM_PBK));\r
 398         vgmPbMusic.pbMode = PBMODE_MUSIC;\r
 399         vgmPbMusic.vgmEnd = 0xFF;\r
 400         vgmPbMusic.oplChnMask = 0x0000;\r
 401         vgmPbMusic.oplRegCache = oplRegs_Music;\r
 402         \r
 403         for (curSFX = 0; curSFX < SFX_CHN_COUNT; curSFX ++)\r
 404         {\r
 405                 memset(&oplRegs_SFX[curSFX], 0x00, sizeof(VGM_PBK));\r
 406                 memset(&vgmPbSFX[curSFX], 0x00, sizeof(VGM_PBK));\r
 407                 vgmPbSFX[curSFX].pbMode = PBMODE_SFX;\r
 408                 vgmPbSFX[curSFX].vgmEnd = 0xFF;\r
 409                 vgmPbSFX[curSFX].oplChnMask = curSFX;\r
 410                 vgmPbSFX[curSFX].oplRegCache = oplRegs_SFX[curSFX];\r
 411         }\r
 412         \r
 413         // reset OPL2 chip\r
 414         curReg = 0x00;\r
 415         do\r
 416         {\r
 417                 curReg --;\r
 418                 OPL2_Write(curReg, 0x00);\r
 419         } while(curReg > 0x20);\r
 420         \r
 421         OPL2_Write(0x02, TIMER1_RATE);  // set Timer 1 Period\r
 422         OPL2_Write(0x04, 0x01); // Timer 1 on/unmasked, Timer 2 off\r
 423         OPL2_Write(0x04, 0x80); // Reset Timer/IRQ Status Flags\r
 424         \r
 425         OPL2_Write(0x01, 0x20); // Waveform Select: Enable\r
 426         \r
 427         return;\r
 428 }\r
 429 \r
 430 void DeinitEngine(void)\r
 431 {\r
 432         UINT8 curSFX;\r
 433         \r
 434         StopPlayback(&vgmPbMusic);\r
 435         for (curSFX = 0; curSFX < SFX_CHN_COUNT; curSFX ++)\r
 436                 StopPlayback(&vgmPbSFX[curSFX]);\r
 437         \r
 438         OPL2_Write(0x04, 0x00); // disable all timers\r
 439         \r
 440         return;\r
 441 }\r
 442 \r
 443 \r
 444 UINT8 PlayMusic(VGM_FILE* vgmFile)\r
 445 {\r
 446         VGM_PBK* vgmPb = &vgmPbMusic;\r
 447         \r
 448         if (! vgmPb->vgmEnd)\r
 449                 StopPlayback(vgmPb);\r
 450         \r
 451         vgmPb->file = vgmFile;\r
 452         \r
 453         StartPlayback(vgmPb);\r
 454         \r
 455         return 0x00;\r
 456 }\r
 457 \r
 458 UINT8 PlaySFX(VGM_FILE* vgmFile, UINT8 sfxChnID)\r
 459 {\r
 460         VGM_PBK* vgmPb;\r
 461         \r
 462         if (sfxChnID >= SFX_CHN_COUNT)\r
 463                 return 0xFF;\r
 464         \r
 465         vgmPb = &vgmPbSFX[sfxChnID];\r
 466         \r
 467         if (! vgmPb->vgmEnd)\r
 468                 StopPlayback(vgmPb);\r
 469         \r
 470         vgmPb->file = vgmFile;\r
 471         \r
 472         StartPlayback(vgmPb);\r
 473         \r
 474         return 0x00;\r
 475 }\r
 476 \r
 477 UINT8 StopMusic(void)\r
 478 {\r
 479         StopPlayback(&vgmPbMusic);\r
 480         return 0x00;\r
 481 }\r
 482 \r
 483 UINT8 StopSFX(UINT8 sfxChnID)\r
 484 {\r
 485         if (sfxChnID == 0xFF)\r
 486         {\r
 487                 for (sfxChnID = 0; sfxChnID < SFX_CHN_COUNT; sfxChnID ++)\r
 488                         StopPlayback(&vgmPbSFX[sfxChnID]);\r
 489                 return 0x00;\r
 490         }\r
 491         \r
 492         if (sfxChnID >= SFX_CHN_COUNT)\r
 493                 return 0xFF;\r
 494         \r
 495         StopPlayback(&vgmPbSFX[sfxChnID]);\r
 496         return 0x00;\r
 497 }\r
 498 \r
 499 UINT8 PauseMusic(void)\r
 500 {\r
 501         if (vgmPbMusic.vgmEnd == 0xFF)\r
 502                 return 0xFF;    // not playing\r
 503         if (vgmPbMusic.vgmEnd == 0x01)\r
 504                 return 0x80;    // finished playing already\r
 505         if (vgmPbMusic.vgmEnd == 0x02)\r
 506                 return 0x01;    // is already paused\r
 507         \r
 508         StopPlayback(&vgmPbMusic);\r
 509         vgmPbMusic.vgmEnd = 0x02;\r
 510         \r
 511         return 0x00;\r
 512 }\r
 513 \r
 514 UINT8 ResumeMusic(void)\r
 515 {\r
 516         if (vgmPbMusic.vgmEnd == 0xFF)\r
 517                 return 0xFF;    // not playing\r
 518         if (vgmPbMusic.vgmEnd == 0x01)\r
 519                 return 0x80;    // finished playing already\r
 520         if (! (vgmPbMusic.vgmEnd & 0x02))\r
 521                 return 0x01;    // is not paused\r
 522         \r
 523         vgmPbMusic.vgmEnd &= ~0x02;\r
 524         \r
 525         return 0x00;\r
 526 }\r
 527 \r
 528 static void StartPlayback(VGM_PBK* vgmPb)\r
 529 {\r
 530         if (vgmPb->file == NULL || vgmPb->file->data == NULL ||\r
 531                 vgmPb->file->header.fccVGM != FCC_VGM)\r
 532         {\r
 533                 vgmPb->vgmEnd = 0xFF;\r
 534                 return;\r
 535         }\r
 536         \r
 537         vgmPb->vgmEnd = 0x00;   // set to 'running'\r
 538         vgmPb->vgmPos = vgmPb->file->header.lngDataOffset;\r
 539         vgmPb->vgmSmplPos = 0;\r
 540         vgmPb->pbSmplPos = 0;\r
 541         vgmPb->curLoopCnt = 0;\r
 542         memset(vgmPb->workRAM, 0x00, 0x04);\r
 543         \r
 544         if (vgmPb->pbMode == PBMODE_SFX)\r
 545         {\r
 546                 UINT8 curReg;\r
 547                 \r
 548                 curReg = 0xB0 | vgmPb->oplChnMask;\r
 549                 if (oplRegs_Music[curReg] & 0x20)\r
 550                         OPL2_Write(curReg, oplRegs_Music[curReg] & ~0x20);      // send Key Off\r
 551                 \r
 552                 vgmPbMusic.oplChnMask |= (1 << vgmPb->oplChnMask);      // mask out music channel\r
 553         }\r
 554         \r
 555         return;\r
 556 }\r
 557 \r
 558 static void StopPlayback(VGM_PBK* vgmPb)\r
 559 {\r
 560         if (vgmPb->vgmEnd & 0x80)\r
 561                 return;\r
 562         \r
 563         if (vgmPb->pbMode == PBMODE_MUSIC)\r
 564         {\r
 565                 UINT8 curReg;\r
 566                 UINT16 chnMask;\r
 567                 \r
 568                 chnMask = 0x0001;\r
 569                 for (curReg = 0xB0; curReg < 0xB9; curReg ++, chnMask <<= 1)\r
 570                 {\r
 571                         if (vgmPb->oplChnMask & chnMask)\r
 572                                 continue;       // keep channels used by SFX untouched\r
 573                         if (vgmPb->oplRegCache[curReg] & 0x20)\r
 574                         {\r
 575                                 vgmPb->oplRegCache[curReg] &= ~0x20;\r
 576                                 OPL2_Write(curReg, vgmPb->oplRegCache[curReg]); // send Key Off\r
 577                         }\r
 578                 }\r
 579                 curReg = 0xBD;  // rhythm register\r
 580                 if (vgmPb->oplRegCache[curReg] & 0x1F)\r
 581                 {\r
 582                         vgmPb->oplRegCache[curReg] &= ~0x1F;\r
 583                         OPL2_Write(curReg, vgmPb->oplRegCache[curReg]); // send Key Off\r
 584                 }\r
 585                 \r
 586                 vgmPb->vgmEnd = 0x01;\r
 587         }\r
 588         else //if (vgmPb->pbMode == PBMODE_SFX)\r
 589         {\r
 590                 UINT8 regID;\r
 591                 UINT8 curReg;\r
 592                 UINT8 opMask;\r
 593                 \r
 594                 curReg = 0xB0 | vgmPb->oplChnMask;\r
 595                 if (vgmPb->oplRegCache[0x0C] & 0x20)\r
 596                 {\r
 597                         vgmPb->oplRegCache[0x0C] &= ~0x20;\r
 598                         OPL2_Write(curReg, vgmPb->oplRegCache[0x0C]);   // send Key Off\r
 599                 }\r
 600                 \r
 601                 vgmPb->vgmEnd = 0x01;\r
 602                 \r
 603                 if (! vgmPbMusic.vgmEnd)        // if (music is playing)\r
 604                 {\r
 605                         opMask = CHN_OPMASK[vgmPb->oplChnMask];\r
 606                         for (regID = 0x00; regID < 0x0A; regID ++)\r
 607                         {\r
 608                                 curReg = SFX_REGS[regID] + opMask;\r
 609                                 OPL2_Write(curReg, oplRegs_Music[curReg]);      // restore Music register\r
 610                         }\r
 611                         for (; regID < 0x0D; regID ++)\r
 612                         {\r
 613                                 curReg = SFX_REGS[regID] | vgmPb->oplChnMask;\r
 614                                 OPL2_Write(curReg, oplRegs_Music[curReg]);      // restore Music register\r
 615                         }\r
 616                         \r
 617                         vgmPbMusic.oplChnMask &= ~(1 << vgmPb->oplChnMask);\r
 618                 }\r
 619         }\r
 620         \r
 621         return;\r
 622 }\r
 623 \r
 624 \r
 625 \r
 626 static void OPL_CachedWrite(VGM_PBK* vgmPb, UINT8 reg, UINT8 data)\r
 627 {\r
 628         UINT8 regChn;\r
 629         UINT8 ramOfs;\r
 630         \r
 631         if (vgmPb->pbMode == PBMODE_MUSIC)\r
 632         {\r
 633                 if (reg == 0x01)\r
 634                         data |= 0x20;   // enforce "Waveform Select Enable" bit\r
 635                 vgmPb->oplRegCache[reg] = data;\r
 636                 \r
 637                 ramOfs = SFX_REGS_REV[reg >> 4];\r
 638                 if (ramOfs < 0x0A)      // Operator 20/40/60/80/E0\r
 639                 {\r
 640                         regChn = CHN_OPMASK_REV[reg & 0x1F] & 0x7F;\r
 641                         if (vgmPb->oplChnMask & (1 << regChn))\r
 642                                 return; // channel overridden by SFX - return\r
 643                 }\r
 644                 else if (ramOfs < 0x0D) // Operator C0/A0/B0\r
 645                 {\r
 646                         regChn = reg & 0x0F;\r
 647                         if (vgmPb->oplChnMask & (1 << regChn))\r
 648                                 return; // channel overridden by SFX - return\r
 649                 }\r
 650         }\r
 651         else //if (vgmPb->pbMode == PBMODE_SFX)\r
 652         {\r
 653                 if (reg == 0xBD)\r
 654                         return; // no rhythm register for SFX\r
 655                 \r
 656                 ramOfs = SFX_REGS_REV[reg >> 4];\r
 657                 if (ramOfs == 0xFF)\r
 658                         return;\r
 659                 \r
 660                 if (ramOfs < 0x0A)      // Operator 20/40/60/80/E0\r
 661                 {\r
 662                         regChn = CHN_OPMASK_REV[reg & 0x1F];\r
 663                         if (regChn == 0xFF)\r
 664                                 return; // ignore writes to invalid channels/operators\r
 665                         ramOfs += (regChn & 0x80) >> 7;\r
 666                         regChn &= 0x7F;\r
 667                         vgmPb->oplRegCache[ramOfs] = data;\r
 668                         \r
 669                         if (regChn != vgmPb->oplChnMask)\r
 670                         {\r
 671                                 // force command to current channel\r
 672                                 reg = SFX_REGS[ramOfs] + CHN_OPMASK[vgmPb->oplChnMask];\r
 673                         }\r
 674                 }\r
 675                 else    // Operator C0/A0/B0\r
 676                 {\r
 677                         regChn = CHN_OPMASK_REV[reg & 0x0F];\r
 678                         if (regChn >= 0x09)\r
 679                                 return; // ignore writes to invalid channels\r
 680                         vgmPb->oplRegCache[ramOfs] = data;\r
 681                         \r
 682                         reg = (reg & 0xF0) | vgmPb->oplChnMask;\r
 683                 }\r
 684         }\r
 685         \r
 686         OPL2_Write(reg, data);\r
 687         return;\r
 688 }\r
 689 \r
 690 \r
 691 static void ym2413_write(VGM_PBK* vgmPb, UINT8 reg, UINT8 data)\r
 692 {\r
 693         return; // unsupported for now\r
 694 }\r
 695 \r
 696 static void ym3812_write(VGM_PBK* vgmPb, UINT8 reg, UINT8 data)\r
 697 {\r
 698         if (reg == 0x01)\r
 699         {\r
 700                 vgmPb->workRAM[0x00] = data & 0x20;     // store "Wave Select Enable" bit\r
 701         }\r
 702         else if ((reg & 0xE0) == 0xE0)\r
 703         {\r
 704                 if (! vgmPb->workRAM[0x00])     // "Wave Select Enable" off?\r
 705                         data = 0x00;    // disable waveforms\r
 706         }\r
 707         \r
 708         OPL_CachedWrite(vgmPb, reg, data);\r
 709         return;\r
 710 }\r
 711 \r
 712 static void ym3512_write(VGM_PBK* vgmPb, UINT8 reg, UINT8 data)\r
 713 {\r
 714         if ((reg & 0xE0) == 0xE0)\r
 715         {\r
 716                 data = 0x00;    // OPL1 has no waveforms\r
 717         }\r
 718         if (reg >= 0x07 && reg < 0x20)\r
 719         {\r
 720                 if (reg == 0x08)\r
 721                         data &= ~0x0F;  // mask out Y8950 DeltaT data\r
 722                 else\r
 723                         return; // ignore Y8950 DeltaT writes\r
 724         }\r
 725         \r
 726         OPL_CachedWrite(vgmPb, reg, data);\r
 727         return;\r
 728 }\r
 729 \r
 730 static void ymf262_write(VGM_PBK* vgmPb, UINT8 port, UINT8 reg, UINT8 data)\r
 731 {\r
 732         return; // unsupported for now\r
 733 }\r
 734 \r
 735 \r
 736 \r
 737 void UpdateSoundEngine(void)\r
 738 {\r
 739         UINT8 tmrMask;\r
 740         UINT8 curSFX;\r
 741         \r
 742         tmrMask = OPL2_ReadStatus();\r
 743         if (! (tmrMask & 0x40))\r
 744                 return; // wait for overflow\r
 745         OPL2_Write(0x04, 0x80); // Reset Timer/IRQ Status Flags\r
 746         \r
 747         if (! vgmPbMusic.vgmEnd)\r
 748                 UpdateVGM(&vgmPbMusic, VGM_UPD_RATE);\r
 749         for (curSFX = 0; curSFX < SFX_CHN_COUNT; curSFX ++)\r
 750         {\r
 751                 if (! vgmPbSFX[curSFX].vgmEnd)\r
 752                         UpdateVGM(&vgmPbSFX[curSFX], VGM_UPD_RATE);\r
 753         }\r
 754         \r
 755         return;\r
 756 }\r