fmopl_midi.cc

Go to the documentation of this file.

/*
Copyright (C) 2000, 2001, 2002  Ryan Nunn

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.  See the
GNU General Public License for more details.

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., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
*/

#ifdef HAVE_CONFIG_H
#  include <config.h>
#endif

#ifdef USE_FMOPL_MIDI

#include <string>

#include "Audio.h"
#include "fmopl_midi.h"
#include "fmopldrv.h"
#include "xmidi.h"
#include "utils.h"
#include "Configuration.h"
#include "SDL_mixer.h"

extern  Configuration *config;

#define FMOPL_MESSAGE_NO_MESSAGE    0
#define FMOPL_MESSAGE_PLAY        1
#define FMOPL_MESSAGE_PLAY_REPEAT   2
#define FMOPL_MESSAGE_STOP        3
#define FMOPL_MESSAGE_INIT        4

const unsigned short FMOpl_Midi::centre_value = 0x2000;
const unsigned char FMOpl_Midi::fine_value = centre_value & 127;
const unsigned char FMOpl_Midi::coarse_value = centre_value >> 7;
const unsigned short FMOpl_Midi::combined_value = (coarse_value << 8) | fine_value;

//#define DO_SMP_TEST

#ifdef DO_SMP_TEST
#define giveinfo() std::cerr << __FILE__ << ":" << __LINE__ << std::endl; std::cerr.flush();
#else
#define giveinfo()
#endif

using std::string;
using std::cout;
using std::cerr;
using std::endl;

class RingBuffer16
{
  uint32    write_pos;
  uint32    read_pos;
  sint16    *buf;
  uint32    size;
  SDL_mutex *mutex;

public:
  void LockWrite(uint32 total, sint16 *&buf1, uint32 &size1, sint16 *&buf2, uint32 &size2);
  void LockRead(uint32 total, sint16 *&buf1, uint32 &size1, sint16 *&buf2, uint32 &size2);
  void Unlock();

  RingBuffer16(uint32 s);
  ~RingBuffer16();
};

RingBuffer16::RingBuffer16(uint32 s) : write_pos(0), read_pos(0), size(s)
{
  buf = new sint16[size];
  std::memset(buf, 0, sizeof(sint16)*size);
  mutex = SDL_CreateMutex();
}

RingBuffer16::~RingBuffer16()
{
  SDL_DestroyMutex(mutex);
  delete [] buf;
}

void RingBuffer16::Unlock()
{
  // Unlock it
  SDL_mutexV(mutex);
}

void RingBuffer16::LockRead(uint32 total, sint16 *&buf1, uint32 &size1, sint16 *&buf2, uint32 &size2)
{
  // Lock it
  SDL_mutexP(mutex);

  // Too many samples
  if (size < total) {
    size1 = 0;
    buf1 = 0;
    size2 = 0;
    buf2 = 0;
    return;
  }

  // It will run over the end of the ring buffer. Need to return end and start
  if (read_pos + total >= size) {

    // Buffer 1
    buf1 = buf + read_pos;
    size1 = size - read_pos;

    // Increment read_pos
    read_pos += total;
    read_pos -= size;

    // Buffer 2
    buf2 = buf;
    size2 = read_pos;

    return;
  }

  // Handle it normally
  buf1 = buf + read_pos;
  size1 = total;
  buf2 = 0;
  size2 = 0;
  read_pos += total;

}

void RingBuffer16::LockWrite(uint32 total, sint16 *&buf1, uint32 &size1, sint16 *&buf2, uint32 &size2)
{
  // Lock it
  SDL_mutexP(mutex);

  // Too many samples
  if (size < total) {
    size1 = 0;
    buf1 = 0;
    size2 = 0;
    buf2 = 0;
    return;
  }

  // It will run over the end of the ring buffer. Need to return end and start
  if (write_pos + total >= size) {

    // Buffer 1
    buf1 = buf + write_pos;
    size1 = size - write_pos;

    // Increment read_pos
    write_pos += total;
    write_pos -= size;

    // Buffer 2
    buf2 = buf;
    size2 = write_pos;

    return;
  }

  // Handle it normally
  buf1 = buf + write_pos;
  size1 = total;
  buf2 = 0;
  size2 = 0;
  write_pos += total;
}

FMOpl_Midi::FMOpl_Midi()
{
  giveinfo();
  playing = false;
  is_available = false;
  giveinfo();
  init_device();
  giveinfo();
}

