windows-xp/Source/XPSP1/NT/multimedia/media/drivers/synthlib/adlib.c

/*
 * Copyright (c) 1992-1995 Microsoft Corporation
 */


/*
 * definition of interface functions to the adlib midi device type.
 *
 * These functions are called from midi.c when the kernel driver
 * has decreed that this is an adlib-compatible device.
 *
 * Geraint Davies, Dec 92
 */

#include <windows.h>
#include <mmsystem.h>
#include <mmddk.h>
#include "driver.h"
#include "adlib.h"

/*
 * overview
 *
 * The FM synthesis chip consists of 18 operator cells or 'slots'. Each slot
 * can produce a sine wave modified by a number of parameters such
 * as frequency, output level and envelope shape (attack/decay/sustain
 * release). Slots are arranged in pairs, with one slot modulating
 * the sine wave of another to produce the harmonics desired for
 * a given instrument sound. Thus one pair of slots is a 'voice' and can
 * play one note at a time.
 *
 * In percussive mode (which we always use), there are 6 melodic voices
 * available, and one voice for the base drum. The remaining four slots
 * are used singly rather than in pairs to produce four further percussive
 * voices. The 6 melodic voices will be changed to any given timbre
 * as needed. The five percussive voices are fixed to particular instrument
 * timbres: bass drum, snare, tom-tom, hi-hat and cymbal.
 *
 * To play a note, we first find a free voice of the appropriate type. If
 * there are none free, we use the oldest busy one. We then set the
 * parameters for both operator slots from the patch table - this table gives
 * parameter settings for the different instrument timbres available.
 * We adjust the output level and frequency depending on the
 * note played and the velocity it was played with, and then switch on the
 * note.
 */

/* --- typedefs ------------------------------------------------- */

#define NUMVOICES     (11)		// number of voices we have
#define NUMMELODIC    (6)  		// number of melodic voices
#define NUMPERCUSSIVE (5)  		// number of percussive voices

#define MAXPATCH      180		// nr of patches (including drums)
#define MAXVOLUME    0x7f
#define NUMLOCPARAM    14               // number of loc params per slot

#define FIRSTDRUMNOTE  35
#define LASTDRUMNOTE   81
#define NUMDRUMNOTES   (LASTDRUMNOTE - FIRSTDRUMNOTE + 1)

#define MAX_PITCH    0x3fff         	// maximum pitch bend value
#define MID_PITCH    0x2000         	// mid pitch bend value (no shift)
#define PITCHRANGE	  2		// total bend range +- 2 semitones
#define NR_STEP_PITCH    25         	// steps per half-tone for pitch bend
#define MID_C            60         	// MIDI standard mid C
#define CHIP_MID_C       48         	// sound chip mid C

/*
 * to write to the device, we write a SYNTH_DATA port,data pair
 * to the kernel driver.
 */
#define SndOutput(p,d)	MidiSendFM(p, d)




/****************************************************************************
 *
 *   definitions of sound chip parameters
 */

// parameters of each voice
#define prmKsl          0         // key scale level (KSL) - level controller
#define prmMulti        1         // frequency multiplier (MULTI) - oscillator
#define prmFeedBack     2         // modulation feedback (FB) - oscillator
#define prmAttack       3         // attack rate (AR) - envelope generator
#define prmSustain      4         // sustain level (SL) - envelope generator
#define prmStaining     5         // sustaining sound (SS) - envelope generator
#define prmDecay        6         // decay rate (DR) - envelope generator
#define prmRelease      7         // release rate (RR) - envelope generator
#define prmLevel        8         // output level (OL) - level controller
#define prmAm           9         // amplitude vibrato (AM) - level controller
#define prmVib          10        // frequency vibrator (VIB) - oscillator
#define prmKsr          11        // envelope scaling (KSR) - envelope generator
#define prmFm           12        // fm=0, additive=1 (FM) (operator 0 only)
#define prmWaveSel      13        // wave select

// global parameters
#define prmAmDepth      14
#define prmVibDepth     15
#define prmNoteSel      16
#define prmPercussion   17

// percussive voice numbers (0-5 are melodic voices, 2 op):
#define BD              6         // bass drum (2 op)
#define SD              7         // snare drum (1 op)
#define TOM             8         // tom-tom (1 op)
#define CYMB            9         // cymbal (1 op)
#define HIHAT           10        // hi-hat (1 op)

// In percussive mode, the last 4 voices (SD TOM HH CYMB) are created
// using melodic voices 7 & 8. A noise generator uses channels 7 & 8
// frequency information for creating rhythm instruments. Best results
// are obtained by setting TOM two octaves below mid C and SD 7 half-tones
// above TOM. In this implementation, only the TOM pitch may vary, with the
// SD always set 7 half-tones above.
#define TOM_PITCH        24      // best frequency, in range of 0 to 95
#define TOM_TO_SD        7       // 7 half-tones between voice 7 & 8
#define SD_PITCH         (TOM_PITCH + TOM_TO_SD)

/****************************************************************************
 *
 *   bank file support
 *
 ***************************************************************************/

#define BANK_SIG_LEN        6
#define BANK_FILLER_SIZE    8

typedef BYTE *HPBYTE;
typedef BYTE NEAR * NPBYTE;
typedef WORD NEAR * NPWORD;

// instrument bank file header
typedef struct {
    char      majorVersion;
    char      minorVersion;
    char      sig[BANK_SIG_LEN];            // signature: "ADLIB-"
    WORD      nrDefined;                    // number of list entries used
    WORD      nrEntry;                      // number of total entries in list
    long      offsetIndex;                  // offset of start of list of names
    long      offsetTimbre;                 // offset of start of data
    char      filler[BANK_FILLER_SIZE];     // must be zero
} BANKHDR, NEAR *NPBANKHDR, FAR *LPBANKHDR;


// all the parameters for one slot
typedef struct {
    BYTE ksl;            // KSL
    BYTE freqMult;       // MULTI
    BYTE feedBack;       // FB
    BYTE attack;         // AR
    BYTE sustLevel;      // SL
    BYTE sustain;        // SS
    BYTE decay;          // DR
    BYTE release;        // RR
    BYTE output;         // OL
    BYTE am;             // AM
    BYTE vib;            // VIB
    BYTE ksr;            // KSR
    BYTE fm;             // FM
} OPERATOR, NEAR *NPOPERATOR, FAR *LPOPERATOR;

