MIDI.h

Go to the documentation of this file.

 
#ifndef __MIDI__
#define __MIDI__
 
#ifndef __MACERRORS__
#include <MacErrors.h>
#endif
 
#ifndef __MACTYPES__
#include <MacTypes.h>
#endif
 
#ifndef __MIXEDMODE__
#include <MixedMode.h>
#endif
 
#if PRAGMA_ONCE
#pragma once
#endif
 
#ifdef __cplusplus
extern "C"
{
#endif
 
#if PRAGMA_IMPORT
#pragma import on
#endif
 
#if PRAGMA_STRUCT_ALIGN
#pragma options align = mac68k
#elif PRAGMA_STRUCT_PACKPUSH
#pragma pack(push, 2)
#elif PRAGMA_STRUCT_PACK
#pragma pack(2)
#endif
 
  enum
  {
    midiMaxNameLen = 31 
  };
 
  enum
  {
    midiFormatMSec = 0,      
    midiFormatBeats = 1,     
    midiFormat24fpsBit = 2,  
    midiFormat25fpsBit = 3,  
    midiFormat30fpsDBit = 4, 
    midiFormat30fpsBit = 5,  
    midiFormat24fpsQF = 6,   
    midiFormat25fpsQF = 7,   
    midiFormat30fpsDQF = 8,  
    midiFormat30fpsQF = 9    
  };
 
  enum
  {
    midiInternalSync = 0, 
    midiExternalSync = 1  
  };
 
  enum
  {
    midiPortTypeTime = 0,    
    midiPortTypeInput = 1,   
    midiPortTypeOutput = 2,  
    midiPortTypeTimeInv = 3, 
    midiPortInvisible =
        0x8000,               
    midiPortTypeMask = 0x0007 
  };
 
  enum
  {
    midiGetEverything =
        0x7FFFFFFF, 
    midiGetNothing =
        (long)0x80000000,       
    midiGetCurrent = 0x00000000 
  };
 
  enum
  {
    midiContMask = 0x03,
    midiNoCont = 0x00,
    midiStartCont = 0x01,
    midiMidCont = 0x03,
    midiEndCont = 0x02,
    midiTypeMask = 0x70,
    midiMsgType = 0x00,
    midiMgrType = 0x10,
    midiTimeStampMask = 0x80,
    midiTimeStampCurrent = 0x80,
    midiTimeStampValid = 0x00
  };
 
  enum
  {
    midiOverflowErr = 0x0001,
    midiSCCErr = 0x0002,
    midiPacketErr =
        0x0003, 
    midiMaxErr = 0x00FF
  };
 
  enum
  {
    midiKeepPacket = 0,
    midiMorePacket = 1,
    midiNoMorePacket = 2,
    midiHoldPacket = 3
  };
 
  enum
  {
    midiOpenDriver = 1,
    midiCloseDriver = 2
  };
 
  enum
  {
    mdvrAbortNotesOff = 0, 
    mdvrChanNotesOff = 1,  
    mdvrAllNotesOff = 2    
  };
 
  enum
  {
    mdvrStopOut = 0, 
    mdvrStartOut = 1 
  };
 
  struct MIDIPacket
  {
    UInt8 flags;
    UInt8 len;
    long tStamp;
    UInt8 data[249];
  };
  typedef struct MIDIPacket MIDIPacket;
  typedef MIDIPacket *MIDIPacketPtr;
  typedef CALLBACK_API(short, MIDIReadHookProcPtr)(MIDIPacketPtr myPacket,
                                                   long myRefCon);
  typedef CALLBACK_API(void, MIDITimeProcPtr)(long curTime, long myRefCon);
  typedef CALLBACK_API(void,
                       MIDIConnectionProcPtr)(short refnum, long refcon,
                                              short portType, OSType clientID,
                                              OSType portID, Boolean connect,
                                              short direction);
  typedef CALLBACK_API(long, MDVRCommProcPtr)(short refnum, short request,
                                              long refCon);
  typedef CALLBACK_API(void, MDVRTimeCodeProcPtr)(short refnum, short newFormat,
                                                  long refCon);
  typedef CALLBACK_API(void, MDVRReadProcPtr)(char *midiChars, short length,
                                              long refCon);
  typedef STACK_UPP_TYPE(MIDIReadHookProcPtr) MIDIReadHookUPP;
  typedef STACK_UPP_TYPE(MIDITimeProcPtr) MIDITimeUPP;
  typedef STACK_UPP_TYPE(MIDIConnectionProcPtr) MIDIConnectionUPP;
  typedef STACK_UPP_TYPE(MDVRCommProcPtr) MDVRCommUPP;
  typedef STACK_UPP_TYPE(MDVRTimeCodeProcPtr) MDVRTimeCodeUPP;
  typedef STACK_UPP_TYPE(MDVRReadProcPtr) MDVRReadUPP;
  struct MIDIClkInfo
  {
    short syncType; 
    long curTime;   
    short format;   
  };
  typedef struct MIDIClkInfo MIDIClkInfo;
  struct MIDIIDRec
  {
    OSType clientID;
    OSType portID;
  };
  typedef struct MIDIIDRec MIDIIDRec;
  struct MIDIPortInfo
  {
    short portType;     
    MIDIIDRec timeBase; 
    short numConnects;  
    MIDIIDRec cList[1]; 
  };
  typedef struct MIDIPortInfo MIDIPortInfo;
  typedef MIDIPortInfo *MIDIPortInfoPtr;
  typedef MIDIPortInfoPtr *MIDIPortInfoHdl;
  typedef MIDIPortInfoPtr *MIDIPortInfoHandle;
  struct MIDIPortParams
  {
    OSType portID;            
    short portType;           
    short timeBase;           
    long offsetTime;          
    MIDIReadHookUPP readHook; 
    long refCon;              
    MIDIClkInfo initClock;    
    Str255 name;              
  };
  typedef struct MIDIPortParams MIDIPortParams;
  typedef MIDIPortParams *MIDIPortParamsPtr;
  struct MIDIIDList
  {
    short numIDs;
    OSType list[1];
  };
  typedef struct MIDIIDList MIDIIDList;
  typedef MIDIIDList *MIDIIDListPtr;
  typedef MIDIIDListPtr *MIDIIDListHdl;
  typedef MIDIIDListPtr *MIDIIDListHandle;
  struct MDVRInCtlRec
  {
    short timeCodeClock;  
    short timeCodeFormat; 
    MDVRReadUPP readProc; 
    MDVRCommUPP commProc; 
    long refCon;          
  };
  typedef struct MDVRInCtlRec MDVRInCtlRec;
  typedef MDVRInCtlRec *MDVRInCtlPtr;
  struct MDVROutCtlRec
  {
    short timeCodeClock;          
    short timeCodeFormat;         
    MDVRTimeCodeUPP timeCodeProc; 
    MDVRCommUPP commProc;         
    long refCon;                  
    Boolean timeCodeFilter;       
    UInt8 padding;                
    long midiMsgTicks;            
    long timeCodeTicks;           
  };
  typedef struct MDVROutCtlRec MDVROutCtlRec;
  typedef MDVROutCtlRec *MDVROutCtlPtr;
  typedef void *MDVRPtr;
#if CALL_NOT_IN_CARBON
  NumVersion
  MIDIVersion(void);
 
  OSErr
  MIDISignIn(OSType clientID, long refCon, Handle icon, ConstStr255Param name);
 
  void
  MIDISignOut(OSType clientID);
 
  MIDIIDListHandle
  MIDIGetClients(void);
 
  void
  MIDIGetClientName(OSType clientID, Str255 name);
 
  void
  MIDISetClientName(OSType clientID, ConstStr255Param name);
 
  MIDIIDListHandle
  MIDIGetPorts(OSType clientID);
 
  OSErr
  MIDIAddPort(OSType clientID, short BufSize, short *refnum,
              MIDIPortParamsPtr init);
 
  MIDIPortInfoHandle
  MIDIGetPortInfo(OSType clientID, OSType portID);
 
  OSErr
  MIDIConnectData(OSType srcClID, OSType srcPortID, OSType dstClID,
                  OSType dstPortID);
 
  OSErr
  MIDIUnConnectData(OSType srcClID, OSType srcPortID, OSType dstClID,
                    OSType dstPortID);
 
  OSErr
  MIDIConnectTime(OSType srcClID, OSType srcPortID, OSType dstClID,
                  OSType dstPortID);
 
  OSErr
  MIDIUnConnectTime(OSType srcClID, OSType srcPortID, OSType dstClID,
                    OSType dstPortID);
 
  void
  MIDIFlush(short refnum);
 
  ProcPtr
  MIDIGetReadHook(short refnum);
 
  void
  MIDISetReadHook(short refnum, ProcPtr hook);
 
  void
  MIDIGetPortName(OSType clientID, OSType portID, Str255 name);
 
  void
  MIDISetPortName(OSType clientID, OSType portID, ConstStr255Param name);
 
  void
  MIDIWakeUp(short refnum, long time, long period, MIDITimeUPP timeProc);
 
  void
  MIDIRemovePort(short refnum);
 
  short
  MIDIGetSync(short refnum);
 
  void
  MIDISetSync(short refnum, short sync);
 
  long
  MIDIGetCurTime(short refnum);
 
  void
  MIDISetCurTime(short refnum, long time);
 
  void
  MIDIStartTime(short refnum);
 
  void
  MIDIStopTime(short refnum);
 
  void
  MIDIPoll(short refnum, long offsetTime);
 
  OSErr
  MIDIWritePacket(short refnum, MIDIPacketPtr packet);
 
  Boolean
  MIDIWorldChanged(OSType clientID);
 
  long
  MIDIGetOffsetTime(short refnum);
 
  void
  MIDISetOffsetTime(short refnum, long offsetTime);
 
  long
  MIDIConvertTime(short srcFormat, short dstFormat, long time);
 
  long
  MIDIGetRefCon(short refnum);
 
  void
  MIDISetRefCon(short refnum, long refCon);
 
  long
  MIDIGetClRefCon(OSType clientID);
 
  void
  MIDISetClRefCon(OSType clientID, long refCon);
 
  short
  MIDIGetTCFormat(short refnum);
 
  void
  MIDISetTCFormat(short refnum, short format);
 
  void
  MIDISetRunRate(short refnum, short rate, long time);
 
  Handle
  MIDIGetClientIcon(OSType clientID);
 
  ProcPtr
  MIDICallAddress(short callNum);
 
  void
  MIDISetConnectionProc(short refNum, ProcPtr connectionProc, long refCon);
 
  void
  MIDIGetConnectionProc(short refnum, ProcPtr *connectionProc, long *refCon);
 
  void
  MIDIDiscardPacket(short refnum, MIDIPacketPtr packet);
 
  OSErr
  MDVRSignIn(OSType clientID, long refCon, Handle icon, Str255 name);
 
  void
  MDVRSignOut(OSType clientID);
 
  MDVRPtr
  MDVROpen(short portType, short refnum);
 
  void
  MDVRClose(MDVRPtr driverPtr);
 
  void
  MDVRControlIn(MDVRPtr portPtr, MDVRInCtlPtr inputCtl);
 
  void
  MDVRControlOut(MDVRPtr portPtr, MDVROutCtlPtr outputCtl);
 
  void
  MDVRIn(MDVRPtr portPtr);
 
  void
  MDVROut(MDVRPtr portPtr, char *dataPtr, short length);
 
  void
  MDVRNotesOff(MDVRPtr portPtr, short mode);
 
#endif 
#if CALL_NOT_IN_CARBON
  MIDIReadHookUPP
  NewMIDIReadHookUPP(MIDIReadHookProcPtr userRoutine);
#if !OPAQUE_UPP_TYPES
  enum
  {
    uppMIDIReadHookProcInfo = 0x000003E0
  }; 
#ifdef __cplusplus
  inline MIDIReadHookUPP NewMIDIReadHookUPP(MIDIReadHookProcPtr userRoutine)
  {
    return (MIDIReadHookUPP)NewRoutineDescriptor((ProcPtr)(userRoutine),
                                                 uppMIDIReadHookProcInfo,
                                                 GetCurrentArchitecture());
  }
#else
#define NewMIDIReadHookUPP(userRoutine)                                     \
  (MIDIReadHookUPP)                                                         \
      NewRoutineDescriptor((ProcPtr)(userRoutine), uppMIDIReadHookProcInfo, \
                           GetCurrentArchitecture())
#endif
#endif
 
  MIDITimeUPP
  NewMIDITimeUPP(MIDITimeProcPtr userRoutine);
#if !OPAQUE_UPP_TYPES
  enum
  {
    uppMIDITimeProcInfo = 0x000003C0
  }; 
#ifdef __cplusplus
  inline MIDITimeUPP NewMIDITimeUPP(MIDITimeProcPtr userRoutine)
  {
    return (MIDITimeUPP)NewRoutineDescriptor(
        (ProcPtr)(userRoutine), uppMIDITimeProcInfo, GetCurrentArchitecture());
  }
#else
#define NewMIDITimeUPP(userRoutine)   \
  (MIDITimeUPP) NewRoutineDescriptor( \
      (ProcPtr)(userRoutine), uppMIDITimeProcInfo, GetCurrentArchitecture())
#endif
#endif
 
  MIDIConnectionUPP
  NewMIDIConnectionUPP(MIDIConnectionProcPtr userRoutine);
#if !OPAQUE_UPP_TYPES
  enum
  {
    uppMIDIConnectionProcInfo = 0x0009FB80
  }; 
#ifdef __cplusplus
  inline MIDIConnectionUPP
  NewMIDIConnectionUPP(MIDIConnectionProcPtr userRoutine)
  {
    return (MIDIConnectionUPP)NewRoutineDescriptor((ProcPtr)(userRoutine),
                                                   uppMIDIConnectionProcInfo,
                                                   GetCurrentArchitecture());
  }
#else
#define NewMIDIConnectionUPP(userRoutine)                                     \
  (MIDIConnectionUPP)                                                         \
      NewRoutineDescriptor((ProcPtr)(userRoutine), uppMIDIConnectionProcInfo, \
                           GetCurrentArchitecture())
#endif
#endif
 
  MDVRCommUPP
  NewMDVRCommUPP(MDVRCommProcPtr userRoutine);
#if !OPAQUE_UPP_TYPES
  enum
  {
    uppMDVRCommProcInfo = 0x00000EB0
  }; 
#ifdef __cplusplus
  inline MDVRCommUPP NewMDVRCommUPP(MDVRCommProcPtr userRoutine)
  {
    return (MDVRCommUPP)NewRoutineDescriptor(
        (ProcPtr)(userRoutine), uppMDVRCommProcInfo, GetCurrentArchitecture());
  }
#else
#define NewMDVRCommUPP(userRoutine)   \
  (MDVRCommUPP) NewRoutineDescriptor( \
      (ProcPtr)(userRoutine), uppMDVRCommProcInfo, GetCurrentArchitecture())
#endif
#endif
 
  MDVRTimeCodeUPP
  NewMDVRTimeCodeUPP(MDVRTimeCodeProcPtr userRoutine);
#if !OPAQUE_UPP_TYPES
  enum
  {
    uppMDVRTimeCodeProcInfo = 0x00000E80
  }; 
#ifdef __cplusplus
  inline MDVRTimeCodeUPP NewMDVRTimeCodeUPP(MDVRTimeCodeProcPtr userRoutine)
  {
    return (MDVRTimeCodeUPP)NewRoutineDescriptor((ProcPtr)(userRoutine),
                                                 uppMDVRTimeCodeProcInfo,
                                                 GetCurrentArchitecture());
  }
#else
#define NewMDVRTimeCodeUPP(userRoutine)                                     \
  (MDVRTimeCodeUPP)                                                         \
      NewRoutineDescriptor((ProcPtr)(userRoutine), uppMDVRTimeCodeProcInfo, \
                           GetCurrentArchitecture())
#endif
#endif
 
  MDVRReadUPP
  NewMDVRReadUPP(MDVRReadProcPtr userRoutine);
#if !OPAQUE_UPP_TYPES
  enum
  {
    uppMDVRReadProcInfo = 0x00000EC0
  }; 
#ifdef __cplusplus
  inline MDVRReadUPP NewMDVRReadUPP(MDVRReadProcPtr userRoutine)
  {
    return (MDVRReadUPP)NewRoutineDescriptor(
        (ProcPtr)(userRoutine), uppMDVRReadProcInfo, GetCurrentArchitecture());
  }
#else
#define NewMDVRReadUPP(userRoutine)   \
  (MDVRReadUPP) NewRoutineDescriptor( \
      (ProcPtr)(userRoutine), uppMDVRReadProcInfo, GetCurrentArchitecture())
#endif
#endif
 
  void
  DisposeMIDIReadHookUPP(MIDIReadHookUPP userUPP);
#if !OPAQUE_UPP_TYPES
#ifdef __cplusplus
  inline void DisposeMIDIReadHookUPP(MIDIReadHookUPP userUPP)
  {
    DisposeRoutineDescriptor((UniversalProcPtr)userUPP);
  }
#else
#define DisposeMIDIReadHookUPP(userUPP) DisposeRoutineDescriptor(userUPP)
#endif
#endif
 
  void
  DisposeMIDITimeUPP(MIDITimeUPP userUPP);
#if !OPAQUE_UPP_TYPES
#ifdef __cplusplus
  inline void DisposeMIDITimeUPP(MIDITimeUPP userUPP)
  {
    DisposeRoutineDescriptor((UniversalProcPtr)userUPP);
  }
#else
#define DisposeMIDITimeUPP(userUPP) DisposeRoutineDescriptor(userUPP)
#endif
#endif
 
  void
  DisposeMIDIConnectionUPP(MIDIConnectionUPP userUPP);
#if !OPAQUE_UPP_TYPES
#ifdef __cplusplus
  inline void DisposeMIDIConnectionUPP(MIDIConnectionUPP userUPP)
  {
    DisposeRoutineDescriptor((UniversalProcPtr)userUPP);
  }
#else
#define DisposeMIDIConnectionUPP(userUPP) DisposeRoutineDescriptor(userUPP)
#endif
#endif
 
  void
  DisposeMDVRCommUPP(MDVRCommUPP userUPP);
#if !OPAQUE_UPP_TYPES
#ifdef __cplusplus
  inline void DisposeMDVRCommUPP(MDVRCommUPP userUPP)
  {
    DisposeRoutineDescriptor((UniversalProcPtr)userUPP);
  }
#else
#define DisposeMDVRCommUPP(userUPP) DisposeRoutineDescriptor(userUPP)
#endif
#endif
 
  void
  DisposeMDVRTimeCodeUPP(MDVRTimeCodeUPP userUPP);
#if !OPAQUE_UPP_TYPES
#ifdef __cplusplus
  inline void DisposeMDVRTimeCodeUPP(MDVRTimeCodeUPP userUPP)
  {
    DisposeRoutineDescriptor((UniversalProcPtr)userUPP);
  }
#else
#define DisposeMDVRTimeCodeUPP(userUPP) DisposeRoutineDescriptor(userUPP)
#endif
#endif
 
  void
  DisposeMDVRReadUPP(MDVRReadUPP userUPP);
#if !OPAQUE_UPP_TYPES
#ifdef __cplusplus
  inline void DisposeMDVRReadUPP(MDVRReadUPP userUPP)
  {
    DisposeRoutineDescriptor((UniversalProcPtr)userUPP);
  }
#else
#define DisposeMDVRReadUPP(userUPP) DisposeRoutineDescriptor(userUPP)
#endif
#endif
 
  short
  InvokeMIDIReadHookUPP(MIDIPacketPtr myPacket, long myRefCon,
                        MIDIReadHookUPP userUPP);
#if !OPAQUE_UPP_TYPES
#ifdef __cplusplus
  inline short InvokeMIDIReadHookUPP(MIDIPacketPtr myPacket, long myRefCon,
                                     MIDIReadHookUPP userUPP)
  {
    return (short)CALL_TWO_PARAMETER_UPP(userUPP, uppMIDIReadHookProcInfo,
                                         myPacket, myRefCon);
  }
#else
#define InvokeMIDIReadHookUPP(myPacket, myRefCon, userUPP)          \
  (short)CALL_TWO_PARAMETER_UPP((userUPP), uppMIDIReadHookProcInfo, \
                                (myPacket), (myRefCon))
#endif
#endif
 
  void
  InvokeMIDITimeUPP(long curTime, long myRefCon, MIDITimeUPP userUPP);
#if !OPAQUE_UPP_TYPES
#ifdef __cplusplus
  inline void InvokeMIDITimeUPP(long curTime, long myRefCon,
                                MIDITimeUPP userUPP)
  {
    CALL_TWO_PARAMETER_UPP(userUPP, uppMIDITimeProcInfo, curTime, myRefCon);
  }
#else
#define InvokeMIDITimeUPP(curTime, myRefCon, userUPP) \
  CALL_TWO_PARAMETER_UPP((userUPP), uppMIDITimeProcInfo, (curTime), (myRefCon))
#endif
#endif
 
  void
  InvokeMIDIConnectionUPP(short refnum, long refcon, short portType,
                          OSType clientID, OSType portID, Boolean connect,
                          short direction, MIDIConnectionUPP userUPP);
#if !OPAQUE_UPP_TYPES
#ifdef __cplusplus
  inline void InvokeMIDIConnectionUPP(short refnum, long refcon, short portType,
                                      OSType clientID, OSType portID,
                                      Boolean connect, short direction,
                                      MIDIConnectionUPP userUPP)
  {
    CALL_SEVEN_PARAMETER_UPP(userUPP, uppMIDIConnectionProcInfo, refnum, refcon,
                             portType, clientID, portID, connect, direction);
  }
#else
#define InvokeMIDIConnectionUPP(refnum, refcon, portType, clientID, portID, \
                                connect, direction, userUPP)                \
  CALL_SEVEN_PARAMETER_UPP((userUPP), uppMIDIConnectionProcInfo, (refnum),  \
                           (refcon), (portType), (clientID), (portID),      \
                           (connect), (direction))
