ref: 516fc276f112baf0bd4508596598aed49929bde9
dir: /src/audiolib/al_midi.c/
/*
Copyright (C) 1994-1995 Apogee Software, Ltd.
Copyright (C) 2002-2015 icculus.org, GNU/Linux port
Copyright (C) 2017-2018 Steven LeVesque
This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
You should have received a copy of the GNU General Public License
along with this program. If not, see <https://www.gnu.org/licenses/>.
*/
/**********************************************************************
module: AL_MIDI.C
author: James R. Dose
date: April 1, 1994
Low level routines to support General MIDI music on Adlib compatible
cards.
(c) Copyright 1994 James R. Dose. All Rights Reserved.
**********************************************************************/
#include <conio.h>
#include <dos.h>
#include <stddef.h>
#include <stdlib.h>
//#include <math.h>
#include "dpmi.h"
#include "interrup.h"
#include "sndcards.h"
#include "blaster.h"
#include "user.h"
#include "al_midi.h"
#include "_al_midi.h"
#include "ll_man.h"
#define TRUE ( 1 == 1 )
#define FALSE ( !TRUE )
static unsigned OctavePitch[ MAX_OCTAVE + 1 ] =
{
OCTAVE_0, OCTAVE_1, OCTAVE_2, OCTAVE_3,
OCTAVE_4, OCTAVE_5, OCTAVE_6, OCTAVE_7,
};
static unsigned NoteMod12[ MAX_NOTE + 1 ];
static unsigned NoteDiv12[ MAX_NOTE + 1 ];
// Pitch table
//static unsigned NotePitch[ FINETUNE_MAX + 1 ][ 12 ] =
// {
// { C, C_SHARP, D, D_SHARP, E, F, F_SHARP, G, G_SHARP, A, A_SHARP, B },
// };
static unsigned NotePitch[ FINETUNE_MAX + 1 ][ 12 ] =
{
{ 0x157, 0x16b, 0x181, 0x198, 0x1b0, 0x1ca, 0x1e5, 0x202, 0x220, 0x241, 0x263, 0x287 },
{ 0x157, 0x16b, 0x181, 0x198, 0x1b0, 0x1ca, 0x1e5, 0x202, 0x220, 0x242, 0x264, 0x288 },
{ 0x158, 0x16c, 0x182, 0x199, 0x1b1, 0x1cb, 0x1e6, 0x203, 0x221, 0x243, 0x265, 0x289 },
{ 0x158, 0x16c, 0x183, 0x19a, 0x1b2, 0x1cc, 0x1e7, 0x204, 0x222, 0x244, 0x266, 0x28a },
{ 0x159, 0x16d, 0x183, 0x19a, 0x1b3, 0x1cd, 0x1e8, 0x205, 0x223, 0x245, 0x267, 0x28b },
{ 0x15a, 0x16e, 0x184, 0x19b, 0x1b3, 0x1ce, 0x1e9, 0x206, 0x224, 0x246, 0x268, 0x28c },
{ 0x15a, 0x16e, 0x185, 0x19c, 0x1b4, 0x1ce, 0x1ea, 0x207, 0x225, 0x247, 0x269, 0x28e },
{ 0x15b, 0x16f, 0x185, 0x19d, 0x1b5, 0x1cf, 0x1eb, 0x208, 0x226, 0x248, 0x26a, 0x28f },
{ 0x15b, 0x170, 0x186, 0x19d, 0x1b6, 0x1d0, 0x1ec, 0x209, 0x227, 0x249, 0x26b, 0x290 },
{ 0x15c, 0x170, 0x187, 0x19e, 0x1b7, 0x1d1, 0x1ec, 0x20a, 0x228, 0x24a, 0x26d, 0x291 },
{ 0x15d, 0x171, 0x188, 0x19f, 0x1b7, 0x1d2, 0x1ed, 0x20b, 0x229, 0x24b, 0x26e, 0x292 },
{ 0x15d, 0x172, 0x188, 0x1a0, 0x1b8, 0x1d3, 0x1ee, 0x20c, 0x22a, 0x24c, 0x26f, 0x293 },
{ 0x15e, 0x172, 0x189, 0x1a0, 0x1b9, 0x1d4, 0x1ef, 0x20d, 0x22b, 0x24d, 0x270, 0x295 },
{ 0x15f, 0x173, 0x18a, 0x1a1, 0x1ba, 0x1d4, 0x1f0, 0x20e, 0x22c, 0x24e, 0x271, 0x296 },
{ 0x15f, 0x174, 0x18a, 0x1a2, 0x1bb, 0x1d5, 0x1f1, 0x20f, 0x22d, 0x24f, 0x272, 0x297 },
{ 0x160, 0x174, 0x18b, 0x1a3, 0x1bb, 0x1d6, 0x1f2, 0x210, 0x22e, 0x250, 0x273, 0x298 },
{ 0x161, 0x175, 0x18c, 0x1a3, 0x1bc, 0x1d7, 0x1f3, 0x211, 0x22f, 0x251, 0x274, 0x299 },
{ 0x161, 0x176, 0x18c, 0x1a4, 0x1bd, 0x1d8, 0x1f4, 0x212, 0x230, 0x252, 0x276, 0x29b },
{ 0x162, 0x176, 0x18d, 0x1a5, 0x1be, 0x1d9, 0x1f5, 0x212, 0x231, 0x254, 0x277, 0x29c },
{ 0x162, 0x177, 0x18e, 0x1a6, 0x1bf, 0x1d9, 0x1f5, 0x213, 0x232, 0x255, 0x278, 0x29d },
{ 0x163, 0x178, 0x18f, 0x1a6, 0x1bf, 0x1da, 0x1f6, 0x214, 0x233, 0x256, 0x279, 0x29e },
{ 0x164, 0x179, 0x18f, 0x1a7, 0x1c0, 0x1db, 0x1f7, 0x215, 0x235, 0x257, 0x27a, 0x29f },
{ 0x164, 0x179, 0x190, 0x1a8, 0x1c1, 0x1dc, 0x1f8, 0x216, 0x236, 0x258, 0x27b, 0x2a1 },
{ 0x165, 0x17a, 0x191, 0x1a9, 0x1c2, 0x1dd, 0x1f9, 0x217, 0x237, 0x259, 0x27c, 0x2a2 },
{ 0x166, 0x17b, 0x192, 0x1aa, 0x1c3, 0x1de, 0x1fa, 0x218, 0x238, 0x25a, 0x27e, 0x2a3 },
{ 0x166, 0x17b, 0x192, 0x1aa, 0x1c3, 0x1df, 0x1fb, 0x219, 0x239, 0x25b, 0x27f, 0x2a4 },
{ 0x167, 0x17c, 0x193, 0x1ab, 0x1c4, 0x1e0, 0x1fc, 0x21a, 0x23a, 0x25c, 0x280, 0x2a6 },
{ 0x168, 0x17d, 0x194, 0x1ac, 0x1c5, 0x1e0, 0x1fd, 0x21b, 0x23b, 0x25d, 0x281, 0x2a7 },
{ 0x168, 0x17d, 0x194, 0x1ad, 0x1c6, 0x1e1, 0x1fe, 0x21c, 0x23c, 0x25e, 0x282, 0x2a8 },
{ 0x169, 0x17e, 0x195, 0x1ad, 0x1c7, 0x1e2, 0x1ff, 0x21d, 0x23d, 0x260, 0x283, 0x2a9 },
{ 0x16a, 0x17f, 0x196, 0x1ae, 0x1c8, 0x1e3, 0x1ff, 0x21e, 0x23e, 0x261, 0x284, 0x2ab },
{ 0x16a, 0x17f, 0x197, 0x1af, 0x1c8, 0x1e4, 0x200, 0x21f, 0x23f, 0x262, 0x286, 0x2ac }
};
// Slot numbers as a function of the voice and the operator.
// ( melodic only)
static int slotVoice[ NUM_VOICES ][ 2 ] =
{
{ 0, 3 }, // voice 0
{ 1, 4 }, // 1
{ 2, 5 }, // 2
{ 6, 9 }, // 3
{ 7, 10 }, // 4
{ 8, 11 }, // 5
{ 12, 15 }, // 6
{ 13, 16 }, // 7
{ 14, 17 }, // 8
};
static int VoiceLevel[ NumChipSlots ][ 2 ];
static int VoiceKsl[ NumChipSlots ][ 2 ];
// This table gives the offset of each slot within the chip.
// offset = fn( slot)
static char offsetSlot[ NumChipSlots ] =
{
0, 1, 2, 3, 4, 5,
8, 9, 10, 11, 12, 13,
16, 17, 18, 19, 20, 21
};
static int VoiceReserved[ NUM_VOICES * 2 ] =
{
FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE,
FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE
};
static VOICE Voice[ NUM_VOICES * 2 ];
static VOICELIST Voice_Pool;
static CHANNEL Channel[ NUM_CHANNELS ];
static int AL_LeftPort = 0x388;
static int AL_RightPort = 0x388;
static int AL_Stereo = FALSE;
static int AL_SendStereo = FALSE;
static int AL_OPL3 = FALSE;
static int AL_MaxMidiChannel = 16;
/**********************************************************************
Memory locked functions:
**********************************************************************/
#define AL_LockStart AL_SendOutputToPort
/*---------------------------------------------------------------------
Function: AL_SendOutputToPort
Sends data to the Adlib using a specified port.
---------------------------------------------------------------------*/
void AL_SendOutputToPort
(
int port,
int reg,
int data
)
{
int delay;
outp( port, reg );
for( delay = 6; delay > 0 ; delay-- )
// for( delay = 2; delay > 0 ; delay-- )
{
inp( port );
}
outp( port + 1, data );
// for( delay = 35; delay > 0 ; delay-- )
for( delay = 27; delay > 0 ; delay-- )
// for( delay = 2; delay > 0 ; delay-- )
{
inp( port );
}
}
/*---------------------------------------------------------------------
Function: AL_SendOutput
Sends data to the Adlib.
---------------------------------------------------------------------*/
void AL_SendOutput
(
int voice,
int reg,
int data
)
{
int port;
if ( AL_SendStereo )
{
AL_SendOutputToPort( AL_LeftPort, reg, data );
AL_SendOutputToPort( AL_RightPort, reg, data );
}
else
{
port = ( voice == 0 ) ? AL_RightPort : AL_LeftPort;
AL_SendOutputToPort( port, reg, data );
}
}
/*---------------------------------------------------------------------
Function: AL_SetVoiceTimbre
Programs the specified voice's timbre.
---------------------------------------------------------------------*/
static void AL_SetVoiceTimbre
(
int voice
)
{
int off;
int slot;
int port;
int voc;
int patch;
int channel;
TIMBRE *timbre;
channel = Voice[ voice ].channel;
if ( channel == 9 )
{
patch = Voice[ voice ].key + 128;
}
else
{
patch = Channel[ channel ].Timbre;
}
if ( Voice[ voice ].timbre == patch )
{
return;
}
Voice[ voice ].timbre = patch;
timbre = &ADLIB_TimbreBank[ patch ];
port = Voice[ voice ].port;
voc = ( voice >= NUM_VOICES ) ? voice - NUM_VOICES : voice;
slot = slotVoice[ voc ][ 0 ];
off = offsetSlot[ slot ];
VoiceLevel[ slot ][ port ] = 63 - ( timbre->Level[ 0 ] & 0x3f );
VoiceKsl[ slot ][ port ] = timbre->Level[ 0 ] & 0xc0;
AL_SendOutput( port, 0xA0 + voc, 0 );
AL_SendOutput( port, 0xB0 + voc, 0 );
// Let voice clear the release
AL_SendOutput( port, 0x80 + off, 0xff );
AL_SendOutput( port, 0x60 + off, timbre->Env1[ 0 ] );
AL_SendOutput( port, 0x80 + off, timbre->Env2[ 0 ] );
AL_SendOutput( port, 0x20 + off, timbre->SAVEK[ 0 ] );
AL_SendOutput( port, 0xE0 + off, timbre->Wave[ 0 ] );
AL_SendOutput( port, 0x40 + off, timbre->Level[ 0 ] );
slot = slotVoice[ voc ][ 1 ];
if ( AL_SendStereo )
{
AL_SendOutputToPort( AL_LeftPort, 0xC0 + voice,
( timbre->Feedback & 0x0f ) | 0x20 );
AL_SendOutputToPort( AL_RightPort, 0xC0 + voice,
( timbre->Feedback & 0x0f ) | 0x10 );
}
else
{
if ( AL_OPL3 )
{
AL_SendOutput( port, 0xC0 + voc, ( timbre->Feedback & 0x0f ) |
0x30 );
}
else
{
AL_SendOutputToPort( ADLIB_PORT, 0xC0 + voice, timbre->Feedback );
}
}
off = offsetSlot[ slot ];
VoiceLevel[ slot ][ port ] = 63 - ( timbre->Level[ 1 ] & 0x3f );
VoiceKsl[ slot ][ port ] = timbre->Level[ 1 ] & 0xc0;
AL_SendOutput( port, 0x40 + off, 63 );
// Let voice clear the release
AL_SendOutput( port, 0x80 + off, 0xff );
AL_SendOutput( port, 0x60 + off, timbre->Env1[ 1 ] );
AL_SendOutput( port, 0x80 + off, timbre->Env2[ 1 ] );
AL_SendOutput( port, 0x20 + off, timbre->SAVEK[ 1 ] );
AL_SendOutput( port, 0xE0 + off, timbre->Wave[ 1 ] );
}
/*---------------------------------------------------------------------
Function: AL_SetVoiceVolume
Sets the volume of the specified voice.
---------------------------------------------------------------------*/
static void AL_SetVoiceVolume
(
int voice
)
{
int channel;
int velocity;
int slot;
int port;
int voc;
unsigned long t1;
unsigned long t2;
unsigned long volume;
TIMBRE *timbre;
channel = Voice[ voice ].channel;
timbre = &ADLIB_TimbreBank[ Voice[ voice ].timbre ];
velocity = Voice[ voice ].velocity + timbre->Velocity;
velocity = min( velocity, MAX_VELOCITY );
voc = ( voice >= NUM_VOICES ) ? voice - NUM_VOICES : voice;
slot = slotVoice[ voc ][ 1 ];
port = Voice[ voice ].port;
// amplitude
t1 = ( unsigned )VoiceLevel[ slot ][ port ];
t1 *= ( velocity + 0x80 );
t1 = ( Channel[ channel ].Volume * t1 ) >> 15;
if ( !AL_SendStereo )
{
volume = t1 ^ 63;
volume |= ( unsigned )VoiceKsl[ slot ][ port ];
AL_SendOutput( port, 0x40 + offsetSlot[ slot ], volume );
// Check if this timbre is Additive
if ( timbre->Feedback & 0x01 )
{
slot = slotVoice[ voc ][ 0 ];
// amplitude
t2 = ( unsigned )VoiceLevel[ slot ][ port ];
t2 *= ( velocity + 0x80 );
t2 = ( Channel[ channel ].Volume * t1 ) >> 15;
volume = t2 ^ 63;
volume |= ( unsigned )VoiceKsl[ slot ][ port ];
AL_SendOutput( port, 0x40 + offsetSlot[ slot ], volume );
}
}
else
{
// Set left channel volume
volume = t1;
if ( Channel[ channel ].Pan < 64 )
{
volume *= Channel[ channel ].Pan;
volume >>= 6;
}
volume ^= 63;
volume |= ( unsigned )VoiceKsl[ slot ][ port ];
AL_SendOutputToPort( AL_LeftPort, 0x40 + offsetSlot[ slot ], volume );
// Set right channel volume
volume = t1;
if ( Channel[ channel ].Pan > 64 )
{
volume *= 127 - Channel[ channel ].Pan;
volume >>= 6;
}
volume ^= 63;
volume |= ( unsigned )VoiceKsl[ slot ][ port ];
AL_SendOutputToPort( AL_RightPort, 0x40 + offsetSlot[ slot ], volume );
// Check if this timbre is Additive
if ( timbre->Feedback & 0x01 )
{
// amplitude
t2 = ( unsigned )VoiceLevel[ slot ][ port ];
t2 *= ( velocity + 0x80 );
t2 = ( Channel[ channel ].Volume * t1 ) >> 15;
slot = slotVoice[ voc ][ 0 ];
// Set left channel volume
volume = t2;
if ( Channel[ channel ].Pan < 64 )
{
volume *= Channel[ channel ].Pan;
volume >>= 6;
}
volume ^= 63;
volume |= ( unsigned )VoiceKsl[ slot ][ port ];
AL_SendOutputToPort( AL_LeftPort, 0x40 + offsetSlot[ slot ], volume );
// Set right channel volume
volume = t2;
if ( Channel[ channel ].Pan > 64 )
{
volume *= 127 - Channel[ channel ].Pan;
volume >>= 6;
}
volume ^= 63;
volume |= ( unsigned )VoiceKsl[ slot ][ port ];
AL_SendOutputToPort( AL_RightPort, 0x40 + offsetSlot[ slot ], volume );
}
}
}
/*---------------------------------------------------------------------
Function: AL_AllocVoice
Retrieves a free voice from the voice pool.
---------------------------------------------------------------------*/
static int AL_AllocVoice
(
void
)
{
int voice;
if ( Voice_Pool.start )
{
voice = Voice_Pool.start->num;
LL_Remove( VOICE, &Voice_Pool, &Voice[ voice ] );
return( voice );
}
return( AL_VoiceNotFound );
}
/*---------------------------------------------------------------------
Function: AL_GetVoice
Determines which voice is associated with a specified note and
MIDI channel.
---------------------------------------------------------------------*/
static int AL_GetVoice
(
int channel,
int key
)
{
VOICE *voice;
voice = Channel[ channel ].Voices.start;
while( voice != NULL )
{
if ( voice->key == key )
{
return( voice->num );
}
voice = voice->next;
}
return( AL_VoiceNotFound );
}
/*---------------------------------------------------------------------
Function: AL_SetVoicePitch
Programs the pitch of the specified voice.
---------------------------------------------------------------------*/
static void AL_SetVoicePitch
(
int voice
)
{
int note;
int channel;
int patch;
int detune;
int ScaleNote;
int Octave;
int pitch;
int port;
int voc;
port = Voice[ voice ].port;
voc = ( voice >= NUM_VOICES ) ? voice - NUM_VOICES : voice;
channel = Voice[ voice ].channel;
if ( channel == 9 )
{
patch = Voice[ voice ].key + 128;
note = ADLIB_TimbreBank[ patch ].Transpose;
}
else
{
patch = Channel[ channel ].Timbre;
note = Voice[ voice ].key + ADLIB_TimbreBank[ patch ].Transpose;
}
note += Channel[ channel ].KeyOffset - 12;
if ( note > MAX_NOTE )
{
note = MAX_NOTE;
}
if ( note < 0 )
{
note = 0;
}
detune = Channel[ channel ].KeyDetune;
ScaleNote = NoteMod12[ note ];
Octave = NoteDiv12[ note ];
pitch = OctavePitch[ Octave ] | NotePitch[ detune ][ ScaleNote ];
Voice[ voice ].pitchleft = pitch;
pitch |= Voice[ voice ].status;
if ( !AL_SendStereo )
{
AL_SendOutput( port, 0xA0 + voc, pitch );
AL_SendOutput( port, 0xB0 + voc, pitch >> 8 );
}
else
{
AL_SendOutputToPort( AL_LeftPort, 0xA0 + voice, pitch );
AL_SendOutputToPort( AL_LeftPort, 0xB0 + voice, pitch >> 8 );
if ( channel != 9 )
{
detune += STEREO_DETUNE;
}
if ( detune > FINETUNE_MAX )
{
detune -= FINETUNE_RANGE;
if ( note < MAX_NOTE )
{
note++;
ScaleNote = NoteMod12[ note ];
Octave = NoteDiv12[ note ];
}
}
pitch = OctavePitch[ Octave ] | NotePitch[ detune ][ ScaleNote ];
Voice[ voice ].pitchright = pitch;
pitch |= Voice[ voice ].status;
AL_SendOutputToPort( AL_RightPort, 0xA0 + voice, pitch );
AL_SendOutputToPort( AL_RightPort, 0xB0 + voice, pitch >> 8 );
}
}
/*---------------------------------------------------------------------
Function: AL_SetChannelVolume
Sets the volume of the specified MIDI channel.
---------------------------------------------------------------------*/
static void AL_SetChannelVolume
(
int channel,
int volume
)
{
VOICE *voice;
volume = max( 0, volume );
volume = min( volume, AL_MaxVolume );
Channel[ channel ].Volume = volume;
voice = Channel[ channel ].Voices.start;
while( voice != NULL )
{
AL_SetVoiceVolume( voice->num );
voice = voice->next;
}
}
/*---------------------------------------------------------------------
Function: AL_SetChannelPan
Sets the pan position of the specified MIDI channel.
---------------------------------------------------------------------*/
static void AL_SetChannelPan
(
int channel,
int pan
)
{
// Don't pan drum sounds
if ( channel != 9 )
{
Channel[ channel ].Pan = pan;
}
}
/*---------------------------------------------------------------------
Function: AL_SetChannelDetune
Sets the stereo voice detune of the specified MIDI channel.
---------------------------------------------------------------------*/
static void AL_SetChannelDetune
(
int channel,
int detune
)
{
Channel[ channel ].Detune = detune;
}
/*---------------------------------------------------------------------
Function: AL_ResetVoices
Sets all voice info to the default state.
---------------------------------------------------------------------*/
static void AL_ResetVoices
(
void
)
{
int index;
int numvoices;
Voice_Pool.start = NULL;
Voice_Pool.end = NULL;
numvoices = NUM_VOICES;
if ( ( AL_OPL3 ) && ( !AL_Stereo ) )
{
numvoices = NUM_VOICES * 2;
}
for( index = 0; index < numvoices; index++ )
{
if ( VoiceReserved[ index ] == FALSE )
{
Voice[ index ].num = index;
Voice[ index ].key = 0;
Voice[ index ].velocity = 0;
Voice[ index ].channel = -1;
Voice[ index ].timbre = -1;
Voice[ index ].port = ( index < NUM_VOICES ) ? 0 : 1;
Voice[ index ].status = NOTE_OFF;
LL_AddToTail( VOICE, &Voice_Pool, &Voice[ index ] );
}
}
for( index = 0; index < NUM_CHANNELS; index++ )
{
Channel[ index ].Voices.start = NULL;
Channel[ index ].Voices.end = NULL;
Channel[ index ].Timbre = 0;
Channel[ index ].Pitchbend = 0;
Channel[ index ].KeyOffset = 0;
Channel[ index ].KeyDetune = 0;
Channel[ index ].Volume = AL_DefaultChannelVolume;
Channel[ index ].Pan = 64;
Channel[ index ].RPN = 0;
Channel[ index ].PitchBendRange = AL_DefaultPitchBendRange;
Channel[ index ].PitchBendSemiTones = AL_DefaultPitchBendRange / 100;
Channel[ index ].PitchBendHundreds = AL_DefaultPitchBendRange % 100;
}
}
/*---------------------------------------------------------------------
Function: AL_CalcPitchInfo
Calculates the pitch table.
---------------------------------------------------------------------*/
static void AL_CalcPitchInfo
(
void
)
{
int note;
// int finetune;
// double detune;
for( note = 0; note <= MAX_NOTE; note++ )
{
NoteMod12[ note ] = note % 12;
NoteDiv12[ note ] = note / 12;
}
// for( finetune = 1; finetune <= FINETUNE_MAX; finetune++ )
// {
// detune = pow( 2, ( double )finetune / ( 12.0 * FINETUNE_RANGE ) );
// for( note = 0; note < 12; note++ )
// {
// NotePitch[ finetune ][ note ] = ( ( double )NotePitch[ 0 ][ note ] * detune );
// }
// }
}
/*---------------------------------------------------------------------
Function: AL_FlushCard
Sets all voices to a known (quiet) state.
---------------------------------------------------------------------*/
void AL_FlushCard
(
int port
)
{
int i;
unsigned slot1;
unsigned slot2;
for( i = 0 ; i < NUM_VOICES; i++ )
{
if ( VoiceReserved[ i ] == FALSE )
{
slot1 = offsetSlot[ slotVoice[ i ][ 0 ] ];
slot2 = offsetSlot[ slotVoice[ i ][ 1 ] ];
AL_SendOutputToPort( port, 0xA0 + i, 0 );
AL_SendOutputToPort( port, 0xB0 + i, 0 );
AL_SendOutputToPort( port, 0xE0 + slot1, 0 );
AL_SendOutputToPort( port, 0xE0 + slot2, 0 );
// Set the envelope to be fast and quiet
AL_SendOutputToPort( port, 0x60 + slot1, 0xff );
AL_SendOutputToPort( port, 0x60 + slot2, 0xff );
AL_SendOutputToPort( port, 0x80 + slot1, 0xff );
AL_SendOutputToPort( port, 0x80 + slot2, 0xff );
// Maximum attenuation
AL_SendOutputToPort( port, 0x40 + slot1, 0xff );
AL_SendOutputToPort( port, 0x40 + slot2, 0xff );
}
}
}
/*---------------------------------------------------------------------
Function: AL_StereoOn
Sets the card send info in stereo.
---------------------------------------------------------------------*/
void AL_StereoOn
(
void
)
{
if ( ( AL_Stereo ) && ( !AL_SendStereo ) )
{
AL_SendStereo = TRUE;
if ( AL_OPL3 )
{
// Set card to OPL3 operation
AL_SendOutputToPort( AL_RightPort, 0x5, 1 );
}
}
else if ( AL_OPL3 )
{
// Set card to OPL3 operation
AL_SendOutputToPort( AL_RightPort, 0x5, 1 );
}
}
/*---------------------------------------------------------------------
Function: AL_StereoOff
Sets the card send info in mono.
---------------------------------------------------------------------*/
void AL_StereoOff
(
void
)
{
if ( ( AL_Stereo ) && ( AL_SendStereo ) )
{
AL_SendStereo = FALSE;
if ( AL_OPL3 )
{
// Set card back to OPL2 operation
AL_SendOutputToPort( AL_RightPort, 0x5, 0 );
}
}
else if ( AL_OPL3 )
{
// Set card back to OPL2 operation
AL_SendOutputToPort( AL_RightPort, 0x5, 0 );
}
}
/*---------------------------------------------------------------------
Function: AL_Reset
Sets the card to a known (quiet) state.
---------------------------------------------------------------------*/
void AL_Reset
(
void
)
{
AL_SendOutputToPort( ADLIB_PORT, 1, 0x20 );
AL_SendOutputToPort( ADLIB_PORT, 0x08, 0 );
// Set the values: AM Depth, VIB depth & Rhythm
AL_SendOutputToPort( ADLIB_PORT, 0xBD, 0 );
AL_StereoOn();
if ( ( AL_SendStereo ) || ( AL_OPL3 ) )
{
AL_FlushCard( AL_LeftPort );
AL_FlushCard( AL_RightPort );
}
else
{
AL_FlushCard( ADLIB_PORT );
}
}
/*---------------------------------------------------------------------
Function: AL_ReserveVoice
Marks a voice as being not available for use. This allows the
driver to use the rest of the card while another driver uses the
reserved voice.
---------------------------------------------------------------------*/
int AL_ReserveVoice
(
int voice
)
{
unsigned flags;
if ( ( voice < 0 ) || ( voice >= NUM_VOICES ) )
{
return( AL_Error );
}
if ( VoiceReserved[ voice ] )
{
return( AL_Warning );
}
flags = DisableInterrupts();
if ( Voice[ voice ].status == NOTE_ON )
{
AL_NoteOff( Voice[ voice ].channel, Voice[ voice ].key, 0 );
}
VoiceReserved[ voice ] = TRUE;
LL_Remove( VOICE, &Voice_Pool, &Voice[ voice ] );
RestoreInterrupts( flags );
return( AL_Ok );
}
/*---------------------------------------------------------------------
Function: AL_ReleaseVoice
Marks a previously reserved voice as being free to use.
---------------------------------------------------------------------*/
int AL_ReleaseVoice
(
int voice
)
{
unsigned flags;
if ( ( voice < 0 ) || ( voice >= NUM_VOICES ) )
{
return( AL_Error );
}
if ( !VoiceReserved[ voice ] )
{
return( AL_Warning );
}
flags = DisableInterrupts();
VoiceReserved[ voice ] = FALSE;
LL_AddToTail( VOICE, &Voice_Pool, &Voice[ voice ] );
RestoreInterrupts( flags );
return( AL_Ok );
}
/*---------------------------------------------------------------------
Function: AL_NoteOff
Turns off a note on the specified MIDI channel.
---------------------------------------------------------------------*/
void AL_NoteOff
(
int channel,
int key,
int velocity
)
{
int voice;
int port;
int voc;
// We only play channels 1 through 10
if ( channel > AL_MaxMidiChannel )
{
return;
}
voice = AL_GetVoice( channel, key );
if ( voice == AL_VoiceNotFound )
{
return;
}
Voice[ voice ].status = NOTE_OFF;
port = Voice[ voice ].port;
voc = ( voice >= NUM_VOICES ) ? voice - NUM_VOICES : voice;
if ( AL_SendStereo )
{
AL_SendOutputToPort( AL_LeftPort, 0xB0 + voice,
hibyte( Voice[ voice ].pitchleft ) );
AL_SendOutputToPort( AL_RightPort, 0xB0 + voice,
hibyte( Voice[ voice ].pitchright ) );
}
else
{
AL_SendOutput( port, 0xB0 + voc, hibyte( Voice[ voice ].pitchleft ) );
}
LL_Remove( VOICE, &Channel[ channel ].Voices, &Voice[ voice ] );
LL_AddToTail( VOICE, &Voice_Pool, &Voice[ voice ] );
}
/*---------------------------------------------------------------------
Function: AL_NoteOn
Plays a note on the specified MIDI channel.
---------------------------------------------------------------------*/
void AL_NoteOn
(
int channel,
int key,
int velocity
)
{
int voice;
// We only play channels 1 through 10
if ( channel > AL_MaxMidiChannel )
{
return;
}
if ( velocity == 0 )
{
AL_NoteOff( channel, key, velocity );
return;
}
voice = AL_AllocVoice();
if ( voice == AL_VoiceNotFound )
{
if ( Channel[ 9 ].Voices.start )
{
AL_NoteOff( 9, Channel[ 9 ].Voices.start->key, 0 );
voice = AL_AllocVoice();
}
if ( voice == AL_VoiceNotFound )
{
return;
}
}
Voice[ voice ].key = key;
Voice[ voice ].channel = channel;
Voice[ voice ].velocity = velocity;
Voice[ voice ].status = NOTE_ON;
LL_AddToTail( VOICE, &Channel[ channel ].Voices, &Voice[ voice ] );
AL_SetVoiceTimbre( voice );
AL_SetVoiceVolume( voice );
AL_SetVoicePitch( voice );
}
/*---------------------------------------------------------------------
Function: AL_AllNotesOff
Turns off all currently playing voices.
---------------------------------------------------------------------*/
void AL_AllNotesOff
(
int channel
)
{
while( Channel[ channel ].Voices.start != NULL )
{
AL_NoteOff( channel, Channel[ channel ].Voices.start->key, 0 );
}
}
/*---------------------------------------------------------------------
Function: AL_ControlChange
Sets the value of a controller on the specified MIDI channel.
---------------------------------------------------------------------*/
void AL_ControlChange
(
int channel,
int type,
int data
)
{
// We only play channels 1 through 10
if ( channel > AL_MaxMidiChannel )
{
return;
}
switch( type )
{
case MIDI_VOLUME :
AL_SetChannelVolume( channel, data );
break;
case MIDI_PAN :
AL_SetChannelPan( channel, data );
break;
case MIDI_DETUNE :
AL_SetChannelDetune( channel, data );
break;
case MIDI_ALL_NOTES_OFF :
AL_AllNotesOff( channel );
break;
case MIDI_RESET_ALL_CONTROLLERS :
AL_ResetVoices();
AL_SetChannelVolume( channel, AL_DefaultChannelVolume );
AL_SetChannelPan( channel, 64 );
AL_SetChannelDetune( channel, 0 );
break;
case MIDI_RPN_MSB :
Channel[ channel ].RPN &= 0x00FF;
Channel[ channel ].RPN |= ( data & 0xFF ) << 8;
break;
case MIDI_RPN_LSB :
Channel[ channel ].RPN &= 0xFF00;
Channel[ channel ].RPN |= data & 0xFF;
break;
case MIDI_DATAENTRY_MSB :
if ( Channel[ channel ].RPN == MIDI_PITCHBEND_RPN )
{
Channel[ channel ].PitchBendSemiTones = data;
Channel[ channel ].PitchBendRange =
Channel[ channel ].PitchBendSemiTones * 100 +
Channel[ channel ].PitchBendHundreds;
}
break;
case MIDI_DATAENTRY_LSB :
if ( Channel[ channel ].RPN == MIDI_PITCHBEND_RPN )
{
Channel[ channel ].PitchBendHundreds = data;
Channel[ channel ].PitchBendRange =
Channel[ channel ].PitchBendSemiTones * 100 +
Channel[ channel ].PitchBendHundreds;
}
break;
}
}
/*---------------------------------------------------------------------
Function: AL_ProgramChange
Selects the instrument to use on the specified MIDI channel.
---------------------------------------------------------------------*/
void AL_ProgramChange
(
int channel,
int patch
)
{
// We only play channels 1 through 10
if ( channel > AL_MaxMidiChannel )
{
return;
}
Channel[ channel ].Timbre = patch;
}
/*---------------------------------------------------------------------
Function: AL_SetPitchBend
Sets the pitch bend amount on the specified MIDI channel.
---------------------------------------------------------------------*/
void AL_SetPitchBend
(
int channel,
int lsb,
int msb
)
{
int pitchbend;
unsigned long TotalBend;
VOICE *voice;
// We only play channels 1 through 10
if ( channel > AL_MaxMidiChannel )
{
return;
}
pitchbend = lsb + ( msb << 8 );
Channel[ channel ].Pitchbend = pitchbend;
TotalBend = pitchbend * Channel[ channel ].PitchBendRange;
TotalBend /= ( PITCHBEND_CENTER / FINETUNE_RANGE );
Channel[ channel ].KeyOffset = ( int )( TotalBend / FINETUNE_RANGE );
Channel[ channel ].KeyOffset -= Channel[ channel ].PitchBendSemiTones;
Channel[ channel ].KeyDetune = ( unsigned )( TotalBend % FINETUNE_RANGE );
voice = Channel[ channel ].Voices.start;
while( voice != NULL )
{
AL_SetVoicePitch( voice->num );
voice = voice->next;
}
}
/*---------------------------------------------------------------------
Function: AL_DetectFM
Determines if an Adlib compatible card is installed in the machine.
---------------------------------------------------------------------*/
int AL_DetectFM
(
void
)
{
int status1;
int status2;
int i;
if ( USER_CheckParameter( NO_ADLIB_DETECTION ) )
{
return( FALSE );
}
AL_SendOutputToPort( ADLIB_PORT, 4, 0x60 ); // Reset T1 & T2
AL_SendOutputToPort( ADLIB_PORT, 4, 0x80 ); // Reset IRQ
status1 = inp( ADLIB_PORT );
AL_SendOutputToPort( ADLIB_PORT, 2, 0xff ); // Set timer 1
AL_SendOutputToPort( ADLIB_PORT, 4, 0x21 ); // Start timer 1
for( i = 100; i > 0; i-- )
{
inp( ADLIB_PORT );
}
status2 = inp( ADLIB_PORT );
AL_SendOutputToPort( ADLIB_PORT, 4, 0x60 );
AL_SendOutputToPort( ADLIB_PORT, 4, 0x80 );
return( ( ( status1 & 0xe0 ) == 0x00 ) && ( ( status2 & 0xe0 ) == 0xc0 ) );
}
/*---------------------------------------------------------------------
Function: AL_LockEnd
Used for determining the length of the functions to lock in memory.
---------------------------------------------------------------------*/
static void AL_LockEnd
(
void
)
{
}
/*---------------------------------------------------------------------
Function: AL_Shutdown
Ends use of the sound card and resets it to a quiet state.
---------------------------------------------------------------------*/
void AL_Shutdown
(
void
)
{
AL_StereoOff();
AL_OPL3 = FALSE;
AL_ResetVoices();
AL_Reset();
DPMI_UnlockMemoryRegion( AL_LockStart, AL_LockEnd );
DPMI_Unlock( slotVoice );
DPMI_Unlock( VoiceLevel );
DPMI_Unlock( VoiceKsl );
DPMI_Unlock( offsetSlot );
DPMI_Unlock( NotePitch );
DPMI_Unlock( OctavePitch );
DPMI_Unlock( NoteMod12 );
DPMI_Unlock( NoteDiv12 );
DPMI_Unlock( VoiceReserved );
DPMI_Unlock( Voice );
DPMI_Unlock( Voice_Pool );
DPMI_Unlock( Channel );
DPMI_Unlock( AL_LeftPort );
DPMI_Unlock( AL_RightPort );
DPMI_Unlock( AL_Stereo );
DPMI_Unlock( AL_SendStereo );
DPMI_Unlock( AL_OPL3 );
DPMI_Unlock( AL_MaxMidiChannel );
}
/*---------------------------------------------------------------------
Function: AL_SetMaxMidiChannel
Sets the maximum MIDI channel that FM cards respond to.
---------------------------------------------------------------------*/
void AL_SetMaxMidiChannel
(
int channel
)
{
AL_MaxMidiChannel = channel - 1;
}
/*---------------------------------------------------------------------
Function: AL_Init
Begins use of the sound card.
---------------------------------------------------------------------*/
int AL_Init
(
int soundcard
)
{
BLASTER_CONFIG Blaster;
int status;
status = DPMI_LockMemoryRegion( AL_LockStart, AL_LockEnd );
status |= DPMI_Lock( slotVoice );
status |= DPMI_Lock( VoiceLevel );
status |= DPMI_Lock( VoiceKsl );
status |= DPMI_Lock( offsetSlot );
status |= DPMI_Lock( NotePitch );
status |= DPMI_Lock( OctavePitch );
status |= DPMI_Lock( NoteMod12 );
status |= DPMI_Lock( NoteDiv12 );
status |= DPMI_Lock( VoiceReserved );
status |= DPMI_Lock( Voice );
status |= DPMI_Lock( Voice_Pool );
status |= DPMI_Lock( Channel );
status |= DPMI_Lock( AL_LeftPort );
status |= DPMI_Lock( AL_RightPort );
status |= DPMI_Lock( AL_Stereo );
status |= DPMI_Lock( AL_SendStereo );
status |= DPMI_Lock( AL_OPL3 );
status |= DPMI_Lock( AL_MaxMidiChannel );
if ( status != DPMI_Ok )
{
return( AL_Error );
}
AL_Stereo = FALSE;
AL_OPL3 = FALSE;
AL_LeftPort = 0x388;
AL_RightPort = 0x388;
switch( soundcard )
{
case ProAudioSpectrum :
case SoundMan16 :
AL_OPL3 = TRUE;
AL_LeftPort = 0x388;
AL_RightPort = 0x38A;
break;
case SoundBlaster :
status = BLASTER_GetCardSettings( &Blaster );
if ( status != BLASTER_Ok )
{
status = BLASTER_GetEnv( &Blaster );
if ( status != BLASTER_Ok )
{
break;
}
}
switch( Blaster.Type )
{
case SBPro2 :
case SB16 :
AL_OPL3 = TRUE;
AL_LeftPort = Blaster.Address;
AL_RightPort = Blaster.Address + 2;
break;
}
break;
}
// Temporarally commented out for ROTT.
// Stereo FM seems to take too long on some computers and
// causes the mouse driver to miss interrupts.
/*
switch( soundcard )
{
case ProAudioSpectrum :
case SoundMan16 :
AL_OPL3 = TRUE;
AL_Stereo = TRUE;
AL_LeftPort = 0x388;
AL_RightPort = 0x38A;
break;
case SoundBlaster :
status = BLASTER_GetCardSettings( &Blaster );
if ( status != BLASTER_Ok )
{
status = BLASTER_GetEnv( &Blaster );
if ( status != BLASTER_Ok )
{
break;
}
}
switch( Blaster.Type )
{
case SBPro2 :
case SB16 :
AL_OPL3 = TRUE;
AL_Stereo = TRUE;
AL_LeftPort = Blaster.Address;
AL_RightPort = Blaster.Address + 2;
break;
case SBPro :
AL_Stereo = TRUE;
AL_LeftPort = Blaster.Address;
AL_RightPort = Blaster.Address + 2;
break;
}
break;
}
*/
AL_CalcPitchInfo();
AL_Reset();
AL_ResetVoices();
return( AL_Ok );
}
/*---------------------------------------------------------------------
Function: AL_RegisterTimbreBank
Copies user supplied timbres over the default timbre bank.
---------------------------------------------------------------------*/
void AL_RegisterTimbreBank
(
unsigned char *timbres
)
{
int i;
for( i = 0; i < 256; i++ )
{
ADLIB_TimbreBank[ i ].SAVEK[ 0 ] = *( timbres++ );
ADLIB_TimbreBank[ i ].SAVEK[ 1 ] = *( timbres++ );
ADLIB_TimbreBank[ i ].Level[ 0 ] = *( timbres++ );
ADLIB_TimbreBank[ i ].Level[ 1 ] = *( timbres++ );
ADLIB_TimbreBank[ i ].Env1[ 0 ] = *( timbres++ );
ADLIB_TimbreBank[ i ].Env1[ 1 ] = *( timbres++ );
ADLIB_TimbreBank[ i ].Env2[ 0 ] = *( timbres++ );
ADLIB_TimbreBank[ i ].Env2[ 1 ] = *( timbres++ );
ADLIB_TimbreBank[ i ].Wave[ 0 ] = *( timbres++ );
ADLIB_TimbreBank[ i ].Wave[ 1 ] = *( timbres++ );
ADLIB_TimbreBank[ i ].Feedback = *( timbres++ );
ADLIB_TimbreBank[ i ].Transpose = *( signed char * )( timbres++ );
ADLIB_TimbreBank[ i ].Velocity = *( signed char * )( timbres++ );
}
}