// definition of a particular instrument sound or timbre -
// one of these per patch
typedef struct {
    BYTE      mode;             // 0 = melodic, 1 = percussive
    BYTE      percVoice;        // if mode == 1, voice number to be used
    OPERATOR  op0;		// params for slot 0
    OPERATOR  op1;		// params for slot 1
    BYTE      wave0;            // waveform for operator 0
    BYTE      wave1;            // waveform for operator 1
} TIMBRE, NEAR *NPTIMBRE, FAR *LPTIMBRE;

typedef struct drumpatch_tag {
    BYTE patch;                 // the patch to use
    BYTE note;                  // the note to play
} DRUMPATCH;

// format of drumkit.dat file
typedef struct drumfilepatch_tag {
    BYTE key;                   // the key to map
    BYTE patch;                 // the patch to use
    BYTE note;                  // the note to play
} DRUMFILEPATCH, *PDRUMFILEPATCH;


typedef struct _VOICE {
    BYTE alloc;                 // is voice allocated?
    BYTE note;                  // note that is currently being played
    BYTE channel;               // channel that it is being played on
    BYTE volume;                // current volume setting of voice
    DWORD dwTimeStamp;          // time voice was allocated
} VOICE;

#define GetLocPrm(slot_num, prm)   ((WORD)paramSlot[slot_num][prm])


/* --- module data ---------------------------------------------- */

// this table gives the offset of each slot within the chip.
BYTE offsetSlot[] = {
         0,  1,  2,  3,  4,  5,
         8,  9, 10, 11, 12, 13,
        16, 17, 18, 19, 20, 21
};

static BYTE percMasks[] = {
        0x10, 0x08, 0x04, 0x02, 0x01 };

// voice number associated with each slot (melodic mode only)
static BYTE voiceSlot[] = {
        0, 1, 2,
        0, 1, 2,
        3, 4, 5,
        3, 4, 5,
        6, 7, 8,
        6, 7, 8,
};

// slot numbers for percussive voices (0 indicates that there is only one slot)
static BYTE slotPerc[][2] = {
        {12, 15},        // Bass Drum
        {16, 0},         // SD
        {14, 0},         // TOM
        {17, 0},         // TOP-CYM
        {13, 0}          // HH
};

// slot numbers as a function of the voice and the operator (melodic only)
static BYTE slotVoice[][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
};

// this table indicates if the slot is a modulator (0) or a carrier (1).
BYTE operSlot[] = {
        0, 0, 0,           // 1 2 3
        1, 1, 1,           // 4 5 6
        0, 0, 0,           // 7 8 9
        1, 1, 1,           // 10 11 12
        0, 0, 0,           // 13 14 15
        1, 1, 1,           // 16 17 18
};

// this array adjusts the octave of a note for certain patches.
static char patchKeyOffset[] = {
       0, -12,  12,   0,   0,  12, -12,   0,   0, -24,   // 0 - 9
       0,   0,   0,   0,   0,   0,   0,   0, -12,   0,   // 10 - 19
       0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   // 20 - 29
       0,   0,  12,  12,  12,   0,   0,  12,  12,   0,   // 30 - 39
     -12, -12,   0,  12, -12, -12,   0,  12,   0,   0,   // 40 - 49
     -12,   0,   0,   0,  12,  12,   0,   0,  12,   0,   // 50 - 59
       0,   0,  12,   0,   0,   0,  12,  12,   0,  12,   // 60 - 69
       0,   0, -12,   0, -12, -12,   0,   0, -12, -12,   // 70 - 79
       0,   0,   0,   0,   0, -12, -19,   0,   0, -12,   // 80 - 89
       0,   0,   0,   0,   0,   0, -31, -12,   0,  12,   // 90 - 99
      12,  12,  12,   0,  12,   0,  12,   0,   0,   0,   // 100 - 109
       0,  12,   0,   0,   0,   0,  12,  12,  12,   0,   // 110 - 119
       0,   0,   0,   0, -24, -36,   0,   0};            // 120 - 127

static BYTE loudervol[128] = {
    0,   0,  65,  65,  66,  66,  67,  67,         // 0 - 7
   68,  68,  69,  69,  70,  70,  71,  71,         // 8 - 15
   72,  72,  73,  73,  74,  74,  75,  75,         // 16 - 23
   76,  76,  77,  77,  78,  78,  79,  79,         // 24 - 31
   80,  80,  81,  81,  82,  82,  83,  83,         // 32 - 39
   84,  84,  85,  85,  86,  86,  87,  87,         // 40 - 47
   88,  88,  89,  89,  90,  90,  91,  91,         // 48 - 55
   92,  92,  93,  93,  94,  94,  95,  95,         // 56 - 63
   96,  96,  97,  97,  98,  98,  99,  99,         // 64 - 71
  100, 100, 101, 101, 102, 102, 103, 103,         // 72 - 79
  104, 104, 105, 105, 106, 106, 107, 107,         // 80 - 87
  108, 108, 109, 109, 110, 110, 111, 111,         // 88 - 95
  112, 112, 113, 113, 114, 114, 115, 115,         // 96 - 103
  116, 116, 117, 117, 118, 118, 119, 119,         // 104 - 111
  120, 120, 121, 121, 122, 122, 123, 123,         // 112 - 119
  124, 124, 125, 125, 126, 126, 127, 127};        // 120 - 127

/*
 * attenuation setting for each slot - combination
 * of the channel attenuation for this channel, and the
 * velocity (converted to attenuation). Combine with
 * global attenuation and timbre output attenuation before
 * writing to device.
 */
WORD slotAtten[18];		// vol-control attenuation of slots

WORD wSynthAtten;		// overall volume setting	

BYTE gbChanAtten[NUMCHANNELS];	// attenuation for each channel

VOICE voices[11];		// 9 voices if melodic mode or 11 if percussive
BYTE voiceKeyOn[11];		// keyOn bit for each voice (implicit 0 init)
BYTE paramSlot[18][NUMLOCPARAM]; // all the parameters of slots...

