![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to midi.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [WindowsNT SDKs] / ntddk / src / mmedia / synth / dll|
Return to midi.c CVS log | Up to [WindowsNT SDKs] / ntddk / src / mmedia / synth / dll |
1.1 ! root 1: /* ! 2: * ! 3: * Copyright (c) 1992 Microsoft Corporation ! 4: * ! 5: */ ! 6: ! 7: /* ! 8: * midi.c ! 9: * ! 10: * Midi FM Synthesis routines. converts midi messages into calls to ! 11: * FM Synthesis functions - currently supports base adlib (in adlib.c) ! 12: * and opl3 synthesisers (in opl3.c). ! 13: * ! 14: * 15 Dec 92 Geraint Davies - based on a combination of the adlib ! 15: * and WSS midi drivers. ! 16: */ ! 17: ! 18: ! 19: #include <windows.h> ! 20: #include <mmsystem.h> ! 21: ! 22: #include "mmddk.h" ! 23: #include "driver.h" ! 24: ! 25: #include "adlib.h" ! 26: #include "opl3.h" ! 27: ! 28: ! 29: /*********************************************************** ! 30: global memory */ ! 31: ! 32: ! 33: PORTALLOC gMidiInClient; // input client information structure ! 34: DWORD dwRefTime; // time when midi input was opened ! 35: ! 36: DWORD dwMsgTime; // timestamp (in ms) of current msg ! 37: DWORD dwMsg = 0L; // short midi message ! 38: BYTE bBytesLeft = 0; // number of bytes needed to complete message ! 39: BYTE bBytePos = 0; // position in short message buffer ! 40: DWORD dwCurData = 0L; // position in long message buffer ! 41: BOOL fSysex = FALSE; // are we in sysex mode? ! 42: BYTE status = 0; ! 43: BYTE fMidiInStarted = 0; /* has the midi been started */ ! 44: LPMIDIHDR lpMIQueue = NULL; ! 45: BYTE gbMidiInUse = 0; /* if MIDI is in use */ ! 46: ! 47: static WORD wMidiOutEntered = 0; // reentrancy check ! 48: static PORTALLOC gMidiOutClient; // client information ! 49: ! 50: /* transformation of linear velocity value to ! 51: logarithmic attenuation */ ! 52: BYTE gbVelocityAtten[32] = { ! 53: 40, 36, 32, 28, 23, 21, 19, 17, ! 54: 15, 14, 13, 12, 11, 10, 9, 8, ! 55: 7, 6, 5, 5, 4, 4, 3, 3, ! 56: 2, 2, 1, 1, 1, 0, 0, 0 }; ! 57: ! 58: short giBend[NUMCHANNELS]; /* bend for each channel */ ! 59: BYTE gbPatch[NUMCHANNELS]; /* patch number mapped to */ ! 60: ! 61: /* --- interface functions ---------------------------------- */ ! 62: ! 63: /* ! 64: * the functions in this section call out to adlib.c or opl3.c ! 65: * depending on which device we have installed. ! 66: */ ! 67: ! 68: ! 69: /*************************************************************** ! 70: MidiNoteOn - This turns a note on. (Including drums, with ! 71: a patch # of the drum Note + 128) ! 72: ! 73: inputs ! 74: BYTE bPatch - MIDI patch number ! 75: BYTE bNote - MIDI note number ! 76: BYTE bChannel - MIDI channel # ! 77: BYTE bVelocity - Velocity # ! 78: short iBend - current pitch bend from -32768, to 32767 ! 79: returns ! 80: WORD - note slot #, or 0xffff if its inaudible ! 81: */ ! 82: VOID NEAR PASCAL MidiNoteOn (BYTE bPatch, ! 83: BYTE bNote, BYTE bChannel, BYTE bVelocity, ! 84: short iBend) ! 85: { ! 86: switch(gMidiType) { ! 87: case TYPE_OPL3: ! 88: Opl3_NoteOn(bPatch, bNote, bChannel, bVelocity, iBend); ! 89: break; ! 90: ! 91: case TYPE_ADLIB: ! 92: Adlib_NoteOn(bPatch, bNote, bChannel, bVelocity, iBend); ! 93: break; ! 94: } ! 95: return; ! 96: } ! 97: ! 98: ! 99: /************************************************************** ! 100: MidiNoteOff - This turns a note off. (Including drums, ! 101: with a patch # of the drum note + 128) ! 102: ! 103: inputs ! 104: BYTE bPatch - MIDI patch # ! 105: BYTE bNote - MIDI note number ! 106: BYTE bChannel - MIDI channel # ! 107: returns ! 108: none ! 109: */ ! 110: VOID FAR PASCAL MidiNoteOff (BYTE bPatch, ! 111: BYTE bNote, BYTE bChannel) ! 112: { ! 113: switch (gMidiType) { ! 114: case TYPE_OPL3: ! 115: Opl3_NoteOff(bPatch, bNote, bChannel); ! 116: break; ! 117: ! 118: case TYPE_ADLIB: ! 119: Adlib_NoteOff(bPatch, bNote, bChannel); ! 120: break; ! 121: } ! 122: } ! 123: ! 124: /************************************************************** ! 125: MidiAllNotesOff - switch off all active voices. ! 126: ! 127: inputs - none ! 128: returns - none ! 129: */ ! 130: VOID MidiAllNotesOff(void) ! 131: { ! 132: switch (gMidiType) { ! 133: case TYPE_OPL3: ! 134: Opl3_AllNotesOff(); ! 135: break; ! 136: ! 137: case TYPE_ADLIB: ! 138: Adlib_AllNotesOff(); ! 139: break; ! 140: } ! 141: } ! 142: ! 143: ! 144: /************************************************************** ! 145: MidiNewVolume - This should be called if a volume level ! 146: has changed. This will adjust the levels of all the playing ! 147: voices. ! 148: ! 149: inputs ! 150: WORD wLeft - left attenuation (1.5 db units) ! 151: WORD wRight - right attenuation (ignore if mono) ! 152: returns ! 153: none ! 154: */ ! 155: VOID FAR PASCAL MidiNewVolume (WORD wLeft, WORD wRight) ! 156: { ! 157: switch (gMidiType) { ! 158: case TYPE_OPL3: ! 159: Opl3_NewVolume(wLeft, wRight); ! 160: break; ! 161: ! 162: case TYPE_ADLIB: ! 163: Adlib_NewVolume(wLeft, wRight); ! 164: break; ! 165: } ! 166: ! 167: } ! 168: ! 169: /*************************************************************** ! 170: MidiChannelVolume - set the volume level for an individual channel. ! 171: ! 172: inputs ! 173: BYTE bChannel - channel number to change ! 174: WORD wAtten - attenuation in 1.5 db units ! 175: ! 176: returns ! 177: none ! 178: */ ! 179: VOID FAR PASCAL MidiChannelVolume(BYTE bChannel, WORD wAtten) ! 180: { ! 181: ! 182: switch (gMidiType) { ! 183: case TYPE_OPL3: ! 184: Opl3_ChannelVolume(bChannel, wAtten); ! 185: break; ! 186: ! 187: case TYPE_ADLIB: ! 188: Adlib_ChannelVolume(bChannel, wAtten); ! 189: break; ! 190: } ! 191: ! 192: } ! 193: ! 194: ! 195: ! 196: /*************************************************************** ! 197: MidiSetPan - set the left-right pan position. ! 198: ! 199: inputs ! 200: BYTE bChannel - channel number to alter ! 201: BYTE bPan - 0 for left, 127 for right or somewhere in the middle. ! 202: ! 203: returns - none ! 204: */ ! 205: VOID FAR PASCAL MidiSetPan(BYTE bChannel, BYTE bPan) ! 206: { ! 207: switch (gMidiType) { ! 208: case TYPE_OPL3: ! 209: Opl3_SetPan(bChannel, bPan); ! 210: break; ! 211: ! 212: case TYPE_ADLIB: ! 213: Adlib_SetPan(bChannel, bPan); ! 214: break; ! 215: } ! 216: ! 217: } ! 218: ! 219: /*************************************************************** ! 220: MidiPitchBend - This pitch bends a channel. ! 221: ! 222: inputs ! 223: BYTE bChannel - channel ! 224: short iBend - Values from -32768 to 32767, being ! 225: -2 to +2 half steps ! 226: returns ! 227: none ! 228: */ ! 229: VOID NEAR PASCAL MidiPitchBend (BYTE bChannel, ! 230: short iBend) ! 231: { ! 232: switch (gMidiType) { ! 233: case TYPE_OPL3: ! 234: Opl3_PitchBend(bChannel, iBend); ! 235: break; ! 236: ! 237: case TYPE_ADLIB: ! 238: Adlib_PitchBend(bChannel, iBend); ! 239: break; ! 240: } ! 241: ! 242: } ! 243: ! 244: /*************************************************************** ! 245: MidiBoardInit - initialise board and load patches as necessary. ! 246: ! 247: * inputs - none ! 248: * returns - 0 for success or the error code ! 249: */ ! 250: WORD MidiBoardInit(void) ! 251: { ! 252: /* ! 253: * load patch tables and reset board ! 254: */ ! 255: ! 256: switch (gMidiType) { ! 257: case TYPE_OPL3: ! 258: return( Opl3_BoardInit()); ! 259: break; ! 260: ! 261: case TYPE_ADLIB: ! 262: return (Adlib_BoardInit()); ! 263: break; ! 264: } ! 265: return(MMSYSERR_ERROR); ! 266: } ! 267: ! 268: /* ! 269: * MidiBoardReset - silence the board and set all voices off. ! 270: */ ! 271: VOID MidiBoardReset(void) ! 272: { ! 273: BYTE i; ! 274: ! 275: /* ! 276: * switch off pitch bend (we own this, not the opl3/adlib code) ! 277: */ ! 278: for (i = 0; i < NUMCHANNELS; i++) ! 279: giBend[i] = 0; ! 280: ! 281: /* ! 282: * set all voices off, set channel atten to default, ! 283: * & silence board. ! 284: */ ! 285: switch (gMidiType) { ! 286: case TYPE_OPL3: ! 287: Opl3_BoardReset(); ! 288: break; ! 289: ! 290: case TYPE_ADLIB: ! 291: Adlib_BoardReset(); ! 292: break; ! 293: } ! 294: } ! 295: ! 296: ! 297: ! 298: /* --- midi interpretation -------------------------------------*/ ! 299: ! 300: ! 301: /*************************************************************** ! 302: MidiMessage - This handles a MIDI message. This ! 303: does not do running status. ! 304: ! 305: inputs ! 306: DWORD dwData - up to 4 bytes of MIDI data ! 307: depending upon the message. ! 308: returns ! 309: none ! 310: */ ! 311: VOID NEAR PASCAL MidiMessage (DWORD dwData) ! 312: { ! 313: BYTE bChannel, bVelocity, bNote; ! 314: WORD wTemp; ! 315: ! 316: // D1("\nMidiMessage"); ! 317: bChannel = (BYTE) dwData & (BYTE)0x0f; ! 318: bVelocity = (BYTE) (dwData >> 16) & (BYTE)0x7f; ! 319: bNote = (BYTE) ((WORD) dwData >> 8) & (BYTE)0x7f; ! 320: ! 321: switch ((BYTE)dwData & 0xf0) { ! 322: case 0x90: ! 323: #ifdef DEBUG ! 324: { ! 325: char szTemp[4]; ! 326: szTemp[0] = "0123456789abcdef"[bNote >> 4]; ! 327: szTemp[1] = "0123456789abcdef"[bNote & 0x0f]; ! 328: szTemp[2] = ' '; ! 329: szTemp[3] = 0; ! 330: if ((bChannel == 9) && bVelocity) D1(szTemp); ! 331: } ! 332: #endif ! 333: /* turn key on, or key off if volume == 0 */ ! 334: if (bVelocity) { ! 335: MidiNoteOn ( ! 336: (BYTE) ((bChannel == DRUMCHANNEL) ? ! 337: (BYTE) (bNote + 128) : (BYTE) gbPatch[bChannel]), ! 338: bNote, bChannel, bVelocity, (short) giBend[bChannel]); ! 339: break; ! 340: }; ! 341: ! 342: /* else, continue through and turn key off */ ! 343: case 0x80: ! 344: /* turn key off */ ! 345: MidiNoteOff ( ! 346: (BYTE) ((bChannel == DRUMCHANNEL) ? ! 347: (BYTE) (bNote + 128) : (BYTE) gbPatch[bChannel]), ! 348: bNote, bChannel); ! 349: break; ! 350: ! 351: case 0xb0: ! 352: // D1("\nChangeControl"); ! 353: /* change control */ ! 354: switch (bNote) { ! 355: case 7: ! 356: /* change channel volume */ ! 357: MidiChannelVolume( ! 358: gbVelocityAtten[(bVelocity & 0x7f) >> 2], ! 359: bChannel); ! 360: ! 361: break; ! 362: case 8: ! 363: case 10: ! 364: /* change the pan level */ ! 365: MidiSetPan(bChannel, bVelocity); ! 366: break; ! 367: }; ! 368: break; ! 369: ! 370: case 0xc0: ! 371: /* program change */ ! 372: ! 373: #if DBG ! 374: if (wDebugLevel > 1) { ! 375: char szTemp[64]; ! 376: ! 377: wsprintfA(szTemp, "0x%x: patch chan %d>%d\n",dwData, bChannel, bNote); ! 378: OutputDebugStringA(szTemp); ! 379: ! 380: } ! 381: #endif ! 382: ! 383: /* change patch */ ! 384: gbPatch[bChannel] = bNote; ! 385: break; ! 386: ! 387: case 0xe0: ! 388: // D1("\nBend"); ! 389: /* pitch bend */ ! 390: wTemp = ((WORD) bVelocity << 9) | ((WORD) bNote << 2); ! 391: giBend[bChannel] = (short) (WORD) (wTemp + 0x8000); ! 392: MidiPitchBend (bChannel, giBend[bChannel]); ! 393: ! 394: break; ! 395: }; ! 396: ! 397: return; ! 398: } ! 399: ! 400: /**************************************************************************** ! 401: * @doc INTERNAL ! 402: * ! 403: * @api void | midiCallback | This calls DriverCallback for a midi device. ! 404: * ! 405: * @parm NPPORTALLOC| pPort | Pointer to the PORTALLOC. ! 406: * ! 407: * @parm WORD | msg | The message to send. ! 408: * ! 409: * @parm DWORD | dw1 | Message-dependent parameter. ! 410: * ! 411: * @parm DWORD | dw2 | Message-dependent parameter. ! 412: * ! 413: * @rdesc There is no return value. ! 414: ***************************************************************************/ ! 415: void NEAR PASCAL midiCallback(NPPORTALLOC pPort, WORD msg, DWORD dw1, DWORD dw2) ! 416: { ! 417: ! 418: // invoke the callback function, if it exists. dwFlags contains driver- ! 419: // specific flags in the LOWORD and generic driver flags in the HIWORD ! 420: if (pPort->dwCallback) ! 421: DriverCallback(pPort->dwCallback, // client's callback DWORD ! 422: HIWORD(pPort->dwFlags) | DCB_NOSWITCH, // callback flags ! 423: pPort->hMidi, // handle to the wave device ! 424: msg, // the message ! 425: pPort->dwInstance, // client's instance data ! 426: dw1, // first DWORD ! 427: dw2); // second DWORD ! 428: } ! 429: ! 430: /**************************************************************************** ! 431: * @doc INTERNAL ! 432: * ! 433: * @api void | midBufferWrite | This function writes a byte into the long ! 434: * message buffer. If the buffer is full or a SYSEX_ERROR or ! 435: * end-of-sysex byte is received, the buffer is marked as 'done' and ! 436: * it's owner is called back. ! 437: * ! 438: * @parm BYTE | byte | The byte received. ! 439: * ! 440: * @rdesc There is no return value ! 441: ***************************************************************************/ ! 442: static void NEAR PASCAL midBufferWrite(BYTE byte) ! 443: { ! 444: LPMIDIHDR lpmh; ! 445: WORD msg; ! 446: ! 447: // if no buffers, nothing happens ! 448: if (lpMIQueue == NULL) ! 449: return; ! 450: ! 451: lpmh = lpMIQueue; ! 452: ! 453: if (byte == SYSEX_ERROR) { ! 454: D2("sysexerror"); ! 455: msg = MIM_LONGERROR; ! 456: } ! 457: else { ! 458: D2("bufferwrite"); ! 459: msg = MIM_LONGDATA; ! 460: *((HPSTR)(lpmh->lpData) + dwCurData++) = byte; ! 461: } ! 462: ! 463: // if end of sysex, buffer full or error, send them back the buffer ! 464: if ((byte == SYSEX_ERROR) || (byte == 0xF7) || (dwCurData >= lpmh->dwBufferLength)) { ! 465: D2("bufferdone"); ! 466: lpMIQueue = lpMIQueue->lpNext; ! 467: lpmh->dwBytesRecorded = dwCurData; ! 468: dwCurData = 0L; ! 469: lpmh->dwFlags |= MHDR_DONE; ! 470: lpmh->dwFlags &= ~MHDR_INQUEUE; ! 471: midiCallback(&gMidiInClient, msg, (DWORD)lpmh, dwMsgTime); ! 472: } ! 473: ! 474: return; ! 475: } ! 476: ! 477: ! 478: ! 479: /**************************************************************************** ! 480: ! 481: This function conforms to the standard MIDI output driver message proc ! 482: modMessage, which is documented in mmddk.d. ! 483: ! 484: ***************************************************************************/ ! 485: DWORD FAR PASCAL _loadds modMessage(UINT id, ! 486: UINT msg, DWORD dwUser, DWORD dwParam1, DWORD dwParam2) ! 487: { ! 488: LPMIDIHDR lpHdr; ! 489: #ifdef FOGHORN ! 490: WORD wTemp1, wTemp2; ! 491: #endif ! 492: LPSTR lpBuf; /* current spot in the long msg buf */ ! 493: DWORD dwBytesRead; /* how far are we in the buffer */ ! 494: DWORD dwMsg = 0; /* short midi message sent to synth */ ! 495: BYTE bBytePos=0; /* shift current byte by dwBytePos*s */ ! 496: BYTE bBytesLeft = 0; /* how many dat bytes needed */ ! 497: BYTE curByte; /* current byte in long buffer */ ! 498: UINT mRc; /* Return code */ ! 499: ! 500: #ifdef WIN16 ! 501: if (!fEnabled || gfMidiSuspended) { ! 502: D1("modMessage called while disabled"); ! 503: } else { ! 504: if (msg == MODM_GETNUMDEVS) ! 505: else ! 506: return MMSYSERR_NOTENABLED; ! 507: } ! 508: #endif // WIN16 ! 509: ! 510: ! 511: // this driver only supports one device ! 512: if (id != 0) { ! 513: D1("invalid midi device id"); ! 514: return MMSYSERR_BADDEVICEID; ! 515: } ! 516: ! 517: switch (msg) { ! 518: case MODM_GETNUMDEVS: ! 519: D1("MODM_GETNUMDEVS"); ! 520: #ifdef WIN16 ! 521: mRc = 1L; ! 522: #else ! 523: // ! 524: // Check if the kernel driver got loaded OK ! 525: // ! 526: { ! 527: HANDLE hDevice; ! 528: if (MidiOpenDevice(&hDevice, FALSE) == MMSYSERR_NOERROR) { ! 529: CloseHandle(hDevice); ! 530: mRc = 1L; ! 531: } else { ! 532: mRc = 0L; ! 533: } ! 534: } ! 535: #endif // WIN16 ! 536: break; ! 537: ! 538: case MODM_GETDEVCAPS: ! 539: D1("MODM_GETDEVCAPS"); ! 540: modGetDevCaps((LPBYTE)dwParam1, (WORD)dwParam2); ! 541: mRc = 0L; ! 542: break; ! 543: ! 544: case MODM_OPEN: ! 545: D1("MODM_OPEN"); ! 546: ! 547: /* open the midi */ ! 548: if (MidiOpen()) ! 549: return MMSYSERR_ALLOCATED; ! 550: ! 551: /* call up the volume control */ ! 552: #ifdef WIN16 ! 553: VolSendMsg (FH_MIDI_BEGIN); ! 554: #endif // WIN16 ! 555: ! 556: // save client information ! 557: gMidiOutClient.dwCallback = ((LPMIDIOPENDESC)dwParam1)->dwCallback; ! 558: gMidiOutClient.dwInstance = ((LPMIDIOPENDESC)dwParam1)->dwInstance; ! 559: gMidiOutClient.hMidi = ((LPMIDIOPENDESC)dwParam1)->hMidi; ! 560: gMidiOutClient.dwFlags = dwParam2; ! 561: ! 562: // notify client ! 563: midiCallback(&gMidiOutClient, MOM_OPEN, 0L, 0L); ! 564: ! 565: /* were in use */ ! 566: gbMidiInUse = TRUE; ! 567: ! 568: mRc = 0L; ! 569: break; ! 570: ! 571: case MODM_CLOSE: ! 572: D1("MODM_CLOSE"); ! 573: ! 574: /* shut up the FM synthesizer */ ! 575: MidiClose(); ! 576: ! 577: /* tell volume about this */ ! 578: #ifdef WIN16 ! 579: VolSendMsg (FH_MIDI_END); ! 580: #endif // WIN16 ! 581: ! 582: // notify client ! 583: midiCallback(&gMidiOutClient, MOM_CLOSE, 0L, 0L); ! 584: ! 585: /* were not used any more */ ! 586: gbMidiInUse = FALSE; ! 587: ! 588: mRc = 0L; ! 589: break; ! 590: ! 591: case MODM_RESET: ! 592: D1("MODM_RESET"); ! 593: ! 594: // ! 595: // turn off FM synthesis ! 596: // ! 597: // note that we increment our 're-entered' counter so that a ! 598: // background interrupt handler doesn't mess up our resetting ! 599: // of the synth by calling midiOut[Short|Long]Msg.. just ! 600: // practicing safe midi. NOTE: this should never be necessary ! 601: // if a midi app is PROPERLY written! ! 602: // ! 603: wMidiOutEntered++; ! 604: { ! 605: if (wMidiOutEntered == 1) ! 606: { ! 607: MidiReset(); ! 608: dwParam1 = 0L; ! 609: } ! 610: else ! 611: { ! 612: D1("MODM_RESET reentered!"); ! 613: dwParam1 = MIDIERR_NOTREADY; ! 614: } ! 615: } ! 616: wMidiOutEntered--; ! 617: mRc = (dwParam1); ! 618: break; ! 619: ! 620: case MODM_DATA: // message is in dwParam1 ! 621: #ifndef WIN16 ! 622: MidiCheckVolume(); // See if the volume has changed ! 623: #endif // WIN16 ! 624: ! 625: // make sure we're not being reentered ! 626: wMidiOutEntered++; ! 627: if (wMidiOutEntered > 1) { ! 628: D1("MODM_DATA reentered!"); ! 629: wMidiOutEntered--; ! 630: return MIDIERR_NOTREADY; ! 631: } ! 632: ! 633: /* if have repeated messages */ ! 634: if (dwParam1 & 0x00000080) /* status byte */ ! 635: status = LOBYTE(LOWORD(dwParam1)); ! 636: else ! 637: dwParam1 = (dwParam1 << 8) | ((DWORD) status); ! 638: ! 639: /* if not, have an FM synthesis message */ ! 640: MidiMessage (dwParam1); ! 641: ! 642: wMidiOutEntered--; ! 643: mRc = 0L; ! 644: break; ! 645: ! 646: case MODM_LONGDATA: // far pointer to header in dwParam1 ! 647: ! 648: #ifndef WIN16 ! 649: MidiCheckVolume(); // See if the volume has changed ! 650: #endif // WIN16 ! 651: ! 652: // make sure we're not being reentered ! 653: wMidiOutEntered++; ! 654: if (wMidiOutEntered > 1) { ! 655: D1("MODM_LONGDATA reentered!"); ! 656: wMidiOutEntered--; ! 657: return MIDIERR_NOTREADY; ! 658: } ! 659: ! 660: // check if it's been prepared ! 661: lpHdr = (LPMIDIHDR)dwParam1; ! 662: if (!(lpHdr->dwFlags & MHDR_PREPARED)) { ! 663: wMidiOutEntered--; ! 664: return MIDIERR_UNPREPARED; ! 665: } ! 666: ! 667: lpBuf = lpHdr->lpData; ! 668: dwBytesRead = 0; ! 669: curByte = *lpBuf; ! 670: ! 671: while (TRUE) { ! 672: /* if its a system realtime message send it and continue ! 673: this does not affect the running status */ ! 674: ! 675: if (curByte >= 0xf8) ! 676: MidiMessage (0x000000ff & curByte); ! 677: else if (curByte >= 0xf0) { ! 678: status = 0; /* kill running status */ ! 679: dwMsg = 0L; /* throw away any incomplete data */ ! 680: bBytePos = 0; /* start at beginning of message */ ! 681: ! 682: switch (curByte) { ! 683: case 0xf0: /* sysex - ignore */ ! 684: case 0xf7: ! 685: break; ! 686: case 0xf4: /* system common, no data */ ! 687: case 0xf5: ! 688: case 0xf6: ! 689: MidiMessage (0x000000ff & curByte); ! 690: break; ! 691: case 0xf1: /* system common, one data byte */ ! 692: case 0xf3: ! 693: dwMsg |= curByte; ! 694: bBytesLeft = 1; ! 695: bBytePos = 1; ! 696: break; ! 697: case 0xf2: /* system common, 2 data bytes */ ! 698: dwMsg |= curByte; ! 699: bBytesLeft = 2; ! 700: bBytePos = 1; ! 701: break; ! 702: }; ! 703: } ! 704: /* else its a channel message */ ! 705: else if (curByte >= 0x80) { ! 706: status = curByte; ! 707: dwMsg = 0L; ! 708: ! 709: switch (curByte & 0xf0) { ! 710: case 0xc0: /* channel message, one data */ ! 711: case 0xd0: ! 712: dwMsg |= curByte; ! 713: bBytesLeft = 1; ! 714: bBytePos = 1; ! 715: break; ! 716: case 0x80: /* two bytes */ ! 717: case 0x90: ! 718: case 0xa0: ! 719: case 0xb0: ! 720: case 0xe0: ! 721: dwMsg |= curByte; ! 722: bBytesLeft = 2; ! 723: bBytePos = 1; ! 724: break; ! 725: }; ! 726: } ! 727: ! 728: /* else if its an expected data byte */ ! 729: else if (bBytePos != 0) { ! 730: dwMsg |= ((DWORD)curByte) << (bBytePos++ * 8); ! 731: if (--bBytesLeft == 0) { ! 732: ! 733: MidiMessage (dwMsg); ! 734: ! 735: if (status) { ! 736: dwMsg |= status; ! 737: bBytesLeft = bBytePos - (BYTE)1; ! 738: bBytePos = 1; ! 739: } ! 740: else { ! 741: dwMsg = 0L; ! 742: bBytePos = 0; ! 743: }; ! 744: }; ! 745: }; ! 746: ! 747: /* read the next byte if there is one */ ! 748: /* remember we have already read and processed one byte that ! 749: * we have not yet counted- so we need to pre-inc, not post-inc ! 750: */ ! 751: if (++dwBytesRead >= lpHdr->dwBufferLength) break; ! 752: curByte = *++lpBuf; ! 753: }; /* while TRUE */ ! 754: ! 755: /* return buffer to client */ ! 756: lpHdr->dwFlags |= MHDR_DONE; ! 757: midiCallback (&gMidiOutClient, MOM_DONE, dwParam1, 0L); ! 758: ! 759: wMidiOutEntered--; ! 760: mRc = 0L; ! 761: break; ! 762: ! 763: #ifdef WIN16 ! 764: case MODM_SETVOLUME: ! 765: gwLinVol[VOL_MIDI][VOL_LEFT] = LOWORD(dwParam1); ! 766: gwLinVol[VOL_MIDI][VOL_RIGHT] = HIWORD(dwParam1); ! 767: VolSetMidiVolume (VolLinearToLog ((WORD)dwParam1), ! 768: VolLinearToLog ((WORD) (dwParam1 >> 16) )); ! 769: mRc = 0L; ! 770: mRc = MidiSetVolume(LOWORD(dwParam1) << 16, HIWORD(dwParam1) << 16); ! 771: break; ! 772: ! 773: case MODM_GETVOLUME: ! 774: *((DWORD FAR *)dwParam1) = ! 775: MAKELONG ( ! 776: gwLinVol[VOL_MIDI][VOL_LEFT], ! 777: gwLinVol[VOL_MIDI][VOL_RIGHT]); ! 778: mRc = 0L; ! 779: break; ! 780: #else ! 781: case MODM_SETVOLUME: ! 782: mRc = MidiSetVolume(LOWORD(dwParam1) << 16, HIWORD(dwParam1) << 16); ! 783: break; ! 784: ! 785: case MODM_GETVOLUME: ! 786: mRc = MidiGetVolume((LPDWORD)dwParam1); ! 787: break; ! 788: #endif // WIN16 ! 789: ! 790: ! 791: #ifdef FOGHORN ! 792: case MODM_VUMETER: ! 793: /* there is a duplicate in auxil.c which must be ! 794: kept up to date */ ! 795: /* if we're out of range then 0 volume */ ! 796: if (dwParam1 >= 16) { ! 797: *((DWORD FAR *)dwParam2) = 0; ! 798: return 0; ! 799: }; ! 800: ! 801: if (!gbMidiInUse) { ! 802: *((DWORD FAR *) dwParam2) = 0; ! 803: return MMSYSERR_ALLOCATED; ! 804: }; ! 805: ! 806: /* find out what the values are */ ! 807: wTemp1 = (WORD) gbLeftLevel[dwParam1] << 9; ! 808: wTemp2 = (WORD) gbRightLevel[dwParam1] << 9; ! 809: gbLeftLevel[dwParam1] = gbRightLevel[dwParam1] = 0; ! 810: *((DWORD FAR *) dwParam2) = ((DWORD) wTemp2 << 16) | wTemp1; ! 811: mRc = 0L; ! 812: break; ! 813: ! 814: case MODM_SETPATCH: ! 815: /* there is a duplicate in auxil.c which must be ! 816: kept up to date */ ! 817: wTemp1 = (LOWORD(dwParam2)); ! 818: if (wTemp1 >= 256) ! 819: wTemp1 = 0; ! 820: MidiSetPatch ((BYTE) wTemp1, (LPSTR) dwParam1, HIWORD(dwParam2)); ! 821: mRc = 0L; ! 822: break; ! 823: ! 824: case MODM_GETPATCH: ! 825: /* there is a duplicate in auxil.c which must be ! 826: kept up to date */ ! 827: wTemp1 = (LOWORD(dwParam2)); ! 828: if (wTemp1 >= 256) ! 829: wTemp1 = 0; ! 830: MidiGetPatch ((BYTE) wTemp1, (LPSTR) dwParam1, HIWORD(dwParam2)); ! 831: mRc = 0L; ! 832: break; ! 833: #endif ! 834: default: ! 835: return MMSYSERR_NOTSUPPORTED; ! 836: } ! 837: #ifndef WIN16 ! 838: MidiFlush(); ! 839: #endif // WIN16 ! 840: ! 841: return mRc; ! 842: ! 843: ! 844: // should never get here... ! 845: return MMSYSERR_NOTSUPPORTED; ! 846: } ! 847: ! 848: ! 849: static TCHAR BCODE gszDefPatchLib[] = TEXT("SYNTH.PAT"); ! 850: static TCHAR BCODE gszIniKeyPatchLib[] = INI_STR_PATCHLIB; ! 851: static TCHAR BCODE gszIniDrvSection[] = INI_DRIVER; ! 852: static TCHAR BCODE gszIniDrvFile[] = INI_SOUND; ! 853: static TCHAR BCODE gszSysIniSection[] = TEXT("synth.dll"); ! 854: static TCHAR BCODE gszSysIniFile[] = TEXT("System.Ini"); ! 855: ! 856: ! 857: ! 858: ! 859: /**************************************************************** ! 860: MidiInit - Initializes the FM synthesis chip and internal ! 861: variables. This assumes that HwInit() has been called ! 862: and that a card location has been found. This loads in ! 863: the patch information. ! 864: ! 865: inputs ! 866: none ! 867: returns ! 868: WORD - 0 if successful, else error ! 869: */ ! 870: WORD FAR PASCAL MidiInit (VOID) ! 871: { ! 872: // WORD i; ! 873: ! 874: D1 ("\nMidiInit"); ! 875: ! 876: // don't reset the patch map - it will be initialised at loadtime to 0 ! 877: // (because its static data) and we should not change it after that ! 878: // since the mci sequencer will not re-send patch change messages. ! 879: // ! 880: // ! 881: // /* reset all channels to patch 0 */ ! 882: // for (i = 0; i < NUMCHANNELS; i++) { ! 883: // gbPatch[i] = 0; ! 884: // } ! 885: ! 886: /* initialise the h/w specific patch tables */ ! 887: return MidiBoardInit(); ! 888: } ! 889: ! 890: ! 891: /***************************************************************** ! 892: MidiOpen - This should be called when a midi file is opened. ! 893: It initializes some variables and locks the patch global ! 894: memories. ! 895: ! 896: inputs ! 897: none ! 898: returns ! 899: UINT - 0 if succedes, else error ! 900: */ ! 901: UINT FAR PASCAL MidiOpen (VOID) ! 902: { ! 903: MMRESULT mRc; ! 904: ! 905: D1("\nMidiOpen"); ! 906: ! 907: ! 908: // ! 909: // For 32-bit we must open our kernel device ! 910: // ! 911: ! 912: mRc = MidiOpenDevice(&MidiDeviceHandle, TRUE); ! 913: ! 914: if (mRc != MMSYSERR_NOERROR) { ! 915: return mRc; ! 916: } ! 917: ! 918: ! 919: /* ! 920: * reset the device (set default channel attenuation etc) ! 921: */ ! 922: MidiBoardReset(); ! 923: ! 924: return 0; ! 925: } ! 926: ! 927: /*************************************************************** ! 928: MidiClose - This kills the playing midi voices and closes the kernel driver ! 929: ! 930: inputs ! 931: none ! 932: returns ! 933: none ! 934: */ ! 935: VOID FAR PASCAL MidiClose (VOID) ! 936: { ! 937: ! 938: D1("\nMidiClose"); ! 939: ! 940: /* make sure all notes turned off */ ! 941: MidiAllNotesOff(); ! 942: ! 943: MidiCloseDevice(MidiDeviceHandle); ! 944: } ! 945: ! 946: /** void FAR PASCAL MidiReset(void) ! 947: * ! 948: * DESCRIPTION: ! 949: * ! 950: * ! 951: * ARGUMENTS: ! 952: * (void) ! 953: * ! 954: * RETURN (void FAR PASCAL): ! 955: * ! 956: * ! 957: * NOTES: ! 958: * ! 959: ** cjp */ ! 960: ! 961: void FAR PASCAL MidiReset(void) ! 962: { ! 963: ! 964: D1("\nMidiReset"); ! 965: ! 966: /* make sure all notes turned off */ ! 967: MidiAllNotesOff(); ! 968: ! 969: /* silence the board and reset board-specific variables */ ! 970: MidiBoardReset(); ! 971: ! 972: ! 973: } /* MidiReset() */ ! 974: ! 975: ! 976: /***************************************************************************** ! 977: * @doc INTERNAL ! 978: * ! 979: * @api void | modGetDevCaps | Get the capabilities of the port. ! 980: * ! 981: * @parm LPBYTE | lpCaps | Far pointer to a MIDIOUTCAPS structure. ! 982: * ! 983: * @parm UINT | wSize | Size of the MIDIOUTCAPS structure. ! 984: * ! 985: * @rdesc There is no return value. ! 986: ****************************************************************************/ ! 987: void FAR PASCAL modGetDevCaps(LPBYTE lpCaps, UINT wSize) ! 988: { ! 989: MIDIOUTCAPS mc; ! 990: ! 991: mc.wMid = MM_MICROSOFT; ! 992: mc.wPid = MM_ADLIB; ! 993: mc.wTechnology = MOD_FMSYNTH; ! 994: mc.wVoices = 128; ! 995: ! 996: mc.wChannelMask = 0xffff; // all channels ! 997: mc.vDriverVersion = 0x100; ! 998: if (gMidiType == TYPE_OPL3) { ! 999: mc.wNotes = 12; ! 1000: mc.dwSupport = MIDICAPS_VOLUME | MIDICAPS_LRVOLUME; ! 1001: } else { ! 1002: mc.wNotes = 11; ! 1003: mc.dwSupport = MIDICAPS_VOLUME; ! 1004: } ! 1005: LoadString(ghModule, SR_STR_DRIVERMIDIOUT, mc.szPname, sizeof(mc.szPname)); ! 1006: ! 1007: AsMemCopy(lpCaps, &mc, min(wSize,sizeof(mc))); ! 1008: } ! 1009:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.