Please consider a donation to the Higher Intellect project. See https://preterhuman.net/donate.php or the Donate to Higher Intellect page for more info. |
QuickTimeMusic.h
Jump to navigation
Jump to search
/* File: QuickTimeMusic.h Contains: QuickTime interfaces Version: Technology: Release: QuickTime 2.5 interfaces to use with ETO #20 Copyright: Š 1984-1996 by Apple Computer, Inc. All rights reserved. Bugs?: If you find a problem with this file, send the file and version information (from above) and the problem description to: Internet: [email protected] AppleLink: APPLE.BUGS */ #ifndef __QUICKTIMEMUSIC__ #define __QUICKTIMEMUSIC__ #ifndef __COMPONENTS__ #include #endif #ifndef __IMAGECOMPRESSION__ #include #endif #ifndef __MOVIES__ #include #endif #ifndef __QUICKDRAW__ #include #endif #ifndef __VIDEO__ #include #endif #ifndef __MEMORY__ #include #endif #ifndef __SOUND__ #include #endif #ifdef __cplusplus extern "C" { #endif #if PRAGMA_IMPORT_SUPPORTED #pragma import on #endif #if PRAGMA_ALIGN_SUPPORTED #pragma options align=mac68k #endif /* AtomicInstrument ToneDescription [NoteRequestInfo] [KnobList] [SampleInfo [1..m]] SampeDescription (identifies corresponding SampleData) [KnobList] [SampleData [1..n]] [itxt/name] [InstrumentInfo] [Pict] [Author] [Copyright] [Other] */ enum { kaiToneDescType = 'tone', kaiNoteRequestInfoType = 'ntrq', kaiKnobListType = 'knbl', kaiKeyRangeInfoType = 'sinf', kaiSampleDescType = 'sdsc', kaiSampleDataType = 'sdat', kaiInstInfoType = 'iinf', /* kaiExtendedNameType = 'name',*/ kaiPictType = 'pict', kaiWriterType = 'Šwrt', kaiCopyrightType = 'Šcpy', kaiOtherStrType = 'str ' }; struct InstKnobRec { long number; long value; }; typedef struct InstKnobRec InstKnobRec; enum { kInstKnobMissingUnknown = 0, kInstKnobMissingDefault = 1 << 0 }; struct InstKnobList { long knobCount; long knobFlags; InstKnobRec knob[1]; }; typedef struct InstKnobList InstKnobList; enum { loopTypeNormal = 0, loopTypeAlternating = 1 /* back & forth*/ }; enum { instSamplePreProcessFlag = 1 << 0 }; struct InstSampleDescRec { OSType dataFormat; short numChannels; short sampleSize; UnsignedFixed sampleRate; short sampleDataID; long offset; /* offset within SampleData - this could be just for internal use*/ long numSamples; /* this could also just be for internal use, we'll see*/ long loopType; long loopStart; long loopEnd; long pitchNormal; long pitchLow; long pitchHigh; }; typedef struct InstSampleDescRec InstSampleDescRec; typedef Handle AtomicInstrument; typedef Ptr AtomicInstrumentPtr; enum { kMusicComponentType = 'musi' }; enum { kSoftSynthType = 'ss ', kGMSynthType = 'gm ' }; typedef ComponentInstance MusicComponent; /* MusicSynthesizerFlags*/ enum { kSynthesizerDynamicVoice = 1, /* can assign voices on the fly (else, polyphony is very important */ kSynthesizerUsesMIDIPort = 2, /* must be patched through MIDI Manager */ kSynthesizerMicrotone = 4, /* can play microtonal scales */ kSynthesizerHasSamples = 8, /* synthesizer has some use for sampled data */ kSynthesizerMixedDrums = 16, /* any part can play drum parts, total = instrument parts */ kSynthesizerSoftware = 32, /* implemented in main CPU software == uses cpu cycles */ kSynthesizerHardware = 64, /* is a hardware device (such as nubus, or maybe DSP?) */ kSynthesizerDynamicChannel = 128, /* can move any part to any channel or disable each part. (else we assume it lives on all channels in masks) */ kSynthesizerHogsSystemChannel = 256, /* can be channelwise dynamic, but always responds on its system channel */ kSynthesizerSlowSetPart = 1024, /* SetPart() and SetPartInstrumentNumber() calls do not have rapid response, may glitch notes */ kSynthesizerOffline = 4096, /* can enter an offline synthesis mode */ kSynthesizerGM = 16384 /* synth is a GM device */ }; /* * Note that these controller numbers * are _not_ identical to the MIDI controller numbers. * These are _signed_ 8.8 values, and the LSB's are * always sent to a MIDI device. Controllers 32-63 are * reserved (for MIDI, they are LSB's for 0-31, but we * always send both). * * The full range, therefore, is -128.00 to 127.7f. * * _Excepting_ _volume_, all controls default to zero. * * Pitch bend is specified in fractional semitones! No * more "pitch bend range" nonsense. You can bend as far * as you want, any time you want. */ typedef SInt32 MusicController; enum { kControllerModulationWheel = 1, kControllerBreath = 2, kControllerFoot = 4, kControllerPortamentoTime = 5, /* portamento on/off is omitted, 0 time = 'off' */ kControllerVolume = 7, kControllerBalance = 8, kControllerPan = 10, /* 0 - "default", 1 - n: positioned in output 1-n (incl fractions) */ kControllerExpression = 11, kControllerLever1 = 16, /* general purpose controllers */ kControllerLever2 = 17, /* general purpose controllers */ kControllerLever3 = 18, /* general purpose controllers */ kControllerLever4 = 19, /* general purpose controllers */ kControllerLever5 = 80, /* general purpose controllers */ kControllerLever6 = 81, /* general purpose controllers */ kControllerLever7 = 82, /* general purpose controllers */ kControllerLever8 = 83, /* general purpose controllers */ kControllerPitchBend = 32, /* positive & negative semitones, with 7 bits fraction */ kControllerAfterTouch = 33, /* aka channel pressure */ kControllerSustain = 64, /* boolean - positive for on, 0 or negative off */ kControllerSostenuto = 66, /* boolean */ kControllerSoftPedal = 67, /* boolean */ kControllerReverb = 91, kControllerTremolo = 92, kControllerChorus = 93, kControllerCeleste = 94, kControllerPhaser = 95, kControllerEditPart = 113, /* last 16 controllers 113-128 and above are global controllers which respond on part zero */ kControllerMasterTune = 114 }; enum { kControllerMaximum = 0x7FFF, /* +01111111.11111111 */ kControllerMinimum = 0x8000 /* -10000000.00000000 */ }; struct SynthesizerDescription { OSType synthesizerType; /* synthesizer type (must be same as component subtype) */ Str31 name; /* text name of synthesizer type */ unsigned long flags; /* from the above enum */ unsigned long voiceCount; /* maximum polyphony */ unsigned long partCount; /* maximum multi-timbrality (and midi channels) */ unsigned long instrumentCount; /* non gm, built in (rom) instruments only */ unsigned long modifiableInstrumentCount; /* plus n-more are user modifiable */ unsigned long channelMask; /* (midi device only) which channels device always uses */ unsigned long drumPartCount; /* maximum multi-timbrality of drum parts */ unsigned long drumCount; /* non gm, built in (rom) drumkits only */ unsigned long modifiableDrumCount; /* plus n-more are user modifiable */ unsigned long drumChannelMask; /* (midi device only) which channels device always uses */ unsigned long outputCount; /* number of audio outputs (usually two) */ unsigned long latency; /* response time in ľSec */ unsigned long controllers[4]; /* array of 128 bits */ unsigned long gmInstruments[4]; /* array of 128 bits */ unsigned long gmDrums[4]; /* array of 128 bits */ }; typedef struct SynthesizerDescription SynthesizerDescription; enum { kVoiceCountDynamic = -1 /* constant to use to specify dynamic voicing */ }; struct ToneDescription { OSType synthesizerType; /* synthesizer type */ Str31 synthesizerName; /* name of instantiation of synth */ Str31 instrumentName; /* preferred name for human use */ long instrumentNumber; /* inst-number used if synth-name matches */ long gmNumber; /* Best matching general MIDI number */ }; typedef struct ToneDescription ToneDescription; enum { kFirstDrumkit = 16384, /* (first value is "no drum". instrument numbers from 16384->16384+128 are drumkits, and for GM they are _defined_ drumkits! */ kLastDrumkit = (kFirstDrumkit + 128) }; /* InstrumentMatch*/ enum { kInstrumentMatchSynthesizerType = 1, kInstrumentMatchSynthesizerName = 2, kInstrumentMatchName = 4, kInstrumentMatchNumber = 8, kInstrumentMatchGMNumber = 16 }; /* KnobFlags*/ enum { kKnobReadOnly = 16, /* knob value cannot be changed by user or with a SetKnob call */ kKnobInterruptUnsafe = 32, /* only alter this knob from foreground task time (may access toolbox) */ kKnobKeyrangeOverride = 64, /* knob can be overridden within a single keyrange (software synth only) */ kKnobGroupStart = 128, /* knob is first in some logical group of knobs */ kKnobFixedPoint8 = 1024, kKnobFixedPoint16 = 2048, /* One of these may be used at a time. */ kKnobTypeNumber = 0 << 12, kKnobTypeGroupName = 1 << 12, /* "knob" is really a group name for display purposes */ kKnobTypeBoolean = 2 << 12, /* if range is greater than 1, its a multi-checkbox field */ kKnobTypeNote = 3 << 12, /* knob range is equivalent to MIDI keys */ kKnobTypePan = 4 << 12, /* range goes left/right (lose this? ) */ kKnobTypeInstrument = 5 << 12, /* knob value = reference to another instrument number */ kKnobTypeSetting = 6 << 12, /* knob value is 1 of n different things (eg, fm algorithms) popup menu */ kKnobTypeMilliseconds = 7 << 12, /* knob is a millisecond time range */ kKnobTypePercentage = 8 << 12, /* knob range is displayed as a Percentage */ kKnobTypeHertz = 9 << 12, /* knob represents frequency */ kKnobTypeButton = 10 << 12 /* momentary trigger push button */ }; enum { kUnknownKnobValue = 0x7FFFFFFF, /* a knob with this value means, we don't know it. */ kDefaultKnobValue = 0x7FFFFFFE /* used to SET a knob to its default value. */ }; struct KnobDescription { Str63 name; long lowValue; long highValue; long defaultValue; /* a default instrument is made of all default values */ long flags; long knobID; }; typedef struct KnobDescription KnobDescription; struct GCInstrumentData { ToneDescription tone; long knobCount; long knob[1]; }; typedef struct GCInstrumentData GCInstrumentData; typedef GCInstrumentData *GCInstrumentDataPtr; typedef GCInstrumentDataPtr *GCInstrumentDataHandle; struct InstrumentAboutInfo { PicHandle p; Str255 author; Str255 copyright; Str255 other; }; typedef struct InstrumentAboutInfo InstrumentAboutInfo; enum { kMusicPacketPortLost = 1, /* received when application loses the default input port */ kMusicPacketPortFound = 2, /* received when application gets it back out from under someone else's claim */ kMusicPacketTimeGap = 3 /* data[0] = number of milliseconds to keep the MIDI line silent */ }; struct MusicMIDIPacket { unsigned short length; unsigned long reserved; /* if length zero, then reserved = above enum */ UInt8 data[249]; }; typedef struct MusicMIDIPacket MusicMIDIPacket; typedef pascal ComponentResult (*MusicMIDISendProcPtr)(MusicComponent self, long refCon, MusicMIDIPacket *mmp); #if GENERATINGCFM typedef UniversalProcPtr MusicMIDISendUPP; #else typedef MusicMIDISendProcPtr MusicMIDISendUPP; #endif typedef pascal ComponentResult (*MusicMIDIReadHookProcPtr)(MusicMIDIPacket *mp, long myRefCon); #if GENERATINGCFM typedef UniversalProcPtr MusicMIDIReadHookUPP; #else typedef MusicMIDIReadHookProcPtr MusicMIDIReadHookUPP; #endif enum { notImplementedMusicErr = (0x80000000 | (0xFFFF & (notImplementedMusicOSErr))), cantSendToSynthesizerErr = (0x80000000 | (0xFFFF & (cantSendToSynthesizerOSErr))), cantReceiveFromSynthesizerErr = (0x80000000 | (0xFFFF & (cantReceiveFromSynthesizerOSErr))), illegalVoiceAllocationErr = (0x80000000 | (0xFFFF & (illegalVoiceAllocationOSErr))), illegalPartErr = (0x80000000 | (0xFFFF & (illegalPartOSErr))), illegalChannelErr = (0x80000000 | (0xFFFF & (illegalChannelOSErr))), illegalKnobErr = (0x80000000 | (0xFFFF & (illegalKnobOSErr))), illegalKnobValueErr = (0x80000000 | (0xFFFF & (illegalKnobValueOSErr))), illegalInstrumentErr = (0x80000000 | (0xFFFF & (illegalInstrumentOSErr))), illegalControllerErr = (0x80000000 | (0xFFFF & (illegalControllerOSErr))), midiManagerAbsentErr = (0x80000000 | (0xFFFF & (midiManagerAbsentOSErr))), synthesizerNotRespondingErr = (0x80000000 | (0xFFFF & (synthesizerNotRespondingOSErr))), synthesizerErr = (0x80000000 | (0xFFFF & (synthesizerOSErr))), illegalNoteChannelErr = (0x80000000 | (0xFFFF & (illegalNoteChannelOSErr))), noteChannelNotAllocatedErr = (0x80000000 | (0xFFFF & (noteChannelNotAllocatedOSErr))), tunePlayerFullErr = (0x80000000 | (0xFFFF & (tunePlayerFullOSErr))), tuneParseErr = (0x80000000 | (0xFFFF & (tuneParseOSErr))) }; enum { kGMType = 'gm ' /* subtype for General MIDI music component */ }; enum { kGetAtomicInstNoExpandedSamples = 1 << 0, kGetAtomicInstNoOriginalSamples = 1 << 1, kGetAtomicInstNoSamples = kGetAtomicInstNoExpandedSamples | kGetAtomicInstNoOriginalSamples, kGetAtomicInstNoKnobList = 1 << 2, kGetAtomicInstNoInstrumentInfo = 1 << 3, kGetAtomicInstOriginalKnobList = 1 << 4, kGetAtomicInstAllKnobs = 1 << 5 /* return even those that are set to default*/ }; /* For non-gm instruments, instrument number of tone description == 0 If you want to speed up while running, slam the inst num with what Get instrument number returns All missing knobs are slammed to the default value */ enum { kSetAtomicInstKeepOriginalInstrument = 1 << 0, kSetAtomicInstShareAcrossParts = 1 << 1, /* inst disappears when app goes away*/ kSetAtomicInstCallerTosses = 1 << 2, /* the caller isn't keeping a copy around (for NASetAtomicInstrument)*/ kSetAtomicInstDontPreprocess = 1 << 7 /* perform no further preprocessing because either 1)you know the instrument is digitally clean, or 2) you got it from a GetPartAtomic*/ }; enum { kInstrumentNamesModifiable = 1, kInstrumentNamesBoth = 2 }; enum { kSetPartInstrumentNumberSafe = 0x40000000 /* or'd with instrument number on MusicSetPartInstrumentNumber means we're calling at interrupt level (dont move RAM)*/ }; /* * Structures specific to the GenericMusicComponent */ enum { kGenericMusicComponentSubtype = 'gene' }; struct GenericKnobDescription { KnobDescription kd; long hw1; /* driver defined */ long hw2; /* driver defined */ long hw3; /* driver defined */ long settingsID; /* resource ID list for boolean and popup names */ }; typedef struct GenericKnobDescription GenericKnobDescription; struct GenericKnobDescriptionList { long knobCount; GenericKnobDescription knob[1]; }; typedef struct GenericKnobDescriptionList GenericKnobDescriptionList; typedef GenericKnobDescriptionList *GenericKnobDescriptionListPtr; typedef GenericKnobDescriptionListPtr *GenericKnobDescriptionListHandle; /* knobTypes for MusicDerivedSetKnob */ enum { kGenericMusicKnob = 1, kGenericMusicInstrumentKnob = 2, kGenericMusicDrumKnob = 3, kGenericMusicGlobalController = 4 }; enum { resFirst = 0, resMiscStringList = 1, /* STR# 1: synth name, 2:about author,3:aboutcopyright,4:aboutother */ resMiscLongList = 2, /* Long various params, see list below */ resInstrumentList = 3, /* NmLs of names and shorts, categories prefixed by 'ĽĽ' */ resDrumList = 4, /* NmLs of names and shorts */ resInstrumentKnobDescriptionList = 5, /* Knob */ resDrumKnobDescriptionList = 6, /* Knob */ resKnobDescriptionList = 7, /* Knob */ resBitsLongList = 8, /* Long back to back bitmaps of controllers, gminstruments, and drums */ resModifiableInstrumentHW = 9, /* Shrt same as the hw shorts trailing the instrument names, a shortlist */ resGMTranslation = 10, /* Long 128 long entries, 1 for each gm inst, of local instrument numbers 1-n (not hw numbers) */ resROMInstrumentData = 11, /* knob lists for ROM instruments, so the knob values may be known */ resAboutPICT = 12, /* picture for aboutlist. must be present for GetAbout call to work */ resLast = 13 }; /* elements of the misc long list */ enum { miscLongFirst = 0, miscLongVoiceCount = 1, miscLongPartCount = 2, miscLongModifiableInstrumentCount = 3, miscLongChannelMask = 4, miscLongDrumPartCount = 5, miscLongModifiableDrumCount = 6, miscLongDrumChannelMask = 7, miscLongOutputCount = 8, miscLongLatency = 9, miscLongFlags = 10, miscLongFirstGMHW = 11, /* number to add to locate GM main instruments */ miscLongFirstGMDrumHW = 12, /* number to add to locate GM drumkits */ miscLongFirstUserHW = 13, /* First hw number of user instruments (presumed sequential) */ miscLongLast = 14 }; struct GCPart { long hwInstrumentNumber; /* internal number of recalled instrument */ short controller[128]; /* current values for all controllers */ long volume; /* ctrl 7 is special case */ long polyphony; long midiChannel; /* 1-16 if in use */ GCInstrumentData id; /* ToneDescription & knoblist, uncertain length */ }; typedef struct GCPart GCPart; /* * Calls specific to the GenericMusicComponent */ enum { kMusicGenericRange = 0x0100, kMusicDerivedRange = 0x0200 }; /* * Flags in GenericMusicConfigure call */ enum { kGenericMusicDoMIDI = 1 << 0, /* implement normal MIDI messages for note, controllers, and program changes 0-127 */ kGenericMusicBank0 = 1 << 1, /* implement instrument bank changes on controller 0 */ kGenericMusicBank32 = 1 << 2, /* implement instrument bank changes on controller 32 */ kGenericMusicErsatzMIDI = 1 << 3, /* construct MIDI packets, but send them to the derived component */ kGenericMusicCallKnobs = 1 << 4, /* call the derived component with special knob format call */ kGenericMusicCallParts = 1 << 5, /* call the derived component with special part format call */ kGenericMusicCallInstrument = 1 << 6, /* call MusicDerivedSetInstrument for MusicSetInstrument calls */ kGenericMusicCallNumber = 1 << 7, /* call MusicDerivedSetPartInstrumentNumber for MusicSetPartInstrumentNumber calls, & don't send any C0 or bank stuff */ kGenericMusicCallROMInstrument = 1 << 8, /* call MusicSetInstrument for MusicSetPartInstrumentNumber for "ROM" instruments, passing params from the ROMi resource */ kGenericMusicAllDefaults = 1 << 9 /* indicates that when a new instrument is recalled, all knobs are reset to DEFAULT settings. True for GS modules */ }; typedef pascal ComponentResult (*MusicOfflineDataProcPtr)(Ptr SoundData, long numBytes, long myRefCon); #if GENERATINGCFM typedef UniversalProcPtr MusicOfflineDataUPP; #else typedef MusicOfflineDataProcPtr MusicOfflineDataUPP; #endif struct OfflineSampleType { unsigned long numChannels; /*number of channels, ie mono = 1*/ UnsignedFixed sampleRate; /*sample rate in Apples Fixed point representation*/ unsigned short sampleSize; /*number of bits in sample*/ }; typedef struct OfflineSampleType OfflineSampleType; struct InstrumentInfoRecord { long instrumentNumber; /* instrument number (if 0, name is a catagory)*/ long flags; /* show in picker, etc.*/ long toneNameIndex; /* index in toneNames (1 based)*/ long itxtNameAtomID; /* index in itxtNames (itxt/name by index)*/ }; typedef struct InstrumentInfoRecord InstrumentInfoRecord; struct InstrumentInfoList { long recordCount; Handle toneNames; /* name from tone description*/ QTAtomContainer itxtNames; /* itxt/name atoms for instruments*/ InstrumentInfoRecord info[1]; }; typedef struct InstrumentInfoList InstrumentInfoList; typedef InstrumentInfoList *InstrumentInfoListPtr; typedef InstrumentInfoListPtr *InstrumentInfoListHandle; extern pascal ComponentResult MusicGetDescription(MusicComponent mc, SynthesizerDescription *sd) FIVEWORDINLINE(0x2F3C, 0x0004, 0x0001, 0x7000, 0xA82A); extern pascal ComponentResult MusicGetPart(MusicComponent mc, long part, long *midiChannel, long *polyphony) FIVEWORDINLINE(0x2F3C, 0x000C, 0x0002, 0x7000, 0xA82A); extern pascal ComponentResult MusicSetPart(MusicComponent mc, long part, long midiChannel, long polyphony) FIVEWORDINLINE(0x2F3C, 0x000C, 0x0003, 0x7000, 0xA82A); extern pascal ComponentResult MusicSetPartInstrumentNumber(MusicComponent mc, long part, long instrumentNumber) FIVEWORDINLINE(0x2F3C, 0x0008, 0x0004, 0x7000, 0xA82A); #if OLDROUTINENAMES #define MusicSetInstrumentNumber(ci,part,instrumentNumber) MusicSetPartInstrumentNumber(ci, part,instrumentNumber) #endif extern pascal ComponentResult MusicGetPartInstrumentNumber(MusicComponent mc, long part) FIVEWORDINLINE(0x2F3C, 0x0004, 0x0005, 0x7000, 0xA82A); extern pascal ComponentResult MusicStorePartInstrument(MusicComponent mc, long part, long instrumentNumber) FIVEWORDINLINE(0x2F3C, 0x0008, 0x0006, 0x7000, 0xA82A); extern pascal ComponentResult MusicGetPartAtomicInstrument(MusicComponent mc, long part, AtomicInstrument *ai, long flags) FIVEWORDINLINE(0x2F3C, 0x000C, 0x0009, 0x7000, 0xA82A); extern pascal ComponentResult MusicSetPartAtomicInstrument(MusicComponent mc, long part, AtomicInstrumentPtr aiP, long flags) FIVEWORDINLINE(0x2F3C, 0x000C, 0x000A, 0x7000, 0xA82A); /* Obsolete calls*/ extern pascal ComponentResult MusicGetInstrumentKnobDescriptionObsolete(MusicComponent mc, long knobIndex, void *mkd) FIVEWORDINLINE(0x2F3C, 0x0008, 0x000D, 0x7000, 0xA82A); extern pascal ComponentResult MusicGetDrumKnobDescriptionObsolete(MusicComponent mc, long knobIndex, void *mkd) FIVEWORDINLINE(0x2F3C, 0x0008, 0x000E, 0x7000, 0xA82A); extern pascal ComponentResult MusicGetKnobDescriptionObsolete(MusicComponent mc, long knobIndex, void *mkd) FIVEWORDINLINE(0x2F3C, 0x0008, 0x000F, 0x7000, 0xA82A); extern pascal ComponentResult MusicGetPartKnob(MusicComponent mc, long part, long knobID) FIVEWORDINLINE(0x2F3C, 0x0008, 0x0010, 0x7000, 0xA82A); extern pascal ComponentResult MusicSetPartKnob(MusicComponent mc, long part, long knobID, long knobValue) FIVEWORDINLINE(0x2F3C, 0x000C, 0x0011, 0x7000, 0xA82A); extern pascal ComponentResult MusicGetKnob(MusicComponent mc, long knobID) FIVEWORDINLINE(0x2F3C, 0x0004, 0x0012, 0x7000, 0xA82A); extern pascal ComponentResult MusicSetKnob(MusicComponent mc, long knobID, long knobValue) FIVEWORDINLINE(0x2F3C, 0x0008, 0x0013, 0x7000, 0xA82A); extern pascal ComponentResult MusicGetPartName(MusicComponent mc, long part, StringPtr name) FIVEWORDINLINE(0x2F3C, 0x0008, 0x0014, 0x7000, 0xA82A); extern pascal ComponentResult MusicSetPartName(MusicComponent mc, long part, StringPtr name) FIVEWORDINLINE(0x2F3C, 0x0008, 0x0015, 0x7000, 0xA82A); extern pascal ComponentResult MusicFindTone(MusicComponent mc, ToneDescription *td, long *instrumentNumber, unsigned long *fit) FIVEWORDINLINE(0x2F3C, 0x000C, 0x0016, 0x7000, 0xA82A); extern pascal ComponentResult MusicPlayNote(MusicComponent mc, long part, long pitch, long velocity) FIVEWORDINLINE(0x2F3C, 0x000C, 0x0017, 0x7000, 0xA82A); extern pascal ComponentResult MusicResetPart(MusicComponent mc, long part) FIVEWORDINLINE(0x2F3C, 0x0004, 0x0018, 0x7000, 0xA82A); extern pascal ComponentResult MusicSetPartController(MusicComponent mc, long part, MusicController controllerNumber, long controllerValue) FIVEWORDINLINE(0x2F3C, 0x000C, 0x0019, 0x7000, 0xA82A); #if OLDROUTINENAMES #define MusicSetController(ci,part,controllerNumber,controllerValue) MusicSetPartController(ci, part,controllerNumber,controllerValue) #endif extern pascal ComponentResult MusicGetPartController(MusicComponent mc, long part, MusicController controllerNumber) FIVEWORDINLINE(0x2F3C, 0x0008, 0x001A, 0x7000, 0xA82A); extern pascal ComponentResult MusicGetMIDIProc(MusicComponent mc, MusicMIDISendUPP *midiSendProc, long *refCon) FIVEWORDINLINE(0x2F3C, 0x0008, 0x001B, 0x7000, 0xA82A); extern pascal ComponentResult MusicSetMIDIProc(MusicComponent mc, MusicMIDISendUPP midiSendProc, long refCon) FIVEWORDINLINE(0x2F3C, 0x0008, 0x001C, 0x7000, 0xA82A); extern pascal ComponentResult MusicGetInstrumentNames(MusicComponent mc, long modifiableInstruments, Handle *instrumentNames, Handle *instrumentCategoryLasts, Handle *instrumentCategoryNames) FIVEWORDINLINE(0x2F3C, 0x0010, 0x001D, 0x7000, 0xA82A); extern pascal ComponentResult MusicGetDrumNames(MusicComponent mc, long modifiableInstruments, Handle *instrumentNumbers, Handle *instrumentNames) FIVEWORDINLINE(0x2F3C, 0x000C, 0x001E, 0x7000, 0xA82A); extern pascal ComponentResult MusicGetMasterTune(MusicComponent mc) FIVEWORDINLINE(0x2F3C, 0x0000, 0x001F, 0x7000, 0xA82A); extern pascal ComponentResult MusicSetMasterTune(MusicComponent mc, long masterTune) FIVEWORDINLINE(0x2F3C, 0x0004, 0x0020, 0x7000, 0xA82A); extern pascal ComponentResult MusicGetInstrumentAboutInfo(MusicComponent mc, long part, InstrumentAboutInfo *iai) FIVEWORDINLINE(0x2F3C, 0x0008, 0x0022, 0x7000, 0xA82A); extern pascal ComponentResult MusicGetDeviceConnection(MusicComponent mc, long index, long *id1, long *id2) FIVEWORDINLINE(0x2F3C, 0x000C, 0x0023, 0x7000, 0xA82A); extern pascal ComponentResult MusicUseDeviceConnection(MusicComponent mc, long id1, long id2) FIVEWORDINLINE(0x2F3C, 0x0008, 0x0024, 0x7000, 0xA82A); extern pascal ComponentResult MusicGetKnobSettingStrings(MusicComponent mc, long knobIndex, long isGlobal, Handle *settingsNames, Handle *settingsCategoryLasts, Handle *settingsCategoryNames) FIVEWORDINLINE(0x2F3C, 0x0014, 0x0025, 0x7000, 0xA82A); extern pascal ComponentResult MusicGetMIDIPorts(MusicComponent mc, long *inputPortCount, long *outputPortCount) FIVEWORDINLINE(0x2F3C, 0x0008, 0x0026, 0x7000, 0xA82A); extern pascal ComponentResult MusicSendMIDI(MusicComponent mc, long portIndex, MusicMIDIPacket *mp) FIVEWORDINLINE(0x2F3C, 0x0008, 0x0027, 0x7000, 0xA82A); extern pascal ComponentResult MusicReceiveMIDI(MusicComponent mc, MusicMIDIReadHookUPP readHook, long refCon) FIVEWORDINLINE(0x2F3C, 0x0008, 0x0028, 0x7000, 0xA82A); extern pascal ComponentResult MusicStartOffline(MusicComponent mc, unsigned long *numChannels, UnsignedFixed *sampleRate, unsigned short *sampleSize, MusicOfflineDataUPP dataProc, long dataProcRefCon) FIVEWORDINLINE(0x2F3C, 0x0014, 0x0029, 0x7000, 0xA82A); extern pascal ComponentResult MusicSetOfflineTimeTo(MusicComponent mc, long newTimeStamp) FIVEWORDINLINE(0x2F3C, 0x0004, 0x002A, 0x7000, 0xA82A); extern pascal ComponentResult MusicGetInstrumentKnobDescription(MusicComponent mc, long knobIndex, KnobDescription *mkd) FIVEWORDINLINE(0x2F3C, 0x0008, 0x002B, 0x7000, 0xA82A); extern pascal ComponentResult MusicGetDrumKnobDescription(MusicComponent mc, long knobIndex, KnobDescription *mkd) FIVEWORDINLINE(0x2F3C, 0x0008, 0x002C, 0x7000, 0xA82A); extern pascal ComponentResult MusicGetKnobDescription(MusicComponent mc, long knobIndex, KnobDescription *mkd) FIVEWORDINLINE(0x2F3C, 0x0008, 0x002D, 0x7000, 0xA82A); extern pascal ComponentResult MusicGetInfoText(MusicComponent mc, long selector, Handle *textH, Handle *styleH) FIVEWORDINLINE(0x2F3C, 0x000C, 0x002E, 0x7000, 0xA82A); extern pascal ComponentResult MusicGetInstrumentInfo(MusicComponent mc, long getInstrumentNamesFlags, InstrumentInfoListHandle *infoListH) FIVEWORDINLINE(0x2F3C, 0x0008, 0x002F, 0x7000, 0xA82A); extern pascal ComponentResult MusicTask(MusicComponent mc) FIVEWORDINLINE(0x2F3C, 0x0000, 0x0031, 0x7000, 0xA82A); extern pascal ComponentResult MusicGenericConfigure(MusicComponent mc, long mode, long flags, long baseResID) FIVEWORDINLINE(0x2F3C, 0x000C, 0x0100, 0x7000, 0xA82A); extern pascal ComponentResult MusicGenericGetPart(MusicComponent mc, long partNumber, GCPart **part) FIVEWORDINLINE(0x2F3C, 0x0008, 0x0101, 0x7000, 0xA82A); extern pascal ComponentResult MusicGenericGetKnobList(MusicComponent mc, long knobType, GenericKnobDescriptionListHandle *gkdlH) FIVEWORDINLINE(0x2F3C, 0x0008, 0x0102, 0x7000, 0xA82A); extern pascal ComponentResult MusicDerivedMIDISend(MusicComponent mc, MusicMIDIPacket *packet) FIVEWORDINLINE(0x2F3C, 0x0004, 0x0200, 0x7000, 0xA82A); extern pascal ComponentResult MusicDerivedSetKnob(MusicComponent mc, long knobType, long knobNumber, long knobValue, long partNumber, GCPart *p, GenericKnobDescription *gkd) FIVEWORDINLINE(0x2F3C, 0x0018, 0x0201, 0x7000, 0xA82A); extern pascal ComponentResult MusicDerivedSetPart(MusicComponent mc, long partNumber, GCPart *p) FIVEWORDINLINE(0x2F3C, 0x0008, 0x0202, 0x7000, 0xA82A); extern pascal ComponentResult MusicDerivedSetInstrument(MusicComponent mc, long partNumber, GCPart *p) FIVEWORDINLINE(0x2F3C, 0x0008, 0x0203, 0x7000, 0xA82A); extern pascal ComponentResult MusicDerivedSetPartInstrumentNumber(MusicComponent mc, long partNumber, GCPart *p) FIVEWORDINLINE(0x2F3C, 0x0008, 0x0204, 0x7000, 0xA82A); extern pascal ComponentResult MusicDerivedSetMIDI(MusicComponent mc, MusicMIDISendProcPtr midiProc, long refcon, long midiChannel) FIVEWORDINLINE(0x2F3C, 0x000C, 0x0205, 0x7000, 0xA82A); extern pascal ComponentResult MusicDerivedStorePartInstrument(MusicComponent mc, long partNumber, GCPart *p, long instrumentNumber) FIVEWORDINLINE(0x2F3C, 0x000C, 0x0206, 0x7000, 0xA82A); /* Mask bit for returned value by InstrumentFind.*/ enum { kExactMatch = 0x00020000, kRecommendedSubstitute = 0x00010000, kQualityField = 0xFF000000, kRoland8BitQuality = 0x05000000 }; typedef InstrumentAboutInfo *InstrumentAboutInfoPtr; typedef InstrumentAboutInfoPtr *InstrumentAboutInfoHandle; struct GMInstrumentInfo { long cmpInstID; long gmInstNum; long instMatch; }; typedef struct GMInstrumentInfo GMInstrumentInfo; typedef GMInstrumentInfo *GMInstrumentInfoPtr; typedef GMInstrumentInfoPtr *GMInstrumentInfoHandle; /* do catagories count here??*/ struct nonGMInstrumentInfoRecord { long cmpInstID; /* if 0, category name*/ long flags; /* match, show in picker*/ long toneNameIndex; /* index in toneNames (1 based)*/ long itxtNameAtomID; /* index in itxtNames (itxt/name by index)*/ }; typedef struct nonGMInstrumentInfoRecord nonGMInstrumentInfoRecord; struct nonGMInstrumentInfo { long recordCount; Handle toneNames; /* name from tone description*/ QTAtomContainer itxtNames; /* itext/name atoms for instruments*/ nonGMInstrumentInfoRecord instInfo[1]; }; typedef struct nonGMInstrumentInfo nonGMInstrumentInfo; typedef nonGMInstrumentInfo *nonGMInstrumentInfoPtr; typedef nonGMInstrumentInfoPtr *nonGMInstrumentInfoHandle; struct InstCompInfo { long infoSize; /* size of this record*/ long GMinstrumentCount; GMInstrumentInfoHandle GMinstrumentInfo; long GMdrumCount; GMInstrumentInfoHandle GMdrumInfo; long nonGMinstrumentCount; nonGMInstrumentInfoHandle nonGMinstrumentInfo; long nonGMdrumCount; nonGMInstrumentInfoHandle nonGMdrumInfo; }; typedef struct InstCompInfo InstCompInfo; typedef InstCompInfo *InstCompInfoPtr; typedef InstCompInfoPtr *InstCompInfoHandle; extern pascal ComponentResult InstrumentGetInst(ComponentInstance ci, long instID, AtomicInstrument *atomicInst, long flags) FIVEWORDINLINE(0x2F3C, 0x000C, 0x0001, 0x7000, 0xA82A); extern pascal ComponentResult InstrumentGetInfo(ComponentInstance ci, InstCompInfoHandle *instInfo) FIVEWORDINLINE(0x2F3C, 0x0004, 0x0002, 0x7000, 0xA82A); extern pascal ComponentResult InstrumentInitialize(ComponentInstance ci, long initFormat, void *initParams) FIVEWORDINLINE(0x2F3C, 0x0008, 0x0003, 0x7000, 0xA82A); extern pascal ComponentResult InstrumentOpenComponentResFile(ComponentInstance ci, short *resFile) FIVEWORDINLINE(0x2F3C, 0x0004, 0x0004, 0x7000, 0xA82A); extern pascal ComponentResult InstrumentCloseComponentResFile(ComponentInstance ci, short resFile) FIVEWORDINLINE(0x2F3C, 0x0002, 0x0005, 0x7000, 0xA82A); extern pascal ComponentResult InstrumentGetComponentRefCon(ComponentInstance ci, void **refCon) FIVEWORDINLINE(0x2F3C, 0x0004, 0x0006, 0x7000, 0xA82A); extern pascal ComponentResult InstrumentSetComponentRefCon(ComponentInstance ci, void *refCon) FIVEWORDINLINE(0x2F3C, 0x0004, 0x0007, 0x7000, 0xA82A); /* -------------------------- Types -------------------------- */ enum { kSynthesizerConnectionMono = 1, /* if set, and synth can be mono/poly, then the partCount channels from the system channel are hogged */ kSynthesizerConnectionMMgr = 2, /* this connection imported from the MIDI Mgr */ kSynthesizerConnectionOMS = 4, /* this connection imported from OMS */ kSynthesizerConnectionQT = 8, /* this connection is a QuickTime-only port */ kSynthesizerConnectionFMS = 16 /* this connection imported from FMS */ }; /* used for MIDI device only */ struct SynthesizerConnections { OSType clientID; OSType inputPortID; /* terminology death: this port is used to SEND to the midi synth */ OSType outputPortID; /* terminology death: this port receives from a keyboard or other control device */ long midiChannel; /* The system channel; others are configurable (or the nubus slot number) */ long flags; long unique; /* unique id may be used instead of index, to getinfo and unregister calls */ long reserved1; /* should be zero */ long reserved2; /* should be zero */ }; typedef struct SynthesizerConnections SynthesizerConnections; struct QTMIDIPort { SynthesizerConnections portConnections; Str63 portName; }; typedef struct QTMIDIPort QTMIDIPort; enum { kNoteRequestNoGM = 1, /* dont degrade to a GM synth */ kNoteRequestNoSynthType = 2 /* dont degrade to another synth of same type but different name */ }; typedef ComponentInstance NoteAllocator; struct NoteRequestInfo { UInt8 flags; /* 1: dont accept GM match, 2: dont accept same-synth-type match */ UInt8 reserved; /* must be zero */ short polyphony; /* Maximum number of voices */ Fixed typicalPolyphony; /* Hint for level mixing */ }; typedef struct NoteRequestInfo NoteRequestInfo; struct NoteRequest { NoteRequestInfo info; ToneDescription tone; }; typedef struct NoteRequest NoteRequest; typedef struct OpaqueNoteChannel* NoteChannel; enum { kPickDontMix = 1, /* dont mix instruments with drum sounds */ kPickSameSynth = 2, /* only allow the same device that went in, to come out */ kPickUserInsts = 4, /* show user insts in addition to ROM voices */ kPickEditAllowEdit = 8, /* lets user switch over to edit mode */ kPickEditAllowPick = 16, /* lets the user switch over to pick mode */ kPickEditSynthGlobal = 32, /* edit the global knobs of the synth */ kPickEditControllers = 64 /* edit the controllers of the notechannel */ }; enum { kNoteAllocatorType = 'nota' }; struct NAStatPiece { Str31 clientName; Str31 synthesizerName; long part; long midiChannel; long polyphony; long valid; NoteChannel nc; }; typedef struct NAStatPiece NAStatPiece; struct NAStat { long pieceCount; NAStatPiece piece[64]; }; typedef struct NAStat NAStat; /* -------------------------------- Note Allocator Prototypes -------------------------------- */ /* * System Configuration */ extern pascal ComponentResult NARegisterMusicDevice(NoteAllocator ci, OSType synthType, Str31 name, SynthesizerConnections *connections) FIVEWORDINLINE(0x2F3C, 0x000C, 0x0000, 0x7000, 0xA82A); extern pascal ComponentResult NAUnregisterMusicDevice(NoteAllocator ci, long index) FIVEWORDINLINE(0x2F3C, 0x0004, 0x0001, 0x7000, 0xA82A); extern pascal ComponentResult NAGetRegisteredMusicDevice(NoteAllocator ci, long index, OSType *synthType, Str31 name, SynthesizerConnections *connections, MusicComponent *mc) FIVEWORDINLINE(0x2F3C, 0x0014, 0x0002, 0x7000, 0xA82A); extern pascal ComponentResult NASaveMusicConfiguration(NoteAllocator ci) FIVEWORDINLINE(0x2F3C, 0x0000, 0x0003, 0x7000, 0xA82A); extern pascal ComponentResult NANewNoteChannel(NoteAllocator ci, NoteRequest *noteRequest, NoteChannel *outChannel) FIVEWORDINLINE(0x2F3C, 0x0008, 0x0004, 0x7000, 0xA82A); extern pascal ComponentResult NADisposeNoteChannel(NoteAllocator ci, NoteChannel noteChannel) FIVEWORDINLINE(0x2F3C, 0x0004, 0x0005, 0x7000, 0xA82A); extern pascal ComponentResult NAGetNoteChannelInfo(NoteAllocator ci, NoteChannel noteChannel, long *index, long *part) FIVEWORDINLINE(0x2F3C, 0x000C, 0x0006, 0x7000, 0xA82A); extern pascal ComponentResult NAPrerollNoteChannel(NoteAllocator ci, NoteChannel noteChannel) FIVEWORDINLINE(0x2F3C, 0x0004, 0x0007, 0x7000, 0xA82A); extern pascal ComponentResult NAUnrollNoteChannel(NoteAllocator ci, NoteChannel noteChannel) FIVEWORDINLINE(0x2F3C, 0x0004, 0x0008, 0x7000, 0xA82A); extern pascal ComponentResult NASetNoteChannelVolume(NoteAllocator ci, NoteChannel noteChannel, Fixed volume) FIVEWORDINLINE(0x2F3C, 0x0008, 0x000B, 0x7000, 0xA82A); extern pascal ComponentResult NAResetNoteChannel(NoteAllocator ci, NoteChannel noteChannel) FIVEWORDINLINE(0x2F3C, 0x0004, 0x000C, 0x7000, 0xA82A); extern pascal ComponentResult NAPlayNote(NoteAllocator ci, NoteChannel noteChannel, long pitch, long velocity) FIVEWORDINLINE(0x2F3C, 0x000C, 0x000D, 0x7000, 0xA82A); extern pascal ComponentResult NASetController(NoteAllocator ci, NoteChannel noteChannel, long controllerNumber, long controllerValue) FIVEWORDINLINE(0x2F3C, 0x000C, 0x000E, 0x7000, 0xA82A); extern pascal ComponentResult NASetKnob(NoteAllocator ci, NoteChannel noteChannel, long knobNumber, long knobValue) FIVEWORDINLINE(0x2F3C, 0x000C, 0x000F, 0x7000, 0xA82A); extern pascal ComponentResult NAFindNoteChannelTone(NoteAllocator ci, NoteChannel noteChannel, ToneDescription *td, long *instrumentNumber) FIVEWORDINLINE(0x2F3C, 0x000C, 0x0010, 0x7000, 0xA82A); extern pascal ComponentResult NASetInstrumentNumber(NoteAllocator ci, NoteChannel noteChannel, long instrumentNumber) FIVEWORDINLINE(0x2F3C, 0x0008, 0x0011, 0x7000, 0xA82A); #if OLDROUTINENAMES #define NASetNoteChannelInstrument(ci, noteChannel,instrumentNumber ) NASetInstrumentNumber(ci, noteChannel,instrumentNumber) #define NASetInstrument(ci, noteChannel,instrumentNumber ) NASetInstrumentNumber(ci, noteChannel,instrumentNumber) #endif extern pascal ComponentResult NAPickInstrument(NoteAllocator ci, ModalFilterUPP filterProc, StringPtr prompt, ToneDescription *sd, unsigned long flags, long refCon, long reserved1, long reserved2) FIVEWORDINLINE(0x2F3C, 0x001C, 0x0012, 0x7000, 0xA82A); extern pascal ComponentResult NAPickArrangement(NoteAllocator ci, ModalFilterUPP filterProc, StringPtr prompt, long zero1, long zero2, Track t, StringPtr songName) FIVEWORDINLINE(0x2F3C, 0x0018, 0x0013, 0x7000, 0xA82A); extern pascal ComponentResult NAGetStatusBlock(NoteAllocator ci, NAStat *stat) FIVEWORDINLINE(0x2F3C, 0x0004, 0x0014, 0x7000, 0xA82A); extern pascal ComponentResult NASetDefaultMIDIInput(NoteAllocator ci, SynthesizerConnections *sc) FIVEWORDINLINE(0x2F3C, 0x0004, 0x0015, 0x7000, 0xA82A); extern pascal ComponentResult NAGetDefaultMIDIInput(NoteAllocator ci, SynthesizerConnections *sc) FIVEWORDINLINE(0x2F3C, 0x0004, 0x0016, 0x7000, 0xA82A); extern pascal ComponentResult NAUseDefaultMIDIInput(NoteAllocator ci, MusicMIDIReadHookUPP readHook, long refCon, unsigned long flags) FIVEWORDINLINE(0x2F3C, 0x000C, 0x0019, 0x7000, 0xA82A); extern pascal ComponentResult NALoseDefaultMIDIInput(NoteAllocator ci) FIVEWORDINLINE(0x2F3C, 0x0000, 0x001A, 0x7000, 0xA82A); extern pascal ComponentResult NAStuffToneDescription(NoteAllocator ci, long gmNumber, ToneDescription *td) FIVEWORDINLINE(0x2F3C, 0x0008, 0x001B, 0x7000, 0xA82A); extern pascal ComponentResult NACopyrightDialog(NoteAllocator ci, PicHandle p, StringPtr author, StringPtr copyright, StringPtr other, StringPtr title, ModalFilterUPP filterProc, long refCon) FIVEWORDINLINE(0x2F3C, 0x001C, 0x001C, 0x7000, 0xA82A); extern pascal ComponentResult NAGetMIDIPorts(NoteAllocator ci, Handle *inputPorts, Handle *outputPorts) FIVEWORDINLINE(0x2F3C, 0x0008, 0x0021, 0x7000, 0xA82A); extern pascal ComponentResult NAGetNoteRequest(NoteAllocator ci, NoteChannel noteChannel, NoteRequest *nrOut) FIVEWORDINLINE(0x2F3C, 0x0008, 0x0022, 0x7000, 0xA82A); extern pascal ComponentResult NASendMIDI(NoteAllocator ci, NoteChannel noteChannel, MusicMIDIPacket *mp) FIVEWORDINLINE(0x2F3C, 0x0008, 0x0023, 0x7000, 0xA82A); extern pascal ComponentResult NAPickEditInstrument(NoteAllocator ci, ModalFilterUPP filterProc, StringPtr prompt, long refCon, NoteChannel nc, AtomicInstrument ai, long flags) FIVEWORDINLINE(0x2F3C, 0x0018, 0x0024, 0x7000, 0xA82A); extern pascal ComponentResult NANewNoteChannelFromAtomicInstrument(NoteAllocator ci, AtomicInstrumentPtr instrument, long flags, NoteChannel *outChannel) FIVEWORDINLINE(0x2F3C, 0x000C, 0x0025, 0x7000, 0xA82A); extern pascal ComponentResult NASetAtomicInstrument(NoteAllocator ci, NoteChannel noteChannel, AtomicInstrumentPtr instrument, long flags) FIVEWORDINLINE(0x2F3C, 0x000C, 0x0026, 0x7000, 0xA82A); extern pascal ComponentResult NAGetKnob(NoteAllocator ci, NoteChannel noteChannel, long knobNumber, long *knobValue) FIVEWORDINLINE(0x2F3C, 0x000C, 0x0028, 0x7000, 0xA82A); extern pascal ComponentResult NATask(NoteAllocator ci) FIVEWORDINLINE(0x2F3C, 0x0000, 0x0029, 0x7000, 0xA82A); extern pascal ComponentResult NASetNoteChannelBalance(NoteAllocator ci, NoteChannel noteChannel, long balance) FIVEWORDINLINE(0x2F3C, 0x0008, 0x002A, 0x7000, 0xA82A); enum { kTuneQueueDepth = 8 /* Deepest you can queue tune segments */ }; struct TuneStatus { unsigned long * tune; /* currently playing tune */ unsigned long * tunePtr; /* position within currently playing piece */ TimeValue time; /* current tune time */ short queueCount; /* how many pieces queued up? */ short queueSpots; /* How many more tunepieces can be queued */ TimeValue queueTime; /* How much time is queued up? (can be very inaccurate) */ long reserved[3]; }; typedef struct TuneStatus TuneStatus; enum { kStopTuneFade = 1, /* do a quick, synchronous fadeout */ kStopTuneSustain = 2, /* don't silece notes */ kStopTuneInstant = 4, /* silence notes fast (else, decay them) */ kStopTuneReleaseChannels = 8 /* afterwards, let the channels go */ }; typedef pascal void (*TuneCallBackProcPtr)(const TuneStatus *status, long refCon); typedef pascal void (*TunePlayCallBackProcPtr)(unsigned long *event, long seed, long refCon); #if GENERATINGCFM typedef UniversalProcPtr TuneCallBackUPP; typedef UniversalProcPtr TunePlayCallBackUPP; #else typedef TuneCallBackProcPtr TuneCallBackUPP; typedef TunePlayCallBackProcPtr TunePlayCallBackUPP; #endif typedef ComponentInstance TunePlayer; enum { kMaxTunePlayerParts = 48, kTunePlayerType = 'tune' }; extern pascal ComponentResult TuneSetHeader(TunePlayer tp, unsigned long *header) FIVEWORDINLINE(0x2F3C, 0x0004, 0x0004, 0x7000, 0xA82A); extern pascal ComponentResult TuneGetTimeBase(TunePlayer tp, TimeBase *tb) FIVEWORDINLINE(0x2F3C, 0x0004, 0x0005, 0x7000, 0xA82A); extern pascal ComponentResult TuneSetTimeScale(TunePlayer tp, TimeScale scale) FIVEWORDINLINE(0x2F3C, 0x0004, 0x0006, 0x7000, 0xA82A); extern pascal ComponentResult TuneGetTimeScale(TunePlayer tp, TimeScale *scale) FIVEWORDINLINE(0x2F3C, 0x0004, 0x0007, 0x7000, 0xA82A); extern pascal ComponentResult TuneGetIndexedNoteChannel(TunePlayer tp, long i, NoteChannel *nc) FIVEWORDINLINE(0x2F3C, 0x0008, 0x0008, 0x7000, 0xA82A); /* Values for when to start. */ enum { kTuneStartNow = 1, /* start after buffer is implied */ kTuneDontClipNotes = 2, /* allow notes to finish their durations outside sample */ kTuneExcludeEdgeNotes = 4, /* dont play notes that start at end of tune */ kTuneQuickStart = 8, /* Leave all the controllers where they are, ignore start time */ kTuneLoopUntil = 16, /* loop a queued tune if there's nothing else in the queue */ kTuneStartNewMaster = 16384 }; extern pascal ComponentResult TuneQueue(TunePlayer tp, unsigned long *tune, Fixed tuneRate, unsigned long tuneStartPosition, unsigned long tuneStopPosition, unsigned long queueFlags, TuneCallBackUPP callBackProc, long refCon) FIVEWORDINLINE(0x2F3C, 0x001C, 0x000A, 0x7000, 0xA82A); extern pascal ComponentResult TuneInstant(TunePlayer tp, void *tune, long tunePosition) FIVEWORDINLINE(0x2F3C, 0x0008, 0x000B, 0x7000, 0xA82A); extern pascal ComponentResult TuneGetStatus(TunePlayer tp, TuneStatus *status) FIVEWORDINLINE(0x2F3C, 0x0004, 0x000C, 0x7000, 0xA82A); /* Values for when to start. */ enum { kStopSustain = 1, /* Leaves notes playing, not silent */ kStopFadeout = 2 /* Does a synchronous fade-out */ }; extern pascal ComponentResult TuneStop(TunePlayer tp, long stopFlags) FIVEWORDINLINE(0x2F3C, 0x0004, 0x000D, 0x7000, 0xA82A); extern pascal ComponentResult TuneSetVolume(TunePlayer tp, Fixed volume) FIVEWORDINLINE(0x2F3C, 0x0004, 0x0010, 0x7000, 0xA82A); extern pascal ComponentResult TuneGetVolume(TunePlayer tp) FIVEWORDINLINE(0x2F3C, 0x0000, 0x0011, 0x7000, 0xA82A); extern pascal ComponentResult TunePreroll(TunePlayer tp) FIVEWORDINLINE(0x2F3C, 0x0000, 0x0012, 0x7000, 0xA82A); extern pascal ComponentResult TuneUnroll(TunePlayer tp) FIVEWORDINLINE(0x2F3C, 0x0000, 0x0013, 0x7000, 0xA82A); extern pascal ComponentResult TuneSetNoteChannels(TunePlayer tp, unsigned long count, NoteChannel *noteChannelList, TunePlayCallBackUPP playCallBackProc, long refCon) FIVEWORDINLINE(0x2F3C, 0x0010, 0x0014, 0x7000, 0xA82A); extern pascal ComponentResult TuneSetPartTranspose(TunePlayer tp, unsigned long part, long transpose, long velocityShift) FIVEWORDINLINE(0x2F3C, 0x000C, 0x0015, 0x7000, 0xA82A); extern pascal NoteAllocator TuneGetNoteAllocator(TunePlayer tp) FIVEWORDINLINE(0x2F3C, 0x0000, 0x0017, 0x7000, 0xA82A); extern pascal ComponentResult TuneSetSofter(TunePlayer tp, long softer) FIVEWORDINLINE(0x2F3C, 0x0004, 0x0018, 0x7000, 0xA82A); extern pascal ComponentResult TuneTask(TunePlayer tp) FIVEWORDINLINE(0x2F3C, 0x0000, 0x0019, 0x7000, 0xA82A); extern pascal ComponentResult TuneSetBalance(TunePlayer tp, long balance) FIVEWORDINLINE(0x2F3C, 0x0004, 0x001A, 0x7000, 0xA82A); typedef unsigned long MusicOpWord; typedef unsigned long *MusicOpWordPtr; /* QuickTime Music Track Event Formats: At this time, QuickTime music tracks support 5 different event types -- REST events, short NOTE events, short CONTROL events, short GENERAL events, Long NOTE events, long CONTROL events, and variable GENERAL events. Ľ REST Event (4 bytes/event): (0 0 0) (5-bit UNUSED) (24-bit Rest Duration) ĽĘShort NOTE Events (4 bytes/event): (0 0 1) (5-bit Part) (6-bit Pitch) (7-bit Volume) (11-bit Duration) where: Pitch is offset by 32 (Actual pitch = pitch field + 32) ĽĘShort CONTROL Events (4 bytes/event): (0 1 0) (5-bit Part) (8-bit Controller) (1-bit UNUSED) (1-bit Sign) (7-bit MSB) (7-bit LSB) ( or 15-bit Signed Value) Ľ Short GENERAL Event (4 bytes/event): (0 1 1) (1-bit UNUSED) (12-bit Sub-Type) (16-bit Value) Ľ Long NOTE Events (8 bytes/event): (1 0 0 1) (12-bit Part) (1-bit UNUSED) (7-bit Pitch) (1-bit UNUSED) (7-bit Volume) (1 0) (8-bit UNUSED) (22-bit Duration) ĽĘLong CONTROL Event (8 bytes/event): (1 0 1 0) (12-bit Part) (16-bit Value MSB) (1 0) (14-bit Controller) (16-bit Value LSB) ĽĘLong KNOB Event (8 bytes/event): (1 0 1 1) (12-bit Sub-Type) (16-bit Value MSB) (1 0) (14-bit KNOB) (16-bit Value LSB) ĽĘVariable GENERAL Length Events (N bytes/event): (1 1 1 1) (12-bit Sub-Type) (16-bit Length) : (32-bit Data values) : (1 1) (14-bit UNUSED) (16-bit Length) where: Length field is the number of LONG words in the record. Lengths include the first and last long words (Minimum length = 2) The following event type values have not been used yet and are reserved for future expansion: Ľ (1 0 0 0) (8 bytes/event) Ľ (1 1 0 0) (N bytes/event) Ľ (1 1 0 1) (N bytes/event) Ľ (1 1 1 0) (N bytes/event) For all events, the following generalizations apply: - All duration values are specified in Millisecond units. - Pitch values are intended to map directly to the MIDI key numbers. - Controllers from 0 to 127 correspond to the standard MIDI controllers. Controllers greater than 127 correspond to other controls (i.e., Pitch Bend, Key Pressure, and Channel Pressure). */ /* Defines for the implemented music event data fields*/ enum { kRestEventType = 0x00000000, /* lower 3-bits */ kNoteEventType = 0x00000001, /* lower 3-bits */ kControlEventType = 0x00000002, /* lower 3-bits */ kMarkerEventType = 0x00000003, /* lower 3-bits */ kUndefined1EventType = 0x00000008, /* 4-bits */ kXNoteEventType = 0x00000009, /* 4-bits */ kXControlEventType = 0x0000000A, /* 4-bits */ kKnobEventType = 0x0000000B, /* 4-bits */ kUndefined2EventType = 0x0000000C, /* 4-bits */ kUndefined3EventType = 0x0000000D, /* 4-bits */ kUndefined4EventType = 0x0000000E, /* 4-bits */ kGeneralEventType = 0x0000000F, /* 4-bits */ kXEventLengthBits = 0x00000002, /* 2 bits: indicates 8-byte event record */ kGeneralEventLengthBits = 0x00000003, /* 2 bits: indicates variable length event record */ kEventLen = 1L, /* length of events in long words */ kXEventLen = 2L, kRestEventLen = kEventLen, /* length of events in long words */ kNoteEventLen = kEventLen, kControlEventLen = kEventLen, kMarkerEventLen = kEventLen, kXNoteEventLen = kXEventLen, kXControlEventLen = kXEventLen, kGeneralEventLen = kXEventLen, /* 2 or more, however */ /* Universal Event Defines*/ kEventLengthFieldPos = 30, /* by looking at these two bits of the 1st or last word */ kEventLengthFieldWidth = 2, /* of an event you can determine the event length */ /* length field: 0 & 1 => 1 long; 2 => 2 longs; 3 => variable length */ kEventTypeFieldPos = 29, /* event type field for short events */ kEventTypeFieldWidth = 3, /* short type is 3 bits */ kXEventTypeFieldPos = 28, /* event type field for extended events */ kXEventTypeFieldWidth = 4, /* extended type is 4 bits */ kEventPartFieldPos = 24, kEventPartFieldWidth = 5, kXEventPartFieldPos = 16, /* in the 1st long word */ kXEventPartFieldWidth = 12, /* Rest Events*/ kRestEventDurationFieldPos = 0, kRestEventDurationFieldWidth = 24, kRestEventDurationMax = ((1L << kRestEventDurationFieldWidth) - 1), /* Note Events*/ kNoteEventPitchFieldPos = 18, kNoteEventPitchFieldWidth = 6, kNoteEventPitchOffset = 32, /* add to value in pitch field to get actual pitch */ kNoteEventVolumeFieldPos = 11, kNoteEventVolumeFieldWidth = 7, kNoteEventVolumeOffset = 0, /* add to value in volume field to get actual volume */ kNoteEventDurationFieldPos = 0, kNoteEventDurationFieldWidth = 11, kNoteEventDurationMax = ((1L << kNoteEventDurationFieldWidth) - 1), kXNoteEventPitchFieldPos = 0, /* in the 1st long word */ kXNoteEventPitchFieldWidth = 16, kXNoteEventDurationFieldPos = 0, /* in the 2nd long word */ kXNoteEventDurationFieldWidth = 22, kXNoteEventDurationMax = ((1L << kXNoteEventDurationFieldWidth) - 1), kXNoteEventVolumeFieldPos = 22, /* in the 2nd long word */ kXNoteEventVolumeFieldWidth = 7, /* Control Events*/ kControlEventControllerFieldPos = 16, kControlEventControllerFieldWidth = 8, kControlEventValueFieldPos = 0, kControlEventValueFieldWidth = 16, kXControlEventControllerFieldPos = 0, /* in the 2nd long word */ kXControlEventControllerFieldWidth = 16, kXControlEventValueFieldPos = 0, /* in the 1st long word */ kXControlEventValueFieldWidth = 16, /* Knob Events*/ kKnobEventValueHighFieldPos = 0, /* 1st long word */ kKnobEventValueHighFieldWidth = 16, kKnobEventKnobFieldPos = 16, /* 2nd long word */ kKnobEventKnobFieldWidth = 14, kKnobEventValueLowFieldPos = 0, /* 2nd long word */ kKnobEventValueLowFieldWidth = 16, /* Marker Events*/ kMarkerEventSubtypeFieldPos = 16, kMarkerEventSubtypeFieldWidth = 8, kMarkerEventValueFieldPos = 0, kMarkerEventValueFieldWidth = 16, /* General Events*/ kGeneralEventSubtypeFieldPos = 16, /* in the last long word */ kGeneralEventSubtypeFieldWidth = 14, kGeneralEventLengthFieldPos = 0, /* in the 1st & last long words */ kGeneralEventLengthFieldWidth = 16 }; /* macros for extracting various fields from the QuickTime event records*/ #define MASK(bitWidth) ((1L << (bitWidth)) - 1) #define EXT(val, pos, width) (((val) >> (pos)) & MASK(width)) #define _EventLength(x) ((EXT(x, kEventLengthFieldPos, kEventLengthFieldWidth) < 2) ? 1 : ((EXT(x, kEventLengthFieldPos, kEventLengthFieldWidth) == 2) ? 2 : EXT(x, kGeneralEventLengthFieldPos, kGeneralEventLengthFieldWidth))) #define _EventType(x) ((EXT(x, kEventTypeFieldPos, kEventTypeFieldWidth) > 3) ? EXT(x, kXEventTypeFieldPos, kXEventTypeFieldWidth) : EXT(x, kEventTypeFieldPos, kEventTypeFieldWidth)) #define _RestDuration(x) (EXT(x, kRestEventDurationFieldPos, kRestEventDurationFieldWidth)) #define _Part(x) (EXT(x, kEventPartFieldPos, kEventPartFieldWidth)) #define _XPart(m, l) (EXT(m, kXEventPartFieldPos, kXEventPartFieldWidth)) #define _NotePitch(x) (EXT(x, kNoteEventPitchFieldPos, kNoteEventPitchFieldWidth) + kNoteEventPitchOffset) #define _NoteVolume(x) (EXT(x, kNoteEventVolumeFieldPos, kNoteEventVolumeFieldWidth) + kNoteEventVolumeOffset) #define _NoteDuration(x) (EXT(x, kNoteEventDurationFieldPos, kNoteEventDurationFieldWidth)) #define _NoteVelocity _NoteVolume #define _XNotePitch(m, l) (EXT(m, kXNoteEventPitchFieldPos, kXNoteEventPitchFieldWidth)) #define _XNoteVolume(m, l) (EXT(l, kXNoteEventVolumeFieldPos, kXNoteEventVolumeFieldWidth)) #define _XNoteDuration(m, l) (EXT(l, kXNoteEventDurationFieldPos, kXNoteEventDurationFieldWidth)) #define _XNoteVelocity _XNoteVolume #define _ControlController(x) (EXT(x, kControlEventControllerFieldPos, kControlEventControllerFieldWidth)) #define _ControlValue(x) (EXT(x, kControlEventValueFieldPos, kControlEventValueFieldWidth)) #define _XControlController(m, l) (EXT(l, kXControlEventControllerFieldPos, kXControlEventControllerFieldWidth)) #define _XControlValue(m, l) (EXT(m, kXControlEventValueFieldPos, kXControlEventValueFieldWidth)) #define _MarkerSubtype(x) (EXT(x,kMarkerEventSubtypeFieldPos,kMarkerEventSubtypeFieldWidth)) #define _MarkerValue(x) (EXT(x, kMarkerEventValueFieldPos, kMarkerEventValueFieldWidth)) #define _KnobValue(m,l) ((EXT(m,kKnobEventValueHighFieldPos,kKnobEventValueHighFieldWidth) << 16) | (EXT(l,kKnobEventValueLowFieldPos,kKnobEventValueLowFieldWidth))) #define _KnobKnob(m,l) (EXT(l,kKnobEventKnobFieldPos,kKnobEventKnobFieldWidth)) #define _GeneralSubtype(m,l) (EXT(l,kGeneralEventSubtypeFieldPos,kGeneralEventSubtypeFieldWidth)) #define _GeneralLength(m,l) (EXT(m,kGeneralEventLengthFieldPos,kGeneralEventLengthFieldWidth)) #define _StuffRestEvent(x, duration) x = (kRestEventType << kEventTypeFieldPos) | ((long)(duration) << kRestEventDurationFieldPos) #define _StuffNoteEvent(x, part, pitch, volume, duration) x = (kNoteEventType << kEventTypeFieldPos) | ((long)(part) << kEventPartFieldPos) | (((long)(pitch) - kNoteEventPitchOffset) << kNoteEventPitchFieldPos) | (((long)(volume) - kNoteEventVolumeOffset) << kNoteEventVolumeFieldPos) | ((long)(duration) << kNoteEventDurationFieldPos) #define _StuffControlEvent(x, part, control, value) x = (kControlEventType << kEventTypeFieldPos) | ((long)(part) << kEventPartFieldPos) | ((long)(control) << kControlEventControllerFieldPos) | ((long)((value) & MASK(kControlEventValueFieldWidth)) << kControlEventValueFieldPos) #define _StuffMarkerEvent(x, markerType, markerValue) x = (kMarkerEventType << kEventTypeFieldPos) | ((long)(markerType) << kMarkerEventSubtypeFieldPos) | ((long)(markerValue) << kMarkerEventValueFieldPos) w1 = (kXNoteEventType << kXEventTypeFieldPos) | ((long)(part) << kXEventPartFieldPos) | ((long)(pitch) << kXNoteEventPitchFieldPos), w2 = (kXEventLengthBits << kEventLengthFieldPos) | ((long)(duration) << kXNoteEventDurationFieldPos) | ((long)(volume) << kXNoteEventVolumeFieldPos) #define _StuffXControlEvent(w1, w2, part, control, value) w1 = (kXControlEventType << kXEventTypeFieldPos) | ((long)(part) << kXEventPartFieldPos) | ((long)((value) & MASK(kXControlEventValueFieldWidth)) << kXControlEventValueFieldPos), w2 = (kXEventLengthBits << kEventLengthFieldPos) | ((long)(control) << kXControlEventControllerFieldPos) #define _StuffKnobEvent(w1, w2, part, knob, value) w1 = (kKnobEventType << kXEventTypeFieldPos) | ((long)(part) << kXEventPartFieldPos) | ((long)(value >> 16) << kKnobEventValueLowFieldPos), w2 = (kXEventLengthBits << kEventLengthFieldPos) | ((long)(knob) << kKnobEventKnobFieldPos) | ((long)(value & 0xFFFF) << kKnobEventValueLowFieldPos) #define _StuffGeneralEvent(w1,w2,part,subType,length) w1 = (kGeneralEventType << kXEventTypeFieldPos) | ((long)(part) << kXEventPartFieldPos) | ((long)(length) << kGeneralEventLengthFieldPos), w2 = (kGeneralEventLengthBits << kEventLengthFieldPos) | ((long)(subType) << kGeneralEventSubtypeFieldPos) | ((long)(length) << kGeneralEventLengthFieldPos) /* General Event Defined Types*/ enum { kGeneralEventNoteRequest = 1, /* Encapsulates NoteRequest data structure */ kGeneralEventPartKey = 4, kGeneralEventTuneDifference = 5, /* Contains a standard sequence, with end marker, for the tune difference of a sequence piece */ kGeneralEventAtomicInstrument = 6, /* Encapsulates AtomicInstrument record */ kGeneralEventKnob = 7, /* knobID/knobValue pairs; smallest event is 4 longs */ kGeneralEventMIDIChannel = 8 /* used in tune header, one longword identifies the midi channel it originally came from */ }; /* Marker Event Defined Types // marker is 60 ee vv vv in hex, where e = event type, and v = value*/ enum { kMarkerEventEnd = 0, /* marker type 0 means: value 0 - stop, value != 0 - ignore*/ kMarkerEventBeat = 1, /* value 0 = single beat; anything else is 65536ths-of-a-beat (quarter note)*/ kMarkerEventTempo = 2 /* value same as beat marker, but indicates that a tempo event should be computed (based on where the next beat or tempo marker is) and emitted upon export*/ }; /* UPP call backs */ #if GENERATINGCFM #else #endif enum { uppMusicMIDISendProcInfo = kPascalStackBased | RESULT_SIZE(SIZE_CODE(sizeof(ComponentResult))) | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(MusicComponent))) | STACK_ROUTINE_PARAMETER(2, SIZE_CODE(sizeof(long))) | STACK_ROUTINE_PARAMETER(3, SIZE_CODE(sizeof(MusicMIDIPacket *))), uppMusicMIDIReadHookProcInfo = kPascalStackBased | RESULT_SIZE(SIZE_CODE(sizeof(ComponentResult))) | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(MusicMIDIPacket *))) | STACK_ROUTINE_PARAMETER(2, SIZE_CODE(sizeof(long))), uppMusicOfflineDataProcInfo = kPascalStackBased | RESULT_SIZE(SIZE_CODE(sizeof(ComponentResult))) | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(Ptr))) | STACK_ROUTINE_PARAMETER(2, SIZE_CODE(sizeof(long))) | STACK_ROUTINE_PARAMETER(3, SIZE_CODE(sizeof(long))), uppTuneCallBackProcInfo = kPascalStackBased | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(const TuneStatus *))) | STACK_ROUTINE_PARAMETER(2, SIZE_CODE(sizeof(long))), uppTunePlayCallBackProcInfo = kPascalStackBased | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(unsigned long *))) | STACK_ROUTINE_PARAMETER(2, SIZE_CODE(sizeof(long))) | STACK_ROUTINE_PARAMETER(3, SIZE_CODE(sizeof(long))) }; #if GENERATINGCFM #define NewMusicMIDISendProc(userRoutine) \ (MusicMIDISendUPP) NewRoutineDescriptor((ProcPtr)(userRoutine), uppMusicMIDISendProcInfo, GetCurrentArchitecture()) #define NewMusicMIDIReadHookProc(userRoutine) \ (MusicMIDIReadHookUPP) NewRoutineDescriptor((ProcPtr)(userRoutine), uppMusicMIDIReadHookProcInfo, GetCurrentArchitecture()) #define NewMusicOfflineDataProc(userRoutine) \ (MusicOfflineDataUPP) NewRoutineDescriptor((ProcPtr)(userRoutine), uppMusicOfflineDataProcInfo, GetCurrentArchitecture()) #define NewTuneCallBackProc(userRoutine) \ (TuneCallBackUPP) NewRoutineDescriptor((ProcPtr)(userRoutine), uppTuneCallBackProcInfo, GetCurrentArchitecture()) #define NewTunePlayCallBackProc(userRoutine) \ (TunePlayCallBackUPP) NewRoutineDescriptor((ProcPtr)(userRoutine), uppTunePlayCallBackProcInfo, GetCurrentArchitecture()) #else #define NewMusicMIDISendProc(userRoutine) \ ((MusicMIDISendUPP) (userRoutine)) #define NewMusicMIDIReadHookProc(userRoutine) \ ((MusicMIDIReadHookUPP) (userRoutine)) #define NewMusicOfflineDataProc(userRoutine) \ ((MusicOfflineDataUPP) (userRoutine)) #define NewTuneCallBackProc(userRoutine) \ ((TuneCallBackUPP) (userRoutine)) #define NewTunePlayCallBackProc(userRoutine) \ ((TunePlayCallBackUPP) (userRoutine)) #endif #if GENERATINGCFM #define CallMusicMIDISendProc(userRoutine, self, refCon, mmp) \ CallUniversalProc((UniversalProcPtr)(userRoutine), uppMusicMIDISendProcInfo, (self), (refCon), (mmp)) #define CallMusicMIDIReadHookProc(userRoutine, mp, myRefCon) \ CallUniversalProc((UniversalProcPtr)(userRoutine), uppMusicMIDIReadHookProcInfo, (mp), (myRefCon)) #define CallMusicOfflineDataProc(userRoutine, SoundData, numBytes, myRefCon) \ CallUniversalProc((UniversalProcPtr)(userRoutine), uppMusicOfflineDataProcInfo, (SoundData), (numBytes), (myRefCon)) #define CallTuneCallBackProc(userRoutine, status, refCon) \ CallUniversalProc((UniversalProcPtr)(userRoutine), uppTuneCallBackProcInfo, (status), (refCon)) #define CallTunePlayCallBackProc(userRoutine, event, seed, refCon) \ CallUniversalProc((UniversalProcPtr)(userRoutine), uppTunePlayCallBackProcInfo, (event), (seed), (refCon)) #else #define CallMusicMIDISendProc(userRoutine, self, refCon, mmp) \ (*(userRoutine))((self), (refCon), (mmp)) #define CallMusicMIDIReadHookProc(userRoutine, mp, myRefCon) \ (*(userRoutine))((mp), (myRefCon)) #define CallMusicOfflineDataProc(userRoutine, SoundData, numBytes, myRefCon) \ (*(userRoutine))((SoundData), (numBytes), (myRefCon)) #define CallTuneCallBackProc(userRoutine, status, refCon) \ (*(userRoutine))((status), (refCon)) #define CallTunePlayCallBackProc(userRoutine, event, seed, refCon) \ (*(userRoutine))((event), (seed), (refCon)) #endif /* selectors for component calls */ enum { kMusicGetDescriptionSelect = 0x0001, kMusicGetPartSelect = 0x0002, kMusicSetPartSelect = 0x0003, kMusicSetPartInstrumentNumberSelect = 0x0004, kMusicGetPartInstrumentNumberSelect = 0x0005, kMusicStorePartInstrumentSelect = 0x0006, kMusicGetPartAtomicInstrumentSelect = 0x0009, kMusicSetPartAtomicInstrumentSelect = 0x000A, kMusicGetInstrumentKnobDescriptionObsoleteSelect = 0x000D, kMusicGetDrumKnobDescriptionObsoleteSelect = 0x000E, kMusicGetKnobDescriptionObsoleteSelect = 0x000F, kMusicGetPartKnobSelect = 0x0010, kMusicSetPartKnobSelect = 0x0011, kMusicGetKnobSelect = 0x0012, kMusicSetKnobSelect = 0x0013, kMusicGetPartNameSelect = 0x0014, kMusicSetPartNameSelect = 0x0015, kMusicFindToneSelect = 0x0016, kMusicPlayNoteSelect = 0x0017, kMusicResetPartSelect = 0x0018, kMusicSetPartControllerSelect = 0x0019, kMusicGetPartControllerSelect = 0x001A, kMusicGetMIDIProcSelect = 0x001B, kMusicSetMIDIProcSelect = 0x001C, kMusicGetInstrumentNamesSelect = 0x001D, kMusicGetDrumNamesSelect = 0x001E, kMusicGetMasterTuneSelect = 0x001F, kMusicSetMasterTuneSelect = 0x0020, kMusicGetInstrumentAboutInfoSelect = 0x0022, kMusicGetDeviceConnectionSelect = 0x0023, kMusicUseDeviceConnectionSelect = 0x0024, kMusicGetKnobSettingStringsSelect = 0x0025, kMusicGetMIDIPortsSelect = 0x0026, kMusicSendMIDISelect = 0x0027, kMusicReceiveMIDISelect = 0x0028, kMusicStartOfflineSelect = 0x0029, kMusicSetOfflineTimeToSelect = 0x002A, kMusicGetInstrumentKnobDescriptionSelect = 0x002B, kMusicGetDrumKnobDescriptionSelect = 0x002C, kMusicGetKnobDescriptionSelect = 0x002D, kMusicGetInfoTextSelect = 0x002E, kMusicGetInstrumentInfoSelect = 0x002F, kMusicTaskSelect = 0x0031, kMusicGenericConfigureSelect = 0x0100, kMusicGenericGetPartSelect = 0x0101, kMusicGenericGetKnobListSelect = 0x0102, kMusicDerivedMIDISendSelect = 0x0200, kMusicDerivedSetKnobSelect = 0x0201, kMusicDerivedSetPartSelect = 0x0202, kMusicDerivedSetInstrumentSelect = 0x0203, kMusicDerivedSetPartInstrumentNumberSelect = 0x0204, kMusicDerivedSetMIDISelect = 0x0205, kMusicDerivedStorePartInstrumentSelect = 0x0206, kInstrumentGetInstSelect = 0x0001, kInstrumentGetInfoSelect = 0x0002, kInstrumentInitializeSelect = 0x0003, kInstrumentOpenComponentResFileSelect = 0x0004, kInstrumentCloseComponentResFileSelect = 0x0005, kInstrumentGetComponentRefConSelect = 0x0006, kInstrumentSetComponentRefConSelect = 0x0007, kNARegisterMusicDeviceSelect = 0x0000, kNAUnregisterMusicDeviceSelect = 0x0001, kNAGetRegisteredMusicDeviceSelect = 0x0002, kNASaveMusicConfigurationSelect = 0x0003, kNANewNoteChannelSelect = 0x0004, kNADisposeNoteChannelSelect = 0x0005, kNAGetNoteChannelInfoSelect = 0x0006, kNAPrerollNoteChannelSelect = 0x0007, kNAUnrollNoteChannelSelect = 0x0008, kNASetNoteChannelVolumeSelect = 0x000B, kNAResetNoteChannelSelect = 0x000C, kNAPlayNoteSelect = 0x000D, kNASetControllerSelect = 0x000E, kNASetKnobSelect = 0x000F, kNAFindNoteChannelToneSelect = 0x0010, kNASetInstrumentNumberSelect = 0x0011, kNAPickInstrumentSelect = 0x0012, kNAPickArrangementSelect = 0x0013, kNAGetStatusBlockSelect = 0x0014, kNASetDefaultMIDIInputSelect = 0x0015, kNAGetDefaultMIDIInputSelect = 0x0016, kNAUseDefaultMIDIInputSelect = 0x0019, kNALoseDefaultMIDIInputSelect = 0x001A, kNAStuffToneDescriptionSelect = 0x001B, kNACopyrightDialogSelect = 0x001C, kNAGetMIDIPortsSelect = 0x0021, kNAGetNoteRequestSelect = 0x0022, kNASendMIDISelect = 0x0023, kNAPickEditInstrumentSelect = 0x0024, kNANewNoteChannelFromAtomicInstrumentSelect = 0x0025, kNASetAtomicInstrumentSelect = 0x0026, kNAGetKnobSelect = 0x0028, kNATaskSelect = 0x0029, kNASetNoteChannelBalanceSelect = 0x002A, kTuneSetHeaderSelect = 0x0004, kTuneGetTimeBaseSelect = 0x0005, kTuneSetTimeScaleSelect = 0x0006, kTuneGetTimeScaleSelect = 0x0007, kTuneGetIndexedNoteChannelSelect = 0x0008, kTuneQueueSelect = 0x000A, kTuneInstantSelect = 0x000B, kTuneGetStatusSelect = 0x000C, kTuneStopSelect = 0x000D, kTuneSetVolumeSelect = 0x0010, kTuneGetVolumeSelect = 0x0011, kTunePrerollSelect = 0x0012, kTuneUnrollSelect = 0x0013, kTuneSetNoteChannelsSelect = 0x0014, kTuneSetPartTransposeSelect = 0x0015, kTuneGetNoteAllocatorSelect = 0x0017, kTuneSetSofterSelect = 0x0018, kTuneTaskSelect = 0x0019, kTuneSetBalanceSelect = 0x001A }; #if PRAGMA_ALIGN_SUPPORTED #pragma options align=reset #endif #if PRAGMA_IMPORT_SUPPORTED #pragma import off #endif #ifdef __cplusplus } #endif #endif /* __QUICKTIMEMUSIC__ */