home *** CD-ROM | disk | FTP | other *** search
/ QuickTime 2.0 Developer Kit / QuickTime 2.0 Developer Kit.iso / mac / MAC / Programming Stuff / Interfaces / PInterfaces / MIDI.p < prev    next >
Encoding:
Text File  |  1994-11-11  |  11.5 KB  |  371 lines  |  [TEXT/MPS ]
  1. {
  2.      File:        MIDI.p
  3.  
  4.      Copyright:    © 1984-1994 by Apple Computer, Inc.
  5.                  All rights reserved.
  6.  
  7.      Version:    Universal Interfaces 2.0a3  ETO #16, MPW prerelease.  Friday, November 11, 1994. 
  8.  
  9.      Bugs?:        If you find a problem with this file, send the file and version
  10.                  information (from above) and the problem description to:
  11.  
  12.                      Internet:    apple.bugs@applelink.apple.com
  13.                      AppleLink:    APPLE.BUGS
  14.  
  15. }
  16.  
  17. {$IFC UNDEFINED UsingIncludes}
  18. {$SETC UsingIncludes := 0}
  19. {$ENDC}
  20.  
  21. {$IFC NOT UsingIncludes}
  22.  UNIT MIDI;
  23.  INTERFACE
  24. {$ENDC}
  25.  
  26. {$IFC UNDEFINED __MIDI__}
  27. {$SETC __MIDI__ := 1}
  28.  
  29. {$I+}
  30. {$SETC MIDIIncludes := UsingIncludes}
  31. {$SETC UsingIncludes := 1}
  32.  
  33.  
  34. {$IFC UNDEFINED __ERRORS__}
  35. {$I Errors.p}
  36. {$ENDC}
  37. {    ConditionalMacros.p                                            }
  38.  
  39. {$IFC UNDEFINED __TYPES__}
  40. {$I Types.p}
  41. {$ENDC}
  42.  
  43. {$IFC UNDEFINED __MIXEDMODE__}
  44. {$I MixedMode.p}
  45. {$ENDC}
  46.  
  47. {$PUSH}
  48. {$ALIGN MAC68K}
  49. {$LibExport+}
  50.  
  51. CONST
  52.     midiToolNum                    = 4;                            {tool number of MIDI Manager for SndDispVersion call}
  53.     midiMaxNameLen                = 31;                            {maximum number of characters in port and client names}
  54. { Time formats }
  55.     midiFormatMSec                = 0;                            {milliseconds}
  56.     midiFormatBeats                = 1;                            {beats}
  57.     midiFormat24fpsBit            = 2;                            {24 frames/sec.}
  58.     midiFormat25fpsBit            = 3;                            {25 frames/sec.}
  59.     midiFormat30fpsDBit            = 4;                            {30 frames/sec. drop-frame}
  60.     midiFormat30fpsBit            = 5;                            {30 frames/sec.}
  61.     midiFormat24fpsQF            = 6;                            {24 frames/sec. longInt format }
  62.     midiFormat25fpsQF            = 7;                            {25 frames/sec. longInt format }
  63.     midiFormat30fpsDQF            = 8;                            {30 frames/sec. drop-frame longInt format }
  64.     midiFormat30fpsQF            = 9;                            {30 frames/sec. longInt format }
  65.     midiInternalSync            = 0;                            {internal sync}
  66.     midiExternalSync            = 1;                            {external sync}
  67. { Port types}
  68.     midiPortTypeTime            = 0;                            {time port}
  69.     midiPortTypeInput            = 1;                            {input port}
  70.     midiPortTypeOutput            = 2;                            {output port}
  71.     midiPortTypeTimeInv            = 3;                            {invisible time port}
  72. { OffsetTimes  }
  73.     midiGetEverything            = $7FFFFFFF;                    {get all packets, regardless of time stamps}
  74.     midiGetNothing                = $80000000;                    {get no packets, regardless of time stamps}
  75.     midiGetCurrent                = $00000000;                    {get current packets only}
  76.  
  77. {    MIDI data and messages are passed in MIDIPacket records (see below).
  78.     The first byte of every MIDIPacket contains a set of flags
  79.  
  80.     bits 0-1    00 = new MIDIPacket, not continued
  81.                      01 = begining of continued MIDIPacket
  82.                      10 = end of continued MIDIPacket
  83.                      11 = continuation
  84.     bits 2-3     reserved
  85.  
  86.     bits 4-6      000 = packet contains MIDI data
  87.  
  88.                   001 = packet contains MIDI Manager message
  89.  
  90.     bit 7         0 = MIDIPacket has valid stamp
  91.                   1 = stamp with current clock
  92. }
  93.     midiContMask                = $03;
  94.     midiNoCont                    = $00;
  95.     midiStartCont                = $01;
  96.     midiMidCont                    = $03;
  97.     midiEndCont                    = $02;
  98.     midiTypeMask                = $70;
  99.     midiMsgType                    = $00;
  100.     midiMgrType                    = $10;
  101.     midiTimeStampMask            = $80;
  102.     midiTimeStampCurrent        = $80;
  103.     midiTimeStampValid            = $00;
  104. { MIDIPacket command words (the first word in the data field for midiMgrType messages) }
  105.     midiOverflowErr                = $0001;
  106.     midiSCCErr                    = $0002;
  107.     midiPacketErr                = $0003;
  108. {all command words less than this value are error indicators}
  109.     midiMaxErr                    = $00FF;
  110. { Valid results to be returned by readHooks }
  111.     midiKeepPacket                = 0;
  112.     midiMorePacket                = 1;
  113.     midiNoMorePacket            = 2;
  114. { Driver calls }
  115.     midiOpenDriver                = 1;
  116.     midiCloseDriver                = 2;
  117.  
  118.  
  119. TYPE
  120.     MIDIPacket = PACKED RECORD
  121.         flags:                    UInt8;
  122.         len:                    UInt8;
  123.         tStamp:                    LONGINT;
  124.         data:                    ARRAY [0..248] OF UInt8;
  125.     END;
  126.     MIDIPacketPtr = ^MIDIPacket;
  127.  
  128.     MIDIReadHookProcPtr = ProcPtr;  { FUNCTION MIDIReadHook(myPacket: MIDIPacketPtr; myRefCon: LONGINT): INTEGER; }
  129.     MIDITimeProcPtr = ProcPtr;  { PROCEDURE MIDITime(curTime: LONGINT; myRefCon: LONGINT); }
  130.     MIDIReadHookUPP = UniversalProcPtr;
  131.     MIDITimeUPP = UniversalProcPtr;
  132.  
  133.     MIDIClkInfo = RECORD
  134.         syncType:                INTEGER;                                {synchronization external/internal}
  135.         curTime:                LONGINT;                                {current value of port's clock}
  136.         format:                    INTEGER;                                {time code format}
  137.     END;
  138.     MIDIIDRec = RECORD
  139.         clientID:                OSType;
  140.         portID:                    OSType;
  141.     END;
  142.     MIDIPortInfo = RECORD
  143.         portType:                INTEGER;                                {type of port}
  144.         timeBase:                MIDIIDRec;                                {MIDIIDRec for time base}
  145.         numConnects:            INTEGER;                                {number of connections}
  146.         cList:                    ARRAY [0..0] OF MIDIIDRec;                {ARRAY [1..numConnects] of MIDIIDRec}
  147.     END;
  148.     MIDIPortInfoPtr = ^MIDIPortInfo;
  149.     MIDIPortInfoHdl = ^MIDIPortInfoPtr;
  150.     MIDIPortInfoHandle = ^MIDIPortInfoPtr;
  151.  
  152.     MIDIPortParams = RECORD
  153.         portID:                    OSType;                                    {ID of port, unique within client}
  154.         portType:                INTEGER;                                {Type of port - input, output, time, etc.}
  155.         timeBase:                INTEGER;                                {refnum of time base, 0 if none}
  156.         offsetTime:                LONGINT;                                {offset for current time stamps}
  157.         readHook:                MIDIReadHookUPP;                        {routine to call when input data is valid}
  158.         refCon:                    LONGINT;                                {refcon for port (for client use)}
  159.         initClock:                MIDIClkInfo;                            {initial settings for a time base}
  160.         name:                    Str255;                                    {name of the port, This is a real live string, not a ptr.}
  161.     END;
  162.     MIDIPortParamsPtr = ^MIDIPortParams;
  163.  
  164.     MIDIIDList = RECORD
  165.         numIDs:                    INTEGER;
  166.         list:                    ARRAY [0..0] OF OSType;
  167.     END;
  168.     MIDIIDListPtr = ^MIDIIDList;
  169.     MIDIIDListHdl = ^MIDIIDListPtr;
  170.     MIDIIDListHandle = ^MIDIIDListPtr;
  171.  
  172.  
  173. FUNCTION MIDIVersion: NumVersion;
  174.     {$IFC NOT GENERATINGCFM}
  175.     INLINE $203C, $0000, 4, $A800;
  176.     {$ENDC}
  177. FUNCTION MIDISignIn(clientID: OSType; refCon: LONGINT; icon: Handle; name: ConstStr255Param): OSErr;
  178.     {$IFC NOT GENERATINGCFM}
  179.     INLINE $203C, $0004, 4, $A800;
  180.     {$ENDC}
  181. PROCEDURE MIDISignOut(clientID: OSType);
  182.     {$IFC NOT GENERATINGCFM}
  183.     INLINE $203C, $0008, 4, $A800;
  184.     {$ENDC}
  185. FUNCTION MIDIGetClients: MIDIIDListHandle;
  186.     {$IFC NOT GENERATINGCFM}
  187.     INLINE $203C, $000C, 4, $A800;
  188.     {$ENDC}
  189. PROCEDURE MIDIGetClientName(clientID: OSType; VAR name: Str255);
  190.     {$IFC NOT GENERATINGCFM}
  191.     INLINE $203C, $0010, 4, $A800;
  192.     {$ENDC}
  193. PROCEDURE MIDISetClientName(clientID: OSType; name: ConstStr255Param);
  194.     {$IFC NOT GENERATINGCFM}
  195.     INLINE $203C, $0014, 4, $A800;
  196.     {$ENDC}
  197. FUNCTION MIDIGetPorts(clientID: OSType): MIDIIDListHandle;
  198.     {$IFC NOT GENERATINGCFM}
  199.     INLINE $203C, $0018, 4, $A800;
  200.     {$ENDC}
  201. FUNCTION MIDIAddPort(clientID: OSType; BufSize: INTEGER; VAR refnum: INTEGER; init: MIDIPortParamsPtr): OSErr;
  202.     {$IFC NOT GENERATINGCFM}
  203.     INLINE $203C, $001C, 4, $A800;
  204.     {$ENDC}
  205. FUNCTION MIDIGetPortInfo(clientID: OSType; portID: OSType): MIDIPortInfoHandle;
  206.     {$IFC NOT GENERATINGCFM}
  207.     INLINE $203C, $0020, 4, $A800;
  208.     {$ENDC}
  209. FUNCTION MIDIConnectData(srcClID: OSType; srcPortID: OSType; dstClID: OSType; dstPortID: OSType): OSErr;
  210.     {$IFC NOT GENERATINGCFM}
  211.     INLINE $203C, $0024, 4, $A800;
  212.     {$ENDC}
  213. FUNCTION MIDIUnConnectData(srcClID: OSType; srcPortID: OSType; dstClID: OSType; dstPortID: OSType): OSErr;
  214.     {$IFC NOT GENERATINGCFM}
  215.     INLINE $203C, $0028, 4, $A800;
  216.     {$ENDC}
  217. FUNCTION MIDIConnectTime(srcClID: OSType; srcPortID: OSType; dstClID: OSType; dstPortID: OSType): OSErr;
  218.     {$IFC NOT GENERATINGCFM}
  219.     INLINE $203C, $002C, 4, $A800;
  220.     {$ENDC}
  221. FUNCTION MIDIUnConnectTime(srcClID: OSType; srcPortID: OSType; dstClID: OSType; dstPortID: OSType): OSErr;
  222.     {$IFC NOT GENERATINGCFM}
  223.     INLINE $203C, $0030, 4, $A800;
  224.     {$ENDC}
  225. PROCEDURE MIDIFlush(refnum: INTEGER);
  226.     {$IFC NOT GENERATINGCFM}
  227.     INLINE $203C, $0034, 4, $A800;
  228.     {$ENDC}
  229. FUNCTION MIDIGetReadHook(refnum: INTEGER): ProcPtr;
  230.     {$IFC NOT GENERATINGCFM}
  231.     INLINE $203C, $0038, 4, $A800;
  232.     {$ENDC}
  233. PROCEDURE MIDISetReadHook(refnum: INTEGER; hook: ProcPtr);
  234.     {$IFC NOT GENERATINGCFM}
  235.     INLINE $203C, $003C, 4, $A800;
  236.     {$ENDC}
  237. PROCEDURE MIDIGetPortName(clientID: OSType; portID: OSType; VAR name: Str255);
  238.     {$IFC NOT GENERATINGCFM}
  239.     INLINE $203C, $0040, 4, $A800;
  240.     {$ENDC}
  241. PROCEDURE MIDISetPortName(clientID: OSType; portID: OSType; name: ConstStr255Param);
  242.     {$IFC NOT GENERATINGCFM}
  243.     INLINE $203C, $0044, 4, $A800;
  244.     {$ENDC}
  245. PROCEDURE MIDIWakeUp(refnum: INTEGER; time: LONGINT; period: LONGINT; timeProc: MIDITimeUPP);
  246.     {$IFC NOT GENERATINGCFM}
  247.     INLINE $203C, $0048, 4, $A800;
  248.     {$ENDC}
  249. PROCEDURE MIDIRemovePort(refnum: INTEGER);
  250.     {$IFC NOT GENERATINGCFM}
  251.     INLINE $203C, $004C, 4, $A800;
  252.     {$ENDC}
  253. FUNCTION MIDIGetSync(refnum: INTEGER): INTEGER;
  254.     {$IFC NOT GENERATINGCFM}
  255.     INLINE $203C, $0050, 4, $A800;
  256.     {$ENDC}
  257. PROCEDURE MIDISetSync(refnum: INTEGER; sync: INTEGER);
  258.     {$IFC NOT GENERATINGCFM}
  259.     INLINE $203C, $0054, 4, $A800;
  260.     {$ENDC}
  261. FUNCTION MIDIGetCurTime(refnum: INTEGER): LONGINT;
  262.     {$IFC NOT GENERATINGCFM}
  263.     INLINE $203C, $0058, 4, $A800;
  264.     {$ENDC}
  265. PROCEDURE MIDISetCurTime(refnum: INTEGER; time: LONGINT);
  266.     {$IFC NOT GENERATINGCFM}
  267.     INLINE $203C, $005C, 4, $A800;
  268.     {$ENDC}
  269. PROCEDURE MIDIStartTime(refnum: INTEGER);
  270.     {$IFC NOT GENERATINGCFM}
  271.     INLINE $203C, $0060, 4, $A800;
  272.     {$ENDC}
  273. PROCEDURE MIDIStopTime(refnum: INTEGER);
  274.     {$IFC NOT GENERATINGCFM}
  275.     INLINE $203C, $0064, 4, $A800;
  276.     {$ENDC}
  277. PROCEDURE MIDIPoll(refnum: INTEGER; offsetTime: LONGINT);
  278.     {$IFC NOT GENERATINGCFM}
  279.     INLINE $203C, $0068, 4, $A800;
  280.     {$ENDC}
  281. FUNCTION MIDIWritePacket(refnum: INTEGER; packet: MIDIPacketPtr): OSErr;
  282.     {$IFC NOT GENERATINGCFM}
  283.     INLINE $203C, $006C, 4, $A800;
  284.     {$ENDC}
  285. FUNCTION MIDIWorldChanged(clientID: OSType): BOOLEAN;
  286.     {$IFC NOT GENERATINGCFM}
  287.     INLINE $203C, $0070, 4, $A800;
  288.     {$ENDC}
  289. FUNCTION MIDIGetOffsetTime(refnum: INTEGER): LONGINT;
  290.     {$IFC NOT GENERATINGCFM}
  291.     INLINE $203C, $0074, 4, $A800;
  292.     {$ENDC}
  293. PROCEDURE MIDISetOffsetTime(refnum: INTEGER; offsetTime: LONGINT);
  294.     {$IFC NOT GENERATINGCFM}
  295.     INLINE $203C, $0078, 4, $A800;
  296.     {$ENDC}
  297. FUNCTION MIDIConvertTime(srcFormat: INTEGER; dstFormat: INTEGER; time: LONGINT): LONGINT;
  298.     {$IFC NOT GENERATINGCFM}
  299.     INLINE $203C, $007C, 4, $A800;
  300.     {$ENDC}
  301. FUNCTION MIDIGetRefCon(refnum: INTEGER): LONGINT;
  302.     {$IFC NOT GENERATINGCFM}
  303.     INLINE $203C, $0080, 4, $A800;
  304.     {$ENDC}
  305. PROCEDURE MIDISetRefCon(refnum: INTEGER; refCon: LONGINT);
  306.     {$IFC NOT GENERATINGCFM}
  307.     INLINE $203C, $0084, 4, $A800;
  308.     {$ENDC}
  309. FUNCTION MIDIGetClRefCon(clientID: OSType): LONGINT;
  310.     {$IFC NOT GENERATINGCFM}
  311.     INLINE $203C, $0088, 4, $A800;
  312.     {$ENDC}
  313. PROCEDURE MIDISetClRefCon(clientID: OSType; refCon: LONGINT);
  314.     {$IFC NOT GENERATINGCFM}
  315.     INLINE $203C, $008C, 4, $A800;
  316.     {$ENDC}
  317. FUNCTION MIDIGetTCFormat(refnum: INTEGER): INTEGER;
  318.     {$IFC NOT GENERATINGCFM}
  319.     INLINE $203C, $0090, 4, $A800;
  320.     {$ENDC}
  321. PROCEDURE MIDISetTCFormat(refnum: INTEGER; format: INTEGER);
  322.     {$IFC NOT GENERATINGCFM}
  323.     INLINE $203C, $0094, 4, $A800;
  324.     {$ENDC}
  325. PROCEDURE MIDISetRunRate(refnum: INTEGER; rate: INTEGER; time: LONGINT);
  326.     {$IFC NOT GENERATINGCFM}
  327.     INLINE $203C, $0098, 4, $A800;
  328.     {$ENDC}
  329. FUNCTION MIDIGetClientIcon(clientID: OSType): Handle;
  330.     {$IFC NOT GENERATINGCFM}
  331.     INLINE $203C, $009C, 4, $A800;
  332.     {$ENDC}
  333. FUNCTION SndDispVersion(toolnum: INTEGER): LONGINT;
  334.     {$IFC NOT GENERATINGCFM}
  335.     INLINE $203C, $0000, $0000, $A800;
  336.     {$ENDC}
  337. CONST
  338.     uppMIDIReadHookProcInfo = $000003E0; { FUNCTION (4 byte param, 4 byte param): 2 byte result; }
  339.     uppMIDITimeProcInfo = $000003C0; { PROCEDURE (4 byte param, 4 byte param); }
  340.  
  341. FUNCTION NewMIDIReadHookProc(userRoutine: MIDIReadHookProcPtr): MIDIReadHookUPP;
  342.     {$IFC NOT GENERATINGCFM }
  343.     INLINE $2E9F;
  344.     {$ENDC}
  345.  
  346. FUNCTION NewMIDITimeProc(userRoutine: MIDITimeProcPtr): MIDITimeUPP;
  347.     {$IFC NOT GENERATINGCFM }
  348.     INLINE $2E9F;
  349.     {$ENDC}
  350.  
  351. FUNCTION CallMIDIReadHookProc(myPacket: MIDIPacketPtr; myRefCon: LONGINT; userRoutine: MIDIReadHookUPP): INTEGER;
  352.     {$IFC NOT GENERATINGCFM}
  353.     INLINE $205F, $4E90;
  354.     {$ENDC}
  355.  
  356. PROCEDURE CallMIDITimeProc(curTime: LONGINT; myRefCon: LONGINT; userRoutine: MIDITimeUPP);
  357.     {$IFC NOT GENERATINGCFM}
  358.     INLINE $205F, $4E90;
  359.     {$ENDC}
  360.  
  361. {$ALIGN RESET}
  362. {$POP}
  363.  
  364. {$SETC UsingIncludes := MIDIIncludes}
  365.  
  366. {$ENDC} {__MIDI__}
  367.  
  368. {$IFC NOT UsingIncludes}
  369.  END.
  370. {$ENDC}
  371.