FMOpl_Midi::~FMOpl_Midi()
{
  giveinfo();
  if (!is_available) return;

  deinit_device();
}

void FMOpl_Midi::deinit_device()
{
  // Un Hook SDL
  is_available = false;
  Mix_HookMusic (NULL, NULL);
#ifdef PENTAGRAM
  Mix_CloseAudio();
#endif

  // Delay a fraction
  SDL_Delay(10);

  // Lock it
  SDL_mutexP(mutex);

  // Free everything
  if (evntlist) evntlist->DecerementCounter();
  evntlist = NULL;

  // Free new list if it exists
  if (new_list) new_list->DecerementCounter();
  new_list = NULL;
  comMessage_priv = FMOPL_MESSAGE_NO_MESSAGE;

  // Reset the reasonable defaults
  repeat = false;
  aim = 0;
  diff = 0;
  last_tick = 0;
  evntlist = NULL;
  event = NULL;
  notes_on.clear();
  loop_num = -1;    
  std::memset(volumes, 64, sizeof(volumes));
  std::memset(balances, 64, sizeof(balances));
  generate_rem = 0;
  total_sample_ticks = 0;

  // Left
  delete opl;
  opl = 0;
  delete buffer;
  buffer = 0;

  // Right
  delete opl_right;
  opl_right = 0;
  delete buffer_right;
  buffer_right = 0;

  // Unlock it
  SDL_mutexV(mutex);

  // Kill it
  SDL_DestroyMutex(mutex);
  SDL_DestroyMutex(comMutex);
  mutex = NULL;
  comMutex = NULL;
}

void FMOpl_Midi::init_device()
{
  string s;

  Audio *audio = Audio::get_ptr();
    
  // Dual Opl mode
  if (audio->is_stereo())
  {
    config->value("config/audio/midi/dual_opl",s,"yes");
    if (s == "yes") dual = true;
    else {
      s = "no";
      dual = false;
    }

    std::cout << "Dual OPL mode: " << s << endl;

    // Make sure it's in the config
    config->set("config/audio/midi/dual_opl",s,true);
  }
  else
  {
    dual = false;
  }

  // Now setup all our settings
  playing = false;
  generate_rem = 0;
  is_available = true;
  comMessage_priv = FMOPL_MESSAGE_NO_MESSAGE;
  new_list = NULL;

  // Create Left
  buffer = new RingBuffer16(44096);
  opl = new OplDriver;
  opl->open(audio->get_sample_rate());

  // Create right, if required
  if (dual) {
    buffer_right = new RingBuffer16(44096);
    opl_right = new OplDriver;
    opl_right->open(audio->get_sample_rate());
  }
  else {
    opl_right = 0;
    buffer_right = 0;
  }

  // Setup some reasonable defaults
  repeat = false;
  aim = 0;
  diff = 0;
  last_tick = 0;
  evntlist = NULL;
  event = NULL;
  notes_on.clear();
  loop_num = -1;    
  std::memset(volumes, 64, sizeof(volumes));
  std::memset(balances, 64, sizeof(balances));

  generate_rem = 0;
  total_sample_ticks = 0;
  global_volume = 255;

  // Create the Mutexes
  mutex = SDL_CreateMutex();
  comMutex = SDL_CreateMutex();

  // Hook the process
#ifdef PENTAGRAM
  Mix_OpenAudio(audio->get_sample_rate(), AUDIO_S16SYS, 2, 4096);
#endif
  Mix_HookMusic (mixer_hook_static, (void*) this);
}

inline void FMOpl_Midi::send_vol_or_balance(uint32 chan) {

  // Single OPL mode only
  if (!dual) return;

  int left = volumes[chan];
  int right = volumes[chan];

  // is left
  if (balances[chan] < 64) {
    right *= balances[chan];
    right >>= 6;  // right /= 64;
  }
  // is right
  else if (balances[chan] > 64) {
    left *= 127 - balances[chan];
    left >>= 6;   // left /= 64;
  }

  opl->send(chan | (MIDI_STATUS_CONTROLLER << 4)|(7 << 8) | (left<<16));
  opl_right->send(chan | (MIDI_STATUS_CONTROLLER << 4)|(7 << 8) | (right<<16));
}

