Midi.cc

Go to the documentation of this file.

/*
Copyright (C) 2000  Dancer A.L Vesperman

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


#ifndef ALPHA_LINUX_CXX
#ifndef UNDER_CE
#  include <csignal>
#endif
#  include <iostream>
#endif
#include <unistd.h>

#include "fnames.h"
#include "exult.h"
#include "game.h"
#include "Audio.h"

#include "../files/U7file.h"
#include "../files/utils.h"
#include "Midi.h"
#include "xmidi.h"
#include "conv.h"
#include "convmusic.h"

#include "../conf/Configuration.h"
extern  Configuration *config;

#ifndef UNDER_CE
using std::cerr;
using std::cout;
using std::endl;
using std::string;
using std::strcpy;
#endif

static Mix_Music *oggmusic;


void    MyMidiPlayer::start_track(int num,bool repeat,int bank)
{
  if (!midi_device && !init_device())
          return;


  #ifdef DEBUG
        cout << "Audio subsystem request: Music track # " << num << endl;
  #endif
  // -1 and 255 are stop tracks
  if (num == -1 || num == 255)
  {
    stop_music();
    return;
  }

  current_track = num;
  repeating = repeat;

  if (output_driver_type == MIDI_DRIVER_OGG)
  {
      char filename[255] ;
    string s;

    //Free previous music, may not have been properly stopped
    if(oggmusic)
    {
      Mix_FreeMusic(oggmusic);
      oggmusic = NULL;
    }

    if(Game::get_game_type()==SERPENT_ISLE)
    {
      if(bank == 2 && num == 28)  //Convert title track number only in SI
        num = 70;

      s = midi_bank[bank];
      to_uppercase(s);
      if((num == 30 || num == 32) && s.find("MAINSHP") != std::string::npos)
      {
        //Convert credit/quote tracks
        if(num == 30)
          s = "endcr01.ogg";
        else
          s = "endcr02.ogg";
      }
      else
      {
        s = bgconvmusic[num];
        s = s + ".ogg";
      }

      s = get_system_path("<MUSIC>/" + s);
      strcpy(filename, s.c_str());
    }
    else
    {
      char outputstr[255];

      s = midi_bank[bank];
      to_uppercase(s);
      if((num == 4 || num == 5) && s.find("INTRORDM") != std::string::npos)
      {
        //Convert credit/quotes tracks
        if(num == 4)
          s = "endcr01.ogg";
        else
          s = "endcr02.ogg";
      }
      else
        s = "%02dbg.ogg";

      s = get_system_path("<MUSIC>/" + s);
      strcpy(outputstr, s.c_str());
      sprintf(filename, outputstr, num);
    }

    if(num == 99)   //Play the Exult theme tune
    {
      s = get_system_path("<MUSIC>/exult.ogg");
      strcpy(filename, s.c_str());
    }

    if(repeat)
      repeat = 2;   //Convert repeats to repeat 2 times only

      oggmusic = Mix_LoadMUS(filename);
    if (!oggmusic) {
      cout << "Error playing " << filename << ": " << Mix_GetError()
         << std::endl;
    }

    Mix_PlayMusic(oggmusic, repeat);
    Mix_VolumeMusic(MIX_MAX_VOLUME);

#ifdef DEBUG
        cout << "OGG audio: Music track " << filename << endl;
#endif

    return;   //We don't want to continue with Midi conversions!!
  }

  // Bank 0 is mainmus, but it's for mt32. If our hardware is an fm synth,
  // use the fmsynth music, which is bank 3
  if (bank == 0 && midi_device->is_fm_synth()) bank = 3;
  // Bank 1 is BG menu/intro. We need Bank 4
  else if (bank == 1 && midi_device->is_fm_synth()) bank = 4;
  // Bank 2 is SI menu/intro. We need to offset -1
  else if (bank == 2 && midi_device->is_fm_synth()) num--;

  U7object  track(midi_bank[bank].c_str(),num);

  char    *buffer;
  size_t    size;
  DataSource  *mid_data;
  
  try
  {
    buffer = track.retrieve(size);
  }
  catch( const std::exception & /*err*/ )
  {
    return;
  }

  // Read the data into the XMIDI class
  mid_data = new BufferDataSource(buffer, size);

  // Play with the conversion type for the FMSynth or MT32EMU drivers
  int conv = music_conversion;

  if (midi_device->use_gs127())
  //if (midi_device->is_fmsynth())
    conv = XMIDI_CONVERT_MT32_TO_GS127;
  //else if (midi_device->is_mt32())
    //conv = XMIDI_CONVERT_NOCONVERSION;

  XMIDI   midfile(mid_data, conv);
  
  delete mid_data;
  delete [] buffer;

  // Now give the xmidi object to the midi device

  XMIDIEventList *eventlist = midfile.GetEventList(0);
  if (eventlist) midi_device->start_track(eventlist, repeat);

}

