mac_midi.cc

Go to the documentation of this file.

/*
 *  mac_midi.cc - QuickTime based midi player for MacOS.
 *
 *  Copyright (C) 2001  Max Horn
 *
 *  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

//MacOS-specific code
#if defined(MACOS) || defined(MACOSX)

#include <iomanip>
#include <cstdlib>
#include <string>

#include "mac_midi.h"

#ifdef MACOSX
#include <CoreServices/CoreServices.h>
#include <QuickTime/QuickTimeMusic.h>
#endif

using std::cout;
using std::endl;
using std::malloc;
using std::free;
using std::realloc;
using std::memset;

enum
{
  // number of (32-bit) long words in a note request event
  kNoteRequestEventLength = ((sizeof(NoteRequest)/sizeof(long)) + 2),

  // number of (32-bit) long words in a marker event
  kMarkerEventLength  = 1,

  // number of (32-bit) long words in a general event, minus its data
  kGeneralEventLength = 2
};

#define BUFFER_INCREMENT    5000

#define REST_IF_NECESSARY() do {\
      int timeDiff = eventPos->time - lastEventTime;  \
      if(timeDiff)  \
      { \
        timeDiff = (int)(timeDiff*tick);  \
        qtma_StuffRestEvent(*tunePos, timeDiff);  \
        tunePos++;  \
        lastEventTime = eventPos->time; \
      } \
    } while(0)


static uint32 *BuildTuneSequence(midi_event *evntlist, int ppqn, int part_poly_max[32], int part_to_inst[32], int &numParts);
static uint32 *BuildTuneHeader(int part_poly_max[32], int part_to_inst[32], int numParts);


Mac_QT_midi::Mac_QT_midi()
  : MidiAbstract(), mTunePlayer(0), mTuneSequence(0), mTuneHeader(0)
{
// FIX ME - check for QuickTime!!!
  
  mTunePlayer = OpenDefaultComponent(kTunePlayerComponentType, 0);
  if( 0 == mTunePlayer )
    throw exult_exception("Couldn't get tune place component");
}

Mac_QT_midi::~Mac_QT_midi(void)
{
  if(mTunePlayer)
  {
    if(mTuneSequence)
      TuneStop(mTunePlayer, 0);
    CloseComponent(mTunePlayer);
    mTunePlayer = 0;
  }
  if(mTuneSequence)
  {
    free(mTuneSequence);
    mTuneSequence = 0;
  }
  if(mTuneHeader)
  {
    DisposePtr((Ptr)mTuneHeader);
    mTuneHeader = 0;
  }
}


void  Mac_QT_midi::start_track(XMIDIEventList *elist, bool repeat)
{
  int     part_to_inst[32];
  int     part_poly_max[32];
  int     numParts = 0;

  // Max, this is just a work around that should allow things to compile
  // Note that now the ppqn is always 60, and the tempo is always 500000 mcs
  // This means each tick is now always 120th of a second
  int ppqn = 60;
  midi_event *evntlist = elist->events;

  UInt32    queueFlags = 0;
  ComponentResult tpError;

  memset(part_poly_max,0,sizeof(part_poly_max));
  memset(part_to_inst,-1,sizeof(part_to_inst));

  // First thing we do - stop any already playing music
  stop_track();
  
  // Build a tune sequence from the event list
  mTuneSequence = BuildTuneSequence(evntlist, ppqn, part_poly_max, part_to_inst, numParts);
  if(!mTuneSequence)
    goto bail;

  // Now build a tune header from the data we collect above, create
  // all parts as needed and assign them the correct instrument.
  mTuneHeader = BuildTuneHeader(part_poly_max, part_to_inst, numParts);
  if(!mTuneHeader)
    goto bail;

  // Set up the queue flags
  queueFlags = kTuneStartNow;
  if(repeat)
    queueFlags |= kTuneLoopUntil;

  // Set the time scale (units per second), we want milliseconds
  tpError = TuneSetTimeScale(mTunePlayer, 1000);
  assert (tpError == noErr);

  // Set the header, to tell what instruments are used
  tpError = TuneSetHeader(mTunePlayer, (UInt32 *)mTuneHeader);
  assert (tpError == noErr);
  
  // Have it allocate whatever resources are needed
  tpError = TunePreroll(mTunePlayer);
  assert (tpError == noErr);

  // We want to play at normal volume
  tpError = TuneSetVolume(mTunePlayer, 0x00010000);
  assert (tpError == noErr);
  
  // Finally, start playing the full song
  tpError = TuneQueue(mTunePlayer, (UInt32 *)mTuneSequence, 0x00010000, 0, 0xFFFFFFFF, queueFlags, NULL, 0);
  assert (tpError == noErr);

  return;
  
bail:

  // This disposes of the allocated tune header/sequence
  stop_track();
}

void  Mac_QT_midi::stop_track(void)
{
  if(0 == mTuneSequence)
        return;

// For some resons, using a non-zero stopflag doesn't stop the music at all:/
//  TuneStop(mTunePlayer, kTuneStopFade | kTuneStopInstant | kTuneStopReleaseChannels);

  // Stop music
  TuneStop(mTunePlayer, 0);
  
  // Deallocate all instruments
  TuneUnroll(mTunePlayer);
  
  // Finally, free the data storage
  free(mTuneSequence);
  mTuneSequence = 0;

  if(mTuneHeader)
  {
    DisposePtr((Ptr)mTuneHeader);
    mTuneHeader = 0;
  }
}

bool  Mac_QT_midi::is_playing(void)
{
  TuneStatus  ts;

  TuneGetStatus(mTunePlayer,&ts);
  return ts.queueTime != 0;
}

const char *Mac_QT_midi::copyright(void)
{
  return "Internal QuickTime MIDI player";
}

uint32 *BuildTuneSequence(midi_event *evntlist, int ppqn, int part_poly_max[32], int part_to_inst[32], int &numParts)
{
  int     part_poly[32];
  int     channel_to_part[16];
  
  int     channel_pan[16];
  int     channel_vol[16];
  int     channel_pitch_bend[16];
  
  int     lastEventTime = 0;
  int     tempo = 500000;
  double    Ippqn = 1.0 / (1000*ppqn);
  double    tick = tempo * Ippqn;
  midi_event  *eventPos = evntlist;
  uint32    *tunePos, *endPos;
  uint32    *tuneSequence;
  size_t    tuneSize;
#ifdef DEBUG
  int     numEventsHandled = 0;
#endif
  
  // allocate space for the tune header
  tuneSize = 5000;
  tuneSequence = (uint32 *)malloc(tuneSize * sizeof(uint32));
  if (tuneSequence == NULL)
    return NULL;
  
  // Set starting position in our tune memory
  tunePos = tuneSequence;
  endPos = tuneSequence + tuneSize;

  // Initialise the arrays
  memset(part_poly,0,sizeof(part_poly));
  
  memset(channel_to_part,-1,sizeof(channel_to_part));
  memset(channel_pan,-1,sizeof(channel_pan));
  memset(channel_vol,-1,sizeof(channel_vol));
  memset(channel_pitch_bend,-1,sizeof(channel_pitch_bend));

  /*
   * Now the major work - iterate over all GM events,
   * and turn them into QuickTime Music format.
   * At the same time, calculate the max. polyphony for each part,
   * and also the part->instrument mapping.
   */
  while(eventPos)
  {
    int status = (eventPos->status&0xF0)>>4;
    int channel = eventPos->status&0x0F;
    int part = channel_to_part[channel];
        int velocity, pitch;
        int value, controller;
        int bend;
        int newInst;
    
    // Check if we are running low on space...
    if((tunePos+16) > endPos)
    {
      // Resize our data storage.
      uint32    *oldTuneSequence = tuneSequence;

      tuneSize += BUFFER_INCREMENT;
      tuneSequence = (uint32 *)realloc(tuneSequence, tuneSize * sizeof(uint32));
      if(oldTuneSequence != tuneSequence)
        tunePos += tuneSequence - oldTuneSequence;
      endPos = tuneSequence + tuneSize;
    }
    
#if defined(DEBUG) && 0
    numEventsHandled++;

    cout << std::setw(4) << numEventsHandled << ". ";
    cout << "Time: " << std::setw(5) << eventPos->time << " ";
    cout << std::hex << std::uppercase;
    cout << "Status 0x" << status << " Channel: 0x" << channel << " ";
    cout << "Data 0x" << std::setw(4) <<*(unsigned short *)(eventPos->data) << " ";
    cout << std::dec;
    cout << "Length " << eventPos->len << endl;
#endif

    switch (status)
    {
    case MIDI_STATUS_NOTE_OFF:
      assert(part>=0 && part<=31);

      // Keep track of the polyphony of the current part
      part_poly[part]--;
      break;
    case MIDI_STATUS_NOTE_ON:
      if (part < 0)
      {
        // If no part is specified yet, we default to the first instrument, which
        // is piano (or the first drum kit if we are on the drum channel)
        int newInst;
        
        if (channel == 9)
          newInst = kFirstDrumkit + 1;    // the first drum kit is the "no drum" kit!
        else
          newInst = kFirstGMInstrument;
        part = channel_to_part[channel] = numParts;
        part_to_inst[numParts++] = newInst;
      }
      // TODO - add support for more than 32 parts using eXtended QTMA events
      assert(part<=31);
      
      // Decode pitch & velocity
      pitch = eventPos->data[0];
      velocity = eventPos->data[1];
      
      if (velocity == 0)
      {
        // was a NOTE OFF in disguise, so we decrement the polyphony
        part_poly[part]--;
      }
      else
      {
        // Keep track of the polyphony of the current part
        int foo = ++part_poly[part];
        if (part_poly_max[part] < foo)
          part_poly_max[part] = foo;

        // Now scan forward to find the matching NOTE OFF event
        midi_event *noteOffPos;
        for(noteOffPos = eventPos; noteOffPos; noteOffPos = noteOffPos->next)
        {
          if ((noteOffPos->status&0xF0)>>4 == MIDI_STATUS_NOTE_OFF
            && channel == (eventPos->status&0x0F)
            && pitch == noteOffPos->data[0])
            break;
          // NOTE ON with velocity == 0 is the same as a NOTE OFF
          if ((noteOffPos->status&0xF0)>>4 == MIDI_STATUS_NOTE_ON
            && channel == (eventPos->status&0x0F)
            && pitch == noteOffPos->data[0]
            && 0 == noteOffPos->data[1])
            break;
        }
        
        // Did we find a note off? Should always be the case, but who knows...
        if (noteOffPos)
        {
          // We found a NOTE OFF, now calculate the note duration
          int duration = (int)((noteOffPos->time - eventPos->time)*tick);
          
          REST_IF_NECESSARY();
          // Now we need to check if we get along with a normal Note Even, or if we need an extended one...
          if (duration < 2048 && pitch>=32 && pitch<=95 && velocity>=0 && velocity<=127)
          {
            qtma_StuffNoteEvent(*tunePos, part, pitch, velocity, duration);
            tunePos++;
          }
          else
          {
            qtma_StuffXNoteEvent(*tunePos, *(tunePos+1), part, pitch, velocity, duration);
            tunePos+=2;
          }
          
#if defined(DEBUG) && 0
          cout << std::setw(4) << numEventsHandled << ". ";
          cout << "NOTE ON duration " << std::setw(4) << duration << " ";
          cout << "Channel " << std::setw(2) << channel << " ";
          cout << "Part " << std::setw(2) << part << " ";
          cout << "Pitch " << std::setw(2) << pitch << " ";
          cout << "Velocity " << std::setw(2) << velocity << endl;
#endif
        }
      }
      break;
    case MIDI_STATUS_AFTERTOUCH:
      COUT("MIDI_STATUS_AFTERTOUCH");
      break;
    case MIDI_STATUS_CONTROLLER:
      controller = eventPos->data[0];
      value = eventPos->data[1];

      switch(controller)
      {
      case 0: // bank change - igore for now
        break;
      case kControllerVolume:
        if(channel_vol[channel] != value<<8)
        {
          channel_vol[channel] = value<<8;
          if(part>=0 && part<=31)
          {
            REST_IF_NECESSARY();
            qtma_StuffControlEvent(*tunePos, part, kControllerVolume, channel_vol[channel]);
            tunePos++;
          }
        }
        break;
      case kControllerPan:
        if(channel_pan[channel] != ((value << 1) + 256))
        {
          channel_pan[channel] = ((value << 1) + 256);
          if(part>=0 && part<=31)
          {
            REST_IF_NECESSARY();
            qtma_StuffControlEvent(*tunePos, part, kControllerPan, channel_pan[channel]);
            tunePos++;
          }
        }
        break;
      default:
        COUT("CONTROLLER not handled: "<< controller);
        break;
      }
      
      break;
    case MIDI_STATUS_PROG_CHANGE:
      // Instrument changed
      newInst = eventPos->data[0];
      // Channel 9 (the 10th channel) is different, it indicates a drum kit
      if (channel == 9)
        newInst += kFirstDrumkit;
      else
        newInst += kFirstGMInstrument;
      // Only if the instrument for this channel *really* changed, add a new part.
      if(newInst != part_to_inst[part])
      {
        // TODO maybe make use of kGeneralEventPartChange here,
        // to help QT reuse note channels?
        part = channel_to_part[channel] = numParts;
        part_to_inst[numParts++] = newInst;

        if(channel_vol[channel] >= 0)
        {
          REST_IF_NECESSARY();
          qtma_StuffControlEvent(*tunePos, part, kControllerVolume, channel_vol[channel]);
          tunePos++;
        }
        if(channel_pan[channel] >= 0)
        {
          REST_IF_NECESSARY();
          qtma_StuffControlEvent(*tunePos, part, kControllerPan, channel_pan[channel]);
          tunePos++;
        }
        if(channel_pitch_bend[channel] >= 0)
        {
          REST_IF_NECESSARY();
          qtma_StuffControlEvent(*tunePos, part, kControllerPitchBend, channel_pitch_bend[channel]);
          tunePos++;
        }     
      }
      break;
    case MIDI_STATUS_PRESSURE:
      COUT("MIDI_STATUS_PRESSURE");
      break;
    case MIDI_STATUS_PITCH_WHEEL:
      // In the midi spec, 0x2000 = center, 0x0000 = - 2 semitones, 0x3FFF = +2 semitones
      // but for QTMA, we specify it as a 8.8 fixed point of semitones
      // TODO: detect "pitch bend range changes"
      bend = eventPos->data[0] & 0x7f | (eventPos->data[1] & 0x7f) << 7;
      
      // "Center" the bend
      bend -= 0x2000;
      
      // Move it to our format:
      bend <<= 4;
      
      // If it turns out the pitch bend didn't change, stop here
      if(channel_pitch_bend[channel] == bend)
        break;
      
      channel_pitch_bend[channel] = bend;
      if(part>=0 && part<=31)
      {
        // Stuff a control event
        REST_IF_NECESSARY();
        qtma_StuffControlEvent(*tunePos, part, kControllerPitchBend, bend);
        tunePos++;
      }     
      break;
    case MIDI_STATUS_SYSEX:
      if (eventPos->status == 0xFF && eventPos->data[0] == 0x51) // Tempo change
      {
        tempo = (eventPos->buffer[0] << 16) +
          (eventPos->buffer[1] << 8) +
          eventPos->buffer[2];
        
        tick = tempo * Ippqn;
      }
      break;
    }
    
    // on to the next event
    eventPos = eventPos->next;
  } 
  
  // Finally, place an end marker
  *tunePos = kEndMarkerValue;
  
  return tuneSequence;
}


