Logo Search packages:      
Sourcecode: ia32-libs-sdl version File versions  Download package

emumidi.c

/************************************************************************
   emumidi.c  -- emulation of midi device for FM/OPL3/GUS

   Copyright (C) 1994-1996 Nathan I. Laredo

   This program is modifiable/redistributable under the terms
   of the GNU General Public Licence.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
   Send your comments and all your spare pocket change to
   laredo@gnu.ai.mit.edu (Nathan Laredo) or to PSC 1, BOX 709, 2401
   Kelly Drive, Lackland AFB, TX 78236-5128, USA.
 *************************************************************************/
/*    edited by Peter Kutak         */
/*    email : kutak@stonline.sk     */

#if defined(linux) || defined(__FreeBSD__)

#include "emumidi.h"

SEQ_USE_EXTBUF();

extern int seqfd, play_ext, play_gus, play_fm, play_awe;
extern int gus_dev, sb_dev, ext_dev, awe_dev;
extern struct synth_info card_info[MAX_CARDS];
extern int chanmask, perc, ticks, dochan, wantopl3, MT32;
extern int patchloaded[256], fmloaded[256], useprog[16];
int note_vel[16][128];
struct voicestate voice[2][36];
struct chanstate channel[16];
#define C_GUS 0
#define C_FM 1
#define CN (ISGUS(chn) ? C_GUS : C_FM)
#define CHANNEL (dochan ? chn : 0)

void load_sysex(length, data, type)
int length;
unsigned char *data;
int type;
{
    unsigned long int i, j;

    /*
     * If the system exclusive is for roland, evaluate it.  More than
     * roland could be evaluated here if i had documentation.  Please
     * submit patches for any other hardware to laredo@gnu.ai.mit.edu
     * Complete emulation of all GS sysex messages in the works....
     */
    if (length > 7 && data[0] == 0x41 && data[2] == 0x42 && data[3] == 0x12) {
      /* GS DATA SET MESSAGES */
      if (data[4] == 0x40 && (data[5] & 0xf0) == 0x10 && data[6] == 0x15) {
            /* USE RHYTHM PART */
            if (!(i = (data[5] & 0xf)))
                i = 0x09;
            else if (i < 10)
                i--;
            i = 1<<i;
            if (data[7])
                perc |= i;
            else
                perc &= ~i;
      }
      if ((data[4] == 0x40 || data[4] == 0) &&
          data[5] == 0x00 && data[6] == 0x7f) { /* GS RESET */
            perc = 0x0200;    /* percussion in channel 10 only */
            for (i = 0; i < 16; i++) {    /* set state info */
                for (j = 0; j < 128; j++)
                  note_vel[i][j] = 0;
                channel[i].bender = channel[i].oldbend = 8192;
                channel[i].bender_range = channel[i].oldrange = 2;
                channel[i].controller[CTL_PAN] = 64;
                channel[i].controller[CTL_SUSTAIN] = 0;
            }
      }
    }
    if (!play_ext)
      return;
    if (type == MIDI_SYSTEM_PREFIX)
      SEQ_MIDIOUT(ext_dev, MIDI_SYSTEM_PREFIX);
    for (i = 0; i < length; i++)
      SEQ_MIDIOUT(ext_dev, data[i]);
}

int seq_set_patch(chn, pgm)
int chn, pgm;
{
    if (MT32 && pgm < 128)
      pgm = mt32pgm[pgm];
    if (useprog[chn])
      pgm = useprog[chn] - 1;
    if (ISMIDI(chn)) {
      SEQ_MIDIOUT(ext_dev, MIDI_PGM_CHANGE + CHANNEL);
      SEQ_MIDIOUT(ext_dev, pgm);
    } else if (ISAWE(chn)) {
      SEQ_SET_PATCH(awe_dev, chn, pgm);
    } else if (ISPERC(chn)) {
      if (ISGUS(chn) && patchloaded[pgm] != 1)
          return -1;
      else if (ISFM(chn) && !fmloaded[pgm])
          return -1;
    } else if (ISGUS(chn) && patchloaded[pgm] != 1)
      /* find first loaded gus program to replace missing one */
      for (pgm = 0; patchloaded[pgm] != 1; pgm++);
    return (channel[chn].program = pgm);
}

/* finetune returns exact frequency with bender applied.  Not used */
/*
int finetune(chn, note)
int chn, note;
{
    long int r, b, d;

    r = channel[chn].bender_range;
    b = channel[chn].bender - 8192;
    if (!b || r + note > 127 || r - note < 0)
      return n_freq[note];
    r = n_freq[note + r] - n_freq[note - r];
    d = b * r;
    d /= 8192;
    return n_freq[note] + d;

}
*/
extern int _seqbufptr;