BYTE percBits;              // control bits of percussive voices

WORD fNumNotes[NR_STEP_PITCH][12];
PWORD fNumFreqPtr[11];      // lines of fNumNotes table (one per voice)
int  halfToneOffset[11];    // one per voice
BYTE notePitch[11];         // pitch value for each voice (implicit 0 init)

// patches - parameters for different instrument timbres
TIMBRE    patches[MAXPATCH];            // patch data
DRUMPATCH drumpatch[NUMDRUMNOTES];      // drum kit data


DWORD dwAge = 0;                // voice relative age




/* --- internal functions --------------------------------------- */



/* -- initialisation --- */
/****************************************************************************
 * @doc INTERNAL
 *
 * @api int | LoadPatches | Reads the patch set from the BANK resource and
 *     builds the <p patches> array.
 *
 * @rdesc Returns the number of patches loaded, or 0 if an error occurs.
 ***************************************************************************/
static BYTE PatchRes[] = {
#include "adlib.dat"
};

int  LoadPatches(void)
{
#ifdef WIN16
    HANDLE hResInfo;
    HANDLE hResData;
#endif
    LPSTR  lpRes;
    int    iPatches;
    DWORD  dwOffset;
    DWORD  dwResSize;
    LPTIMBRE  lpBankTimbre;
    LPTIMBRE  lpPatchTimbre;
    LPBANKHDR lpBankHdr;


    // find resource and get its size
#ifdef WIN16
    hResInfo = FindResource(ghInstance, MAKEINTRESOURCE(DEFAULTBANK), MAKEINTRESOURCE(RT_BANK));
    if (!hResInfo) {
        D1(("Default bank resource not found"));
        return 0;
    }
    dwResSize = (DWORD)SizeofResource(ghInstance, hResInfo);

    // load and lock resource
    hResData = LoadResource(ghInstance, hResInfo);
    if (!hResData) {
        D1(("Bank resource not loaded"));
        return 0;
    }
    lpRes = LockResource(hResData);
    if (!lpRes) {
        D1(("Bank resource not locked"));
        return 0;
    }
#else
    lpRes = PatchRes;
    dwResSize = sizeof(PatchRes);
#endif

    // read the bank resource, loading patches as we find them

    D2(("loading patches"));
    lpBankHdr = (LPBANKHDR)lpRes;
    dwOffset = lpBankHdr->offsetTimbre;                // point to first one

    for (iPatches = 0; iPatches < MAXPATCH; iPatches++) {

        lpBankTimbre = (LPTIMBRE)(lpRes + dwOffset);
        lpPatchTimbre = &patches[iPatches];
        *lpPatchTimbre = *lpBankTimbre;

        dwOffset += sizeof(TIMBRE);
        if (dwOffset + sizeof(TIMBRE) > dwResSize) {
            D1(("Attempt to read past end of bank resource"));
            break;
        }
    }

#ifdef WIN16
    UnlockResource(hResData);
    FreeResource(hResData);
#endif

    return iPatches;
}


/****************************************************************************
 * @doc INTERNAL
 *
 * @api int | LoadDrumPatches | Reads the drum kit patch set from the
 *     DRUMKIT resource and builds the <p drumpatch> array.
 *
 * @comm Each entry of the <t drumpatch> array (representing a key number
 *     from the "drum patch") consists of a patch number and note number
 *     from some other patch.
 *
 * @rdesc Returns the number of patches loaded, or 0 if an error occurs.
 ***************************************************************************/

static BYTE DrumRes[] = {
#include "drumkit.dat"
};

int LoadDrumPatches(void)
{
#ifdef WIN16
    HANDLE hResInfo;
    HANDLE hResData;
#endif
    LPSTR  lpRes;
    int    iPatches;
    int    key;
    DWORD  dwOffset;
    DWORD  dwResSize;
    PDRUMFILEPATCH lpResPatch;

#ifdef WIN16
    // find resource and get its size
    hResInfo = FindResource(ghInstance, MAKEINTRESOURCE(DEFAULTDRUMKIT), MAKEINTRESOURCE(RT_DRUMKIT));
    if (!hResInfo) {
        D1(("Default drum resource not found"));
        return 0;
    }
    dwResSize = (DWORD)SizeofResource(ghInstance, hResInfo);

    // load and lock resource
    hResData = LoadResource(ghInstance, hResInfo);
    if (!hResData) {
        D1(("Drum resource not loaded"));
        return 0;
    }
    lpRes = LockResource(hResData);
    if (!lpRes) {
        D1(("Drum resource not locked"));
        return 0;
    }
#else
    lpRes = DrumRes;
    dwResSize = sizeof(DrumRes);
#endif

    // read the drum resource, loading patches as we find them

    D2(("reading drum data"));
    dwOffset = 0;
    for (iPatches = 0; iPatches < NUMDRUMNOTES; iPatches++) {

        lpResPatch = (PDRUMFILEPATCH)(lpRes + dwOffset);
        key = lpResPatch->key;
        if ((key >= FIRSTDRUMNOTE) && (key <= LASTDRUMNOTE)) {
            drumpatch[key - FIRSTDRUMNOTE].patch = lpResPatch->patch;
            drumpatch[key - FIRSTDRUMNOTE].note = lpResPatch->note;
        }
        else {
            D1(("Drum patch key out of range"));
        }

        dwOffset += sizeof(DRUMFILEPATCH);
        if (dwOffset > dwResSize) {
            D1(("Attempt to read past end of drum resource"));
            break;
        }
    }

#ifdef WIN16
    UnlockResource(hResData);
    FreeResource(hResData);
#endif

    return iPatches;
}

/****************************************************************************
 * @doc INTERNAL
 *
 * @api long | CalcPremFNum | Calculates some magic number that is used in
 *     setting the values in the <p fNumNotes> table.
 *
 * @parm int | numDeltaDemiTon | Numerator (-100 to +100).
 *
 * @parm int | denDeltaDemiTon | Denominator (1 to 100).
 *
 * @comm If the numerator (numDeltaDemiTon) is positive, the frequency is
 *     increased; if negative, it is decreased.  The function calculates:
 *         f8 = Fb(1 + 0.06 num /den)          (where Fb = 26044 * 2 / 25)
 *         fNum8 = f8 * 65536 * 72 / 3.58e6
 *
 * @rdesc Returns fNum8, which is the binary value of the frequency 260.44 (C)
 *     shifted by +/- <p numdeltaDemiTon> / <p denDeltaDemiTon> * 8.
 ***************************************************************************/