inline void FMOpl_Midi::send(uint32 b) {

  // Volume
  if (dual && (b&0xFFF0) == ((MIDI_STATUS_CONTROLLER << 4)|(7 << 8)))
  {
    int chan = b&0xF;
    volumes[chan] = (b >> 16) & 0x7F;
    send_vol_or_balance(chan);
  }
  // Balance
  else if (dual && (b&0xFFF0) == ((MIDI_STATUS_CONTROLLER << 4)|(10 << 8)))
  {
    int chan = b&0xF;
    balances[chan] = (b >> 16) & 0x7F;
    send_vol_or_balance(chan);
  }
  else {
    opl->send(b);
    if (opl_right) opl_right->send(b);
  }
}

uint32 FMOpl_Midi::GenerateSamples(uint32 count_required, uint32 sample_rate) {

  uint32 amount_generated = 0;

  uint32 inc = 1;
  uint32 gen = OPL_NUM_SAMPLES_PER_PASS;

  if (sample_rate == 44100) gen *= 2;
  else if (sample_rate == 11025) inc *= 2;
  else if (sample_rate != 22050) 
  {
    // Approximate it!
    inc = 6;
    gen = (OPL_TIME_PER_PASS*sample_rate)/(120*OPL_TICK_MULTIPLIER*inc);
  }

  while (amount_generated < count_required) {

    HandleStop();
    PlayNotes();
    HandlePlay();

    GetSamples(gen);
    amount_generated += gen;
    wmoClockIncTime(inc);
  }

  return amount_generated - count_required;
}

void FMOpl_Midi::PlayNotes()
{
  // Handle note off's here
  while (midi_event *note = notes_on.PopTime(wmoGetRealTime()))
    send(note->status | (note->data[0] << 8));

  while (event)
  {
    aim = (event->time-last_tick)*OPL_TICK_MULTIPLIER;

    //printf ("aim %i time %i\n", aim, wmoGetTime ());

    diff = aim - wmoGetTime ();

    if (diff > 0) break;

    last_tick = event->time;
    wmoAddOffset(aim);
  
      // XMIDI For Loop
    if ((event->status >> 4) == MIDI_STATUS_CONTROLLER && event->data[0] == XMIDI_CONTROLLER_FOR_LOOP)
    {
      if (loop_num < XMIDI_MAX_FOR_LOOP_COUNT) loop_num++;

      loop_count[loop_num] = event->data[1];
      loop_event[loop_num] = event;

    } // XMIDI Next/Break
    else if ((event->status >> 4) == MIDI_STATUS_CONTROLLER && event->data[0] == XMIDI_CONTROLLER_NEXT_BREAK)
    {
      if (loop_num != -1)
      {
        if (event->data[1] < 64)
        {
          loop_num--;
        }
      }
      event = NULL;

    } // XMIDI Callback Trigger
    else if ((event->status >> 4) == MIDI_STATUS_CONTROLLER && event->data[0] == XMIDI_CONTROLLER_CALLBACK_TRIG)
    {
      // TODO
    } // Not SysEx
    else if (event->status < 0xF0)
    {
      int type = event->status >> 4;

      if ((type != MIDI_STATUS_NOTE_ON || event->data[1]) && type != MIDI_STATUS_NOTE_OFF) {
        if (type == MIDI_STATUS_NOTE_ON) {
          notes_on.Remove(event);
          notes_on.Push (event, event->duration * OPL_TICK_MULTIPLIER + wmoGetStart());
        }

        send(event->status | (event->data[0] << 8) | (event->data[1] << 16));
      }
    }
  
    if (event) event = event->next;

    // Lock com system
    int &comMessage = LockComs();

    if (!event || comMessage != FMOPL_MESSAGE_NO_MESSAGE)
    {
      bool clean = !repeat || (comMessage != FMOPL_MESSAGE_NO_MESSAGE) || last_tick == 0;

      if (clean)
      {
        playing = false;
        if (comMessage == FMOPL_MESSAGE_STOP)
          comMessage = FMOPL_MESSAGE_NO_MESSAGE;

        // Handle note off's here
        while (midi_event *note = notes_on.Pop())
          send(note->status | (note->data[0] << 8));

        // Clean up
        for (int i = 0; i < 16; i++) reset_channel (i); 
        //midiOutReset (midi_port);
        if (evntlist) evntlist->DecerementCounter();
        evntlist = NULL;
        event = NULL;

        loop_num = -1;
        wmoInitClock ();
      }

      last_tick = 0;

      if (evntlist)
      {
        if (loop_num == -1) event = evntlist->events;
        else
        {
          event = loop_event[loop_num]->next;
          last_tick = loop_event[loop_num]->time;

          if (loop_count[loop_num])
            if (!--loop_count[loop_num])
              loop_num--;
        }
      }
    }

    // UnLock com system
    UnlockComs();
  }

}

