//
// Programmer:    Craig Stuart Sapp <craig@ccrma.stanford.edu>
// Creation Date: Sun May 14 22:35:27 PDT 2000
// Last Modified: Thu May 18 23:36:00 PDT 2000
// Last Modified: Sat Nov  2 20:37:49 PST 2002 (added ifdef ALSA OSS)
// Filename:      ...sig/maint/code/control/MidiInPort/MidiInPort_linux.cpp
// Web Address:   http://sig.sapp.org/include/sig/MidiInPort_linux.cpp
// Syntax:        C++ 
//
// Description:   An interface for MIDI input capabilities of an
//                operating-system specific MIDI input method.
//                Provides control of all low-level MIDI input
//                functionality such that it will work on all
//                computers in the same manner.
//

#ifdef LINUX
#if defined(ALSA) && defined(OSS)

#include <sys/types.h>
#include <sys/stat.h>

#include "MidiInPort_linux.h"

// initialize static variables oss_input->close(); break;
int MidiInPort_linux::objectCount = 0;
int MidiInPort_linux::current = MIDI_IN_OSS_SELECT; 
int MidiInPort_linux::alsaQ   = 0;         
int MidiInPort_linux::ossQ    = 0;          
MidiInPort_oss          *MidiInPort_linux::oss_input     = NULL;
MidiInPort_alsa         *MidiInPort_linux::alsa_input    = NULL;
MidiInPort_unsupported  *MidiInPort_linux::unknown_input = NULL;


//////////////////////////////
//
// MidiInPort_linux::MidiInPort_linux --
//

MidiInPort_linux::MidiInPort_linux(void) {
   if (objectCount == 0) {
      determineDrivers();
   } else if (objectCount < 0) {
      cout << "Error: unusual MidiInPort_linux object count" << endl;
      exit(1);
   } 

   objectCount++;
} 


MidiInPort_linux::MidiInPort_linux(int aPort, int autoOpen = 1) {
   if (objectCount == 0) {
      determineDrivers();
      setAndOpenPort(aPort);
   } else if (objectCount < 0) {
      cout << "Error: unusual MidiInPort_linux object count" << endl;
      exit(1);
   } 

   objectCount++;
} 



//////////////////////////////
//
// MidiInPort_linux::~MidiInPort_linux --
//

MidiInPort_linux::~MidiInPort_linux() {
   objectCount--;
   if (objectCount == 0) {
      if (oss_input != NULL) {
         delete oss_input;
         oss_input = NULL;
      }
      if (alsa_input != NULL) {
         delete alsa_input;
         alsa_input = NULL;
      }
      if (unknown_input != NULL) {
         delete unknown_input;
         unknown_input = NULL;
      }
   }

   if (objectCount < 0) {
      cout << "Error: unusual MidiOutPort_linux count when destructing" << endl;
      exit(1);
   }
} 



//////////////////////////////
//
// MidiInPort_linux::clearSysex --
//

void MidiInPort_linux::clearSysex(void) {
   switch (getSelect()) {
      case MIDI_IN_OSS_SELECT:  oss_input->clearSysex(); break;
      case MIDI_IN_ALSA_SELECT: alsa_input->clearSysex(); break;
      default:                  unknown_input->clearSysex(); break;
   }
}


void MidiInPort_linux::clearSysex(int buffer) {
   switch (getSelect()) {
      case MIDI_IN_OSS_SELECT:  oss_input->clearSysex(); break;
      case MIDI_IN_ALSA_SELECT: alsa_input->clearSysex(); break;
      default:                  unknown_input->clearSysex(); break;
   }
}



//////////////////////////////
//
// MidiInPort_linux::close --
//

void MidiInPort_linux::close(void) {
   switch (getSelect()) {
      case MIDI_IN_OSS_SELECT:  oss_input->close(); break;
      case MIDI_IN_ALSA_SELECT: alsa_input->close(); break;
      default:                  unknown_input->close(); break;
   }
}



//////////////////////////////
//
// MidiInPort_linux::closeAll --
//

void MidiInPort_linux::closeAll(void) {
   switch (getSelect()) {
      case MIDI_IN_OSS_SELECT:  oss_input->closeAll(); break;
      case MIDI_IN_ALSA_SELECT: alsa_input->closeAll(); break;
      default:                  unknown_input->closeAll(); break;
   }
}



//////////////////////////////
//
// MidiInPort_linux::extract --
//