void    MyMidiPlayer::start_track(const char *fname,int num,bool repeat)
{
  if (!fname || (!midi_device && !init_device()))
          return;

  current_track = -1;
  repeating = repeat;

  #ifdef DEBUG
        cout << "Audio subsystem request: Music track # " << num << " in file "<< fname << endl;
  #endif

  // -1 and 255 are stop tracks
  if (num == -1 || num == 255)
  {
    midi_device->stop_track();
    return;
  }

  //Only called from the endgame sequences  
  if (output_driver_type == MIDI_DRIVER_OGG)
  {
      char filename[255] ;

    //Free previous music, may not have been properly stopped
    if(oggmusic)
    {
      Mix_FreeMusic(oggmusic);
      oggmusic = NULL;
    }

    string s = fname;
    to_uppercase(s);

    if(s.find("ENDSCORE") != std::string::npos && Game::get_game_type()!=SERPENT_ISLE)
    {
        sprintf(filename, "end%02dbg.ogg", num);
    }
    else if(s.find("R_SINTRO") != std::string::npos && Game::get_game_type()==SERPENT_ISLE)
      strcpy(filename, "si01.ogg");   //SI introduction sequence
    else if(s.find("R_SEND") != std::string::npos && Game::get_game_type()==SERPENT_ISLE)
      strcpy(filename, "si13.ogg");   //SI end sequence
    else
      return;

    string s2 = filename;
    s2 = get_system_path("<MUSIC>/" + s2);
    strcpy(filename, s2.c_str());

        oggmusic = Mix_LoadMUS(filename);
        Mix_PlayMusic(oggmusic, repeat);
    Mix_VolumeMusic(MIX_MAX_VOLUME);

    return;   //We don't want to continue with Midi conversions!!
  }


  FILE    *mid_file;
  DataSource  *mid_data;
  

  // Read the data into the XMIDI class

  mid_file = U7open(fname, "rb");  //DARKE FIXME
  mid_data = new FileDataSource(mid_file);

  // Play with the conversion type for the FMSynth or MT32EMU drivers
  int conv = music_conversion;

  if (midi_device->use_gs127())
  //if (midi_device->is_fmsynth())
    conv = XMIDI_CONVERT_MT32_TO_GS127;
  //else if (midi_device->is_mt32())
    //conv = XMIDI_CONVERT_NOCONVERSION;

  XMIDI   midfile(mid_data, conv);
  
  delete mid_data;
  fclose(mid_file);
  
  // Now give the xmidi object to the midi device
  XMIDIEventList *eventlist = midfile.GetEventList(num);
  if (eventlist) midi_device->start_track(eventlist, repeat);
}

void    MyMidiPlayer::start_track(XMIDIEventList *midfile, bool repeat)
{

  #ifdef DEBUG
        cout << "Audio subsystem request: Custom Music track" << endl;
  #endif
  if (!midi_device && !init_device())
          return;
  
  // Now give the xmidi object to the midi device
  midi_device->start_track(midfile, repeat);
}