long NEAR CalcPremFNum(int numDeltaDemiTon, int denDeltaDemiTon)
{
    long f8;
    long fNum8;
    long d100;

    d100 = denDeltaDemiTon * 100;
    f8 = (d100 + 6 * numDeltaDemiTon) * (26044L * 2L);
    f8 /= d100 * 25;

    fNum8 = f8 * 16384;
    fNum8 *= 9L;
    fNum8 /= 179L * 625L;

    return fNum8;
}

/****************************************************************************
 * @doc INTERNAL
 *
 * @api void | SetFNum | Initializes a line in the frequency table with
 *     shifted frequency values.  The values are shifted a fraction (num/den)
 *     of a half-tone.
 *
 * @parm NPWORD | fNumVec | The line from the frequency table.
 *
 * @parm int | num | Numerator.
 *
 * @parm int | den | Denominator.
 *
 * @xref CalcPremFNum
 *
 * @rdesc There is no return value.
 ***************************************************************************/
void NEAR SetFNum(NPWORD fNumVec, int num, int den)
{
    int  i;
    long val;

    *fNumVec++ = (WORD)((4 + (val = CalcPremFNum(num, den))) >> 3);
    for (i = 1; i < 12; i++) {
        val *= 106;
        *fNumVec++ = (WORD)((4 + (val /= 100)) >> 3);
    }
}

/****************************************************************************
 * @doc INTERNAL
 *
 * @api void | InitFNums | Initializes all lines of the frequency table
 *     (the <p fNumNotes> array). Each line represents 12 half-tones shifted
 *     by (n / NR_STEP_PITCH), where 'n' is the line number and ranges from
 *     1 to NR_STEP_PITCH.
 *
 * @rdesc There is no return value.
 ***************************************************************************/
void NEAR InitFNums(void)
{
    WORD i;
    WORD num;           // numerator
    WORD numStep;       // step value for numerator
    WORD row;           // row in the frequency table

    // calculate each row in the fNumNotes table
    numStep = 100 / NR_STEP_PITCH;
    for (num = row = 0; row < NR_STEP_PITCH; row++, num += numStep)
        SetFNum(fNumNotes[row], num, 100);

    // fNumFreqPtr has an element for each voice, pointing to the
    // appropriate row in the fNumNotes table.  They're all initialized
    // to the first row, which represents no pitch shift.
    for (i = 0; i < 11; i++) {
        fNumFreqPtr[i] = fNumNotes[0];
        halfToneOffset[i] = 0;
    }
}

/****************************************************************************
 * @doc INTERNAL
 *
 * @api void | SoundChut | Sets the frequency of voice <p voice> to 0 Hz.
 *
 * @parm BYTE | voice | Specifies which voice to set.
 *
 * @rdesc There is no return value.
 ***************************************************************************/
void NEAR SoundChut(BYTE voice)
{

    SndOutput((BYTE)(0xA0 | voice), 0);
    SndOutput((BYTE)(0xB0 | voice), 0);
}

/* --- write parameters to chip ------------------------*/

/*
 * switch chip to rhythm (percussive) mode, set the amplitude and
 * vibrato depth and switch on any percussion voices that are on
 */
void SndSAmVibRhythm(void)
{

    // we always set amdepth, vibdepth to 0 and perc mode on

    // t1 = (BYTE)(amDepth ? 0x80 : 0);
    // t1 |= vibDepth ? 0x40 : 0;
    // t1 |= (percussionmode ? 0x20 : 0);

    SndOutput((BYTE)0xBD, (BYTE)(0x20|percBits));
}

/****************************************************************************
 * @doc INTERNAL
 *
 * @api void | SndSNoteSel | Sets the NoteSel value.
 *
 * @rdesc There is no return value.
 ***************************************************************************/
void SndSNoteSel(BOOL bNoteSel)
{
    SndOutput(0x08, (BYTE)(bNoteSel ? 64 : 0));
}

/****************************************************************************
 * @doc INTERNAL
 *
 * @api void | SndSKslLevel | Sets the KSL and LEVEL values.
 *
 * @parm BYTE | slot | Specifies which slot to set.
 *
 * @rdesc There is no return value.
 ***************************************************************************/
void SndSKslLevel(BYTE slot)
{
    WORD t1;

    t1 = GetLocPrm(slot, prmLevel) & 0x3f;

    t1 += slotAtten[slot];
    t1 = min (t1, 0x3f);
    t1 |= GetLocPrm(slot, prmKsl) << 6;
    SndOutput((BYTE)(0x40 | offsetSlot[slot]), (BYTE) t1);
}


/****************************************************************************
 * @doc INTERNAL
 *
 * @api void | SndSAVEK | Sets the AM, VIB, EG-TYP (sustaining), KSR, and
 *     MULTI values.
 *
 * @parm BYTE | slot | Specifies which slot to set.
 *
 * @rdesc There is no return value.
 ***************************************************************************/
void SndSAVEK(BYTE slot)
{
    BYTE t1;

    t1 = (BYTE)(GetLocPrm(slot, prmAm) ? 0x80 : 0);
    t1 += GetLocPrm(slot, prmVib) ? 0x40 : 0;
    t1 += GetLocPrm(slot, prmStaining) ? 0x20 : 0;
    t1 += GetLocPrm(slot, prmKsr) ? 0x10 : 0;
    t1 += GetLocPrm(slot, prmMulti) & 0xf;
    SndOutput((BYTE)(0x20 | offsetSlot[slot]), t1);
}

/****************************************************************************
 * @doc INTERNAL
 *
 * @api void | SndSFeedFm | Sets the FEEDBACK and FM (connection) values.
 *     Applicable only to operator 0 for melodic voices.
 *
 * @parm BYTE | slot | Specifies which slot to set.
 *
 * @rdesc There is no return value.
 ***************************************************************************/