MidiMessage MidiInPort_linux::extract(void) {
   switch (getSelect()) {
      case MIDI_IN_OSS_SELECT:  return oss_input->extract(); break;
      case MIDI_IN_ALSA_SELECT: return alsa_input->extract(); break;
      default:                  return unknown_input->extract(); break;
   }
}



//////////////////////////////
//
// MidiInPort_linux::getBufferSize --
//

int MidiInPort_linux::getBufferSize(void) {
   switch (getSelect()) {
      case MIDI_IN_OSS_SELECT:  return oss_input->getBufferSize(); break;
      case MIDI_IN_ALSA_SELECT: return alsa_input->getBufferSize(); break;
      default:                  return unknown_input->getBufferSize(); break;
   }
}



//////////////////////////////
//
// MidiInPort_linux::getChannelOffset --
//

int MidiInPort_linux::getChannelOffset(void) const {
   switch (getSelect()) {
      case MIDI_IN_OSS_SELECT:  return oss_input->getChannelOffset(); break;
      case MIDI_IN_ALSA_SELECT: return alsa_input->getChannelOffset(); break;
      default:                  return unknown_input->getChannelOffset(); break;
   }
}



//////////////////////////////
//
// MidiInPort_linux::getCount --
//

int MidiInPort_linux::getCount(void) {
   switch (getSelect()) {
      case MIDI_IN_OSS_SELECT:  return oss_input->getCount(); break;
      case MIDI_IN_ALSA_SELECT: return alsa_input->getCount(); break;
      default:                  return unknown_input->getCount(); break;
   }
}


//////////////////////////////
//
// MidiInPort_linux::getName --
//

const char* MidiInPort_linux::getName(void) {
   switch (getSelect()) {
      case MIDI_IN_OSS_SELECT:  return oss_input->getName(); break;
      case MIDI_IN_ALSA_SELECT: return alsa_input->getName(); break;
      default:                  return unknown_input->getName(); break;
   }
}


const char* MidiInPort_linux::getName(int i) {
   switch (getSelect()) {
      case MIDI_IN_OSS_SELECT:  return oss_input->getName(i); break;
      case MIDI_IN_ALSA_SELECT: return alsa_input->getName(i); break;
      default:                  return unknown_input->getName(i); break;
   }
}



//////////////////////////////
//
// MidiInPort_linux::getNumPorts --
//

int MidiInPort_linux::getNumPorts(void) {
   switch (getSelect()) {
      case MIDI_IN_OSS_SELECT:  return oss_input->getNumPorts(); break;
      case MIDI_IN_ALSA_SELECT: return alsa_input->getNumPorts(); break;
      default:                  return unknown_input->getNumPorts(); break;
   }
}



//////////////////////////////
//
// MidiInPort_linux::getPort --
//

int MidiInPort_linux::getPort(void) {
   switch (getSelect()) {
      case MIDI_IN_OSS_SELECT:  return oss_input->getPort(); break;
      case MIDI_IN_ALSA_SELECT: return alsa_input->getPort(); break;
      default:                  return unknown_input->getPort(); break;
   }
}



//////////////////////////////
//
// MidiInPort_linux::getPortStatus --
//

int MidiInPort_linux::getPortStatus(void) {
   switch (getSelect()) {
      case MIDI_IN_OSS_SELECT:  return oss_input->getPortStatus(); break;
      case MIDI_IN_ALSA_SELECT: return alsa_input->getPortStatus(); break;
      default:                  return unknown_input->getPortStatus(); break;
   }
}



//////////////////////////////
//
// MidiInPort_linux::getSysex --
//

uchar* MidiInPort_linux::getSysex(int buffer) {
   switch (getSelect()) {
      case MIDI_IN_OSS_SELECT:  return oss_input->getSysex(buffer); break;
      case MIDI_IN_ALSA_SELECT: return alsa_input->getSysex(buffer); break;
      default:                  return unknown_input->getSysex(buffer); break;
   }
}



//////////////////////////////
//
// MidiInPort_linux::getSysexSize --
//

int MidiInPort_linux::getSysexSize(int buffer) {
   switch (getSelect()) {
      case MIDI_IN_OSS_SELECT:  return oss_input->getSysexSize(buffer); break;
      case MIDI_IN_ALSA_SELECT: return alsa_input->getSysexSize(buffer); break;
      default: return unknown_input->getSysexSize(buffer); break;
   }
}