void  MyMidiPlayer::start_music(int num,bool repeat,int bank)
{
  if(!midi_device && !init_device())
    return;
  if(current_track==num&&midi_device->is_playing())
    return; // Already playing it

  if(num == 0 && bank == 0 && Game::get_game_type() == BLACK_GATE)
    return;   //Gets around Usecode bug where track 0 is played at Intro Earthquake

  start_track(num,repeat,bank);
}

void  MyMidiPlayer::start_music(const char *fname,int num,bool repeat)
{
  if(!fname || (!midi_device && !init_device()))
    return;
  start_track(fname,num,repeat);
}

void  MyMidiPlayer::stop_music()
{
  if(!midi_device && !init_device())
    return;

  current_track = -1;
  repeating = false;
  
  midi_device->stop_track();
}

bool  MyMidiPlayer::add_midi_bank(const char *bankname)
{
  string  bank(bankname);
  midi_bank.push_back(bank);
  return true;
}


#if HAVE_TIMIDITY_BIN
  #include "midi_drivers/Timidity_binary.h"
#endif
#if HAVE_LIBKMIDI
  #include "midi_drivers/KMIDI.h"
#endif
#if !defined(MACOS) && !defined(WIN32)
  #include "midi_drivers/forked_player.h"
#endif
#ifdef USE_FMOPL_MIDI
  #include "midi_drivers/fmopl_midi.h"
#endif
#ifdef WIN32
  #include "midi_drivers/win_midiout.h"
#endif
#ifdef BEOS
  #include "midi_drivers/be_midi.h"
#endif
#if defined(MACOS) || defined(MACOSX)
  #include "midi_drivers/mac_midi.h"
#endif
#if defined( __MORPHOS__ ) || defined( AMIGA )
  #include "midi_drivers/amiga_midi.h"
#endif

#define TRY_MIDI_DRIVER(CLASS_NAME) do { \
  if(no_device) { \
    try { \
      midi_device=new CLASS_NAME(); \
      no_device=false;  \
      cout << "Music player: " << midi_device->copyright() << endl; \
    } catch(...) {  \
      no_device=true; \
    } \
  } \
} while(0)
  
void MyMidiPlayer::set_music_conversion(int conv)
{
  music_conversion = conv;
  
  switch(music_conversion) {
  case XMIDI_CONVERT_MT32_TO_GS:
    config->set("config/audio/midi/convert","gs",true);
    break;
  case XMIDI_CONVERT_NOCONVERSION:
    config->set("config/audio/midi/convert","none",true);
    break;
  case XMIDI_CONVERT_MT32_TO_GS127:
    config->set("config/audio/midi/convert","gs127",true);
    break;
  default:
    config->set("config/audio/midi/convert","gm",true);
    break;
  }
}

void MyMidiPlayer::set_effects_conversion(int conv)
{
  effects_conversion = conv;
  
  switch(effects_conversion) {
  case XMIDI_CONVERT_NOCONVERSION:
    config->set("config/audio/effects/convert","none",true);
    break;
  default:
    config->set("config/audio/effects/convert","gs",true);
    break;
  }
}

void MyMidiPlayer::set_output_driver_type(int type)
{
  // Don't kill the device if we don't need to
  if (type != output_driver_type) {
    stop_music();
    delete midi_device;
    midi_device = 0;
    initialized = false;
  }

  output_driver_type = type;

  switch(output_driver_type) {
  case MIDI_DRIVER_OGG:
    config->set("config/audio/midi/driver","digital",true);
    break;
#ifdef USE_FMOPL_MIDI
  case MIDI_DRIVER_FMSYNTH:
    config->set("config/audio/midi/driver","fmsynth",true);
    break;
#endif
#ifdef USE_MT32EMU_MIDI
  case MIDI_DRIVER_MT32EMU:
    config->set("config/audio/midi/driver","mt32emu",true);
    break;
#endif
  default:
    config->set("config/audio/midi/driver","normal",true);
    break;
  };
}