void SndSFeedFm(BYTE slot)
{
    BYTE t1;

    if (operSlot[slot])
        return;

    t1 = (BYTE)(GetLocPrm(slot, prmFeedBack) << 1);
    t1 |= GetLocPrm(slot, prmFm) ? 0 : 1;
    SndOutput((BYTE)(0xC0 | voiceSlot[slot]), t1);
}

/****************************************************************************
 * @doc INTERNAL
 *
 * @api void | SndSAttDecay | Sets the ATTACK and DECAY values.
 *
 * @parm BYTE | slot | Specifies which slot to set.
 *
 * @rdesc There is no return value.
 ***************************************************************************/
void SndSAttDecay(BYTE slot)
{
    BYTE t1;

    t1 = (BYTE)(GetLocPrm(slot, prmAttack) << 4);
    t1 |= GetLocPrm(slot, prmDecay) & 0xf;
    SndOutput((BYTE)(0x60 | offsetSlot[slot]), t1);
}

/****************************************************************************
 * @doc INTERNAL
 *
 * @api void | SndSSusRelease | Sets the SUSTAIN and RELEASE values.
 *
 * @parm BYTE | slot | Specifies which slot to set.
 *
 * @rdesc There is no return value.
 ***************************************************************************/
void SndSSusRelease(BYTE slot)
{
    BYTE t1;

    t1 = (BYTE)(GetLocPrm(slot, prmSustain) << 4);
    t1 |= GetLocPrm(slot, prmRelease) & 0xf;
    SndOutput((BYTE)(0x80 | offsetSlot[slot]), t1);
}

/****************************************************************************
 * @doc INTERNAL
 *
 * @api void | SndWaveSelect | Sets the wave-select parameter.
 *
 * @parm BYTE | slot | Specifies which slot to set.
 *
 * @rdesc There is no return value.
 ***************************************************************************/
void SndWaveSelect(BYTE slot)
{
    BYTE wave;

    wave = (BYTE)(GetLocPrm(slot, prmWaveSel) & 0x03);

    SndOutput((BYTE)(0xE0 | offsetSlot[slot]), wave);
}


/****************************************************************************
 * @doc INTERNAL
 *
 * @api void | SndSetAllPrm | Transfers all the parameters from slot <p slot>
 *     to the chip.
 *
 * @parm BYTE | slot | Specifies which slot to set.
 *
 * @rdesc There is no return value.
 ***************************************************************************/
void SndSetAllPrm(BYTE slot)
{

    /* global am-depth and vib-depth settings */
    SndSAmVibRhythm();

    /* note sel is always false */
    SndSNoteSel(FALSE);

    /* slot-specific parameters */

    /* initialise volume to minimum to avoid clicks if the note is
     * off but still playing (during decay phase).
     *
     * only applies to carrier slots.
     */
    if (operSlot[slot]) {
	/* its a carrier slot */
        slotAtten[slot] = 0x3f;		// max attenuation
    }
    SndSKslLevel(slot);

    SndSFeedFm(slot);
    SndSAttDecay(slot);
    SndSSusRelease(slot);
    SndSAVEK(slot);
    SndWaveSelect(slot);
}



/* --- setting slot parameters ------------------ */

/****************************************************************************
 * @doc INTERNAL
 *
 * @api void | SetSlotParam | Sets the 14 parameters (13 in <p param>,
 *     1 in <p waveSel>) of slot <p slot>. Updates both the parameter array
 *     and the chip.
 *
 * @parm BYTE | slot | Specifies which slot to set.
 *
 * @parm NPBYTE | param | Pointer to the new parameter array.
 *
 * @parm BYTE | waveSel | The new waveSel value.
 *
 * @rdesc There is no return value.
 ***************************************************************************/
void SetSlotParam(BYTE slot, NPOPERATOR pOper, BYTE waveSel)
{
    LPBYTE ptr;

    ptr = &paramSlot[slot][0];

    *ptr++ = pOper->ksl;
    *ptr++ = pOper->freqMult;
    *ptr++ = pOper->feedBack;
    *ptr++ = pOper->attack;
    *ptr++ = pOper->sustLevel;
    *ptr++ = pOper->sustain;
    *ptr++ = pOper->decay;
    *ptr++ = pOper->release;
    *ptr++ = pOper->output;
    *ptr++ = pOper->am;
    *ptr++ = pOper->vib;
    *ptr++ = pOper->ksr;
    *ptr++ = pOper->fm;

    *ptr = waveSel & 0x3;

    // set default volume settings
    slotAtten[slot] = 0;

    SndSetAllPrm(slot);
}

/*
 * set this voice up to the correct parameters for a timbre
 * copy the parameters to the slot array and write them to the
 * chip
 *
 */

void SetVoiceTimbre(BYTE voice, NPTIMBRE pTimbre)
{

    if (voice < BD) {        // melodic only
	SetSlotParam(slotVoice[voice][0], &pTimbre->op0, pTimbre->wave0);
	SetSlotParam(slotVoice[voice][1], &pTimbre->op1, pTimbre->wave1);
    }
    else if (voice == BD) {                   // bass drum
	SetSlotParam(slotPerc[0][0], &pTimbre->op0, pTimbre->wave0);
	SetSlotParam(slotPerc[0][1], &pTimbre->op1, pTimbre->wave1);
    } else {                                    // percussion, 1 slot
	SetSlotParam(slotPerc[voice - BD][0], &pTimbre->op0, pTimbre->wave0);
    }
}



/* --- frequency calculation -------------------- */


/* convert the given pitch (0 .. 95) into a frequency
 * and write to the chip.
 *
 * this will turn the note on if keyon is true.
 */
VOID SetFreq(BYTE voice, BYTE pitch, BYTE keyOn)
{
    WORD  FNum;
    BYTE  t1;


    // remember the keyon and pitch of the voice

    voiceKeyOn[voice] = keyOn;
    notePitch[voice] = pitch;

    pitch += (BYTE)halfToneOffset[voice];
    if (pitch > 95)
        pitch = 95;

    // get the FNum for the voice
    FNum = * (fNumFreqPtr[voice] + pitch % 12);

    // output the FNum, KeyOn and Block values
    SndOutput((BYTE)(0xA0 | voice), (BYTE)FNum);   // FNum bits 0 - 7 (D0 - D7)
    t1 = (BYTE)(keyOn ? 32 : 0);                   // Key On (D5)
    t1 += (pitch / 12 << 2);                       // Block (D2 - D4)
    t1 += (0x3 & (FNum >> 8));                     // FNum bits 8 - 9 (D0 - D1)
    SndOutput((BYTE)(0xB0 | voice), t1);
}