//////////////////////////////
//
// MidiInPort_linux::getTrace --
//

int MidiInPort_linux::getTrace(void) {
   switch (getSelect()) {
      case MIDI_IN_OSS_SELECT:  return oss_input->getTrace(); break;
      case MIDI_IN_ALSA_SELECT: return alsa_input->getTrace(); break;
      default:                  return unknown_input->getTrace(); break;
   }
}



//////////////////////////////
//
// MidiInPort_linux::insert --
//

void MidiInPort_linux::insert(const MidiMessage& aMessage) {
   switch (getSelect()) {
      case MIDI_IN_OSS_SELECT:  oss_input->insert(aMessage); break;
      case MIDI_IN_ALSA_SELECT: alsa_input->insert(aMessage); break;
      default:                  unknown_input->insert(aMessage); break;
   }
}



//////////////////////////////
//
// MidiInPort_linux::installSysex --
//

int MidiInPort_linux::installSysex(uchar* anArray, int aSize) {
   switch (getSelect()) {
      case MIDI_IN_OSS_SELECT:  
         return oss_input->installSysex(anArray, aSize);
         break;
      case MIDI_IN_ALSA_SELECT: 
         return alsa_input->installSysex(anArray, aSize); 
         break;
      default:                  
         return unknown_input->installSysex(anArray, aSize); 
         break;
   }
}



//////////////////////////////
//
// MidiInPort_linux::message --
//

MidiMessage& MidiInPort_linux::message(int index) {
   switch (getSelect()) {
      case MIDI_IN_OSS_SELECT:  return oss_input->message(index); break;
      case MIDI_IN_ALSA_SELECT: return alsa_input->message(index); break;
      default:                  return unknown_input->message(index); break;
   }
}



//////////////////////////////
//
// MidiInPort_linux::open --
//

int MidiInPort_linux::open(void) {
   switch (getSelect()) {
      case MIDI_IN_OSS_SELECT:  return oss_input->open(); break;
      case MIDI_IN_ALSA_SELECT: return alsa_input->open(); break;
      default:                  return unknown_input->open(); break;
   }
}



//////////////////////////////
//
// MidiInPort_linux::operator[] --
//

MidiMessage& MidiInPort_linux::operator[](int index) {
   switch (getSelect()) {
      case MIDI_IN_OSS_SELECT:  return oss_input->message(index); break;
      case MIDI_IN_ALSA_SELECT: return alsa_input->message(index); break;
      default:                  return unknown_input->message(index); break;
   }
}



//////////////////////////////
//
// MidiInPort_linux::pause --
//

void MidiInPort_linux::pause(void) {
   switch (getSelect()) {
      case MIDI_IN_OSS_SELECT:  oss_input->pause(); break;
      case MIDI_IN_ALSA_SELECT: alsa_input->pause(); break;
      default:                  unknown_input->pause(); break;
   }
}



//////////////////////////////
//
// MidiInPort_linux::setBufferSize --
//

void MidiInPort_linux::setBufferSize(int aSize) {
   switch (getSelect()) {
      case MIDI_IN_OSS_SELECT:  oss_input->setBufferSize(aSize); break;
      case MIDI_IN_ALSA_SELECT: alsa_input->setBufferSize(aSize); break;
      default:                  unknown_input->setBufferSize(aSize); break;
   }
}



//////////////////////////////
//
// MidiInPort_linux::setChannelOffset --
//

void MidiInPort_linux::setChannelOffset(int anOffset) {
   switch (getSelect()) {
      case MIDI_IN_OSS_SELECT:  oss_input->setChannelOffset(anOffset); break;
      case MIDI_IN_ALSA_SELECT: alsa_input->setChannelOffset(anOffset); break;
      default:                  unknown_input->setChannelOffset(anOffset); break;
   }
}



//////////////////////////////
//
// MidiInPort_linux::setAndOpenPort --
//

void MidiInPort_linux::setAndOpenPort(int aPort) {
   switch (getSelect()) {
      case MIDI_IN_OSS_SELECT:  
         oss_input->setPort(aPort); 
         oss_input->open();
         break;
      case MIDI_IN_ALSA_SELECT:
         alsa_input->setPort(aPort); 
         alsa_input->open();
         break;
      default:
         unknown_input->setPort(aPort); 
         unknown_input->open();
         break;
   }
}



//////////////////////////////
//
// MidiInPort_linux::setPort --
//