#endif
#endif
 
  long
  InvokeMDVRCommUPP(short refnum, short request, long refCon,
                    MDVRCommUPP userUPP);
#if !OPAQUE_UPP_TYPES
#ifdef __cplusplus
  inline long InvokeMDVRCommUPP(short refnum, short request, long refCon,
                                MDVRCommUPP userUPP)
  {
    return (long)CALL_THREE_PARAMETER_UPP(userUPP, uppMDVRCommProcInfo, refnum,
                                          request, refCon);
  }
#else
#define InvokeMDVRCommUPP(refnum, request, refCon, userUPP)                \
  (long)CALL_THREE_PARAMETER_UPP((userUPP), uppMDVRCommProcInfo, (refnum), \
                                 (request), (refCon))
#endif
#endif
 
  void
  InvokeMDVRTimeCodeUPP(short refnum, short newFormat, long refCon,
                        MDVRTimeCodeUPP userUPP);
#if !OPAQUE_UPP_TYPES
#ifdef __cplusplus
  inline void InvokeMDVRTimeCodeUPP(short refnum, short newFormat, long refCon,
                                    MDVRTimeCodeUPP userUPP)
  {
    CALL_THREE_PARAMETER_UPP(userUPP, uppMDVRTimeCodeProcInfo, refnum, newFormat,
                             refCon);
  }