void seq_stop_note(dev, chn, note, vel)
int dev, chn, note, vel;
{
    int i, card = CN;

    note_vel[chn][note] = 0;
    if (ISMIDI(chn)) {
      SEQ_MIDIOUT(dev, MIDI_NOTEOFF + CHANNEL);
      SEQ_MIDIOUT(dev, note);
      SEQ_MIDIOUT(dev, vel);
    } else if (ISAWE(chn)) {
      SEQ_STOP_NOTE(dev, chn, note, vel);
    } else
      for (i = 0; i < card_info[dev].nr_voices; i++)
          if (voice[card][i].channel == chn &&
            voice[card][i].note == note) {
            voice[card][i].dead = 1;
            voice[card][i].timestamp /= 2;
            if (!channel[chn].controller[CTL_SUSTAIN] && !ISPERC(chn))
                SEQ_STOP_NOTE(dev, i, note, vel);
          }
}

void seq_key_pressure(dev, chn, note, vel)
int dev, chn, note, vel;
{
    int i, card = CN;

    if (ISMIDI(chn)) {
      SEQ_MIDIOUT(dev, MIDI_KEY_PRESSURE + CHANNEL);
      SEQ_MIDIOUT(dev, note);
      SEQ_MIDIOUT(dev, vel);
    } else if (ISAWE(chn)) {
      AWE_KEY_PRESSURE(dev, chn, note, vel);
    } else
      for (i = 0; i < card_info[dev].nr_voices; i++)
          if (voice[card][i].channel == chn &&
            voice[card][i].note == note)
            SEQ_KEY_PRESSURE(dev, i, note, vel);
}

int new_voice(dev, chn)
int dev, chn;
{
    int i, oldest, last, card = CN;

    if (ISFM(chn) && fmloaded[channel[chn].program] == OPL3_PATCH)
      last = 6;         /* 4-op voice can only use first six voices */
    else
      last = card_info[dev].nr_voices;

    for (i = oldest = 0; i < last; i++)
      if (voice[card][i].timestamp < voice[card][oldest].timestamp)
          oldest = i;
    return oldest;
}

void seq_start_note(dev, chn, note, vel)
int dev, chn, note, vel;
{
    int v, c, card = CN;

    note_vel[chn][note] = vel;
    if (ISMIDI(chn)) {
      SEQ_MIDIOUT(dev, MIDI_NOTEON + CHANNEL);
      SEQ_MIDIOUT(dev, note);
      SEQ_MIDIOUT(dev, vel);
    } else if (vel == 0)
      seq_stop_note(dev, chn, note, 64);
    else if (ISAWE(chn)) {
      SEQ_START_NOTE(dev, chn, note, vel);
    } else {
      v = new_voice(dev, chn);
      SEQ_SET_PATCH(dev, v, channel[chn].program);
      SEQ_BENDER_RANGE(dev, v, (channel[chn].bender_range * 100));
      SEQ_BENDER(dev, v, channel[chn].bender);
      SEQ_CONTROL(dev, v, CTL_PAN,
                channel[chn].controller[CTL_PAN]);
      SEQ_START_NOTE(dev, v, note, vel);
      voice[card][v].note = note;
      voice[card][v].channel = chn;
      voice[card][v].timestamp = ticks;
      voice[card][v].dead = 0;
      if ((c = channel[chn].controller[CTL_CHORUS_DEPTH] * 8)) {
          if (channel[chn].bender_range)
            c /= channel[chn].bender_range;
          v = new_voice(dev, chn);
          SEQ_SET_PATCH(dev, v, channel[chn].program);
          SEQ_BENDER_RANGE(dev, v, (channel[chn].bender_range * 100));
          if (channel[chn].bender + c < 0x4000) {
            SEQ_BENDER(dev, v, channel[chn].bender + c);
          } else {
            SEQ_BENDER(dev, v, channel[chn].bender - c);
          }
          /* put chorus note on the "extreme" side */
          c = channel[chn].controller[CTL_PAN];
          if (c < 64)
            c = 0;
          else if (c > 64)
            c = 127;
          SEQ_CONTROL(dev, v, CTL_PAN, c);
          SEQ_START_NOTE(dev, v, note, vel);
          voice[card][v].note = note;
          voice[card][v].channel = chn;
          /* allow chorus note to be stolen very quickly */
          voice[card][v].timestamp = ticks / 2;
          voice[card][v].dead = 0;
      }
    }
}

static int rpn1[16] =
{127, 127, 127, 127, 127, 127, 127, 127,
 127, 127, 127, 127, 127, 127, 127, 127};
static int rpn2[16] =
{127, 127, 127, 127, 127, 127, 127, 127,
 127, 127, 127, 127, 127, 127, 127, 127};