void MidiInPort_linux::setPort(int aPort) {
   switch (getSelect()) {
      case MIDI_IN_OSS_SELECT:  oss_input->setPort(aPort); break;
      case MIDI_IN_ALSA_SELECT: alsa_input->setPort(aPort); break;
      default:                  unknown_input->setPort(aPort); break;
   }
}



//////////////////////////////
//
// MidiInPort_linux::setTrace --
//

int MidiInPort_linux::setTrace(int aState) {
   switch (getSelect()) {
      case MIDI_IN_OSS_SELECT:  return oss_input->setTrace(aState); break;
      case MIDI_IN_ALSA_SELECT: return alsa_input->setTrace(aState); break;
      default:                  return unknown_input->setTrace(aState); break;
   }
}



//////////////////////////////
//
// MidiInPort_linux::toggleTrace --
//

void MidiInPort_linux::toggleTrace(void) {
   switch (getSelect()) {
      case MIDI_IN_OSS_SELECT:  oss_input->toggleTrace(); break;
      case MIDI_IN_ALSA_SELECT: alsa_input->toggleTrace(); break;
      default:                  unknown_input->toggleTrace(); break;
   }
}



//////////////////////////////
//
// MidiInPort_linux::unpause --
//

void MidiInPort_linux::unpause(void) {
   switch (getSelect()) {
      case MIDI_IN_OSS_SELECT:  oss_input->unpause(); break;
      case MIDI_IN_ALSA_SELECT: alsa_input->unpause(); break;
      default:                  unknown_input->unpause(); break;
   }
}



//////////////////////////////
//
// MidiInPort_linux::getSelect -- return the type of MIDI which
//      is being used to send MIDI output.
//

int MidiInPort_linux::getSelect(void) {
   return current;
}



//////////////////////////////
//
// MidiInPort_linux::selectOSS -- select the OSS MIDI output
//   returns 1 if OSS is available, otherwise returns 0.
//

int MidiInPort_linux::selectOSS(void) {
   if (ossQ) {
      current = MIDI_IN_OSS_SELECT;
      return 1;
   } else {
      return 0;
   }
}



//////////////////////////////
//
// MidiInPort_linux::selectALSA -- select the ALSA MIDI output
//   returns 1 if ALSA is available, otherwise returns 0.
//

int MidiInPort_linux::selectALSA(void) {
   if (alsaQ) {
      current = MIDI_IN_ALSA_SELECT;
      return 1;
   } else {
      return 0;
   }
}



//////////////////////////////
//
// MidiInPort_linux::selectUnknown -- select the Unknown MIDI output
//   returns 1 always.
//

int MidiInPort_linux::selectUnknown(void) {
   current = MIDI_IN_UNKNOWN_SELECT;
   return 1;
}


//////////////////////////////////////////////////////////////////////////
//
// Private Functions
//

//////////////////////////////
//
// MidiInPort_linux::determineDrivers -- see if OSS/ALSA are
//      available.  If /dev/sequencer is present, assume that OSS is
//      available.  If /dev/snd/sdq is present, assume that ALSA is
//      available.  
//

void MidiInPort_linux::determineDrivers(void) {
   struct stat filestats;
   int status;
   status = stat("/dev/sequencer", &filestats);

   if (status != 0) {
      ossQ = 0;
   } else {
      ossQ = 1;
   }

   status = stat("/dev/snd/seq", &filestats);

   if (status != 0) {
      alsaQ = 0;
   } else {
      alsaQ = 1;
   }


   current = MIDI_IN_UNKNOWN_SELECT;

   if (ossQ) {
      current = MIDI_IN_OSS_SELECT;
   }

   if (alsaQ) {
      current = MIDI_IN_ALSA_SELECT;
   }

   // create MIDI output types which are available:

   if (oss_input != NULL) {
      delete oss_input;
      oss_input = NULL;
   }
   if (alsa_input != NULL) {
      delete alsa_input;
      alsa_input = NULL;
   }
   if (unknown_input != NULL) {
      delete unknown_input;
      unknown_input = NULL;
   }

   if (ossQ) {
      oss_input = new MidiInPort_oss;
   }
   if (alsaQ) {
      alsa_input = new MidiInPort_alsa;
   }

   unknown_input = new MidiInPort_unsupported;

}


#endif /* ALSA and OSS */
#endif /* LINUX */


// md5sum: 60d2db9f42fc5ab24c00a72b5a0f9a04 MidiInPort_linux.cpp [20050403]