#else
#define InvokeMDVRTimeCodeUPP(refnum, newFormat, refCon, userUPP)        \
  CALL_THREE_PARAMETER_UPP((userUPP), uppMDVRTimeCodeProcInfo, (refnum), \
                           (newFormat), (refCon))
#endif
#endif
 
  void
  InvokeMDVRReadUPP(char *midiChars, short length, long refCon,
                    MDVRReadUPP userUPP);
#if !OPAQUE_UPP_TYPES
#ifdef __cplusplus
  inline void InvokeMDVRReadUPP(char *midiChars, short length, long refCon,
                                MDVRReadUPP userUPP)
  {
    CALL_THREE_PARAMETER_UPP(userUPP, uppMDVRReadProcInfo, midiChars, length,
                             refCon);
  }
#else
#define InvokeMDVRReadUPP(midiChars, length, refCon, userUPP)           \
  CALL_THREE_PARAMETER_UPP((userUPP), uppMDVRReadProcInfo, (midiChars), \
                           (length), (refCon))
#endif
#endif
 
#endif 
#if CALL_NOT_IN_CARBON || OLDROUTINENAMES
#define NewMIDIReadHookProc(userRoutine) NewMIDIReadHookUPP(userRoutine)
#define NewMIDITimeProc(userRoutine) NewMIDITimeUPP(userRoutine)
#define NewMIDIConnectionProc(userRoutine) NewMIDIConnectionUPP(userRoutine)
#define NewMDVRCommProc(userRoutine) NewMDVRCommUPP(userRoutine)
#define NewMDVRTimeCodeProc(userRoutine) NewMDVRTimeCodeUPP(userRoutine)
#define NewMDVRReadProc(userRoutine) NewMDVRReadUPP(userRoutine)
#define CallMIDIReadHookProc(userRoutine, myPacket, myRefCon) \
  InvokeMIDIReadHookUPP(myPacket, myRefCon, userRoutine)
