|
|
/*
* Copyright (c) 1992-1994 Microsoft Corporation */
/*
* Interface functions for the OPL3 midi device type. * * These functions are called from midi.c when the kernel driver * has decreed that this is an opl3-compatible device. * * Geraint Davies, Dec 92 */
#include <windows.h>
#include <mmsystem.h>
#include <mmddk.h>
#include "driver.h"
#include "opl3.h"
#pragma pack(1)
/* --- typedefs ----------------------------------------------- */
/* typedefs for MIDI patches */#define NUMOPS (4)
#define PATCH_1_4OP (0) /* use 4-operator patch */
#define PATCH_2_2OP (1) /* use two 2-operator patches */
#define PATCH_1_2OP (2) /* use one 2-operator patch */
#define RIFF_PATCH (mmioFOURCC('P','t','c','h'))
#define RIFF_FM4 (mmioFOURCC('f','m','4',' '))
#define NUM2VOICES (18) /* # 2operator voices */
typedef struct _operStruct { BYTE bAt20; /* flags which are send to 0x20 on fm */ BYTE bAt40; /* flags seet to 0x40 */ /* the note velocity & midi velocity affect total level */ BYTE bAt60; /* flags sent to 0x60 */ BYTE bAt80; /* flags sent to 0x80 */ BYTE bAtE0; /* flags send to 0xe0 */} operStruct;
typedef struct _noteStruct { operStruct op[NUMOPS]; /* operators */ BYTE bAtA0[2]; /* send to 0xA0, A3 */ BYTE bAtB0[2]; /* send to 0xB0, B3 */ /* use in a patch, the block should be 4 to indicate
normal pitch, 3 => octave below, etc. */ BYTE bAtC0[2]; /* sent to 0xc0, C3 */ BYTE bOp; /* see PATCH_??? */ BYTE bDummy; /* place holder */} noteStruct;
typedef struct _patchStruct { noteStruct note; /* note. This is all in the structure at the moment */} patchStruct;#pragma pack()
/* MIDI */
typedef struct _voiceStruct { BYTE bNote; /* note played */ BYTE bChannel; /* channel played on */ BYTE bPatch; /* what patch is the note,
drums patch = drum note + 128 */ BYTE bOn; /* TRUE if note is on, FALSE if off */ BYTE bVelocity; /* velocity */ BYTE bJunk; /* filler */ DWORD dwTime; /* time that was turned on/off;
0 time indicates that its not in use */ DWORD dwOrigPitch[2]; /* original pitch, for pitch bend */ BYTE bBlock[2]; /* value sent to the block */} voiceStruct;
/* --- module data -------------------------------------------- */
/* a bit of tuning information */#define FSAMP (50000.0) /* sampling frequency */
#define PITCH(x) ((DWORD)((x) * (double) (1L << 19) / FSAMP))
/* x is the desired frequency,
== FNUM at b=1 */#define EQUAL (1.059463094359)
#ifdef EUROPE
# define A (442.0)
#else
# define A (440.0)
#endif
#define ASHARP (A * EQUAL)
#define B (ASHARP * EQUAL)
#define C (B * EQUAL / 2.0)
#define CSHARP (C * EQUAL)
#define D (CSHARP * EQUAL)
#define DSHARP (D * EQUAL)
#define E (DSHARP * EQUAL)
#define F (E * EQUAL)
#define FSHARP (F * EQUAL)
#define G (FSHARP * EQUAL)
#define GSHARP (G * EQUAL)
/* volume */WORD wSynthAttenL = 0; /* in 1.5dB steps */WORD wSynthAttenR = 0; /* in 1.5dB steps */
/* patch library */patchStruct FAR * glpPatch = NULL; /* points to the patches */
/* voices being played */voiceStruct gVoice[NUM2VOICES]; /* info on what voice is where */static DWORD gdwCurTime = 1; /* for note on/off */
BYTE gbCur4opReg = 0; /* current value to 4-operator connection */
/* channel volumes */BYTE gbChanAtten[NUMCHANNELS]; /* attenuation of each channel, in .75 db steps */BYTE gbStereoMask[NUMCHANNELS]; /* mask for left/right for stereo midi files */extern short giBend[ NUMCHANNELS ] ; // bend for each channel
/* operator offset location */static WORD BCODE gw2OpOffset[ NUM2VOICES ][ 2 ] = { { 0x000,0x003 }, { 0x001,0x004 }, { 0x002,0x005 }, { 0x008,0x00b }, { 0x009,0x00c }, { 0x00a,0x00d }, { 0x010,0x013 }, { 0x011,0x014 }, { 0x012,0x015 },
{ 0x100,0x103 }, { 0x101,0x104 }, { 0x102,0x105 }, { 0x108,0x10b }, { 0x109,0x10c }, { 0x10a,0x10d }, { 0x110,0x113 }, { 0x111,0x114 }, { 0x112,0x115 }, } ;
/* pitch values, from middle c, to octave above it */static DWORD BCODE gdwPitch[12] = { PITCH(C), PITCH(CSHARP), PITCH(D), PITCH(DSHARP), PITCH(E), PITCH(F), PITCH(FSHARP), PITCH(G), PITCH(GSHARP), PITCH(A), PITCH(ASHARP), PITCH(B)};
/* --- internal functions -------------------------------------- */
//------------------------------------------------------------------------
// VOID MidiFMNote
//
// Description:
// Turns on an FM-synthesizer note.
//
// Parameters:
// WORD wNote
// the note number from 0 to NUMVOICES
//
// noteStruct FAR *lpSN
// structure containing information about what
// is to be played.
//
// Return Value:
// Nothing.
//
//
//------------------------------------------------------------------------
VOID NEAR PASCAL Opl3_FMNote( WORD wNote, noteStruct FAR * lpSN){ WORD i ; WORD wOffset ; operStruct FAR *lpOS ;
// D1( "\nMidiFMNote" ) ;
// write out a note off, just to make sure...
wOffset = (wNote < (NUM2VOICES / 2)) ? wNote : (wNote + 0x100 - 9) ; MidiSendFM( AD_BLOCK + wOffset, 0 ) ;
// writing the operator information
// for (i = 0; i < (WORD)((wNote < NUM4VOICES) ? NUMOPS : 2); i++)
for (i = 0; i < 2; i++) { lpOS = &lpSN -> op[ i ] ; wOffset = gw2OpOffset[ wNote ][ i ] ; MidiSendFM( 0x20 + wOffset, lpOS -> bAt20) ; MidiSendFM( 0x40 + wOffset, lpOS -> bAt40) ; MidiSendFM( 0x60 + wOffset, lpOS -> bAt60) ; MidiSendFM( 0x80 + wOffset, lpOS -> bAt80) ; MidiSendFM( 0xE0 + wOffset, lpOS -> bAtE0) ;
#ifdef DEBUG
{ char szDebug[ 80 ] ;
wsprintf( szDebug, "20=%02x 40=%02x 60=%02x 80=%02x E0=%02x", lpOS -> bAt20, lpOS -> bAt40, lpOS -> bAt60, lpOS -> bAt80, lpOS -> bAtE0 ) ; D1( szDebug ) ;}#endif
}
// write out the voice information
wOffset = (wNote < 9) ? wNote : (wNote + 0x100 - 9) ; MidiSendFM( 0xa0 + wOffset, lpSN -> bAtA0[ 0 ] ) ; MidiSendFM( 0xc0 + wOffset, lpSN -> bAtC0[ 0 ] ) ;
// Note on...
MidiSendFM( 0xb0 + wOffset, (BYTE)(lpSN -> bAtB0[ 0 ] | 0x20) ) ;
#ifdef NOT_USED
{ char szDebug[ 80 ] ;
wsprintf( szDebug, "A0=%02x B0=%02x C0=%02x", lpSN -> bAtA0[ 0 ], lpSN -> bAtB0[ 0 ], lpSN -> bAtC0[ 0 ] ) ; D1( szDebug ) ;}#endif
} // end of MidiFMNote()
//------------------------------------------------------------------------
// WORD MidiFindEmptySlot
//
// Description:
// This finds an empty note-slot for a MIDI voice.
// If there are no empty slots then this looks for the oldest
// off note. If this doesn't work then it looks for the oldest
// on-note of the same patch. If all notes are still on then
// this finds the oldests turned-on-note.
//
// Parameters:
// BYTE bPatch
// MIDI patch that will replace it.
//
// Return Value:
// WORD
// note slot #
//
//
//------------------------------------------------------------------------
WORD NEAR PASCAL Opl3_FindEmptySlot( BYTE bPatch){ WORD i, found ; DWORD dwOldest ;
// D1( "\nMidiFindEmptySlot" ) ;
// First, look for a slot with a time == 0
for (i = 0; i < NUM2VOICES; i++) if (!gVoice[ i ].dwTime) return ( i ) ;
// Now, look for a slot of the oldest off-note
dwOldest = 0xffffffff ; found = 0xffff ;
for (i = 0; i < NUM2VOICES; i++) if (!gVoice[ i ].bOn && (gVoice[ i ].dwTime < dwOldest)) { dwOldest = gVoice[ i ].dwTime ; found = i ; } if (found != 0xffff) return ( found ) ;
// Now, look for a slot of the oldest note with
// the same patch
dwOldest = 0xffffffff ; found = 0xffff ; for (i = 0; i < NUM2VOICES; i++) if ((gVoice[ i ].bPatch == bPatch) && (gVoice[ i ].dwTime < dwOldest)) { dwOldest = gVoice[ i ].dwTime ; found = i ; } if (found != 0xffff) return ( found ) ;
// Now, just look for the oldest voice
found = 0 ; dwOldest = gVoice[ found ].dwTime ; for (i = (found + 1); i < NUM2VOICES; i++) if (gVoice[ i ].dwTime < dwOldest) { dwOldest = gVoice[ i ].dwTime ; found = i ; }
return ( found ) ;
} // end of MidiFindEmptySlot()
//------------------------------------------------------------------------
// WORD MidiFindFullSlot
//
// Description:
// This finds a slot with a specific note, and channel.
// If it is not found then 0xFFFF is returned.
//
// Parameters:
// BYTE bNote
// MIDI note number
//
// BYTE bChannel
// MIDI channel #
//
// Return Value:
// WORD
// note slot #, or 0xFFFF if can't find it
//
//
//------------------------------------------------------------------------
WORD NEAR PASCAL Opl3_FindFullSlot( BYTE bNote, BYTE bChannel){ WORD i ;
// D1( "\nMidiFindFullSlot" ) ;
for (i = 0; i < NUM2VOICES; i++) if ((bChannel == gVoice[ i ].bChannel) && (bNote == gVoice[ i ].bNote) && (gVoice[ i ].bOn)) return ( i ) ;
// couldn't find it
return ( 0xFFFF ) ;
} // end of MidiFindFullSlot()
/**************************************************************
Opl3_CalcBend - This calculates the effects of pitch bend on an original value.
inputs DWORD dwOrig - original frequency short iBend - from -32768 to 32768, -2 half steps to +2returns DWORD - new frequency*/DWORD NEAR PASCAL Opl3_CalcBend (DWORD dwOrig, short iBend){ DWORD dw; // D1 (("Opl3_CalcBend"));
/* do different things depending upon positive or
negative bend */ if (iBend > 0) { dw = (DWORD)((iBend * (LONG)(256.0 * (EQUAL * EQUAL - 1.0))) >> 8); dwOrig += (DWORD)(AsULMUL(dw, dwOrig) >> 15); } else if (iBend < 0) { dw = (DWORD)(((-iBend) * (LONG)(256.0 * (1.0 - 1.0 / EQUAL / EQUAL))) >> 8); dwOrig -= (DWORD)(AsULMUL(dw, dwOrig) >> 15); }
return dwOrig;}
/*****************************************************************
Opl3_CalcFAndB - Calculates the FNumber and Block given a frequency.
inputs DWORD dwPitch - pitchreturns WORD - High byte contains the 0xb0 section of the block and fNum, and the low byte contains the 0xa0 section of the fNumber*/WORD NEAR PASCAL Opl3_CalcFAndB (DWORD dwPitch){ BYTE bBlock;
// D1(("Opl3_CalcFAndB"));
/* bBlock is like an exponential to dwPitch (or FNumber) */ for (bBlock = 1; dwPitch >= 0x400; dwPitch >>= 1, bBlock++) ;
if (bBlock > 0x07) bBlock = 0x07; /* we cant do anything about this */
/* put in high two bits of F-num into bBlock */ return ((WORD) bBlock << 10) | (WORD) dwPitch;}
/**************************************************************
Opl3_CalcVolume - This calculates the attenuation for an operator.
inputs BYTE bOrigAtten - original attenuation in 0.75 dB units BYTE bChannel - MIDI channel BYTE bVelocity - velocity of the note BYTE bOper - operator number (from 0 to 3) BYTE bMode - voice mode (from 0 through 7 for modulator/carrier selection)returns BYTE - new attenuation in 0.75 dB units, maxing out at 0x3f.*/BYTE NEAR PASCAL Opl3_CalcVolume (BYTE bOrigAtten, BYTE bChannel, BYTE bVelocity, BYTE bOper, BYTE bMode){ BYTE bVolume; WORD wTemp; WORD wMin;
switch (bMode) { case 0: bVolume = (BYTE)(bOper == 3); break; case 1: bVolume = (BYTE)((bOper == 1) || (bOper == 3)); break; case 2: bVolume = (BYTE)((bOper == 0) || (bOper == 3)); break; case 3: bVolume = (BYTE)(bOper != 1); break; case 4: bVolume = (BYTE)((bOper == 1) || (bOper == 3)); break; case 5: bVolume = (BYTE)(bOper >= 1); break; case 6: bVolume = (BYTE)(bOper <= 2); break; case 7: bVolume = TRUE; break; }; if (!bVolume) return bOrigAtten; /* this is a modulator wave */
wMin =(wSynthAttenL < wSynthAttenR) ? wSynthAttenL : wSynthAttenR; wTemp = bOrigAtten + ((wMin << 1) + gbChanAtten[bChannel] + gbVelocityAtten[bVelocity >> 2]); return (wTemp > 0x3f) ? (BYTE) 0x3f : (BYTE) wTemp;}
/**************************************************************
Opl3_CalcStereoMask - This calculates the stereo mask.
inputs BYTE bChannel - MIDI channelreturns BYTE - mask (for register 0xc0-c8) for eliminating the left/right/both channels*/BYTE NEAR PASCAL Opl3_CalcStereoMask (BYTE bChannel){ WORD wLeft, wRight;
/* figure out the basic levels of the 2 channels */ wLeft = (wSynthAttenL << 1) + gbChanAtten[bChannel]; wRight = (wSynthAttenR << 1) + gbChanAtten[bChannel];
/* if both are too quiet then mask to nothing */ if ((wLeft > 0x3f) && (wRight > 0x3f)) return 0xcf;
/* if one channel is significantly quieter than the other than
eliminate it */ if ((wLeft + 8) < wRight) return (BYTE)(0xef & gbStereoMask[bChannel]); /* right is too quiet so eliminate */ else if ((wRight + 8) < wLeft) return (BYTE)(0xdf & gbStereoMask[bChannel]); /* left too quiet so eliminate */ else return (BYTE)(gbStereoMask[bChannel]); /* use both channels */}
//------------------------------------------------------------------------
// VOID MidiNewVolume
//
// Description:
// This should be called if a volume level has changed.
// This will adjust the levels of all the playing voices.
//
// Parameters:
// BYTE bChannel
// channel # of 0xFF for all channels
//
// Return Value:
// Nothing.
//
//
//------------------------------------------------------------------------
VOID FAR PASCAL Opl3_setvolume( BYTE bChannel){ WORD i, j, wTemp, wOffset ; noteStruct FAR *lpPS ; BYTE bMode, bStereo ;
// Make sure that we are actually open...
if (!glpPatch) return ;
// Loop through all the notes looking for the right
// channel. Anything with the right channel gets
// its pitch bent.
for (i = 0; i < NUM2VOICES; i++) if ((gVoice[ i ].bChannel == bChannel) || (bChannel == 0xff)) { // Get a pointer to the patch
lpPS = &(glpPatch + gVoice[ i ].bPatch) -> note ;
// Modify level for each operator, but only if they
// are carrier waves...
bMode = (BYTE) ( (lpPS->bAtC0[0] & 0x01) * 2 + 4);
for (j = 0; j < 2; j++) { wTemp = (BYTE) Opl3_CalcVolume( (BYTE)(lpPS -> op[ j ].bAt40 & (BYTE) 0x3f), gVoice[ i ].bChannel, gVoice[i].bVelocity, (BYTE) j, bMode ) ;
// Write the new value out.
wOffset = gw2OpOffset[ i ][ j ] ; MidiSendFM( 0x40 + wOffset, (BYTE) ((lpPS -> op[ j ].bAt40 & (BYTE)0xc0) | (BYTE) wTemp) ) ; }
// Do stereo panning, but cutting off a left or right
// channel if necessary.
bStereo = Opl3_CalcStereoMask( gVoice[ i ].bChannel ) ; wOffset = (i < (NUM2VOICES / 2)) ? i : (i + 0x100 - 9) ; MidiSendFM( 0xc0 + wOffset, (BYTE)(lpPS -> bAtC0[ 0 ] & bStereo) ) ; }
} // end of MidiNewVolume()
//------------------------------------------------------------------------
// WORD MidiNoteOn
//
// Description:
// This turns on a note, including drums with a patch # of the
// drum note + 0x80.
//
// Parameters:
// BYTE bPatch
// MIDI patch
//
// BYTE bNote
// MIDI note
//
// BYTE bChannel
// MIDI channel
//
// BYTE bVelocity
// velocity value
//
// short iBend
// current pitch bend from -32768 to 32767
//
// Return Value:
// WORD
// note slot #, or 0xFFFF if it is inaudible
//
//
//------------------------------------------------------------------------
VOID NEAR PASCAL Opl3_NoteOn( BYTE bPatch, BYTE bNote, BYTE bChannel, BYTE bVelocity, short iBend){ WORD wTemp, i, j ; BYTE b4Op, bTemp, bMode, bStereo ; patchStruct FAR *lpPS ; DWORD dwBasicPitch, dwPitch[ 2 ] ; noteStruct NS ;
// D1( "\nMidiNoteOn" ) ;
// Get a pointer to the patch
lpPS = glpPatch + bPatch ;
#ifdef DEBUG
{ char szDebug[ 80 ] ;
wsprintf( szDebug, "bPatch = %d, bNote = %d", bPatch, bNote ) ; D1( szDebug ) ;}#endif
// Find out the basic pitch according to our
// note value. This may be adjusted because of
// pitch bends or special qualities for the note.
dwBasicPitch = gdwPitch[ bNote % 12 ] ; bTemp = bNote / (BYTE) 12 ; if (bTemp > (BYTE) (60 / 12)) dwBasicPitch = AsLSHL( dwBasicPitch, (BYTE)(bTemp - (BYTE)(60/12)) ) ; else if (bTemp < (BYTE) (60/12)) dwBasicPitch = AsULSHR( dwBasicPitch, (BYTE)((BYTE) (60/12) - bTemp) ) ;
// Copy the note information over and modify
// the total level and pitch according to
// the velocity, midi volume, and tuning.
AsMemCopy( (LPSTR) &NS, (LPSTR) &lpPS -> note, sizeof( noteStruct ) ) ; b4Op = (BYTE)(NS.bOp != PATCH_1_2OP) ;
// for (j = 0; j < (WORD)(b4Op ? 2 : 1); j++)
for (j = 0; j < 2; j++) { // modify pitch
dwPitch[ j ] = dwBasicPitch ; bTemp = (BYTE)((NS.bAtB0[ j ] >> 2) & 0x07) ; if (bTemp > 4) dwPitch[ j ] = AsLSHL( dwPitch[ j ], (BYTE)(bTemp - (BYTE)4) ) ; else if (bTemp < 4) dwPitch[ j ] = AsULSHR( dwPitch[ j ], (BYTE)((BYTE)4 - bTemp) ) ;
wTemp = Opl3_CalcFAndB( Opl3_CalcBend( dwPitch[ j ], iBend ) ) ; NS.bAtA0[ j ] = (BYTE) wTemp ; NS.bAtB0[ j ] = (BYTE) 0x20 | (BYTE) (wTemp >> 8) ; }
// Modify level for each operator, but only
// if they are carrier waves
// if (b4Op)
// {
// bMode = (BYTE)((NS.bAtC0[ 0 ] & 0x01) * 2 | (NS.bAtC0[ 1 ] & 0x01)) ;
// if (NS.bOp == PATCH_2_2OP)
// bMode += 4 ;
// }
// else
bMode = (BYTE) ((NS.bAtC0[ 0 ] & 0x01) * 2 + 4) ;
// for (i = 0; i < (WORD)(b4Op ? NUMOPS : 2); i++)
for (i = 0; i < 2; i++) { wTemp = (BYTE) Opl3_CalcVolume ( (BYTE)(NS.op[ i ].bAt40 & (BYTE) 0x3f), bChannel, bVelocity, (BYTE) i, bMode ) ; NS.op[ i ].bAt40 = (NS.op[ i ].bAt40 & (BYTE)0xc0) | (BYTE) wTemp ; }
// Do stereo panning, but cutting off a left or
// right channel if necessary...
bStereo = Opl3_CalcStereoMask( bChannel ) ; NS.bAtC0[ 0 ] &= bStereo ;// if (b4Op)
// NS.bAtC0[ 1 ] &= bStereo ;
// Find an empty slot, and use it...
// wTemp = Opl3_FindEmptySlot( bPatch, b4Op ) ;
wTemp = Opl3_FindEmptySlot( bPatch ) ;
#ifdef DEBUG
{ char szDebug[ 80 ] ;
wsprintf( szDebug, "Found empty slot: %d", wTemp ) ; D1( szDebug ) ;
}#endif
Opl3_FMNote( wTemp, &NS ) ; gVoice[ wTemp ].bNote = bNote ; gVoice[ wTemp ].bChannel = bChannel ; gVoice[ wTemp ].bPatch = bPatch ; gVoice[ wTemp ].bVelocity = bVelocity ; gVoice[ wTemp ].bOn = TRUE ; gVoice[ wTemp ].dwTime = gdwCurTime++ ; gVoice[ wTemp ].dwOrigPitch[0] = dwPitch[ 0 ] ; // not including bend
gVoice[ wTemp ].dwOrigPitch[1] = dwPitch[ 1 ] ; // not including bend
gVoice[ wTemp ].bBlock[0] = NS.bAtB0[ 0 ] ; gVoice[ wTemp ].bBlock[1] = NS.bAtB0[ 1 ] ;
} // end of Opl3_NoteOn()
//------------------------------------------------------------------------
// VOID Opl3_NoteOff
//
// Description:
// This turns off a note, including drums with a patch
// # of the drum note + 128.
//
// Parameters:
// BYTE bPatch
// MIDI patch
//
// BYTE bNote
// MIDI note
//
// BYTE bChannel
// MIDI channel
//
// Return Value:
// Nothing.
//
//
//------------------------------------------------------------------------
VOID FAR PASCAL Opl3_NoteOff( BYTE bPatch, BYTE bNote, BYTE bChannel){ patchStruct FAR *lpPS ; WORD wOffset, wTemp ;
// D1( "\nMidiNoteOff" ) ;
// Find the note slot
wTemp = Opl3_FindFullSlot( bNote, bChannel ) ;
if (wTemp != 0xffff) { // get a pointer to the patch
lpPS = glpPatch + (BYTE) gVoice[ wTemp ].bPatch ;
// shut off the note portion
// we have the note slot, turn it off.
// if (wTemp < NUM4VOICES)
// {
// MidiSendFM( AD_BLOCK + gw4VoiceOffset[ wTemp ],
// (BYTE)(gVoice[ wTemp ].bBlock[ 0 ] & 0x1f) ) ;
// MidiSendFM( AD_BLOCK + gw4VoiceOffset[ wTemp ] + 3,
// (BYTE)(gVoice[ wTemp ].bBlock[ 1 ] & 0x1f) ) ;
// }
// else
wOffset = (wTemp < (NUM2VOICES / 2)) ? wTemp : (wTemp + 0x100 - 9) ; MidiSendFM( AD_BLOCK + wOffset, (BYTE)(gVoice[ wTemp ].bBlock[ 0 ] & 0x1f) ) ;
// Note this...
gVoice[ wTemp ].bOn = FALSE ; gVoice[ wTemp ].bBlock[ 0 ] &= 0x1f ; gVoice[ wTemp ].bBlock[ 1 ] &= 0x1f ; gVoice[ wTemp ].dwTime = gdwCurTime ; }
} // end of Opl3_NoteOff()
/*
* Opl3_ChannelNotesOff - turn off all notes on a channel */VOID Opl3_ChannelNotesOff(BYTE bChannel){ int i;
for (i = 0; i < NUM2VOICES; i++) { if ((gVoice[ i ].bOn) && (gVoice[ i ].bChannel == bChannel)) {
Opl3_NoteOff( gVoice[i].bPatch, gVoice[i].bNote, gVoice[i].bChannel ) ; } }}/*
* Opl3_AllNotesOff - turn off all notes * */VOID Opl3_AllNotesOff(void){ BYTE i;
for (i = 0; i < NUM2VOICES; i++) { Opl3_NoteOff (gVoice[i].bPatch, gVoice[i].bNote, gVoice[i].bChannel); }}
/* Opl3_NewVolume - This should be called if a volume level
* has changed. This will adjust the levels of all the playing * voices. * * inputs * WORD wLeft - left attenuation (1.5 db units) * WORD wRight - right attenuation (ignore if mono) * returns * none */VOID FAR PASCAL Opl3_NewVolume (WORD wLeft, WORD wRight){
/* make sure that we are actually open */ if (!glpPatch) return;
wSynthAttenL = wLeft; wSynthAttenR = wRight;
Opl3_setvolume(0xff);
}
/* Opl3_ChannelVolume - set the volume level for an individual channel.
* * inputs * BYTE bChannel - channel number to change * WORD wAtten - attenuation in 1.5 db units * * returns * none */VOID FAR PASCAL Opl3_ChannelVolume(BYTE bChannel, WORD wAtten){ gbChanAtten[bChannel] = (BYTE)wAtten;
Opl3_setvolume(bChannel);}
/* Opl3_SetPan - set the left-right pan position.
* * inputs * BYTE bChannel - channel number to alter * BYTE bPan - 0 for left, 127 for right or somewhere in the middle. * * returns - none */VOID FAR PASCAL Opl3_SetPan(BYTE bChannel, BYTE bPan){ /* change the pan level */ if (bPan > (64 + 16)) gbStereoMask[bChannel] = 0xef; /* let only right channel through */ else if (bPan < (64 - 16)) gbStereoMask[bChannel] = 0xdf; /* let only left channel through */ else gbStereoMask[bChannel] = 0xff; /* let both channels */
/* change any curently playing patches */ Opl3_setvolume(bChannel);}
//------------------------------------------------------------------------
// VOID MidiPitchBend
//
// Description:
// This pitch bends a channel.
//
// Parameters:
// BYTE bChannel
// channel
//
// short iBend
// values from -32768 to 32767, being -2 to +2 half steps
//
// Return Value:
// Nothing.
//
//
//------------------------------------------------------------------------
VOID NEAR PASCAL Opl3_PitchBend( BYTE bChannel, short iBend){ WORD i, wTemp[ 2 ], wOffset, j ; DWORD dwNew ;
// D1( "\nMidiPitchBend" ) ;
// Remember the current bend..
giBend[ bChannel ] = iBend ;
// Loop through all the notes looking for the right
// channel. Anything with the right channel gets its
// pitch bent...
for (i = 0; i < NUM2VOICES; i++) if (gVoice[ i ].bChannel == bChannel) { j = 0 ; dwNew = Opl3_CalcBend( gVoice[ i ].dwOrigPitch[ j ], iBend ) ; wTemp[ j ] = Opl3_CalcFAndB( dwNew ) ; gVoice[ i ].bBlock[ j ] = (gVoice[ i ].bBlock[ j ] & (BYTE) 0xe0) | (BYTE) (wTemp[ j ] >> 8) ;
wOffset = (i < (NUM2VOICES / 2)) ? i : (i + 0x100 - 9) ; MidiSendFM( AD_BLOCK + wOffset, gVoice[ i ].bBlock[ 0 ] ) ; MidiSendFM( AD_FNUMBER + wOffset, (BYTE) wTemp[ 0 ] ) ; }
} // end of MidiPitchBend()
#ifdef LOAD_PATCHES
static TCHAR BCODE gszDefPatchLib[] = TEXT("SYNTH.PAT");static TCHAR BCODE gszIniKeyPatchLib[] = INI_STR_PATCHLIB;static TCHAR BCODE gszIniDrvSection[] = INI_DRIVER;static TCHAR BCODE gszIniDrvFile[] = INI_SOUND;static TCHAR BCODE gszSysIniSection[] = TEXT("synth.dll");static TCHAR BCODE gszSysIniFile[] = TEXT("System.Ini");
/** static DWORD NEAR PASCAL DrvGetProfileString(LPSTR szKeyName, LPSTR szDef, LPSTR szBuf, UINT wBufLen)
* * DESCRIPTION: * * * ARGUMENTS: * (LPSTR szKeyName, LPSTR szDef, LPSTR szBuf, WORD wBufLen) * HINT wSystem - if TRUE write/read to system.ini * * RETURN (static DWORD NEAR PASCAL): * * * NOTES: * ** cjp */
static DWORD NEAR PASCAL DrvGetProfileString(LPTSTR szKeyName, LPTSTR szDef, LPTSTR szBuf, UINT wBufLen, UINT wSystem){ return GetPrivateProfileString(wSystem ? gszSysIniSection : gszIniDrvSection, szKeyName, szDef, szBuf, wBufLen, wSystem ? gszSysIniFile : gszIniDrvFile);} /* DrvGetProfileString() */#endif // LOAD_PATCHES
/* Opl3_BoardInit - initialise board and load patches as necessary.
* * inputs - none * returns - 0 for success or the error code */WORD Opl3_BoardInit(void){ HMMIO hmmio; MMCKINFO mmckinfo, mm2; TCHAR szPatchLib[STRINGLEN]; /* patch libarary */
D1 (("Opl3_Init"));
/* Check we haven't already initialized */ if (glpPatch != NULL) { return 0; }
/* allocate the memory, and fill it up from the patch
* library. */ glpPatch = (patchStruct FAR *)GlobalLock(GlobalAlloc(GMEM_MOVEABLE|GMEM_SHARE|GMEM_ZEROINIT, sizeof(patchStruct) * NUMPATCHES)); if (!glpPatch) { D1 (("Opl3_Init: could not allocate patch container memory!")); return ERROR_OUTOFMEMORY; }
#ifdef LOAD_PATCHES
/* should the load patches be moved to the init section? */ DrvGetProfileString(gszIniKeyPatchLib, TEXT(""), szPatchLib, sizeof(szPatchLib), FALSE);
if (lstrcmpi( (LPTSTR) szPatchLib, TEXT("") ) == 0)#endif // LOAD_PATCHES
{ HRSRC hrsrcPatches ; HGLOBAL hPatches ; LPTSTR lpPatches ;
hrsrcPatches = FindResource( ghModule, MAKEINTRESOURCE( DATA_FMPATCHES ), RT_BINARY ) ;
if (NULL != hrsrcPatches) { hPatches = LoadResource( ghModule, hrsrcPatches ) ; lpPatches = LockResource( hPatches ) ; AsMemCopy( glpPatch, lpPatches, sizeof( patchStruct ) * NUMPATCHES ) ; UnlockResource( hPatches ) ; FreeResource( hPatches ) ; } else { TCHAR szAlert[ 50 ] ; TCHAR szErrorBuffer[ 255 ] ;
LoadString( ghModule, SR_ALERT, szAlert, sizeof( szAlert ) / sizeof(TCHAR)) ; LoadString( ghModule, SR_ALERT_NORESOURCE, szErrorBuffer, sizeof( szErrorBuffer ) / sizeof(TCHAR) ) ; MessageBox( NULL, szErrorBuffer, szAlert, MB_OK|MB_ICONHAND ) ; } }#ifdef LOAD_PATCHES
else {
hmmio = mmioOpen (szPatchLib, NULL, MMIO_READ); if (hmmio) { mmioDescend (hmmio, &mmckinfo, NULL, 0); if ((mmckinfo.ckid == FOURCC_RIFF) && (mmckinfo.fccType == RIFF_PATCH)) {
mm2.ckid = RIFF_FM4; if (!mmioDescend (hmmio, &mm2, &mmckinfo, MMIO_FINDCHUNK)) { /* we have found the synthesis chunk */ if (mm2.cksize > (sizeof(patchStruct)*NUMPATCHES)) mm2.cksize = sizeof(patchStruct)*NUMPATCHES; mmioRead (hmmio, (LPSTR) glpPatch, mm2.cksize); } else { D1(("Bad mmioDescend2")); } } else { D1(("Bad mmioDescend1")); }
mmioClose (hmmio, 0); } else {
TCHAR szAlert[50]; TCHAR szErrorBuffer[255];
LoadString(ghModule, SR_ALERT, szAlert, sizeof(szAlert)); LoadString(ghModule, SR_ALERT_NOPATCH, szErrorBuffer, sizeof(szErrorBuffer)); MessageBox(NULL, szErrorBuffer, szAlert, MB_OK|MB_ICONHAND); D1 (("Bad mmioOpen")); }
}#endif // LOAD_PATCHES
return 0; /* done */}
/*
* Opl3_BoardReset - silence the board and set all voices off. */VOID Opl3_BoardReset(void){
BYTE i;
/* make sure all notes turned off */ Opl3_AllNotesOff();
/* ---- silence the chip -------- */
/* tell the FM chip to use 4-operator mode, and
fill in any other random variables */ MidiSendFM (AD_NEW, 0x01); MidiSendFM (AD_MASK, 0x60); MidiSendFM (AD_CONNECTION, 0x00); MidiSendFM (AD_NTS, 0x00);
/* turn off the drums, and use high vibrato/modulation */ MidiSendFM (AD_DRUM, 0xc0);
/* turn off all the oscillators */ for (i = 0; i < 0x15; i++) { MidiSendFM (AD_LEVEL + i, 0x3f); MidiSendFM (AD_LEVEL2 + i, 0x3f); };
/* turn off all the voices */ for (i = 0; i < 0x08; i++) { MidiSendFM (AD_BLOCK + i, 0x00); MidiSendFM (AD_BLOCK2 + i, 0x00); };
/* clear all of the voice slots to empty */ for (i = 0; i < NUM2VOICES; i++) gVoice[i].dwTime = 0;
/* start attenuations at -3 dB, which is 90 MIDI level */ for (i = 0; i < NUMCHANNELS; i++) { gbChanAtten[i] = 4; gbStereoMask[i] = 0xff; };
/* turn off the pitch bend */ for (i = 0; i < NUMCHANNELS; i++) giBend[i] = 0;}
|