bool MyMidiPlayer::init_device(void)
{
  // already initialized? Do this first
  if (initialized) return (midi_device != 0);

  bool  no_device=true;

  // instrument_patches=AccessTableFile(XMIDI_MT);
  string  s;

  bool sfx = Audio::get_ptr()->are_effects_enabled();

  if (!sfx) s = "no";
  else s = "yes";

  config->set("config/audio/effects/enabled",s,true);

  bool music = Audio::get_ptr()->is_music_enabled();

  if (!music) s = "no";
  else s = "yes";

  // Global Midi Enable/Disable
  config->set("config/audio/midi/enabled",s,true);

  // String for default value for driver type
  std::string driver_default = "normal";

  // Music conversion
  config->value("config/audio/midi/convert",s,"gm");

  if (s == "gs")
    music_conversion = XMIDI_CONVERT_MT32_TO_GS;
  else if (s == "none")
    music_conversion = XMIDI_CONVERT_NOCONVERSION;
  else if (s == "gs127")
    music_conversion = XMIDI_CONVERT_MT32_TO_GS127;
  else if (s == "gs127drum")
  {
    music_conversion = XMIDI_CONVERT_MT32_TO_GS;
    config->set("config/audio/midi/convert","gs",true);
  }
  else
  {
    music_conversion = XMIDI_CONVERT_MT32_TO_GM;
    config->set("config/audio/midi/convert","gm",true);
    driver_default = s;
  }

  // Effects conversion
  config->value("config/audio/effects/convert",s,"gs");

  if (s == "none")
    effects_conversion = XMIDI_CONVERT_NOCONVERSION;
  else if (s == "gs127")
    effects_conversion = XMIDI_CONVERT_NOCONVERSION;
  else
  {
    effects_conversion = XMIDI_CONVERT_GS127_TO_GS;
    config->set("config/audio/effects/convert","gs",true);
  }

  // Midi driver type.
  config->value("config/audio/midi/driver",s,driver_default.c_str());

  if (s == "digital")
  {
    output_driver_type = MIDI_DRIVER_OGG;
    config->set("config/audio/effects/driver","digital",true);
  }
#ifdef USE_FMOPL_MIDI
  else if (s == "fmsynth")
  {
    output_driver_type = MIDI_DRIVER_FMSYNTH;
    config->set("config/audio/effects/driver","fmsynth",true);
  }
#endif
#ifdef USE_MT32EMU_MIDI
  else if (s == "mt32emu")
  {
    output_driver_type = MIDI_DRIVER_MT32EMU;
  }
#endif
  else
  {
    output_driver_type = MIDI_DRIVER_NORMAL;
    config->set("config/audio/effects/driver","normal",true);
  }

  // no need for a MIDI device (for now)
  if (!sfx && !music)
  {
    midi_device = 0;
    return false;
  }


  // OGG is handled differently to the other MIDI devices, due to it
  // not actually being a midi device. There are hacks all over the place 
  // for it. The OGG_MIDI driver does do some 'stuff', such as init
  if (output_driver_type == MIDI_DRIVER_OGG)
    TRY_MIDI_DRIVER(OGG_MIDI);
#ifdef USE_FMOPL_MIDI
  else if (output_driver_type == MIDI_DRIVER_FMSYNTH)
    TRY_MIDI_DRIVER(FMOpl_Midi);
#endif

#if defined(WIN32) && !defined(UNDER_CE)
  TRY_MIDI_DRIVER(Windows_MidiOut);
#endif
#ifdef BEOS
  TRY_MIDI_DRIVER(Be_midi);
#endif
#if defined(HAVE_TIMIDITY_BIN) && (defined(XWIN) || defined(WIN32))
  TRY_MIDI_DRIVER(Timidity_binary);
#endif
#if HAVE_LIBKMIDI
  TRY_MIDI_DRIVER(KMIDI);
#endif
#if (defined(XWIN) && !defined(OPENBSD) && !defined(__zaurus__))
  TRY_MIDI_DRIVER(forked_player);
#endif
#if defined(MACOS) || defined(MACOSX)
  TRY_MIDI_DRIVER(Mac_QT_midi);
#endif
#if defined(__MORPHOS__) || defined(AMIGA)
  TRY_MIDI_DRIVER(AmigaMIDI);
#endif
#ifdef USE_FMOPL_MIDI
  TRY_MIDI_DRIVER(FMOpl_Midi);
#endif

  initialized = true;

  if(no_device)
  {
    midi_device=0;
    cerr << "Unable to create a MIDI device. No music will be played." << endl;
    return false;
  }

  load_patches(false);
    
  return true;
}