void seq_control(dev, chn, p1, p2)
int dev, chn, p1, p2;
{
    int i, card = CN;

    channel[chn].controller[p1] = p2;

    if (ISMIDI(chn)) {
      SEQ_MIDIOUT(dev, MIDI_CTL_CHANGE + CHANNEL);
      SEQ_MIDIOUT(dev, p1);
      SEQ_MIDIOUT(dev, p2);
    }
    if (p1 == 7 || p1 == 39)
      return;
    switch (p1) {
    case CTL_SUSTAIN:
      if (ISAWE(chn)) {
          SEQ_CONTROL(dev, chn, p1, p2);
      } else if (!ISMIDI(chn))
          if (p1 == CTL_SUSTAIN && !p2) {
            for (i = 0; i < card_info[card].nr_voices; i++)
                if (voice[card][i].channel == chn
                  && voice[card][i].dead) {
                  SEQ_STOP_NOTE(dev, i, voice[card][i].note, 64);
                  voice[card][i].dead = 0;
                }
          }
      break;
    case CTL_REGIST_PARM_NUM_MSB:
      rpn1[chn] = p2;
      break;
    case CTL_REGIST_PARM_NUM_LSB:
      rpn2[chn] = p2;
      break;
    case CTL_DATA_ENTRY:
      if (rpn1[chn] == 0 && rpn2[chn] == 0) {
          channel[chn].oldrange = channel[chn].bender_range;
          channel[chn].bender_range = p2;
          rpn1[chn] = rpn2[chn] = 127;
          if (ISAWE(chn)) {
            SEQ_BENDER_RANGE(dev, chn, p2 * 100);
          } else if (!ISMIDI(chn))
            for (i = 0; i < card_info[card].nr_voices; i++)
                SEQ_BENDER_RANGE(dev, i, p2 * 100);
      }
      break;
    default:
      /* sent on the off chance the sound driver is enhanced */
      if (ISAWE(chn)) {
          SEQ_CONTROL(dev, chn, p1, p2);
      } else if (!ISMIDI(chn) && (p1 < 0x10 || (p1 & 0xf0) == 0x50))
          for (i = 0; i < card_info[card].nr_voices; i++)
            if (voice[card][i].channel == chn)
                SEQ_CONTROL(dev, i, p1, p2);
      break;
    }
}

void seq_chn_pressure(dev, chn, vel)
int dev, chn, vel;
{
    int card = CN, i;

    channel[chn].pressure = vel;
    if (ISMIDI(chn)) {
      SEQ_MIDIOUT(dev, MIDI_CHN_PRESSURE + CHANNEL);
      SEQ_MIDIOUT(dev, vel);
    } else if (ISAWE(chn)) {
      AWE_CHN_PRESSURE(dev, chn, vel);
    } else
      for (i = 0; i < card_info[dev].nr_voices; i++)
          if (voice[card][i].channel == chn)
            SEQ_KEY_PRESSURE(dev, i, voice[card][i].note, vel);
}

void seq_bender(dev, chn, p1, p2)
int dev, chn, p1, p2;
{
    int card = CN, i, val;

    val = (p2 << 7) + p1;
    channel[chn].oldbend = channel[chn].bender;
    channel[chn].bender = val;

    if (ISMIDI(chn)) {
      SEQ_MIDIOUT(dev, MIDI_PITCH_BEND + CHANNEL);
      SEQ_MIDIOUT(dev, p1);
      SEQ_MIDIOUT(dev, p2);
    } else if (ISAWE(chn)) {
      SEQ_BENDER(dev, chn, val);
    } else
      for (i = 0; i < card_info[dev].nr_voices; i++)
          if (voice[card][i].channel == chn)
            SEQ_BENDER(dev, i, val);
}

void seq_reset()
{
    int i, j;

    _seqbufptr = ticks = 0;
    ioctl(seqfd, SNDCTL_SEQ_RESET);
    for (i = 0; i < 16; i++) {
      if (ISMIDI(i)) {
          seq_control(ext_dev,i,0,0);
          seq_control(ext_dev,i,32,0);
      }
      seq_set_patch(i, 0);
      for (j = 0; j < 128; j++)
          note_vel[i][j] = 0;
      channel[i].bender = channel[i].oldbend = 8192;
      channel[i].bender_range = channel[i].oldrange = 2;
      channel[i].controller[CTL_PAN] = 64;
      channel[i].controller[CTL_SUSTAIN] = 0;
    }
    if (play_gus)
      for (i = 0; i < card_info[gus_dev].nr_voices; i++) {
          SEQ_CONTROL(gus_dev, i, SEQ_VOLMODE, VOL_METHOD_LINEAR);
          if (voice[0][i].note)
            SEQ_STOP_NOTE(gus_dev, i, voice[0][i].note, 64);
          voice[0][i].dead = voice[0][i].timestamp = -1;
      }
    if (play_fm) {
      if (wantopl3)
          ioctl(seqfd, SNDCTL_FM_4OP_ENABLE, &sb_dev);
      for (i = 0; i < card_info[sb_dev].nr_voices; i++) {
          SEQ_CONTROL(sb_dev, i, SEQ_VOLMODE, VOL_METHOD_LINEAR);
          if (voice[1][i].note)
            SEQ_STOP_NOTE(sb_dev, i, voice[1][i].note, 64);
          voice[1][i].dead = voice[1][i].timestamp = -1;
      }
    }
    if (play_awe) {
      AWE_SET_CHANNEL_MODE(awe_dev, 1);
      AWE_DRUM_CHANNELS(awe_dev, perc);
      AWE_TERMINATE_ALL(awe_dev);
      for (i = 0; i < card_info[awe_dev].nr_voices; i++) {
          voice[0][i].dead = voice[0][i].timestamp = -1;
      }
    }
    SEQ_DUMPBUF();
}

#endif /* linux || FreeBSD */

Generated by  Doxygen 1.6.0   Back to index