/****************************************************************************
 * @doc INTERNAL
 *
 * @api void | ChangePitch | This routine sets the <t halfToneOffset[]> and
 *     <t fNumFreqPtr[]> arrays.  These two global variables are used to
 *     determine the frequency variation to use when a note is played.
 *
 * @parm BYTE | voice | Specifies which voice to use.
 *
 * @parm WORD | pitchBend | Specifies the pitch bend value (0 to 0x3fff,
 *     where 0x2000 is exact tuning).
 *
 * @rdesc There is no return value.
 ***************************************************************************/
void  ChangePitch(BYTE voice, WORD pitchBend)
{
    int     t1;
    int     t2;
    int     delta;
    int pitchrange;

    /* pitch bend range 0-3fff is +-PITCHRANGE semitones. We move
     * NR_STEP_PITCH steps per semitone.
     * so the bend range is +- (PITCHRANGE * NR_STEP_PITCH) steps.
     */
    pitchrange = PITCHRANGE * NR_STEP_PITCH;

    t1 = (int)(((long)((int)pitchBend - MID_PITCH) * pitchrange) / MID_PITCH);

    if (t1 < 0)
    {
	t2 = NR_STEP_PITCH - 1 - t1;
	halfToneOffset[voice] = -(t2 / NR_STEP_PITCH);
	delta = (t2 - NR_STEP_PITCH + 1) % NR_STEP_PITCH;
	if (delta) {
	    delta = NR_STEP_PITCH - delta;
	}
    }
    else
    {
	halfToneOffset[voice] = t1 / NR_STEP_PITCH;
	delta = t1 % NR_STEP_PITCH;
    }
    fNumFreqPtr[voice] = fNumNotes[delta];

}

/****************************************************************************
 * @doc INTERNAL
 *
 * @api void | SetVoicePitch | Changes the pitch value of a voice.  Does
 *     not affect the percussive voices, except for the bass drum.  The change
 *     takes place immediately.
 *
 * @parm BYTE | voice | Specifies which voice to set.
 *
 * @parm WORD | pitchBend | Specifies the new pitch bend value (0 to 0x3fff,
 *     where 0x2000 == exact tuning).
 *
 * @comm The variation in pitch is a function of the previous call to
 *     <f SetPitchRange> and the value of <p pitchBend>.  A value of 0 means
 *     -half-tone * pitchRangeStep, 0x2000 means no variation (exact pitch) and
 *      0x3fff means +half-tone * pitchRangeStep.
 *
 * @rdesc There is no return value.
 ***************************************************************************/
void SetVoicePitch(BYTE voice, WORD pitchBend)
{
    if (voice <= BD) {       // melodic and bass drum voices
        if (pitchBend > MAX_PITCH) {
	    pitchBend = MAX_PITCH;
	}
        ChangePitch(voice, pitchBend);
        SetFreq(voice, notePitch[voice], voiceKeyOn[voice]);
    }
}

/* --- volume calculation ------------------------ */

/*
 * set the attenuation for a slot (combine the channel attenuation
 * setting with the key velocity).
 */
VOID SetVoiceAtten(BYTE voice, BYTE bChannel, BYTE bVelocity)
{
    BYTE bAtten;
    BYTE   slot;
    PBYTE slots;

    // scale up the volume since the patch maps are too quiet
    //bVelocity = loudervol[bVelocity];


    /*
     * set channel attenuation
     */
    bAtten = gbVelocityAtten[bVelocity >> 2] + gbChanAtten[bChannel];


    /*
     * add on any global (volume-setting) attenuation
     */
    bAtten += wSynthAtten;


    /* save this for each non-modifier slot */

    if (voice <= BD) {      // melodic voice
        slots = slotVoice[voice];

        slotAtten[slots[1]] = bAtten;
        SndSKslLevel(slots[1]);

        if (!GetLocPrm(slots[0], prmFm)) {
            // additive synthesis: set volume of first slot too
	    slotAtten[slots[0]] = bAtten;
            SndSKslLevel(slots[0]);
        }
    }
    else {                                  // percussive voice
        slot = slotPerc[voice - BD][0];
	slotAtten[slot] = bAtten;
        SndSKslLevel(slot);
    }
}

/* adjust each slot attenuation to allow for a global volume
 * change - note that we only need to change the
 * carrier, not the modifier slots.
 *
 * change for channel bChannel, or all channels if bChannel is
 * 0xff
 */
VOID ChangeAtten(BYTE bChannel, int iChangeAtten)
{
    BYTE voice;
    BYTE   slot;
    PBYTE slots;

    /* find voices using this channel */
    for (voice = 0; voice < NUMVOICES; voice++) {
	if ((voices[voice].channel == bChannel) || (bChannel == 0xff)) {

	    if (voice <= BD) {

		/* melodic voice */
		slots = slotVoice[voice];

		slotAtten[slots[1]] += (WORD)iChangeAtten;
		SndSKslLevel(slots[1]);

		if (!GetLocPrm(slots[0], prmFm)) {
		    // additive synthesis: set volume of first slot too
		    slotAtten[slots[0]] += (WORD)iChangeAtten;
		    SndSKslLevel(slots[0]);
		}
    	    } else {
		slot = slotPerc[voice - BD][0];
		slotAtten[slot] += (WORD)iChangeAtten;
		SndSKslLevel(slot);
	    }
	}
    }
}


/* --- note on/off ------------------------------- */

/* switch off the note a given voice is playing */
void NoteOff(BYTE voice)
{

    if (voice < BD) {

	/* melodic voice */
	SetFreq(voice, notePitch[voice], 0);
    } else {
	percBits &= ~percMasks[voice-BD];
	SndSAmVibRhythm();
    }
}