MyMidiPlayer::MyMidiPlayer()  : current_track(-1),repeating(false),
          midi_device(0), initialized(false),
          music_conversion(XMIDI_CONVERT_MT32_TO_GM),
          effects_conversion(XMIDI_CONVERT_GS127_TO_GS),
          output_driver_type(MIDI_DRIVER_NORMAL)
{
  add_midi_bank(MAINMUS);
  add_midi_bank(INTROMUS);
  add_midi_bank("<STATIC>/mainshp.flx");
  add_midi_bank(MAINMUS_AD);
  add_midi_bank(INTROMUS_AD);
  
  init_device();
}

MyMidiPlayer::~MyMidiPlayer()
{
  if(midi_device)//&&midi_device->is_playing())
    //midi_device->stop_track();
    delete midi_device;
}


void    MyMidiPlayer::start_sound_effect(int num)
{
#ifdef DEBUG
  cout << "Audio subsystem request: sound effect # " << num << endl;
#endif

  int real_num = num;

  if (Game::get_game_type() == BLACK_GATE) real_num = bgconv[num];

  cout << "Real num " << real_num << endl;

  U7object  track("<DATA>/midisfx.flx",real_num);

  if (!midi_device && !init_device())
          return;
  
  char    *buffer;
  size_t    size;
  DataSource  *mid_data;
  
  try
  {
    buffer = track.retrieve(size);
  }
  catch( const std::exception & /*err*/ )
  {
    return;
  }

  // Read the data into the XMIDI class
  mid_data = new BufferDataSource(buffer, size);

  // It's already GM, so dont convert
  XMIDI   midfile(mid_data, effects_conversion);
  
  delete mid_data;
  delete [] buffer;

  // Now give the xmidi object to the midi device
  XMIDIEventList *eventlist = midfile.GetEventList(0);
  if (eventlist) midi_device->start_sfx(eventlist);
  
}

void    MyMidiPlayer::stop_sound_effects()
{
  if (midi_device)
    midi_device->stop_sfx();
}

OGG_MIDI::OGG_MIDI()
{
  oggmusic = NULL;
  Mix_HookMusicFinished(music_complete_callback);
  Mix_VolumeMusic(MIX_MAX_VOLUME);
}

OGG_MIDI::~OGG_MIDI()
{
  Mix_HaltMusic();
  if(oggmusic)
  {
    Mix_FreeMusic(oggmusic);
    oggmusic = NULL;
  }
}

//Clean up last track played, freeing memory each time
void OGG_MIDI::music_complete_callback(void)
{
  if(oggmusic)
  {
    Mix_FreeMusic(oggmusic);
    oggmusic = NULL;
  }
}

void OGG_MIDI::start_track(XMIDIEventList *, bool repeat)
{
}

void OGG_MIDI::stop_track(void)
{
  Mix_HaltMusic();
  if(oggmusic)
  {
    Mix_FreeMusic(oggmusic);
    oggmusic = NULL;
  }
}

bool OGG_MIDI::is_playing(void)
{
  return Mix_PlayingMusic()!=0;
}

const char * OGG_MIDI::copyright(void)
{
  return "Internal OGG digital music player";
}

---