void FMOpl_Midi::HandlePlay()
{
  // Lock com system
  int &comMessage = LockComs();

  // Got issued a music play command
  // set up the music playing routine
  if (comMessage == FMOPL_MESSAGE_PLAY || comMessage == FMOPL_MESSAGE_PLAY_REPEAT)
  {
    // Handle note off's here
    while (midi_event *note = notes_on.Pop())
      send(note->status | (note->data[0] << 8));

    // Manual Reset since I don't trust midiOutReset()
    giveinfo();
    for (int i = 0; i < 16; i++) reset_channel (i);

    if (evntlist) evntlist->DecerementCounter();
    evntlist = NULL;
    event = NULL;
    playing = false;

  
    giveinfo();
    evntlist = new_list;
    repeat = (comMessage == FMOPL_MESSAGE_PLAY_REPEAT);

    giveinfo();
    new_list = NULL;
    giveinfo();
    comMessage = FMOPL_MESSAGE_NO_MESSAGE;
    
    giveinfo();
    if (evntlist) event = evntlist->events;
    else event = 0;

    giveinfo();
    last_tick = 0;
    
    giveinfo();
    wmoInitClock ();

    // Reset XMIDI Looping
    loop_num = -1;

    giveinfo();
    playing = true;
  }

  // Unlock com system
  UnlockComs();
}

void FMOpl_Midi::HandleStop()
{
  // Lock com system
  int &comMessage = LockComs();

  if (comMessage == FMOPL_MESSAGE_STOP)
  {
    giveinfo();
    playing = false;
    comMessage = FMOPL_MESSAGE_NO_MESSAGE;

    // Handle note off's here
    while (midi_event *note = notes_on.Pop())
      send(note->status | (note->data[0] << 8));

    giveinfo();
    // Clean up
    for (int i = 0; i < 16; i++) reset_channel (i); 
    //midiOutReset (midi_port);
    giveinfo();
    if (evntlist) evntlist->DecerementCounter();
    giveinfo();
    evntlist = NULL;
    event = NULL;
    giveinfo();

    // If stop was requested, we are ready to receive another song

    loop_num = -1;

    wmoInitClock ();
    last_tick = 0;
  }

  // Unlock com system
  UnlockComs();
}

void FMOpl_Midi::reset_channel (int i)
{
  // Bank Select (General Midi)
  send(i | (MIDI_STATUS_CONTROLLER << 4) | (0 << 8) | (127 << 16));

  // Modulation Wheel
  send(i | (MIDI_STATUS_CONTROLLER << 4) | (1 << 8) | (coarse_value << 16));
  
  // Volume 
  send(i | (MIDI_STATUS_CONTROLLER << 4) | (7 << 8) | (coarse_value << 16));

  // Balance
  send(i | (MIDI_STATUS_CONTROLLER << 4) | (10 << 8) | (coarse_value << 16));

  // Expression
  send(i | (MIDI_STATUS_CONTROLLER << 4) | (11 << 8) | (127 << 16));

  // XMIDI Bank Select
  send(i | (MIDI_STATUS_CONTROLLER << 4) | (XMIDI_CONTROLLER_BANK_CHANGE << 8) | (0 << 16));

  // All notes off
  send(i | (MIDI_STATUS_CONTROLLER << 4) | (123 << 8));

  // Instrument
  send(i | (MIDI_STATUS_PROG_CHANGE << 4) | (0 << 8));

  // Pitch Wheel
  send(i | (MIDI_STATUS_PITCH_WHEEL << 4) | (combined_value << 8));
  
}

// Lock the coms
int &FMOpl_Midi::LockComs()
{
  SDL_mutexP(comMutex);
  return comMessage_priv;
}

// Unlock the coms
void FMOpl_Midi::UnlockComs()
{
  SDL_mutexV(comMutex);
}

// Clead coms
void FMOpl_Midi::ClearComs()
{
  comMessage_priv = FMOPL_MESSAGE_NO_MESSAGE;

  // Free everything
  if (new_list) new_list->DecerementCounter();
  new_list = NULL;
}