/* switch on a voice at a given note (0 - 127, where 60 is middle c) */
void NoteOn(BYTE voice, BYTE bNote)
{
    BYTE bPitch;

    /* convert note to chip pitch */
    if (bNote < (MID_C - CHIP_MID_C)) {
	bPitch = 0;
    } else {
	bPitch = bNote - (MID_C - CHIP_MID_C);
    }

    if (voice < BD) {
	/* melodic voice */

	/* set frequency and start note */
	SetFreq(voice, bPitch, 1);
    } else {
	/*
	 * nb we don't change the pitch of some percussion instruments.
	 *
	 * also note that for percussive instruments (including BD),
	 * the note-on setting should always be 0. You switch the percussion
	 * on by writing to the AmVibRhythm register.
	 */

	if (voice == BD) {
	    SetFreq(voice, bPitch, 0);
	} else if (voice == TOM) {
	    /*
	     * for best sounds, we do change the TOM freq, but we always keep
	     * the SD 7 semi-tones above TOM.
	     */
	    SetFreq(TOM, bPitch, 0);
	    SetFreq(SD, (BYTE)(bPitch + TOM_TO_SD), 0);
	}
	/* other instruments never change */

	percBits |= percMasks[voice - BD];
	SndSAmVibRhythm();
    }
}



/* -- voice allocation -------- */

/*
 * find the voice that is currently playing a given channel/note pair
 * (if any)
 */
BYTE
FindVoice(BYTE bNote, BYTE bChannel)
{
    BYTE i;

    for (i = 0; i < (BYTE)NUMVOICES; i++) {
	if ((voices[i].alloc) && (voices[i].note == bNote)
	   && (voices[i].channel == bChannel)) {
    	    voices[i].dwTimeStamp = dwAge++;
    	    return(i);
	}
    }

    /* no voice is playing this */
    return(0xff);
}

/*
 * mark a voice as unused
 */
VOID FreeVoice(voice)
{
    voices[voice].alloc = 0;
}


/*
 * GetNewVoice - allocate a voice to play this note. if no voices are
 * free, re-use the note with the oldest timestamp.
 */
BYTE GetNewVoice(BYTE patch, BYTE note, BYTE channel)
{
    BYTE  i;
    BYTE  voice;
    BYTE  bVoiceToUse, bVoiceSame, bVoiceOldest;
    DWORD dwOldestTime = dwAge + 1;	 	// init to past current "time"
    DWORD dwOldestSame = dwAge + 1;
    DWORD dwOldestOff = dwAge + 1;

    if (patches[patch].mode) {            // it's a percussive patch
        voice = patches[patch].percVoice;       // use fixed percussion voice
        voices[voice].alloc = TRUE;
        voices[voice].note = note;
        voices[voice].channel = channel;
        voices[voice].dwTimeStamp = MAKELONG(patch, 0);

        SetVoiceTimbre(voice, &patches[patch]);

        return voice;
    }

    bVoiceToUse = bVoiceSame = bVoiceOldest = 0xff;

    // find a free melodic voice to use
    for (i = 0; i < (BYTE)NUMMELODIC; i++) {    // it's a melodic patch
        if (!voices[i].alloc) {

	    if (voices[i].dwTimeStamp < dwOldestOff) {
		bVoiceToUse = i;
		dwOldestOff = voices[i].dwTimeStamp;
	    }

        } else if (voices[i].channel == channel) {
	    if (voices[i].dwTimeStamp < dwOldestSame) {
		dwOldestSame = voices[i].dwTimeStamp;
		bVoiceSame = i;
	    }
        } else if (voices[i].dwTimeStamp < dwOldestTime) {
                dwOldestTime = voices[i].dwTimeStamp;
                bVoiceOldest = i;                // remember oldest one to steal
        }
    }

    // choose a free voice if we have found one. If not, choose the
    // oldest voice of the same channel. if none, choose the oldest voice.
    if (bVoiceToUse == 0xff) {
	if (bVoiceSame != 0xff) {
	    bVoiceToUse = bVoiceSame;
	} else {
	    bVoiceToUse = bVoiceOldest;
	}
    }


    if (voices[bVoiceToUse].alloc)  {      // if we stole it, turn it off
        NoteOff(bVoiceToUse);
    }

    voices[bVoiceToUse].alloc = 1;
    voices[bVoiceToUse].note = note;
    voices[bVoiceToUse].channel = channel;
    voices[bVoiceToUse].dwTimeStamp = dwAge++;

    SetVoiceTimbre(bVoiceToUse, &patches[patch]);

    return bVoiceToUse;
}


/* --- externally-called functions ------------------------------ */

/*
 * Adlib_NoteOn - This turns a note on. (Including drums, with
 *	a patch # of the drum Note + 128)
 *
 * inputs
 *      BYTE    bPatch - MIDI patch number
 *	BYTE    bNote - MIDI note number
 *      BYTE    bChannel - MIDI channel #
 *	BYTE    bVelocity - Velocity #
 *	short   iBend - current pitch bend from -32768, to 32767
 * returns
 *	none
 */
VOID NEAR PASCAL Adlib_NoteOn (BYTE bPatch,
	BYTE bNote, BYTE bChannel, BYTE bVelocity,
	short iBend)
{

    BYTE voice;
    WORD wBend;

    if (bVelocity == 0) {               // 0 velocity means note off
        Adlib_NoteOff(bPatch, bNote, bChannel);
	return;
    }

    // octave registration for melodic patches
    if (bPatch < 128) {
	bNote += patchKeyOffset[bPatch];
	if ((bNote < 0) || (bNote > 127)) {
	    bNote -= patchKeyOffset[bPatch];
	}
    }


    if (bPatch >= 128) {
	/*
	 * it's a percussion note
	 */

	bNote = bPatch - 128;

        if ((bNote < FIRSTDRUMNOTE) || (bNote > LASTDRUMNOTE)) {
            return;
	}

	/* use the drum patch table to map the note to a given
	 * TIMBRE/note pair
	 */
	bPatch = drumpatch[bNote - FIRSTDRUMNOTE].patch;
	bNote = drumpatch[bNote - FIRSTDRUMNOTE].note;

	/* each drum patch plays on one specific voice.
	 * find that voice
	 */
	voice = patches[bPatch].percVoice;
	
	/* switch note off if playing */
	if (voices[voice].alloc) {
	    NoteOff(voice);
	}

	/* call GetNewVoice to set the voice params and timestamp
	 * even if we found it.
	 */
	voice = GetNewVoice(bPatch, bNote, bChannel);

    } else {

	/* switch note off if it's playing  */
	if ( (voice = FindVoice(bNote, bChannel)) != 0xFF ) {
		NoteOff(voice);
	} else {
	    voice = GetNewVoice(bPatch, bNote, bChannel);
	}
    }

    /* convert the velocity to an attenuation setting, and
     * write that to the device
     */
    SetVoiceAtten(voice, bChannel, bVelocity);

    /*
     * apply pitch bend. note that we are passed a pitch bend in the
     * range 8000-7fff, but our code assumes 0-3fff, so we convert here.
     */
    wBend = (((WORD)iBend + 0x8000) >> 2) & 0x3fff;
    SetVoicePitch(voice, wBend);

    // play the note
    NoteOn(voice, bNote);

}


