al_MIDI.hpp

#ifndef INCLUDE_AL_IO_MIDI_HPP
#define INCLUDE_AL_IO_MIDI_HPP
 
#include <exception>
#include <iostream>
#include <queue>
#include <string>
#include <vector>
 
/**********************************************************************/
/* \class MIDI
    \brief An abstract base class for realtime MIDI input/output.
 
    This class implements some common functionality for the realtime
    MIDI input/output subclasses RtRtMidiIn and RtMidiOut.
 
    RtMidi WWW site: http://music.mcgill.ca/~gary/rtmidi/
*/
/**********************************************************************/
 
#define NOMINMAX
#include "RtMidi.h"
#undef NOMINMAX
 
namespace al {
 
// Internal classes to maintain backward compatibility
// class[[depreacated("User RtRtMidiIn directly")]] RtMidiIn : public
// RtMidiIn{};
 
// class[[depreacated("User RtMidiOut directly")]] MIDIOut : public RtMidiOut{};
 
// class[[depreacated("User RtMidiError directly")]] MIDIError
//    : public RtMidiError{};
 
double noteToHz(double noteNumber);
 
int getMIDIDeviceIndex(std::string deviceName);;
 
class MIDIByte {
 public:
#define BITS_(a, b, c, d, e, f, g, h) \
  (a << 7 | b << 6 | c << 5 | d << 4 | e << 3 | f << 2 | g << 1 | h)
 
  // Constants for checking the first message byte
  // http://www.midi.org/techspecs/midimessages.php
  static const unsigned char
      CHANNEL_MASK = BITS_(0, 0, 0, 0, 1, 1, 1,
                           1),  
      MESSAGE_MASK =
          BITS_(1, 1, 1, 1, 0, 0, 0, 0),  
 
      NOTE_OFF =
          BITS_(1, 0, 0, 0, 0, 0, 0, 0),  
      NOTE_ON =
          BITS_(1, 0, 0, 1, 0, 0, 0, 0),  
      CONTROL_CHANGE = BITS_(1, 0, 1, 1, 0, 0, 0,
                             0),  
      BANK_SELECT = 0x00,         
      MODULATION = 0x01,          
      BREATH = 0x02,              
      FOOT = 0x04,                
      PORTAMENTO_TIME = 0x05,     
      VOLUME = 0x07,              
      BALANCE = 0x08,             
      PAN = 0x0A,                 
      EXPRESSION = 0x0B,          
      DAMPER_PEDAL = 0x40,        
      PORTAMENTO_ON = 0x41,       
      SOSTENUTO_ON = 0x42,        
      SOFT_PEDAL = 0x43,          
      LEGATO_ON = 0x44,           
 
      PROGRAM_CHANGE = BITS_(1, 1, 0, 0, 0, 0, 0,
                             0),  
      PRESSURE_POLY =
          BITS_(1, 0, 1, 0, 0, 0, 0,
                0),  
      PRESSURE_CHAN =
          BITS_(1, 1, 0, 1, 0, 0, 0,
                0),  
      PITCH_BEND =
          BITS_(1, 1, 1, 0, 0, 0, 0, 0),  
 
      SYSTEM_MSG = BITS_(1, 1, 1, 1, 0, 0, 0, 0),  
 
      SYS_EX = BITS_(1, 1, 1, 1, 0, 0, 0,
                     0),  
      SYS_EX_END = BITS_(1, 1, 1, 1, 0, 1, 1,
                         1),  
      TIME_CODE =
          BITS_(1, 1, 1, 1, 0, 0, 0, 1),  
      SONG_POSITION =
          BITS_(1, 1, 1, 1, 0, 0, 1, 0),  
      SONG_SELECT =
          BITS_(1, 1, 1, 1, 0, 0, 1, 1),  
      TUNE_REQUEST =
          BITS_(1, 1, 1, 1, 0, 1, 1, 0),  
      TIMING_CLOCK =
          BITS_(1, 1, 1, 1, 1, 0, 0, 0),  
      SEQ_START = BITS_(1, 1, 1, 1, 1, 0, 1,
                        0),  
      SEQ_CONTINUE = BITS_(1, 1, 1, 1, 1, 0, 1,
                           1),  
      SEQ_STOP =
          BITS_(1, 1, 1, 1, 1, 1, 0, 0),  
      ACTIVE_SENSING = BITS_(1, 1, 1, 1, 1, 1, 1,
                             0),  
      RESET = BITS_(1, 1, 1, 1, 1, 1, 1,
                    1)  
      ;
#undef BITS_
 
  static bool isChannelMessage(unsigned char statusByte) {
    return (statusByte & MESSAGE_MASK) != SYSTEM_MSG;
  }
 
  static const char* messageTypeString(unsigned char statusByte);
 
  static const char* controlNumberString(unsigned char controlNumber);
 
  static unsigned short convertPitchBend(unsigned char byte2,
                                         unsigned char byte3);
};
 
class MIDIMessage {
 public:
  unsigned char bytes[3];
 
  MIDIMessage(double timeStamp, unsigned port, unsigned char b1,
              unsigned char b2 = 0, unsigned char b3 = 0,
              unsigned char* data = nullptr);
 
  unsigned port() const { return mPort; }
 
  double timeStamp() const { return mTimeStamp; }
 
  unsigned char status() const { return bytes[0]; }
 
  bool isChannelMessage() const { return MIDIByte::isChannelMessage(status()); }
 
  unsigned char channel() const { return bytes[0] & MIDIByte::CHANNEL_MASK; }
 
  unsigned char type() const { return bytes[0] & MIDIByte::MESSAGE_MASK; }
 
  unsigned char noteNumber() const { return bytes[1]; }
 
  double velocity(double mul = 1. / 127.) const { return bytes[2] * mul; }
 
  double pitchBend() const {
    int v = int(MIDIByte::convertPitchBend(bytes[1], bytes[2]));
    v += 1 - bool(v);  // clip interval to [1, 16383]
    return double(v - 8192) / 8191.;
  }
 
  unsigned char controlNumber() const { return bytes[1]; }
 
  double controlValue(double mul = 1. / 127.) const { return bytes[2] * mul; }
 
  unsigned char* data() const { return mData; }
 
  void print(std::ostream& stream = std::cout) const;
 
 protected:
  double mTimeStamp;
  unsigned mPort;
  unsigned char* mData;
};
 
class MIDIMessageHandler {
 public:
  virtual ~MIDIMessageHandler() {}
 
  virtual void onMIDIMessage(const MIDIMessage& m) = 0;
 
  void bindTo(RtMidiIn& RtMidiIn, unsigned port = 0);
 
  void clearBindings() {
    for (auto& binding : mBindings) {
      binding.midiIn->cancelCallback();
    }
    mBindings.clear();
  }
 
 protected:
  struct Binding {
    RtMidiIn* midiIn;
    MIDIMessageHandler* handler;
    unsigned port;
  };
 
  std::vector<Binding> mBindings;
};
 
}  // namespace al
 
#endif