void FMOpl_Midi::start_track (XMIDIEventList *xmidi, bool repeat)
{
  giveinfo();
  if (!is_available)
    init_device();

  giveinfo();
  if (!is_available)
    return;

  giveinfo();

  // Lock and clear the com system
  int &comMessage = LockComs();
  ClearComs();

  // Increment the list counter
  giveinfo();
  xmidi->IncerementCounter();
  new_list = xmidi;
  
  // Set the com message
  if (repeat) comMessage = FMOPL_MESSAGE_PLAY_REPEAT;
  else comMessage = FMOPL_MESSAGE_PLAY;

  // Unlock the coms
  UnlockComs();
}

void FMOpl_Midi::stop_track(void)
{
  giveinfo();
  if (!is_available) return;

  giveinfo();

  // Lock and clear the com system
  int &comMessage = LockComs();
  ClearComs();

  // If we are playing, we need to issue a stop com
  if (playing) comMessage = FMOPL_MESSAGE_STOP;

  // Unlock the coms
  UnlockComs();
}

bool FMOpl_Midi::is_playing(void)
{
  giveinfo();

  int &comMessage = LockComs();

  // If a stop command has been issued, we'll return and say that we have actually stopped
  // even though, there may still be some output.
  bool ret = playing && comMessage != FMOPL_MESSAGE_STOP;

  UnlockComs();

  return ret;
}

const char *FMOpl_Midi::copyright(void)
{
  giveinfo();
  return "Internal Emulated FM Opl Midi Synth.";
}

void FMOpl_Midi::mixer_hook_static(void *udata, Uint8 *stream, int len)
{
  ((FMOpl_Midi *)udata)->mixer_hook(stream, len);
}

void FMOpl_Midi::mixer_hook(Uint8 *stream, int len)
{
  // Lock the mutex
  SDL_mutexP(mutex);

  // Looks like we are shutting down
  if (!is_available) return;

  Audio *audio = Audio::get_ptr();

  // Generate the music
  if (audio->is_stereo())
    generate_rem = GenerateSamples(len/4-generate_rem, audio->get_sample_rate());
  else
    generate_rem = GenerateSamples(len/2-generate_rem, audio->get_sample_rate());

  // Copy the buffers into SDL_Mixer's buffer
  sint16* stream16 = (sint16*) stream;

  sint16* b1 = 0;
  sint16* b2 = 0;
  uint32  size1 = 0;
  uint32  size2 = 0;
  int i = 0;

  // Lock it (Left or Mono)
  if (audio->is_stereo())
    buffer->LockRead(len/4, b1, size1, b2, size2);
  else
    buffer->LockRead(len/2, b1, size1, b2, size2);

  sint16* b1_r = b1;
  sint16* b2_r = b2;
  uint32  size1_r = size1;
  uint32  size2_r = size2;

  // Right, if in dual mode
  if (dual) buffer_right->LockRead(len/4, b1_r, size1_r, b2_r, size2_r);

  // Copy the samples
  if (global_volume >= 255) {

    if (audio->is_stereo()) {

      for (i = 0; i < size1; ++i) {
        stream16[i<<1] = b1[i];
        stream16[(i<<1)+1] = b1_r[i];
      }

      for (i = 0; i < size2; ++i) {
        stream16[(i+size1)<<1] = b2[i];
        stream16[((i+size1)<<1)+1] = b2_r[i];
      }
    }
    else {

      for (i = 0; i < size1; ++i) {
        stream16[i] = b1[i];
      }

      for (i = 0; i < size2; ++i) {
        stream16[i+size1] = b2[i];
      }
    }
  }
  else if (global_volume && dual) {
    for (i = 0; i < size1; ++i) {
      stream16[i<<1] = (b1[i]*global_volume)/255;
      stream16[(i<<1)+1] = (b1_r[i]*global_volume)/255;
    }

    for (i = 0; i < size2; ++i) {
      stream16[(i+size1)<<1] = (b2[i]*global_volume)/255;
      stream16[((i+size1)<<1)+1] = (b2_r[i]*global_volume)/255;
    }
  }
  else if (global_volume) {
    if (audio->is_stereo()) {

      for (i = 0; i < size1; ++i) {
        stream16[(i<<1)+1] = stream16[i<<1] = (b1[i]*global_volume)/255;
      }

      for (i = 0; i < size2; ++i) {
        stream16[((i+size1)<<1)+1] = stream16[(i+size1)<<1] = (b2[i]*global_volume)/255;
      }
    }
    else {

      for (i = 0; i < size1; ++i) {
        stream16[i] = (b1[i]*global_volume)/255;
      }

      for (i = 0; i < size2; ++i) {
        stream16[i+size1] = (b2[i]*global_volume)/255;
      }
    }
  }

  // Unlock right first
  if (dual) buffer_right->Unlock();

  // Unlock it
  buffer->Unlock();

  // Unlock the mutex
  SDL_mutexV(mutex);

}

