![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to opl3.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 opl3.c CVS log | Up to [WindowsNT SDKs] / ntddk / src / mmedia / synth / dll |
1.1 root 1: /*
2: * Copyright (c) 1992 Microsoft Corporation
3: */
4:
5: /*
6: * Interface functions for the OPL3 midi device type.
7: *
8: * These functions are called from midi.c when the kernel driver
9: * has decreed that this is an opl3-compatible device.
10: *
11: * Geraint Davies, Dec 92
12: */
13:
14: #include <windows.h>
15: #include <mmsystem.h>
16: #include <mmddk.h>
17: #include "driver.h"
18: #include "opl3.h"
19:
20: /* --- typedefs ----------------------------------------------- */
21:
22: /* typedefs for MIDI patches */
23: #define NUMOPS (4)
24: #define PATCH_1_4OP (0) /* use 4-operator patch */
25: #define PATCH_2_2OP (1) /* use two 2-operator patches */
26: #define PATCH_1_2OP (2) /* use one 2-operator patch */
27:
28: #define RIFF_PATCH (mmioFOURCC('P','t','c','h'))
29: #define RIFF_FM4 (mmioFOURCC('f','m','4',' '))
30: #define NUM4VOICES (6) /* # 4-op voices that can play at once */
31: #define NUM2VOICES (6) /* # 2operator voices */
32: #define NUMVOICES (NUM4VOICES + NUM2VOICES)
33:
34: typedef struct _operStruct {
35: BYTE bAt20; /* flags which are send to 0x20 on fm */
36: BYTE bAt40; /* flags seet to 0x40 */
37: /* the note velocity & midi velocity affect total level */
38: BYTE bAt60; /* flags sent to 0x60 */
39: BYTE bAt80; /* flags sent to 0x80 */
40: BYTE bAtE0; /* flags send to 0xe0 */
41: } operStruct;
42:
43: typedef struct _noteStruct {
44: operStruct op[NUMOPS]; /* operators */
45: BYTE bAtA0[2]; /* send to 0xA0, A3 */
46: BYTE bAtB0[2]; /* send to 0xB0, B3 */
47: /* use in a patch, the block should be 4 to indicate
48: normal pitch, 3 => octave below, etc. */
49: BYTE bAtC0[2]; /* sent to 0xc0, C3 */
50: BYTE bOp; /* see PATCH_??? */
51: BYTE bDummy; /* place holder */
52: } noteStruct;
53:
54:
55: typedef struct _patchStruct {
56: noteStruct note; /* note. This is all in the structure at the moment */
57: } patchStruct;
58:
59: /* MIDI */
60:
61: typedef struct _voiceStruct {
62: BYTE bNote; /* note played */
63: BYTE bChannel; /* channel played on */
64: BYTE bPatch; /* what patch is the note,
65: drums patch = drum note + 128 */
66: BYTE bOn; /* TRUE if note is on, FALSE if off */
67: BYTE bVelocity; /* velocity */
68: BYTE bJunk; /* filler */
69: DWORD dwTime; /* time that was turned on/off;
70: 0 time indicates that its not in use */
71: DWORD dwOrigPitch[2]; /* original pitch, for pitch bend */
72: BYTE bBlock[2]; /* value sent to the block */
73: } voiceStruct;
74:
75: /* --- module data -------------------------------------------- */
76:
77: /* a bit of tuning information */
78: #define FSAMP (50000.0) /* sampling frequency */
79: #define PITCH(x) ((DWORD)((x) * (double) (1L << 19) / FSAMP))
80: /* x is the desired frequency,
81: == FNUM at b=1 */
82: #define EQUAL (1.059463094359)
83: #ifdef EUROPE
84: # define A (442.0)
85: #else
86: # define A (440.0)
87: #endif
88: #define ASHARP (A * EQUAL)
89: #define B (ASHARP * EQUAL)
90: #define C (B * EQUAL / 2.0)
91: #define CSHARP (C * EQUAL)
92: #define D (CSHARP * EQUAL)
93: #define DSHARP (D * EQUAL)
94: #define E (DSHARP * EQUAL)
95: #define F (E * EQUAL)
96: #define FSHARP (F * EQUAL)
97: #define G (FSHARP * EQUAL)
98: #define GSHARP (G * EQUAL)
99:
100: /* volume */
101: WORD wSynthAttenL = 0; /* in 1.5dB steps */
102: WORD wSynthAttenR = 0; /* in 1.5dB steps */
103:
104: /* patch library */
105: patchStruct FAR * glpPatch = NULL; /* points to the patches */
106:
107: /* voices being played */
108: voiceStruct gVoice[NUMVOICES]; /* info on what voice is where */
109: static DWORD gdwCurTime = 1; /* for note on/off */
110:
111: BYTE gbCur4opReg = 0; /* current value to 4-operator connection */
112:
113: /* channel volumes */
114: BYTE gbChanAtten[NUMCHANNELS]; /* attenuation of each channel, in .75 db steps */
115: BYTE gbStereoMask[NUMCHANNELS]; /* mask for left/right for stereo midi files */
116:
117: /* operator offset location */
118: static WORD BCODE gw4OpOffset[NUM4VOICES][NUMOPS] = {
119: {0x000,0x003,0x008,0x00b}, {0x001,0x004,0x009,0x00c},
120: {0x002,0x005,0x00a,0x00d}, {0x100,0x103,0x108,0x10b},
121: {0x101,0x104,0x109,0x10c}, {0x102,0x105,0x10a,0x10d}};
122: static WORD BCODE gw2OpOffset[NUM2VOICES][2] = {
123: {0x010,0x013}, {0x011,0x014}, {0x012,0x015},
124: {0x110,0x113}, {0x111,0x114}, {0x112,0x115}
125: };
126:
127: /* voice offset location */
128: static WORD BCODE gw4VoiceOffset[NUM4VOICES] = {
129: 0x000, 0x001, 0x002, 0x100, 0x101, 0x102};
130: static WORD BCODE gw2VoiceOffset[NUM2VOICES] = {
131: 0x006, 0x007, 0x008, 0x106, 0x107, 0x108};
132:
133: /* pitch values, from middle c, to octave above it */
134: static DWORD BCODE gdwPitch[12] = {
135: PITCH(C), PITCH(CSHARP), PITCH(D), PITCH(DSHARP),
136: PITCH(E), PITCH(F), PITCH(FSHARP), PITCH(G),
137: PITCH(GSHARP), PITCH(A), PITCH(ASHARP), PITCH(B)};
138:
139:
140:
141: /* --- internal functions -------------------------------------- */
142:
143:
144: /***************************************************************
145: Opl3_FMNote - This turns on a FM-synthesizer note.
146:
147: inputs
148: WORD wNote - the note number from 0 to NUMVOICES.
149: If wNote < NUM4VOICES then dealing with 4 operator synth,
150: else using 2-operator synth.
151: noteStruct FAR * lpSN - structure containing information about
152: what is to be played.
153: returns
154: none
155: */
156: VOID NEAR PASCAL Opl3_FMNote (WORD wNote, noteStruct FAR * lpSN)
157: {
158: WORD i;
159: WORD wOffset;
160: operStruct FAR * lpOS;
161:
162: // D1 ("\nOpl3_FMNote");
163: /* write out a note off, just to make sure */
164: MidiSendFM (AD_BLOCK +
165: ((wNote < NUM4VOICES) ? gw4VoiceOffset[wNote] : gw2VoiceOffset[wNote - NUM4VOICES]),
166: (BYTE)0);
167:
168: /* write out information specifying if we are
169: to use 2 or 4 operators */
170: if (wNote < NUM4VOICES) {
171: if (lpSN->bOp == PATCH_1_4OP)
172: gbCur4opReg |= (1 << wNote);
173: else
174: gbCur4opReg &= (~(1 << wNote));
175: MidiSendFM (AD_CONNECTION, gbCur4opReg);
176: };
177: /* else send out nothing */
178:
179: /* writing the operator information */
180: for (i = 0; i < (WORD)((wNote < NUM4VOICES) ? NUMOPS : 2); i++) {
181: wOffset = (wNote < NUM4VOICES) ?
182: gw4OpOffset[wNote][i] : gw2OpOffset[wNote - NUM4VOICES][i];
183: lpOS = &lpSN->op[i];
184: MidiSendFM (0x20 + wOffset, lpOS->bAt20);
185: MidiSendFM (0x40 + wOffset, lpOS->bAt40);
186: MidiSendFM (0x60 + wOffset, lpOS->bAt60);
187: MidiSendFM (0x80 + wOffset, lpOS->bAt80);
188: MidiSendFM (0xE0 + wOffset, lpOS->bAtE0);
189: };
190: /* write out the voice information */
191: wOffset = (wNote < NUM4VOICES) ?
192: gw4VoiceOffset[wNote] : gw2VoiceOffset[wNote - NUM4VOICES];
193: MidiSendFM (0xa0 + wOffset, lpSN->bAtA0[0]);
194: MidiSendFM (0xc0 + wOffset, lpSN->bAtC0[0]);
195: if (wNote < NUM4VOICES) {
196: MidiSendFM (0xc3 + wOffset, lpSN->bAtC0[1]);
197: MidiSendFM (0xa3 + wOffset, lpSN->bAtA0[1]);
198: MidiSendFM (0xb3 + wOffset, (BYTE)(lpSN->bAtB0[1] | 0x20) /* note on */);
199: };
200: MidiSendFM (0xb0 + wOffset, (BYTE)(lpSN->bAtB0[0] | 0x20) /* note on */);
201:
202: /* done */
203: }
204:
205: /***************************************************************
206: Opl3_FindEmptySlot - This finds an empty note-slot for a MIDI voice.
207: If there are no empty slots then this looks for the oldest
208: off note. It this doesnt work then it looks\
209: for the oldest on-note of the same patch. If all notes are still on then this
210: finds the oldest turned-on-note.
211:
212: inputs
213: BYTE bPatch - MIDI patch that will replace it
214: BYTE b4Op - if TRUE then looking through 4-operator voices,
215: else looking through 2-operator voices
216: returns
217: WORD - note slot #
218: */
219: WORD NEAR PASCAL Opl3_FindEmptySlot (BYTE bPatch, BYTE b4Op)
220: {
221: WORD i, found;
222: DWORD dwOldest;
223:
224: // D1 ("\nOpl3_FindEmptySlot");
225: /* first, look for a slot with a time == 0 */
226: for (i = (b4Op ? 0 : NUM4VOICES); i < (WORD)(b4Op ? NUM4VOICES : NUMVOICES); i++)
227: if (!gVoice[i].dwTime)
228: return i;
229:
230: /* now, look for a slot of the oldest off-note */
231: dwOldest = 0xffffffff;
232: found = 0xffff;
233: for (i = (b4Op ? 0 : NUM4VOICES); i < (WORD)(b4Op ? NUM4VOICES : NUMVOICES); i++)
234: if (!gVoice[i].bOn && (gVoice[i].dwTime < dwOldest)) {
235:
236: dwOldest = gVoice[i].dwTime;
237: found = i;
238: };
239: if (found != 0xffff)
240: return found;
241:
242: /* now, look for a slot of the oldest note with the same patch */
243: dwOldest = 0xffffffff;
244: found = 0xffff;
245: for (i = (b4Op ? 0 : NUM4VOICES); i < (WORD)(b4Op ? NUM4VOICES : NUMVOICES); i++)
246: if ((gVoice[i].bPatch == bPatch) &&
247: (gVoice[i].dwTime < dwOldest)) {
248:
249: dwOldest = gVoice[i].dwTime;
250: found = i;
251: };
252: if (found != 0xffff)
253: return found;
254:
255: /* now, just look for the oldest voice */
256: found = (b4Op ? 0 : NUM4VOICES);
257: dwOldest = gVoice[found].dwTime;
258: for (i = (found + 1); i < (WORD)(b4Op ? NUM4VOICES : NUMVOICES); i++)
259: if (gVoice[i].dwTime < dwOldest) {
260:
261: dwOldest = gVoice[i].dwTime;
262: found = i;
263: };
264:
265: return found;
266: }
267:
268:
269: /***************************************************************
270: Opl3_FindFullSlot - This finds a slot with a specific note,
271: and channel. If it is not found then 0xffff is
272: returned.
273:
274: inputs
275: BYTE bNote - MIDI note number
276: BYTE bChannel - MIDI channel #
277: returns
278: WORD - note slot #, or 0xffff if cant find
279: */
280: WORD NEAR PASCAL Opl3_FindFullSlot (
281: BYTE bNote, BYTE bChannel)
282: {
283: WORD i;
284:
285: // D1("\nOpl3_FindFullSlot");
286: for (i = 0; i < NUMVOICES; i++)
287: if ((bChannel == gVoice[i].bChannel) &&
288: (bNote == gVoice[i].bNote) && (gVoice[i].bOn))
289: return i;
290:
291: /* couldnt find it */
292: return 0xffff;
293: }
294:
295: /**************************************************************
296: Opl3_CalcBend - This calculates the effects of pitch bend
297: on an original value.
298:
299: inputs
300: DWORD dwOrig - original frequency
301: short iBend - from -32768 to 32768, -2 half steps to +2
302: returns
303: DWORD - new frequency
304: */
305: DWORD NEAR PASCAL Opl3_CalcBend (DWORD dwOrig, short iBend)
306: {
307: DWORD dw;
308: // D1 ("\nOpl3_CalcBend");
309:
310: /* do different things depending upon positive or
311: negative bend */
312: if (iBend > 0)
313: {
314: dw = (DWORD)((iBend * (LONG)(256.0 * (EQUAL * EQUAL - 1.0))) >> 8);
315: dwOrig += (DWORD)(AsULMUL(dw, dwOrig) >> 15);
316: }
317: else if (iBend < 0)
318: {
319: dw = (DWORD)(((-iBend) * (LONG)(256.0 * (1.0 - 1.0 / EQUAL / EQUAL))) >> 8);
320: dwOrig -= (DWORD)(AsULMUL(dw, dwOrig) >> 15);
321: }
322:
323: return dwOrig;
324: }
325:
326:
327: /*****************************************************************
328: Opl3_CalcFAndB - Calculates the FNumber and Block given
329: a frequency.
330:
331: inputs
332: DWORD dwPitch - pitch
333: returns
334: WORD - High byte contains the 0xb0 section of the
335: block and fNum, and the low byte contains the
336: 0xa0 section of the fNumber
337: */
338: WORD NEAR PASCAL Opl3_CalcFAndB (DWORD dwPitch)
339: {
340: BYTE bBlock;
341:
342: // D1("\nOpl3_CalcFAndB");
343: /* bBlock is like an exponential to dwPitch (or FNumber) */
344: for (bBlock = 1; dwPitch >= 0x400; dwPitch >>= 1, bBlock++)
345: ;
346:
347: if (bBlock > 0x07)
348: bBlock = 0x07; /* we cant do anything about this */
349:
350: /* put in high two bits of F-num into bBlock */
351: return ((WORD) bBlock << 10) | (WORD) dwPitch;
352: }
353:
354:
355: /**************************************************************
356: Opl3_CalcVolume - This calculates the attenuation for an operator.
357:
358: inputs
359: BYTE bOrigAtten - original attenuation in 0.75 dB units
360: BYTE bChannel - MIDI channel
361: BYTE bVelocity - velocity of the note
362: BYTE bOper - operator number (from 0 to 3)
363: BYTE bMode - voice mode (from 0 through 7 for
364: modulator/carrier selection)
365: returns
366: BYTE - new attenuation in 0.75 dB units, maxing out at 0x3f.
367: */
368: BYTE NEAR PASCAL Opl3_CalcVolume (BYTE bOrigAtten, BYTE bChannel,
369: BYTE bVelocity, BYTE bOper, BYTE bMode)
370: {
371: BYTE bVolume;
372: WORD wTemp;
373: WORD wMin;
374:
375: switch (bMode) {
376: case 0:
377: bVolume = (BYTE)(bOper == 3);
378: break;
379: case 1:
380: bVolume = (BYTE)((bOper == 1) || (bOper == 3));
381: break;
382: case 2:
383: bVolume = (BYTE)((bOper == 0) || (bOper == 3));
384: break;
385: case 3:
386: bVolume = (BYTE)(bOper != 1);
387: break;
388: case 4:
389: bVolume = (BYTE)((bOper == 1) || (bOper == 3));
390: break;
391: case 5:
392: bVolume = (BYTE)(bOper >= 1);
393: break;
394: case 6:
395: bVolume = (BYTE)(bOper <= 2);
396: break;
397: case 7:
398: bVolume = TRUE;
399: break;
400: };
401: if (!bVolume)
402: return bOrigAtten; /* this is a modulator wave */
403:
404: wMin =(wSynthAttenL < wSynthAttenR) ? wSynthAttenL : wSynthAttenR;
405: wTemp = bOrigAtten + ((wMin << 1) +
406: gbChanAtten[bChannel] + gbVelocityAtten[bVelocity >> 2]);
407: return (wTemp > 0x3f) ? (BYTE) 0x3f : (BYTE) wTemp;
408: }
409:
410: /**************************************************************
411: Opl3_CalcStereoMask - This calculates the stereo mask.
412:
413: inputs
414: BYTE bChannel - MIDI channel
415: returns
416: BYTE - mask (for register 0xc0-c8) for eliminating the
417: left/right/both channels
418: */
419: BYTE NEAR PASCAL Opl3_CalcStereoMask (BYTE bChannel)
420: {
421: WORD wLeft, wRight;
422:
423: /* figure out the basic levels of the 2 channels */
424: wLeft = (wSynthAttenL << 1) + gbChanAtten[bChannel];
425: wRight = (wSynthAttenR << 1) + gbChanAtten[bChannel];
426:
427: /* if both are too quiet then mask to nothing */
428: if ((wLeft > 0x3f) && (wRight > 0x3f))
429: return 0xcf;
430:
431: /* if one channel is significantly quieter than the other than
432: eliminate it */
433: if ((wLeft + 8) < wRight)
434: return (BYTE)(0xef & gbStereoMask[bChannel]); /* right is too quiet so eliminate */
435: else if ((wRight + 8) < wLeft)
436: return (BYTE)(0xdf & gbStereoMask[bChannel]); /* left too quiet so eliminate */
437: else
438: return (BYTE)(gbStereoMask[bChannel]); /* use both channels */
439: }
440:
441:
442:
443: /*
444: * opl3_setvolume
445: *
446: * set the volume on channel bChannel (all channels if 0xff).
447: */
448: static VOID Opl3_setvolume(BYTE bChannel)
449: {
450: WORD i, j, wTemp, wOffset;
451: noteStruct FAR * lpPS;
452: BYTE b4Op, bMode, bStereo;
453:
454: /* loop through all the notes looking for the right
455: * channel. Anything with the right channel gets its vol. changed
456: */
457: for (i = 0; i < NUMVOICES; i++) {
458: if ((gVoice[i].bChannel == bChannel) || (bChannel == 0xff)) {
459:
460: /* get a pointer to the patch*/
461: lpPS = &(glpPatch + gVoice[i].bPatch)->note;
462: b4Op = (BYTE)(lpPS->bOp != PATCH_1_2OP);
463:
464: /* moify level for each operator, but only if they
465: are carrier waves*/
466: if (b4Op) {
467: bMode = (BYTE)((lpPS->bAtC0[0] & 0x01) * 2 |
468: (lpPS->bAtC0[1] & 0x01));
469: if (lpPS->bOp == PATCH_2_2OP)
470: bMode += 4;
471: }
472: else
473: bMode = (BYTE) ( (lpPS->bAtC0[0] & 0x01) * 2 + 4);
474:
475: for (j = 0; j < (WORD)(b4Op ? NUMOPS : 2); j++) {
476: wTemp = (BYTE) Opl3_CalcVolume (
477: (BYTE)(lpPS->op[j].bAt40 & (BYTE) 0x3f), gVoice[i].bChannel,
478: gVoice[i].bVelocity, (BYTE) j, bMode);
479:
480: /* write the new value out */
481: wOffset = (i < NUM4VOICES) ?
482: gw4OpOffset[i][j] : gw2OpOffset[i - NUM4VOICES][j];
483: MidiSendFM (0x40 + wOffset,
484: (BYTE) ((lpPS->op[j].bAt40 & (BYTE)0xc0) | (BYTE) wTemp));
485: };
486:
487: /* do stereo panning, but cutting off a left or right
488: channel if necessary */
489: bStereo = Opl3_CalcStereoMask(gVoice[i].bChannel);
490: wOffset = (i < NUM4VOICES) ?
491: gw4VoiceOffset[i] : gw2VoiceOffset[i - NUM4VOICES];
492: MidiSendFM (0xc0 + wOffset,
493: (BYTE)(lpPS->bAtC0[0] & bStereo));
494: if (b4Op)
495: MidiSendFM (0xc3 + wOffset,
496: (BYTE) (lpPS->bAtC0[1] & bStereo));
497: }
498: }
499: }
500:
501: /* --- externally called functions ---------------------------- */
502:
503: /*
504: * Opl3_NoteOn - This turns a note on. (Including drums, with
505: * a patch # of the drum Note + 128)
506: *
507: * inputs
508: * BYTE bPatch - MIDI patch number
509: * BYTE bNote - MIDI note number
510: * BYTE bChannel - MIDI channel #
511: * BYTE bVelocity - Velocity #
512: * short iBend - current pitch bend from -32768, to 32767
513: * returns
514: * none
515: */
516: VOID NEAR PASCAL Opl3_NoteOn (BYTE bPatch,
517: BYTE bNote, BYTE bChannel, BYTE bVelocity,
518: short iBend)
519: {
520: WORD wTemp, i, j;
521: BYTE bTemp, bMode, bStereo;
522: patchStruct FAR * lpPS;
523: DWORD dwBasicPitch, dwPitch[2];
524: noteStruct NS;
525: BYTE b4Op; /* use a 4-operator voice */
526:
527: /* get a pointer to the patch*/
528: lpPS = glpPatch + bPatch;
529:
530: /* find out the basic pitch according to our
531: note. This may be adjusted because of
532: pitch bends or special qualities for the note */
533: dwBasicPitch = gdwPitch[bNote % 12];
534: bTemp = bNote / (BYTE)12;
535: if (bTemp > (BYTE) (60 / 12))
536: dwBasicPitch = AsLSHL(dwBasicPitch, (BYTE)(bTemp - (BYTE)(60/12)));
537: else if (bTemp < (BYTE) (60/12))
538: dwBasicPitch = AsULSHR(dwBasicPitch, (BYTE)((BYTE) (60/12) - bTemp));
539:
540: /* copy the note information over and modify
541: the total level and pitch according to
542: the velocity, midi volume, and tuning */
543: AsMemCopy ((LPSTR) &NS, (LPSTR) &lpPS->note, sizeof(noteStruct));
544: b4Op = (BYTE)(NS.bOp != PATCH_1_2OP);
545:
546: for (j = 0; j < (WORD)(b4Op ? 2 : 1); j++) {
547: /* modify pitch */
548: dwPitch[j] = dwBasicPitch;
549: bTemp = (BYTE)((NS.bAtB0[j] >> 2) & 0x07);
550: if (bTemp > 4)
551: dwPitch[j] = AsLSHL(dwPitch[j], (BYTE)(bTemp - (BYTE)4));
552: else if (bTemp < 4)
553: dwPitch[j] = AsULSHR(dwPitch[j], (BYTE)((BYTE)4 - bTemp));
554:
555: wTemp = Opl3_CalcFAndB (Opl3_CalcBend (dwPitch[j], iBend));
556: NS.bAtA0[j] = (BYTE) wTemp;
557: NS.bAtB0[j] = (BYTE)0x20 | (BYTE) (wTemp >> 8);
558: };
559:
560: /* modify level for each operator, but only if they
561: are carrier waves*/
562: if (b4Op) {
563: bMode = (BYTE)((NS.bAtC0[0] & 0x01) * 2 | (NS.bAtC0[1] & 0x01));
564: if (NS.bOp == PATCH_2_2OP)
565: bMode += 4;
566: }
567: else
568: bMode = (BYTE) ( (NS.bAtC0[0] & 0x01) * 2 + 4);
569:
570: for (i = 0; i < (WORD)(b4Op ? NUMOPS : 2); i++) {
571: wTemp = (BYTE) Opl3_CalcVolume (
572: (BYTE)(NS.op[i].bAt40 & (BYTE) 0x3f), bChannel,
573: bVelocity, (BYTE) i, bMode);
574: NS.op[i].bAt40 = (NS.op[i].bAt40 & (BYTE)0xc0) | (BYTE) wTemp;
575: };
576:
577: /* do stereo panning, but cutting off a left or right
578: channel if necessary */
579: bStereo = Opl3_CalcStereoMask(bChannel);
580: NS.bAtC0[0] &= bStereo;
581: if (b4Op)
582: NS.bAtC0[1] &= bStereo;
583:
584: /* find an empty slot, and use it */
585: wTemp = Opl3_FindEmptySlot (bPatch, b4Op);
586: Opl3_FMNote (wTemp, &NS);
587: gVoice[wTemp].bNote = bNote;
588: gVoice[wTemp].bChannel = bChannel;
589: gVoice[wTemp].bPatch = bPatch;
590: gVoice[wTemp].bVelocity = bVelocity;
591: gVoice[wTemp].bOn = TRUE;
592: gVoice[wTemp].dwTime = gdwCurTime++;
593: gVoice[wTemp].dwOrigPitch[0] = dwPitch[0]; /* not including bend */
594: gVoice[wTemp].dwOrigPitch[1] = dwPitch[1]; /* not including bend */
595: gVoice[wTemp].bBlock[0] = NS.bAtB0[0];
596: gVoice[wTemp].bBlock[1] = NS.bAtB0[1];
597:
598: return;
599: }
600:
601:
602: /* Opl3_NoteOff - This turns a note off. (Including drums,
603: * with a patch # of the drum note + 128)
604: *
605: * inputs
606: * BYTE bPatch - MIDI patch #
607: * BYTE bNote - MIDI note number
608: * BYTE bChannel - MIDI channel #
609: * returns
610: * none
611: */
612: VOID FAR PASCAL Opl3_NoteOff (BYTE bPatch,
613: BYTE bNote, BYTE bChannel)
614: {
615: WORD wTemp;
616:
617: // D1("\nOpl3_NoteOff");
618:
619: /* find the note slot */
620: wTemp = Opl3_FindFullSlot (bNote, bChannel);
621: if (wTemp != 0xffff) {
622:
623: /* shut off the note portion */
624: /* we have the note slot. turn it off */
625: if (wTemp < NUM4VOICES) {
626: MidiSendFM (AD_BLOCK + gw4VoiceOffset[wTemp],
627: (BYTE)(gVoice[wTemp].bBlock[0] & 0x1f));
628: MidiSendFM (AD_BLOCK + gw4VoiceOffset[wTemp] + 3,
629: (BYTE)(gVoice[wTemp].bBlock[1] & 0x1f));
630: }
631: else
632: MidiSendFM (AD_BLOCK + gw2VoiceOffset[wTemp - NUM4VOICES],
633: (BYTE)(gVoice[wTemp].bBlock[0] & 0x1f));
634:
635: /* note this */
636: gVoice[wTemp].bOn = FALSE;
637: gVoice[wTemp].bBlock[0] &= 0x1f;
638: gVoice[wTemp].bBlock[1] &= 0x1f;
639: gVoice[wTemp].dwTime = gdwCurTime;
640: };
641:
642: }
643:
644: /*
645: * Opl3_AllNotesOff - turn off all notes
646: *
647: */
648: VOID Opl3_AllNotesOff(void)
649: {
650: BYTE i;
651:
652: for (i = 0; i < NUMVOICES; i++) {
653: Opl3_NoteOff (gVoice[i].bPatch, gVoice[i].bNote, gVoice[i].bChannel);
654: }
655: }
656:
657:
658:
659: /* Opl3_NewVolume - This should be called if a volume level
660: * has changed. This will adjust the levels of all the playing
661: * voices.
662: *
663: * inputs
664: * WORD wLeft - left attenuation (1.5 db units)
665: * WORD wRight - right attenuation (ignore if mono)
666: * returns
667: * none
668: */
669: VOID FAR PASCAL Opl3_NewVolume (WORD wLeft, WORD wRight)
670: {
671:
672: /* make sure that we are actually open */
673: if (!glpPatch)
674: return;
675:
676: wSynthAttenL = wLeft;
677: wSynthAttenR = wRight;
678:
679: Opl3_setvolume(0xff);
680:
681: }
682:
683:
684:
685: /* Opl3_ChannelVolume - set the volume level for an individual channel.
686: *
687: * inputs
688: * BYTE bChannel - channel number to change
689: * WORD wAtten - attenuation in 1.5 db units
690: *
691: * returns
692: * none
693: */
694: VOID FAR PASCAL Opl3_ChannelVolume(BYTE bChannel, WORD wAtten)
695: {
696: gbChanAtten[bChannel] = wAtten;
697:
698: Opl3_setvolume(bChannel);
699: }
700:
701:
702:
703: /* Opl3_SetPan - set the left-right pan position.
704: *
705: * inputs
706: * BYTE bChannel - channel number to alter
707: * BYTE bPan - 0 for left, 127 for right or somewhere in the middle.
708: *
709: * returns - none
710: */
711: VOID FAR PASCAL Opl3_SetPan(BYTE bChannel, BYTE bPan)
712: {
713: /* change the pan level */
714: if (bPan > (64 + 16))
715: gbStereoMask[bChannel] = 0xef; /* let only right channel through */
716: else if (bPan < (64 - 16))
717: gbStereoMask[bChannel] = 0xdf; /* let only left channel through */
718: else
719: gbStereoMask[bChannel] = 0xff; /* let both channels */
720:
721: /* change any curently playing patches */
722: Opl3_setvolume(bChannel);
723: }
724:
725:
726: /* Opl3_PitchBend - This pitch bends a channel.
727: *
728: * inputs
729: * BYTE bChannel - channel
730: * short iBend - Values from -32768 to 32767, being
731: * -2 to +2 half steps
732: * returns
733: * none
734: */
735: VOID NEAR PASCAL Opl3_PitchBend (BYTE bChannel, short iBend)
736: {
737: WORD i, wTemp[2], j;
738: DWORD dwNew;
739:
740: /* loop through all the notes looking for the right
741: * channel. Anything with the right channel gets its pitch bent
742: */
743: for (i = 0; i < NUMVOICES; i++) {
744: if (gVoice[i].bChannel == bChannel) {
745: for (j = 0; j < (WORD)((i < NUM4VOICES) ? 2 : 1); j++) {
746: dwNew = Opl3_CalcBend (gVoice[i].dwOrigPitch[j], iBend);
747: wTemp[j] = Opl3_CalcFAndB (dwNew);
748: gVoice[i].bBlock[j] = (gVoice[i].bBlock[j] & (BYTE)0xe0) |
749: (BYTE) (wTemp[j] >> 8);
750: }
751:
752: if (i < NUM4VOICES) {
753: MidiSendFM (AD_BLOCK + gw4VoiceOffset[i],
754: gVoice[i].bBlock[0]);
755: MidiSendFM (AD_BLOCK + gw4VoiceOffset[i] + 3,
756: gVoice[i].bBlock[1]);
757: MidiSendFM (AD_FNUMBER + gw4VoiceOffset[i],
758: (BYTE) wTemp[0]);
759: MidiSendFM (AD_FNUMBER + gw4VoiceOffset[i] + 3,
760: (BYTE) wTemp[1]);
761: } else {
762: MidiSendFM (AD_BLOCK + gw2VoiceOffset[i - NUM4VOICES],
763: gVoice[i].bBlock[0]);
764: MidiSendFM (AD_FNUMBER + gw2VoiceOffset[i - NUM4VOICES],
765: (BYTE) wTemp[0]);
766: }
767: }
768: }
769: }
770:
771: static TCHAR BCODE gszDefPatchLib[] = TEXT("SYNTH.PAT");
772: static TCHAR BCODE gszIniKeyPatchLib[] = INI_STR_PATCHLIB;
773: static TCHAR BCODE gszIniDrvSection[] = INI_DRIVER;
774: static TCHAR BCODE gszIniDrvFile[] = INI_SOUND;
775: static TCHAR BCODE gszSysIniSection[] = TEXT("synth.dll");
776: static TCHAR BCODE gszSysIniFile[] = TEXT("System.Ini");
777:
778: /** static DWORD NEAR PASCAL DrvGetProfileString(LPSTR szKeyName, LPSTR szDef, LPSTR szBuf, UINT wBufLen)
779: *
780: * DESCRIPTION:
781: *
782: *
783: * ARGUMENTS:
784: * (LPSTR szKeyName, LPSTR szDef, LPSTR szBuf, WORD wBufLen)
785: * HINT wSystem - if TRUE write/read to system.ini
786: *
787: * RETURN (static DWORD NEAR PASCAL):
788: *
789: *
790: * NOTES:
791: *
792: ** cjp */
793:
794: static DWORD NEAR PASCAL DrvGetProfileString(LPTSTR szKeyName, LPTSTR szDef, LPTSTR szBuf, UINT wBufLen,
795: UINT wSystem)
796: {
797: return GetPrivateProfileString(wSystem ? gszSysIniSection : gszIniDrvSection, szKeyName, szDef,
798: szBuf, wBufLen, wSystem ? gszSysIniFile : gszIniDrvFile);
799: } /* DrvGetProfileString() */
800:
801: /* Opl3_BoardInit - initialise board and load patches as necessary.
802: *
803: * inputs - none
804: * returns - 0 for success or the error code
805: */
806: WORD Opl3_BoardInit(void)
807: {
808: HMMIO hmmio;
809: MMCKINFO mmckinfo, mm2;
810: TCHAR szPatchLib[STRINGLEN]; /* patch libarary */
811:
812: D1 ("\nOpl3_Init");
813:
814: /* Check we haven't already initialized */
815: if (glpPatch != NULL) {
816: return 0;
817: }
818:
819: /* should the load patches be moved to the init section? */
820: DrvGetProfileString(gszIniKeyPatchLib, gszDefPatchLib,
821: szPatchLib, sizeof(szPatchLib), FALSE);
822:
823:
824: /* allocate the memory, and fill it up from the patch
825: * library. The name of the library has been set previously
826: * and written into szPatchLib
827: */
828: glpPatch = (patchStruct FAR *)GlobalLock(GlobalAlloc(GMEM_MOVEABLE|GMEM_SHARE|GMEM_ZEROINIT, sizeof(patchStruct) * NUMPATCHES));
829: if (!glpPatch) {
830: D1 ("Opl3_Init: could not allocate patch container memory!");
831: return ERR_OUTOFMEMORY;
832: }
833:
834: hmmio = mmioOpen (szPatchLib, NULL, MMIO_READ);
835: if (hmmio) {
836: mmioDescend (hmmio, &mmckinfo, NULL, 0);
837: if ((mmckinfo.ckid == FOURCC_RIFF) &&
838: (mmckinfo.fccType == RIFF_PATCH)) {
839:
840: mm2.ckid = RIFF_FM4;
841: if (!mmioDescend (hmmio, &mm2, &mmckinfo, MMIO_FINDCHUNK)) {
842: /* we have found the synthesis chunk */
843: if (mm2.cksize > (sizeof(patchStruct)*NUMPATCHES))
844: mm2.cksize = sizeof(patchStruct)*NUMPATCHES;
845: mmioRead (hmmio, (LPSTR) glpPatch, mm2.cksize);
846: } else {
847: D1("\nBad mmioDescend2");
848: };
849: } else {
850: D1("\nBad mmioDescend1");
851: };
852:
853: mmioClose (hmmio, 0);
854: } else {
855:
856: TCHAR szAlert[50];
857: TCHAR szErrorBuffer[255];
858:
859: LoadString(ghModule, SR_ALERT, szAlert, sizeof(szAlert));
860: LoadString(ghModule, SR_ALERT_NOPATCH, szErrorBuffer, sizeof(szErrorBuffer));
861: MessageBox(NULL, szErrorBuffer, szAlert, MB_OK|MB_ICONHAND);
862: D1 ("\nBad mmioOpen");
863: };
864:
865:
866: return 0; /* done */
867: }
868:
869:
870: /*
871: * Opl3_BoardReset - silence the board and set all voices off.
872: */
873: VOID Opl3_BoardReset(void)
874: {
875:
876: BYTE i;
877:
878: /* make sure all notes turned off */
879: Opl3_AllNotesOff();
880:
881:
882: /* ---- silence the chip -------- */
883:
884: /* tell the FM chip to use 4-operator mode, and
885: fill in any other random variables */
886: MidiSendFM (AD_NEW, 0x01);
887: MidiSendFM (AD_MASK, 0x60);
888: MidiSendFM (AD_CONNECTION, 0x3f);
889: MidiSendFM (AD_NTS, 0x00);
890:
891:
892: /* turn off the drums, and use high vibrato/modulation */
893: MidiSendFM (AD_DRUM, 0xc0);
894:
895: /* turn off all the oscillators */
896: for (i = 0; i < 0x15; i++) {
897: MidiSendFM (AD_LEVEL + i, 0x3f);
898: MidiSendFM (AD_LEVEL2 + i, 0x3f);
899: };
900:
901: /* turn off all the voices */
902: for (i = 0; i < 0x08; i++) {
903: MidiSendFM (AD_BLOCK + i, 0x00);
904: MidiSendFM (AD_BLOCK2 + i, 0x00);
905: };
906:
907:
908: /* clear all of the voice slots to empty */
909: for (i = 0; i < NUMVOICES; i++)
910: gVoice[i].dwTime = 0;
911:
912: /* start attenuations at -3 dB, which is 90 MIDI level */
913: for (i = 0; i < NUMCHANNELS; i++) {
914: gbChanAtten[i] = 4;
915: gbStereoMask[i] = 0xff;
916: };
917:
918: }
919:
920:
921:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.