#define CallMIDITimeProc(userRoutine, curTime, myRefCon) \
  InvokeMIDITimeUPP(curTime, myRefCon, userRoutine)
#define CallMIDIConnectionProc(userRoutine, refnum, refcon, portType,          \
                               clientID, portID, connect, direction)           \
  InvokeMIDIConnectionUPP(refnum, refcon, portType, clientID, portID, connect, \
                          direction, userRoutine)
#define CallMDVRCommProc(userRoutine, refnum, request, refCon) \
  InvokeMDVRCommUPP(refnum, request, refCon, userRoutine)
#define CallMDVRTimeCodeProc(userRoutine, refnum, newFormat, refCon) \
  InvokeMDVRTimeCodeUPP(refnum, newFormat, refCon, userRoutine)
#define CallMDVRReadProc(userRoutine, midiChars, length, refCon) \
  InvokeMDVRReadUPP(midiChars, length, refCon, userRoutine)
#endif 
#if PRAGMA_STRUCT_ALIGN
#pragma options align = reset
#elif PRAGMA_STRUCT_PACKPUSH
#pragma pack(pop)
#elif PRAGMA_STRUCT_PACK
#pragma pack()
#endif
 
#ifdef PRAGMA_IMPORT_OFF
#pragma import off
#elif PRAGMA_IMPORT
#pragma import reset
#endif
 
#ifdef __cplusplus
}
#endif
 
#endif