void FMOpl_Midi::GetSamples(uint32 samples)
{
  // Got samples
  if (samples) {

    // Do the lock and generate the samples
    sint16* b1 = 0;
    sint16* b2 = 0;
    uint32  size1 = 0;
    uint32  size2 = 0;

    // Lock left
    buffer->LockWrite(samples, b1, size1, b2, size2);

    //  printf ("Generating %i samples\n", samples);

    if (size1 && b1) opl->generate_samples(b1, size1);
    if (size2 && b2) opl->generate_samples(b2, size2);

    if (dual) {
      // Lock it (right)
      buffer_right->LockWrite(samples, b1, size1, b2, size2);

      if (size1 && b1) opl_right->generate_samples(b1, size1);
      if (size2 && b2) opl_right->generate_samples(b2, size2);

      // Unlock (right)
      buffer_right->Unlock();
    }

    // Unlock left
    buffer->Unlock();

  }
}

void FMOpl_Midi::load_patches(bool force_xmidi)
{
  // Lock the mutex
  SDL_mutexP(mutex);

  if (opl) opl->LoadMT32Bank(force_xmidi);
  if (opl_right) opl_right->LoadMT32Bank(force_xmidi);

  // Unlock the mutex
  SDL_mutexV(mutex);
}

bool FMOpl_Midi::is_fm_synth()
{
  return true;
}

bool FMOpl_Midi::use_gs127() 
{ 
  return true; 
}

//
// PSMDEX - Pentagram Streaming Midi Driver Extensions
//

int FMOpl_Midi::max_streams()
{
  return 1;
}

void FMOpl_Midi::start_stream(int str_num, XMIDIEventList *eventlist, bool repeat, bool activate, int vol)
{
  stop_track();
  set_volume(0, vol);
  start_track(eventlist, repeat);
}

void FMOpl_Midi::activate_stream(int str_num)
{

}

void FMOpl_Midi::stop_stream(int str_num)
{
  stop_track();
}

void FMOpl_Midi::set_volume(int str_num, int level)
{
  if (!is_available) return;

  // Lock the mutex
  SDL_mutexP(mutex);

  // Set the volume
  global_volume = level;

  // Unlock the mutex
  SDL_mutexV(mutex);
}

bool FMOpl_Midi::is_playing(int str_num)
{
  return is_playing();
}

int FMOpl_Midi::get_active()
{ 
  return 0;
}

/*

what we need to do

  play notes and generate 5512 samples

  delay till we are past the amount of time it should have taken to generate those samples

  repeat

what we will do for now

  play notes and generate 5513 samples (250ms)

  delay till we are 250ms ahead

  play notes and generate 5512 samples (250ms)

  delay till we are 250ms ahead

  repeat

at audio->get_sample_rate() KHz there are 735 samples for every 4 ticks.
at audio->get_sample_rate() KHz there are 147 samples for every 4/5 ticks
at audio->get_sample_rate() KHz there are  98 samples for every 8/15 ticks
at audio->get_sample_rate() KHz there are  49 samples for every 4/15 ticks

  The wmo clock 'should' be based on the 98 samples number. For every 98 samples,
  we increment the clock 15 units. Working out the midi tick is unit/8. The unit
  from the midi tick is tick*8

  I could base it on the 49 samples number too. For every 49 samples we increment
  the clock 15 units aslso. The midi tick being then is unit/4. The unit from the
  midi tick is tick*4


The generate samples function:

  uint32 generate_sample (uint32 count_required) {

  uint32 amount_generated = 0;

  while (amount_generated < count_required) {

    while_event_loop();

    get_opls_to_generate_samples(NUM_SAMPLES_PER_PASS);

    amount_generated += NUM_SAMPLES_PER_PASS;
    wmoClockIncTime(TIME_PER_PASS);
  }

  return amount_generated;
  }

*/
#endif //USE_FMOPL_MIDI

---