uint32 *BuildTuneHeader(int part_poly_max[32], int part_to_inst[32], int numParts)
{
  uint32      *myHeader;
  uint32      *myPos1, *myPos2;   // pointers to the head and tail long words of a music event
  NoteRequest   *myNoteRequest;
  NoteAllocator myNoteAllocator;    // for the NAStuffToneDescription call
  ComponentResult myErr = noErr;

  myHeader = NULL;
  myNoteAllocator = NULL;

  /*
   * Open up the Note Allocator
   */
  myNoteAllocator = OpenDefaultComponent(kNoteAllocatorComponentType,0);
  if (myNoteAllocator == NULL)
    goto bail;
  
  /*
   * Allocate space for the tune header
   */
  myHeader = (uint32 *)
      NewPtrClear((numParts * kNoteRequestEventLength + kMarkerEventLength) * sizeof(uint32));
  if (myHeader == NULL)
    goto bail;
  
  myPos1 = myHeader;
  
  /*
   * Loop over all parts
   */
  for(int part = 0; part < numParts; ++part)
  {
    /*
     * Stuff request for the instrument with the given polyphony
     */
    myPos2 = myPos1 + (kNoteRequestEventLength - 1); // last longword of general event
    qtma_StuffGeneralEvent(*myPos1, *myPos2, part, kGeneralEventNoteRequest, kNoteRequestEventLength);
    myNoteRequest = (NoteRequest *)(myPos1 + 1);
    myNoteRequest->info.flags = 0;
#if defined(MACOS) || defined(MACOSX)
    myNoteRequest->info.polyphony.bigEndianValue = EndianS32_LtoB(part_poly_max[part]);
    myNoteRequest->info.typicalPolyphony.bigEndianValue = EndianS32_LtoB(0x00010000);
#else
    myNoteRequest->info.polyphony = part_poly_max[part];
    myNoteRequest->info.typicalPolyphony = 0x00010000;
#endif
    myErr = NAStuffToneDescription(myNoteAllocator,part_to_inst[part],&myNoteRequest->tone);
    if (myErr != noErr)
      goto bail;
    
    // move pointer to beginning of next event
    myPos1 += kNoteRequestEventLength;
  }

  *myPos1 = kEndMarkerValue;    /* end of sequence marker */


bail:
  if(myNoteAllocator)
    CloseComponent(myNoteAllocator);

  // if we encountered an error, dispose of the storage we allocated and return NULL
  if (myErr != noErr) {
    DisposePtr((Ptr)myHeader);
    myHeader = NULL;
  }

  return myHeader;
}

#endif

---