/* Adlib_NoteOff - This turns a note off. (Including drums,
 *	with a patch # of the drum note + 128)
 *
 * inputs
 *	BYTE    bPatch - MIDI patch #
 *	BYTE    bNote - MIDI note number
 *	BYTE    bChannel - MIDI channel #
 * returns
 *	none
 */
VOID FAR PASCAL Adlib_NoteOff (BYTE bPatch,
	BYTE bNote, BYTE bChannel)
{
    BYTE bVoice;

    if (bPatch > 127) {

	/* drum note. These all use a fixed voice */


        if ((bNote < FIRSTDRUMNOTE) || (bNote > LASTDRUMNOTE)) {
            return;
	}

	/* use the drum patch table to map the note to a given
	 * TIMBRE/note pair
	 */
	bPatch = drumpatch[bNote - FIRSTDRUMNOTE].patch;
	bNote = drumpatch[bNote - FIRSTDRUMNOTE].note;
	bVoice = patches[bPatch].percVoice;
	
	/* switch note off if playing our patch */
	if (LOWORD(voices[bVoice].dwTimeStamp) == bPatch) {
	    NoteOff(bVoice);
	}
    } else {

	bVoice = FindVoice(bNote, bChannel);
	if (bVoice != 0xff) {

	    if (voices[bVoice].note) {
		NoteOff(bVoice);
		FreeVoice(bVoice);
	    }
	}
    }
}

/* Adlib_AllNotesOff - turn off all notes
 *
 * inputs - none
 * returns - none
 */
VOID Adlib_AllNotesOff(void)
{

    BYTE i;

    for (i = 0; i < NUMVOICES; i++) {
    	NoteOff(i);
    }
}


/* Adlib_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 Adlib_NewVolume (WORD wLeft, WORD wRight)
{
    /* ignore the right attenuation since this is a mono device */
    int iChange;

    wLeft = min(wLeft, wRight) << 1;
    iChange = wLeft - wSynthAtten;

    wSynthAtten = wLeft;

    /* change attenuation for all channels */
    ChangeAtten(0xff, iChange);
}



/* Adlib_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 Adlib_ChannelVolume(BYTE bChannel, WORD wAtten)
{	
    int iChange;

    iChange = wAtten - gbChanAtten[bChannel];

    gbChanAtten[bChannel] = (BYTE)wAtten;


    /* change attenuation for this channel */
    ChangeAtten(bChannel, iChange);
}


/* Adlib_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
 *
 * does nothing - this is a mono device
 */
VOID FAR PASCAL Adlib_SetPan(BYTE bChannel, BYTE bPan)
{

    /* do nothing */
}


/* Adlib_PitchBend - This pitch bends a channel.
 *
 * inputs
 *	BYTE    bChannel - channel
 *	short   iBend - Values from -32768 to 32767, being
 *			-2 to +2 half steps
 * returns
 *	none
 */
VOID NEAR PASCAL Adlib_PitchBend (BYTE bChannel, short iBend)
{
    BYTE i;
    WORD w;

    /* note that our code expects 0 - 0x3fff not 0x8000 - 0x7fff */
    w = (((WORD) iBend + 0x8000) >> 2) & 0x3fff;

    for (i = 0; i < NUMVOICES; i++) {
	if ((voices[i].alloc) && (voices[i].channel == bChannel)) {
	    SetVoicePitch(i,  w);
	}
    }
}



/* Adlib_BoardInit - initialise board and load patches as necessary.
 *
 * inputs - none
 * returns - 0 for success or the error code
 */
WORD Adlib_BoardInit(void)
{
    BYTE i;

    wSynthAtten = 0;

    /* build the freq table */
    InitFNums();

    /* silence and free all voices */
    for (i = 0; i <= 8; i++) {
	SoundChut(i);
	FreeVoice(i);
    }

    /* switch to percussive mode and set fixed frequencies */
    SetFreq(TOM, TOM_PITCH, 0);
    SetFreq(SD, SD_PITCH, 0);
    percBits = 0;
    SndSAmVibRhythm();

    /* init all slots to sine-wave */
    for (i= 0; i < 18; i++) {
	SndOutput((BYTE)(0xE0 | offsetSlot[i]), 0);
    }
    /* enable wave-form selection */
    SndOutput(1, 0x20);

    LoadPatches();
    LoadDrumPatches();

// don't initialise - the data is static and will thus
// be initialised to 0 at load time. no other change should be made
// since the mci sequencer will not re-send channel volume change
// messages.
//
//    /* init all channels to loudest */
//    for (i = 0; i < NUMCHANNELS; i++) {
//	gbChanAtten[i] = 4;
//    }

    return(0);
}


/*
 * Adlib_BoardReset - silence the board and set all voices off.
 */
VOID Adlib_BoardReset(void)
{
    BYTE i;

    /* silence and free all voices */
    for (i = 0; i <= 8; i++) {
	SoundChut(i);
	FreeVoice(i);
    }

    /* switch to percussive mode and set fixed frequencies */
    SetFreq(TOM, TOM_PITCH, 0);
    SetFreq(SD, SD_PITCH, 0);
    percBits = 0;
    SndSAmVibRhythm();

}