1HEADmaster

1 files changed, 3240 insertions, 0 deletions

diff --git a/common/quicktime_win32/Sound.h b/common/quicktime_win32/Sound.h
new file mode 100644
index 0000000..43876a9
--- /dev/null
+++ b/common/quicktime_win32/Sound.h
@@ -0,0 +1,3240 @@
+/*
+     File:       Sound.h
+ 
+     Contains:   Sound Manager Interfaces.
+ 
+     Version:    QuickTime 7.3
+ 
+     Copyright:  (c) 2007 (c) 1986-2001 by Apple Computer, Inc., all rights reserved
+ 
+     Bugs?:      For bug reports, consult the following page on
+                 the World Wide Web:
+ 
+                     http://developer.apple.com/bugreporter/
+ 
+*/
+#ifndef __SOUND__
+#define __SOUND__
+
+#ifndef __MACTYPES__
+#include <MacTypes.h>
+#endif
+
+#ifndef __COMPONENTS__
+#include <Components.h>
+#endif
+
+#ifndef __MIXEDMODE__
+#include <MixedMode.h>
+#endif
+
+#ifndef __DIALOGS__
+#include <Dialogs.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
+
+/*
+                        * * *  N O T E  * * *
+
+    This file has been updated to include Sound Manager 3.3 interfaces.
+
+    Some of the Sound Manager 3.0 interfaces were not put into the InterfaceLib
+    that originally shipped with the PowerMacs. These missing functions and the
+    new 3.3 interfaces have been released in the SoundLib library for PowerPC
+    developers to link with. The runtime library for these functions are
+    installed by the Sound Manager. The following functions are found in SoundLib.
+
+        GetCompressionInfo(), GetSoundPreference(), SetSoundPreference(),
+        UnsignedFixedMulDiv(), SndGetInfo(), SndSetInfo(), GetSoundOutputInfo(),
+        SetSoundOutputInfo(), GetCompressionName(), SoundConverterOpen(),
+        SoundConverterClose(), SoundConverterGetBufferSizes(), SoundConverterBeginConversion(),
+        SoundConverterConvertBuffer(), SoundConverterEndConversion(),
+        AudioGetBass(), AudioGetInfo(), AudioGetMute(), AudioGetOutputDevice(),
+        AudioGetTreble(), AudioGetVolume(), AudioMuteOnEvent(), AudioSetBass(),
+        AudioSetMute(), AudioSetToDefaults(), AudioSetTreble(), AudioSetVolume(),
+        OpenMixerSoundComponent(), CloseMixerSoundComponent(), SoundComponentAddSource(),
+        SoundComponentGetInfo(), SoundComponentGetSource(), SoundComponentGetSourceData(),
+        SoundComponentInitOutputDevice(), SoundComponentPauseSource(),
+        SoundComponentPlaySourceBuffer(), SoundComponentRemoveSource(),
+        SoundComponentSetInfo(), SoundComponentSetOutput(), SoundComponentSetSource(),
+        SoundComponentStartSource(), SoundComponentStopSource(),
+        ParseAIFFHeader(), ParseSndHeader(), SoundConverterGetInfo(), SoundConverterSetInfo()
+*/
+/*
+    Interfaces for Sound Driver, !!! OBSOLETE and NOT SUPPORTED !!!
+
+    These items are no longer defined, but appear here so that someone
+    searching the interfaces might find them. If you are using one of these
+    items, you must change your code to support the Sound Manager.
+
+        swMode, ftMode, ffMode
+        FreeWave, FFSynthRec, Tone, SWSynthRec, Wave, FTSoundRec
+        SndCompletionProcPtr
+        StartSound, StopSound, SoundDone
+        SetSoundVol, GetSoundVol
+*/
+/*
+  ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+   constants
+  ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+*/
+#define twelfthRootTwo 1.05946309435
+
+enum {
+  soundListRsrc                 = FOUR_CHAR_CODE('snd '), /*Resource type used by Sound Manager*/
+  kSoundCodecInfoResourceType   = FOUR_CHAR_CODE('snfo') /*Resource type holding codec information (optional public component resource)*/
+};
+
+enum {
+  kSimpleBeepID                 = 1     /*reserved resource ID for Simple Beep*/
+};
+
+enum {
+  rate48khz                     = (long)0xBB800000, /*48000.00000 in fixed-point*/
+  rate44khz                     = (long)0xAC440000, /*44100.00000 in fixed-point*/
+  rate32khz                     = 0x7D000000, /*32000.00000 in fixed-point*/
+  rate22050hz                   = 0x56220000, /*22050.00000 in fixed-point*/
+  rate22khz                     = 0x56EE8BA3, /*22254.54545 in fixed-point*/
+  rate16khz                     = 0x3E800000, /*16000.00000 in fixed-point*/
+  rate11khz                     = 0x2B7745D1, /*11127.27273 in fixed-point*/
+  rate11025hz                   = 0x2B110000, /*11025.00000 in fixed-point*/
+  rate8khz                      = 0x1F400000 /* 8000.00000 in fixed-point*/
+};
+
+/*synthesizer numbers for SndNewChannel*/
+enum {
+  sampledSynth                  = 5     /*sampled sound synthesizer*/
+};
+
+#if CALL_NOT_IN_CARBON
+enum {
+  squareWaveSynth               = 1,    /*square wave synthesizer*/
+  waveTableSynth                = 3,    /*wave table synthesizer*/
+                                        /*old Sound Manager MACE synthesizer numbers*/
+  MACE3snthID                   = 11,
+  MACE6snthID                   = 13
+};
+
+#endif  /* CALL_NOT_IN_CARBON */
+
+enum {
+  kMiddleC                      = 60    /*MIDI note value for middle C*/
+};
+
+enum {
+  kNoVolume                     = 0,    /*setting for no sound volume*/
+  kFullVolume                   = 0x0100 /*1.0, setting for full hardware output volume*/
+};
+
+enum {
+  stdQLength                    = 128
+};
+
+enum {
+  dataOffsetFlag                = 0x8000
+};
+
+enum {
+  kUseOptionalOutputDevice      = -1    /*only for Sound Manager 3.0 or later*/
+};
+
+enum {
+  notCompressed                 = 0,    /*compression ID's*/
+  fixedCompression              = -1,   /*compression ID for fixed-sized compression*/
+  variableCompression           = -2    /*compression ID for variable-sized compression*/
+};
+
+enum {
+  twoToOne                      = 1,
+  eightToThree                  = 2,
+  threeToOne                    = 3,
+  sixToOne                      = 4,
+  sixToOnePacketSize            = 8,
+  threeToOnePacketSize          = 16
+};
+
+enum {
+  stateBlockSize                = 64,
+  leftOverBlockSize             = 32
+};
+
+enum {
+  firstSoundFormat              = 0x0001, /*general sound format*/
+  secondSoundFormat             = 0x0002 /*special sampled sound format (HyperCard)*/
+};
+
+#if CALL_NOT_IN_CARBON
+enum {
+  dbBufferReady                 = 0x00000001, /*double buffer is filled*/
+  dbLastBuffer                  = 0x00000004 /*last double buffer to play*/
+};
+
+#endif  /* CALL_NOT_IN_CARBON */
+
+enum {
+  sysBeepDisable                = 0x0000, /*SysBeep() enable flags*/
+  sysBeepEnable                 = (1 << 0),
+  sysBeepSynchronous            = (1 << 1) /*if bit set, make alert sounds synchronous*/
+};
+
+enum {
+  unitTypeNoSelection           = 0xFFFF, /*unitTypes for AudioSelection.unitType*/
+  unitTypeSeconds               = 0x0000
+};
+
+enum {
+  stdSH                         = 0x00, /*Standard sound header encode value*/
+  extSH                         = 0xFF, /*Extended sound header encode value*/
+  cmpSH                         = 0xFE  /*Compressed sound header encode value*/
+};
+
+/*command numbers for SndDoCommand and SndDoImmediate*/
+enum {
+  nullCmd                       = 0,
+  quietCmd                      = 3,
+  flushCmd                      = 4,
+  reInitCmd                     = 5,
+  waitCmd                       = 10,
+  pauseCmd                      = 11,
+  resumeCmd                     = 12,
+  callBackCmd                   = 13,
+  syncCmd                       = 14,
+  availableCmd                  = 24,
+  versionCmd                    = 25,
+  volumeCmd                     = 46,   /*sound manager 3.0 or later only*/
+  getVolumeCmd                  = 47,   /*sound manager 3.0 or later only*/
+  clockComponentCmd             = 50,   /*sound manager 3.2.1 or later only*/
+  getClockComponentCmd          = 51,   /*sound manager 3.2.1 or later only*/
+  scheduledSoundCmd             = 52,   /*sound manager 3.3 or later only*/
+  linkSoundComponentsCmd        = 53,   /*sound manager 3.3 or later only*/
+  soundCmd                      = 80,
+  bufferCmd                     = 81,
+  rateMultiplierCmd             = 86,
+  getRateMultiplierCmd          = 87
+};
+
+#if CALL_NOT_IN_CARBON
+/*command numbers for SndDoCommand and SndDoImmediate that are not available for use in Carbon */
+enum {
+  initCmd                       = 1,
+  freeCmd                       = 2,
+  totalLoadCmd                  = 26,
+  loadCmd                       = 27,
+  freqDurationCmd               = 40,
+  restCmd                       = 41,
+  freqCmd                       = 42,
+  ampCmd                        = 43,
+  timbreCmd                     = 44,
+  getAmpCmd                     = 45,
+  waveTableCmd                  = 60,
+  phaseCmd                      = 61,
+  rateCmd                       = 82,
+  continueCmd                   = 83,
+  doubleBufferCmd               = 84,
+  getRateCmd                    = 85,
+  sizeCmd                       = 90,   /*obsolete command*/
+  convertCmd                    = 91    /*obsolete MACE command*/
+};
+
+#endif  /* CALL_NOT_IN_CARBON */
+
+#if OLDROUTINENAMES
+/*channel initialization parameters*/
+enum {
+  waveInitChannelMask           = 0x07,
+  waveInitChannel0              = 0x04, /*wave table only, Sound Manager 2.0 and earlier*/
+  waveInitChannel1              = 0x05, /*wave table only, Sound Manager 2.0 and earlier*/
+  waveInitChannel2              = 0x06, /*wave table only, Sound Manager 2.0 and earlier*/
+  waveInitChannel3              = 0x07, /*wave table only, Sound Manager 2.0 and earlier*/
+  initChan0                     = waveInitChannel0, /*obsolete spelling*/
+  initChan1                     = waveInitChannel1, /*obsolete spelling*/
+  initChan2                     = waveInitChannel2, /*obsolete spelling*/
+  initChan3                     = waveInitChannel3 /*obsolete spelling*/
+};
+
+enum {
+  outsideCmpSH                  = 0,    /*obsolete MACE constant*/
+  insideCmpSH                   = 1,    /*obsolete MACE constant*/
+  aceSuccess                    = 0,    /*obsolete MACE constant*/
+  aceMemFull                    = 1,    /*obsolete MACE constant*/
+  aceNilBlock                   = 2,    /*obsolete MACE constant*/
+  aceBadComp                    = 3,    /*obsolete MACE constant*/
+  aceBadEncode                  = 4,    /*obsolete MACE constant*/
+  aceBadDest                    = 5,    /*obsolete MACE constant*/
+  aceBadCmd                     = 6     /*obsolete MACE constant*/
+};
+
+#endif  /* OLDROUTINENAMES */
+
+enum {
+  initChanLeft                  = 0x0002, /*left stereo channel*/
+  initChanRight                 = 0x0003, /*right stereo channel*/
+  initNoInterp                  = 0x0004, /*no linear interpolation*/
+  initNoDrop                    = 0x0008, /*no drop-sample conversion*/
+  initMono                      = 0x0080, /*monophonic channel*/
+  initStereo                    = 0x00C0, /*stereo channel*/
+  initMACE3                     = 0x0300, /*MACE 3:1*/
+  initMACE6                     = 0x0400, /*MACE 6:1*/
+  initPanMask                   = 0x0003, /*mask for right/left pan values*/
+  initSRateMask                 = 0x0030, /*mask for sample rate values*/
+  initStereoMask                = 0x00C0, /*mask for mono/stereo values*/
+  initCompMask                  = 0xFF00 /*mask for compression IDs*/
+};
+
+/*Get&Set Sound Information Selectors*/
+enum {
+  siActiveChannels              = FOUR_CHAR_CODE('chac'), /*active channels*/
+  siActiveLevels                = FOUR_CHAR_CODE('lmac'), /*active meter levels*/
+  siAGCOnOff                    = FOUR_CHAR_CODE('agc '), /*automatic gain control state*/
+  siAsync                       = FOUR_CHAR_CODE('asyn'), /*asynchronous capability*/
+  siAVDisplayBehavior           = FOUR_CHAR_CODE('avdb'),
+  siChannelAvailable            = FOUR_CHAR_CODE('chav'), /*number of channels available*/
+  siCompressionAvailable        = FOUR_CHAR_CODE('cmav'), /*compression types available*/
+  siCompressionFactor           = FOUR_CHAR_CODE('cmfa'), /*current compression factor*/
+  siCompressionHeader           = FOUR_CHAR_CODE('cmhd'), /*return compression header*/
+  siCompressionNames            = FOUR_CHAR_CODE('cnam'), /*compression type names available*/
+  siCompressionParams           = FOUR_CHAR_CODE('evaw'), /*compression parameters*/
+  siCompressionSampleRate       = FOUR_CHAR_CODE('cprt'), /* SetInfo only: compressor's sample rate*/
+  siCompressionChannels         = FOUR_CHAR_CODE('cpct'), /* SetInfo only: compressor's number of channels*/
+  siCompressionOutputSampleRate = FOUR_CHAR_CODE('cort'), /* GetInfo only: only implemented by compressors that have differing in and out rates */
+  siCompressionInputRateList    = FOUR_CHAR_CODE('crtl'), /* GetInfo only: only implemented by compressors that only take certain input rates */
+  siCompressionType             = FOUR_CHAR_CODE('comp'), /*current compression type*/
+  siCompressionConfiguration    = FOUR_CHAR_CODE('ccfg'), /*compression extensions*/
+  siContinuous                  = FOUR_CHAR_CODE('cont'), /*continous recording*/
+  siDecompressionParams         = FOUR_CHAR_CODE('wave'), /*decompression parameters*/
+  siDecompressionConfiguration  = FOUR_CHAR_CODE('dcfg'), /*decompression extensions*/
+  siDeviceBufferInfo            = FOUR_CHAR_CODE('dbin'), /*size of interrupt buffer*/
+  siDeviceConnected             = FOUR_CHAR_CODE('dcon'), /*input device connection status*/
+  siDeviceIcon                  = FOUR_CHAR_CODE('icon'), /*input device icon*/
+  siDeviceName                  = FOUR_CHAR_CODE('name'), /*input device name*/
+  siEQSpectrumBands             = FOUR_CHAR_CODE('eqsb'), /* number of spectrum bands*/
+  siEQSpectrumLevels            = FOUR_CHAR_CODE('eqlv'), /* gets spectum meter levels*/
+  siEQSpectrumOnOff             = FOUR_CHAR_CODE('eqlo'), /* turn on/off spectum meter levels*/
+  siEQSpectrumResolution        = FOUR_CHAR_CODE('eqrs'), /* set the resolution of the FFT, 0 = low res (<=16 bands), 1 = high res (16-64 bands)*/
+  siEQToneControlGain           = FOUR_CHAR_CODE('eqtg'), /* set the bass and treble gain*/
+  siEQToneControlOnOff          = FOUR_CHAR_CODE('eqtc'), /* turn on equalizer attenuation*/
+  siHardwareBalance             = FOUR_CHAR_CODE('hbal'),
+  siHardwareBalanceSteps        = FOUR_CHAR_CODE('hbls'),
+  siHardwareBass                = FOUR_CHAR_CODE('hbas'),
+  siHardwareBassSteps           = FOUR_CHAR_CODE('hbst'),
+  siHardwareBusy                = FOUR_CHAR_CODE('hwbs'), /*sound hardware is in use*/
+  siHardwareFormat              = FOUR_CHAR_CODE('hwfm'), /*get hardware format*/
+  siHardwareMute                = FOUR_CHAR_CODE('hmut'), /*mute state of all hardware*/
+  siHardwareMuteNoPrefs         = FOUR_CHAR_CODE('hmnp'), /*mute state of all hardware, but don't store in prefs */
+  siHardwareTreble              = FOUR_CHAR_CODE('htrb'),
+  siHardwareTrebleSteps         = FOUR_CHAR_CODE('hwts'),
+  siHardwareVolume              = FOUR_CHAR_CODE('hvol'), /*volume level of all hardware*/
+  siHardwareVolumeSteps         = FOUR_CHAR_CODE('hstp'), /*number of volume steps for hardware*/
+  siHeadphoneMute               = FOUR_CHAR_CODE('pmut'), /*mute state of headphones*/
+  siHeadphoneVolume             = FOUR_CHAR_CODE('pvol'), /*volume level of headphones*/
+  siHeadphoneVolumeSteps        = FOUR_CHAR_CODE('hdst'), /*number of volume steps for headphones*/
+  siInputAvailable              = FOUR_CHAR_CODE('inav'), /*input sources available*/
+  siInputGain                   = FOUR_CHAR_CODE('gain'), /*input gain*/
+  siInputSource                 = FOUR_CHAR_CODE('sour'), /*input source selector*/
+  siInputSourceNames            = FOUR_CHAR_CODE('snam'), /*input source names*/
+  siLevelMeterOnOff             = FOUR_CHAR_CODE('lmet'), /*level meter state*/
+  siModemGain                   = FOUR_CHAR_CODE('mgai'), /*modem input gain*/
+  siMonitorAvailable            = FOUR_CHAR_CODE('mnav'),
+  siMonitorSource               = FOUR_CHAR_CODE('mons'),
+  siNumberChannels              = FOUR_CHAR_CODE('chan'), /*current number of channels*/
+  siOptionsDialog               = FOUR_CHAR_CODE('optd'), /*display options dialog*/
+  siOSTypeInputSource           = FOUR_CHAR_CODE('inpt'), /*input source by OSType*/
+  siOSTypeInputAvailable        = FOUR_CHAR_CODE('inav'), /*list of available input source OSTypes*/
+  siOutputDeviceName            = FOUR_CHAR_CODE('onam'), /*output device name*/
+  siPlayThruOnOff               = FOUR_CHAR_CODE('plth'), /*playthrough state*/
+  siPostMixerSoundComponent     = FOUR_CHAR_CODE('psmx'), /*install post-mixer effect*/
+  siPreMixerSoundComponent      = FOUR_CHAR_CODE('prmx'), /*install pre-mixer effect*/
+  siQuality                     = FOUR_CHAR_CODE('qual'), /*quality setting*/
+  siRateMultiplier              = FOUR_CHAR_CODE('rmul'), /*throttle rate setting*/
+  siRecordingQuality            = FOUR_CHAR_CODE('qual'), /*recording quality*/
+  siSampleRate                  = FOUR_CHAR_CODE('srat'), /*current sample rate*/
+  siSampleRateAvailable         = FOUR_CHAR_CODE('srav'), /*sample rates available*/
+  siSampleSize                  = FOUR_CHAR_CODE('ssiz'), /*current sample size*/
+  siSampleSizeAvailable         = FOUR_CHAR_CODE('ssav'), /*sample sizes available*/
+  siSetupCDAudio                = FOUR_CHAR_CODE('sucd'), /*setup sound hardware for CD audio*/
+  siSetupModemAudio             = FOUR_CHAR_CODE('sumd'), /*setup sound hardware for modem audio*/
+  siSlopeAndIntercept           = FOUR_CHAR_CODE('flap'), /*floating point variables for conversion*/
+  siSoundClock                  = FOUR_CHAR_CODE('sclk'),
+  siUseThisSoundClock           = FOUR_CHAR_CODE('sclc'), /*sdev uses this to tell the mixer to use his sound clock*/
+  siSpeakerMute                 = FOUR_CHAR_CODE('smut'), /*mute state of all built-in speaker*/
+  siSpeakerVolume               = FOUR_CHAR_CODE('svol'), /*volume level of built-in speaker*/
+  siSSpCPULoadLimit             = FOUR_CHAR_CODE('3dll'),
+  siSSpLocalization             = FOUR_CHAR_CODE('3dif'),
+  siSSpSpeakerSetup             = FOUR_CHAR_CODE('3dst'),
+  siStereoInputGain             = FOUR_CHAR_CODE('sgai'), /*stereo input gain*/
+  siSubwooferMute               = FOUR_CHAR_CODE('bmut'), /*mute state of sub-woofer*/
+  siTerminalType                = FOUR_CHAR_CODE('ttyp'), /* usb terminal type */
+  siTwosComplementOnOff         = FOUR_CHAR_CODE('twos'), /*two's complement state*/
+  siVendorProduct               = FOUR_CHAR_CODE('vpro'), /* vendor and product ID */
+  siVolume                      = FOUR_CHAR_CODE('volu'), /*volume level of source*/
+  siVoxRecordInfo               = FOUR_CHAR_CODE('voxr'), /*VOX record parameters*/
+  siVoxStopInfo                 = FOUR_CHAR_CODE('voxs'), /*VOX stop parameters*/
+  siWideStereo                  = FOUR_CHAR_CODE('wide'), /*wide stereo setting*/
+  siSupportedExtendedFlags      = FOUR_CHAR_CODE('exfl'), /*which flags are supported in Extended sound data structures*/
+  siRateConverterRollOffSlope   = FOUR_CHAR_CODE('rcdb'), /*the roll-off slope for the rate converter's filter, in whole dB as a long this value is a long whose range is from 20 (worst quality/fastest performance) to 90 (best quality/slowest performance)*/
+  siOutputLatency               = FOUR_CHAR_CODE('olte'), /*latency of sound output component*/
+  siHALAudioDeviceID            = FOUR_CHAR_CODE('hlid'), /*audio device id*/
+  siHALAudioDeviceUniqueID      = FOUR_CHAR_CODE('huid'), /*audio device unique id*/
+  siClientAcceptsVBR            = FOUR_CHAR_CODE('cvbr'), /*client handles VBR*/
+  siSourceIsExhausted           = FOUR_CHAR_CODE('srcx'), /*the ultimate source of data has run out (keep asking, but when you get nothing, that's it)*/
+  siMediaContextID              = FOUR_CHAR_CODE('uuid'), /*media context id -- UUID */
+  siCompressionMaxPacketSize    = FOUR_CHAR_CODE('cmxp'), /*maximum compressed packet size for current configuration -- unsigned long */
+  siAudioCodecPropertyValue     = FOUR_CHAR_CODE('spva'), /*audio codec property value -- SoundAudioCodecPropertyRequestParams* */
+  siAudioCodecPropertyInfo      = FOUR_CHAR_CODE('spin') /*audio codec property info -- SoundAudioCodecPropertyRequestParams* */
+};
+
+enum {
+  siCloseDriver                 = FOUR_CHAR_CODE('clos'), /*reserved for internal use only*/
+  siInitializeDriver            = FOUR_CHAR_CODE('init'), /*reserved for internal use only*/
+  siPauseRecording              = FOUR_CHAR_CODE('paus'), /*reserved for internal use only*/
+  siUserInterruptProc           = FOUR_CHAR_CODE('user') /*reserved for internal use only*/
+};
+
+/* input source Types*/
+enum {
+  kInvalidSource                = (long)0xFFFFFFFF, /*this source may be returned from GetInfo if no other source is the monitored source*/
+  kNoSource                     = FOUR_CHAR_CODE('none'), /*no source selection*/
+  kCDSource                     = FOUR_CHAR_CODE('cd  '), /*internal CD player input*/
+  kExtMicSource                 = FOUR_CHAR_CODE('emic'), /*external mic input*/
+  kSoundInSource                = FOUR_CHAR_CODE('sinj'), /*sound input jack*/
+  kRCAInSource                  = FOUR_CHAR_CODE('irca'), /*RCA jack input*/
+  kTVFMTunerSource              = FOUR_CHAR_CODE('tvfm'),
+  kDAVInSource                  = FOUR_CHAR_CODE('idav'), /*DAV analog input*/
+  kIntMicSource                 = FOUR_CHAR_CODE('imic'), /*internal mic input*/
+  kMediaBaySource               = FOUR_CHAR_CODE('mbay'), /*media bay input*/
+  kModemSource                  = FOUR_CHAR_CODE('modm'), /*modem input (internal modem on desktops, PCI input on PowerBooks)*/
+  kPCCardSource                 = FOUR_CHAR_CODE('pcm '), /*PC Card pwm input*/
+  kZoomVideoSource              = FOUR_CHAR_CODE('zvpc'), /*zoom video input*/
+  kDVDSource                    = FOUR_CHAR_CODE('dvda'), /* DVD audio input*/
+  kMicrophoneArray              = FOUR_CHAR_CODE('mica') /* microphone array*/
+};
+
+/*Sound Component Types and Subtypes*/
+enum {
+  kNoSoundComponentType         = FOUR_CHAR_CODE('****'),
+  kSoundComponentType           = FOUR_CHAR_CODE('sift'), /*component type*/
+  kSoundComponentPPCType        = FOUR_CHAR_CODE('nift'), /*component type for PowerPC code*/
+  kRate8SubType                 = FOUR_CHAR_CODE('ratb'), /*8-bit rate converter*/
+  kRate16SubType                = FOUR_CHAR_CODE('ratw'), /*16-bit rate converter*/
+  kConverterSubType             = FOUR_CHAR_CODE('conv'), /*sample format converter*/
+  kSndSourceSubType             = FOUR_CHAR_CODE('sour'), /*generic source component*/
+  kMixerType                    = FOUR_CHAR_CODE('mixr'),
+  kMixer8SubType                = FOUR_CHAR_CODE('mixb'), /*8-bit mixer*/
+  kMixer16SubType               = FOUR_CHAR_CODE('mixw'), /*16-bit mixer*/
+  kSoundInputDeviceType         = FOUR_CHAR_CODE('sinp'), /*sound input component*/
+  kWaveInSubType                = FOUR_CHAR_CODE('wavi'), /*Windows waveIn*/
+  kWaveInSnifferSubType         = FOUR_CHAR_CODE('wisn'), /*Windows waveIn sniffer*/
+  kSoundOutputDeviceType        = FOUR_CHAR_CODE('sdev'), /*sound output component*/
+  kClassicSubType               = FOUR_CHAR_CODE('clas'), /*classic hardware, i.e. Mac Plus*/
+  kASCSubType                   = FOUR_CHAR_CODE('asc '), /*Apple Sound Chip device*/
+  kDSPSubType                   = FOUR_CHAR_CODE('dsp '), /*DSP device*/
+  kAwacsSubType                 = FOUR_CHAR_CODE('awac'), /*Another of Will's Audio Chips device*/
+  kGCAwacsSubType               = FOUR_CHAR_CODE('awgc'), /*Awacs audio with Grand Central DMA*/
+  kSingerSubType                = FOUR_CHAR_CODE('sing'), /*Singer (via Whitney) based sound*/
+  kSinger2SubType               = FOUR_CHAR_CODE('sng2'), /*Singer 2 (via Whitney) for Acme*/
+  kWhitSubType                  = FOUR_CHAR_CODE('whit'), /*Whit sound component for PrimeTime 3*/
+  kSoundBlasterSubType          = FOUR_CHAR_CODE('sbls'), /*Sound Blaster for CHRP*/
+  kWaveOutSubType               = FOUR_CHAR_CODE('wavo'), /*Windows waveOut*/
+  kWaveOutSnifferSubType        = FOUR_CHAR_CODE('wosn'), /*Windows waveOut sniffer*/
+  kDirectSoundSubType           = FOUR_CHAR_CODE('dsnd'), /*Windows DirectSound*/
+  kDirectSoundSnifferSubType    = FOUR_CHAR_CODE('dssn'), /*Windows DirectSound sniffer*/
+  kUNIXsdevSubType              = FOUR_CHAR_CODE('un1x'), /*UNIX base sdev*/
+  kUSBSubType                   = FOUR_CHAR_CODE('usb '), /*USB device*/
+  kBlueBoxSubType               = FOUR_CHAR_CODE('bsnd'), /*Blue Box sound component*/
+  kHALCustomComponentSubType    = FOUR_CHAR_CODE('halx'), /*Registered by the HAL output component ('hal!') for each HAL output device*/
+  kSoundCompressor              = FOUR_CHAR_CODE('scom'),
+  kSoundDecompressor            = FOUR_CHAR_CODE('sdec'),
+  kAudioComponentType           = FOUR_CHAR_CODE('adio'), /*Audio components and sub-types*/
+  kAwacsPhoneSubType            = FOUR_CHAR_CODE('hphn'),
+  kAudioVisionSpeakerSubType    = FOUR_CHAR_CODE('telc'),
+  kAudioVisionHeadphoneSubType  = FOUR_CHAR_CODE('telh'),
+  kPhilipsFaderSubType          = FOUR_CHAR_CODE('tvav'),
+  kSGSToneSubType               = FOUR_CHAR_CODE('sgs0'),
+  kSoundEffectsType             = FOUR_CHAR_CODE('snfx'), /*sound effects type*/
+  kEqualizerSubType             = FOUR_CHAR_CODE('eqal'), /*frequency equalizer*/
+  kSSpLocalizationSubType       = FOUR_CHAR_CODE('snd3')
+};
+
+/*Format Types*/
+enum {
+  kSoundNotCompressed           = FOUR_CHAR_CODE('NONE'), /*sound is not compressed*/
+  k8BitOffsetBinaryFormat       = FOUR_CHAR_CODE('raw '), /*8-bit offset binary*/
+  k16BitBigEndianFormat         = FOUR_CHAR_CODE('twos'), /*16-bit big endian*/
+  k16BitLittleEndianFormat      = FOUR_CHAR_CODE('sowt'), /*16-bit little endian*/
+  kFloat32Format                = FOUR_CHAR_CODE('fl32'), /*32-bit floating point*/
+  kFloat64Format                = FOUR_CHAR_CODE('fl64'), /*64-bit floating point*/
+  k24BitFormat                  = FOUR_CHAR_CODE('in24'), /*24-bit integer*/
+  k32BitFormat                  = FOUR_CHAR_CODE('in32'), /*32-bit integer*/
+  k32BitLittleEndianFormat      = FOUR_CHAR_CODE('23ni'), /*32-bit little endian integer */
+  kMACE3Compression             = FOUR_CHAR_CODE('MAC3'), /*MACE 3:1*/
+  kMACE6Compression             = FOUR_CHAR_CODE('MAC6'), /*MACE 6:1*/
+  kCDXA4Compression             = FOUR_CHAR_CODE('cdx4'), /*CD/XA 4:1*/
+  kCDXA2Compression             = FOUR_CHAR_CODE('cdx2'), /*CD/XA 2:1*/
+  kIMACompression               = FOUR_CHAR_CODE('ima4'), /*IMA 4:1*/
+  kULawCompression              = FOUR_CHAR_CODE('ulaw'), /*.Law 2:1*/
+  kALawCompression              = FOUR_CHAR_CODE('alaw'), /*aLaw 2:1*/
+  kMicrosoftADPCMFormat         = 0x6D730002, /*Microsoft ADPCM - ACM code 2*/
+  kDVIIntelIMAFormat            = 0x6D730011, /*DVI/Intel IMA ADPCM - ACM code 17*/
+  kMicrosoftGSMCompression      = 0x6D730031, /*Microsoft GSM 6.10 - ACM code 49*/
+  kDVAudioFormat                = FOUR_CHAR_CODE('dvca'), /*DV Audio*/
+  kQDesignCompression           = FOUR_CHAR_CODE('QDMC'), /*QDesign music*/
+  kQDesign2Compression          = FOUR_CHAR_CODE('QDM2'), /*QDesign2 music*/
+  kQUALCOMMCompression          = FOUR_CHAR_CODE('Qclp'), /*QUALCOMM PureVoice*/
+  kOffsetBinary                 = k8BitOffsetBinaryFormat, /*for compatibility*/
+  kTwosComplement               = k16BitBigEndianFormat, /*for compatibility*/
+  kLittleEndianFormat           = k16BitLittleEndianFormat, /*for compatibility*/
+  kMPEGLayer3Format             = 0x6D730055, /*MPEG Layer 3, CBR only (pre QT4.1)*/
+  kFullMPEGLay3Format           = FOUR_CHAR_CODE('.mp3'), /*MPEG Layer 3, CBR & VBR (QT4.1 and later)*/
+  kVariableDurationDVAudioFormat = FOUR_CHAR_CODE('vdva') /*Variable Duration DV Audio*/
+};
+
+#if TARGET_RT_LITTLE_ENDIAN
+enum {
+  k16BitNativeEndianFormat      = k16BitLittleEndianFormat,
+  k16BitNonNativeEndianFormat   = k16BitBigEndianFormat
+};
+
+#else
+enum {
+  k16BitNativeEndianFormat      = k16BitBigEndianFormat,
+  k16BitNonNativeEndianFormat   = k16BitLittleEndianFormat
+};
+
+#endif  /* TARGET_RT_LITTLE_ENDIAN */
+
+/*Features Flags*/
+enum {
+  k8BitRawIn                    = (1 << 0), /*data description*/
+  k8BitTwosIn                   = (1 << 1),
+  k16BitIn                      = (1 << 2),
+  kStereoIn                     = (1 << 3),
+  k8BitRawOut                   = (1 << 8),
+  k8BitTwosOut                  = (1 << 9),
+  k16BitOut                     = (1 << 10),
+  kStereoOut                    = (1 << 11),
+  kReverse                      = (1L << 16), /*  function description*/
+  kRateConvert                  = (1L << 17),
+  kCreateSoundSource            = (1L << 18),
+  kVMAwareness                  = (1L << 21), /* component will hold its memory*/
+  kHighQuality                  = (1L << 22), /*  performance description*/
+  kNonRealTime                  = (1L << 23)
+};
+
+/*'snfo' Resource Feature Flags*/
+enum {
+  kSoundCodecInfoFixedCompression = (1L << 0), /* has fixed compression format*/
+  kSoundCodecInfoVariableCompression = (1L << 1), /* has variable compression format*/
+  kSoundCodecInfoHasRestrictedInputRates = (1L << 2), /* compressor has restricted set of input sample rates*/
+  kSoundCodecInfoCanChangeOutputRate = (1L << 3), /* compressor may output a different sample rate than it receives*/
+  kSoundCodecInfoRequiresExternalFraming = (1L << 4), /* format requires external framing information during decode/encode*/
+  kSoundCodecInfoVariableDuration = (1L << 5) /* audio packets can vary in duration*/
+};
+
+/*SoundComponentPlaySourceBuffer action flags*/
+enum {
+  kSourcePaused                 = (1 << 0),
+  kPassThrough                  = (1L << 16),
+  kNoSoundComponentChain        = (1L << 17)
+};
+
+/*SoundParamBlock flags, usefull for OpenMixerSoundComponent*/
+enum {
+  kNoMixing                     = (1 << 0), /*don't mix source*/
+  kNoSampleRateConversion       = (1 << 1), /*don't convert sample rate (i.e. 11 kHz -> 22 kHz)*/
+  kNoSampleSizeConversion       = (1 << 2), /*don't convert sample size (i.e. 16 -> 8)*/
+  kNoSampleFormatConversion     = (1 << 3), /*don't convert sample format (i.e. 'twos' -> 'raw ')*/
+  kNoChannelConversion          = (1 << 4), /*don't convert stereo/mono*/
+  kNoDecompression              = (1 << 5), /*don't decompress (i.e. 'MAC3' -> 'raw ')*/
+  kNoVolumeConversion           = (1 << 6), /*don't apply volume*/
+  kNoRealtimeProcessing         = (1 << 7), /*won't run at interrupt time*/
+  kScheduledSource              = (1 << 8), /*source is scheduled*/
+  kNonInterleavedBuffer         = (1 << 9), /*buffer is not interleaved samples*/
+  kNonPagingMixer               = (1 << 10), /*if VM is on, use the non-paging mixer*/
+  kSoundConverterMixer          = (1 << 11), /*the mixer is to be used by the SoundConverter*/
+  kPagingMixer                  = (1 << 12), /*the mixer is to be used as a paging mixer when VM is on*/
+  kVMAwareMixer                 = (1 << 13), /*passed to the output device when the SM is going to deal with VM safety*/
+  kExtendedSoundData            = (1 << 14) /*SoundComponentData record is actually an ExtendedSoundComponentData*/
+};
+
+/*SoundParamBlock quality settings*/
+enum {
+  kBestQuality                  = (1 << 0) /*use interpolation in rate conversion*/
+};
+
+/*useful bit masks*/
+enum {
+  kInputMask                    = 0x000000FF, /*masks off input bits*/
+  kOutputMask                   = 0x0000FF00, /*masks off output bits*/
+  kOutputShift                  = 8,    /*amount output bits are shifted*/
+  kActionMask                   = 0x00FF0000, /*masks off action bits*/
+  kSoundComponentBits           = 0x00FFFFFF
+};
+
+/*audio atom types*/
+enum {
+  kAudioFormatAtomType          = FOUR_CHAR_CODE('frma'),
+  kAudioEndianAtomType          = FOUR_CHAR_CODE('enda'),
+  kAudioVBRAtomType             = FOUR_CHAR_CODE('vbra'),
+  kAudioTerminatorAtomType      = 0
+};
+
+/*siAVDisplayBehavior types*/
+enum {
+  kAVDisplayHeadphoneRemove     = 0,    /* monitor does not have a headphone attached*/
+  kAVDisplayHeadphoneInsert     = 1,    /* monitor has a headphone attached*/
+  kAVDisplayPlainTalkRemove     = 2,    /* monitor either sending no input through CPU input port or unable to tell if input is coming in*/
+  kAVDisplayPlainTalkInsert     = 3     /* monitor sending PlainTalk level microphone source input through sound input port*/
+};
+
+/*Audio Component constants*/
+enum {
+                                        /*Values for whichChannel parameter*/
+  audioAllChannels              = 0,    /*All channels (usually interpreted as both left and right)*/
+  audioLeftChannel              = 1,    /*Left channel*/
+  audioRightChannel             = 2,    /*Right channel*/
+                                        /*Values for mute parameter*/
+  audioUnmuted                  = 0,    /*Device is unmuted*/
+  audioMuted                    = 1,    /*Device is muted*/
+                                        /*Capabilities flags definitions*/
+  audioDoesMono                 = (1L << 0), /*Device supports mono output*/
+  audioDoesStereo               = (1L << 1), /*Device supports stereo output*/
+  audioDoesIndependentChannels  = (1L << 2) /*Device supports independent software control of each channel*/
+};
+
+/*Sound Input Qualities*/
+enum {
+  siCDQuality                   = FOUR_CHAR_CODE('cd  '), /*44.1kHz, stereo, 16 bit*/
+  siBestQuality                 = FOUR_CHAR_CODE('best'), /*22kHz, mono, 8 bit*/
+  siBetterQuality               = FOUR_CHAR_CODE('betr'), /*22kHz, mono, MACE 3:1*/
+  siGoodQuality                 = FOUR_CHAR_CODE('good'), /*22kHz, mono, MACE 6:1*/
+  siNoneQuality                 = FOUR_CHAR_CODE('none') /*settings don't match any quality for a get call*/
+};
+
+enum {
+  siDeviceIsConnected           = 1,    /*input device is connected and ready for input*/
+  siDeviceNotConnected          = 0,    /*input device is not connected*/
+  siDontKnowIfConnected         = -1,   /*can't tell if input device is connected*/
+  siReadPermission              = 0,    /*permission passed to SPBOpenDevice*/
+  siWritePermission             = 1     /*permission passed to SPBOpenDevice*/
+};
+
+/*flags that SoundConverterFillBuffer will return*/
+enum {
+  kSoundConverterDidntFillBuffer = (1 << 0), /*set if the converter couldn't completely satisfy a SoundConverterFillBuffer request*/
+  kSoundConverterHasLeftOverData = (1 << 1) /*set if the converter had left over data after completely satisfying a SoundConverterFillBuffer call*/
+};
+
+/* flags for extendedFlags fields of ExtendedSoundComponentData, ExtendedSoundParamBlock, and ExtendedScheduledSoundHeader*/
+enum {
+  kExtendedSoundSampleCountNotValid = 1L << 0, /* set if sampleCount of SoundComponentData isn't meaningful; use buffer size instead*/
+  kExtendedSoundBufferSizeValid = 1L << 1, /* set if bufferSize field is valid*/
+  kExtendedSoundFrameSizesValid = 1L << 2, /* set if frameSizesArray is valid (will be nil if all sizes are common and kExtendedSoundCommonFrameSizeValid is set*/
+  kExtendedSoundCommonFrameSizeValid = 1L << 3, /* set if all audio frames have the same size and the commonFrameSize field is valid*/
+  kExtendedSoundExtensionsValid = 1L << 4, /* set if pointer to extensions array is valid*/
+  kExtendedSoundBufferFlagsValid = 1L << 5 /* set if buffer flags field is valid*/
+};
+
+/* flags passed in bufferFlags/bufferFlagsMask extended fields if kExtendedSoundBufferFlagsValid extended flag is set*/
+enum {
+  kExtendedSoundBufferIsDiscontinuous = 1L << 0, /* buffer is discontinuous with previous buffer*/
+  kExtendedSoundBufferIsFirstBuffer = 1L << 1 /* buffer is first buffer*/
+};
+
+/*
+  ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+   typedefs
+  ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+*/
+
+struct SndCommand {
+  unsigned short      cmd;
+  short               param1;
+  long                param2;
+};
+typedef struct SndCommand               SndCommand;
+typedef struct SndChannel               SndChannel;
+
+typedef SndChannel *                    SndChannelPtr;
+typedef CALLBACK_API( void , SndCallBackProcPtr )(SndChannelPtr chan, SndCommand *cmd);
+typedef STACK_UPP_TYPE(SndCallBackProcPtr)                      SndCallBackUPP;
+struct SndChannel {
+  SndChannelPtr       nextChan;
+  Ptr                 firstMod;               /* reserved for the Sound Manager */
+  SndCallBackUPP      callBack;
+  long                userInfo;
+  long                wait;                   /* The following is for internal Sound Manager use only.*/
+  SndCommand          cmdInProgress;
+  short               flags;
+  short               qLength;
+  short               qHead;
+  short               qTail;
+  SndCommand          queue[128];
+};
+
+/*
+ *  NewSndCallBackUPP()
+ *  
+ *  Availability:
+ *    Non-Carbon CFM:   available as macro/inline
+ *    CarbonLib:        in CarbonLib 1.0 and later
+ *    Mac OS X:         in version 10.0 and later
+ */
+EXTERN_API_C( SndCallBackUPP )
+NewSndCallBackUPP(SndCallBackProcPtr userRoutine);
+#if !OPAQUE_UPP_TYPES
+  enum { uppSndCallBackProcInfo = 0x000003C0 };  /* pascal no_return_value Func(4_bytes, 4_bytes) */
+  #ifdef __cplusplus
+    inline DEFINE_API_C(SndCallBackUPP) NewSndCallBackUPP(SndCallBackProcPtr userRoutine) { return (SndCallBackUPP)NewRoutineDescriptor((ProcPtr)(userRoutine), uppSndCallBackProcInfo, GetCurrentArchitecture()); }
+  #else
+    #define NewSndCallBackUPP(userRoutine) (SndCallBackUPP)NewRoutineDescriptor((ProcPtr)(userRoutine), uppSndCallBackProcInfo, GetCurrentArchitecture())
+  #endif
+#endif
+
+/*
+ *  DisposeSndCallBackUPP()
+ *  
+ *  Availability:
+ *    Non-Carbon CFM:   available as macro/inline
+ *    CarbonLib:        in CarbonLib 1.0 and later
+ *    Mac OS X:         in version 10.0 and later
+ */
+EXTERN_API_C( void )
+DisposeSndCallBackUPP(SndCallBackUPP userUPP);
+#if !OPAQUE_UPP_TYPES
+  #ifdef __cplusplus
+      inline DEFINE_API_C(void) DisposeSndCallBackUPP(SndCallBackUPP userUPP) { DisposeRoutineDescriptor((UniversalProcPtr)userUPP); }
+  #else
+      #define DisposeSndCallBackUPP(userUPP) DisposeRoutineDescriptor(userUPP)
+  #endif
+#endif
+
+/*
+ *  InvokeSndCallBackUPP()
+ *  
+ *  Availability:
+ *    Non-Carbon CFM:   available as macro/inline
+ *    CarbonLib:        in CarbonLib 1.0 and later
+ *    Mac OS X:         in version 10.0 and later
+ */
+EXTERN_API_C( void )
+InvokeSndCallBackUPP(
+  SndChannelPtr   chan,
+  SndCommand *    cmd,
+  SndCallBackUPP  userUPP);
+#if !OPAQUE_UPP_TYPES
+  #ifdef __cplusplus
+      inline DEFINE_API_C(void) InvokeSndCallBackUPP(SndChannelPtr chan, SndCommand * cmd, SndCallBackUPP userUPP) { CALL_TWO_PARAMETER_UPP(userUPP, uppSndCallBackProcInfo, chan, cmd); }
+  #else
+    #define InvokeSndCallBackUPP(chan, cmd, userUPP) CALL_TWO_PARAMETER_UPP((userUPP), uppSndCallBackProcInfo, (chan), (cmd))
+  #endif
+#endif
+
+#if CALL_NOT_IN_CARBON || OLDROUTINENAMES
+    /* support for pre-Carbon UPP routines: New...Proc and Call...Proc */
+    #define NewSndCallBackProc(userRoutine)                     NewSndCallBackUPP(userRoutine)
+    #define CallSndCallBackProc(userRoutine, chan, cmd)         InvokeSndCallBackUPP(chan, cmd, userRoutine)
+#endif /* CALL_NOT_IN_CARBON */
+
+/*MACE structures*/
+struct StateBlock {
+  short               stateVar[64];
+};
+typedef struct StateBlock               StateBlock;
+typedef StateBlock *                    StateBlockPtr;
+struct LeftOverBlock {
+  unsigned long       count;
+  SInt8               sampleArea[32];
+};
+typedef struct LeftOverBlock            LeftOverBlock;
+typedef LeftOverBlock *                 LeftOverBlockPtr;
+struct ModRef {
+  unsigned short      modNumber;
+  long                modInit;
+};
+typedef struct ModRef                   ModRef;
+struct SndListResource {
+  short               format;
+  short               numModifiers;
+  ModRef              modifierPart[1];
+  short               numCommands;
+  SndCommand          commandPart[1];
+  UInt8               dataPart[1];
+};
+typedef struct SndListResource          SndListResource;
+typedef SndListResource *               SndListPtr;
+typedef SndListPtr *                    SndListHandle;
+typedef SndListHandle                   SndListHndl;
+/*HyperCard sound resource format*/
+struct Snd2ListResource {
+  short               format;
+  short               refCount;
+  short               numCommands;
+  SndCommand          commandPart[1];
+  UInt8               dataPart[1];
+};
+typedef struct Snd2ListResource         Snd2ListResource;
+typedef Snd2ListResource *              Snd2ListPtr;
+typedef Snd2ListPtr *                   Snd2ListHandle;
+typedef Snd2ListHandle                  Snd2ListHndl;
+struct SoundHeader {
+  Ptr                 samplePtr;              /*if NIL then samples are in sampleArea*/
+  unsigned long       length;                 /*length of sound in bytes*/
+  UnsignedFixed       sampleRate;             /*sample rate for this sound*/
+  unsigned long       loopStart;              /*start of looping portion*/
+  unsigned long       loopEnd;                /*end of looping portion*/
+  UInt8               encode;                 /*header encoding*/
+  UInt8               baseFrequency;          /*baseFrequency value*/
+  UInt8               sampleArea[1];          /*space for when samples follow directly*/
+};
+typedef struct SoundHeader              SoundHeader;
+typedef SoundHeader *                   SoundHeaderPtr;
+struct CmpSoundHeader {
+  Ptr                 samplePtr;              /*if nil then samples are in sample area*/
+  unsigned long       numChannels;            /*number of channels i.e. mono = 1*/
+  UnsignedFixed       sampleRate;             /*sample rate in Apples Fixed point representation*/
+  unsigned long       loopStart;              /*loopStart of sound before compression*/
+  unsigned long       loopEnd;                /*loopEnd of sound before compression*/
+  UInt8               encode;                 /*data structure used , stdSH, extSH, or cmpSH*/
+  UInt8               baseFrequency;          /*same meaning as regular SoundHeader*/
+  unsigned long       numFrames;              /*length in frames ( packetFrames or sampleFrames )*/
+  extended80          AIFFSampleRate;         /*IEEE sample rate*/
+  Ptr                 markerChunk;            /*sync track*/
+  OSType              format;                 /*data format type, was futureUse1*/
+  unsigned long       futureUse2;             /*reserved by Apple*/
+  StateBlockPtr       stateVars;              /*pointer to State Block*/
+  LeftOverBlockPtr    leftOverSamples;        /*used to save truncated samples between compression calls*/
+  short               compressionID;          /*0 means no compression, non zero means compressionID*/
+  unsigned short      packetSize;             /*number of bits in compressed sample packet*/
+  unsigned short      snthID;                 /*resource ID of Sound Manager snth that contains NRT C/E*/
+  unsigned short      sampleSize;             /*number of bits in non-compressed sample*/
+  UInt8               sampleArea[1];          /*space for when samples follow directly*/
+};
+typedef struct CmpSoundHeader           CmpSoundHeader;
+typedef CmpSoundHeader *                CmpSoundHeaderPtr;
+struct ExtSoundHeader {
+  Ptr                 samplePtr;              /*if nil then samples are in sample area*/
+  unsigned long       numChannels;            /*number of channels,  ie mono = 1*/
+  UnsignedFixed       sampleRate;             /*sample rate in Apples Fixed point representation*/
+  unsigned long       loopStart;              /*same meaning as regular SoundHeader*/
+  unsigned long       loopEnd;                /*same meaning as regular SoundHeader*/
+  UInt8               encode;                 /*data structure used , stdSH, extSH, or cmpSH*/
+  UInt8               baseFrequency;          /*same meaning as regular SoundHeader*/
+  unsigned long       numFrames;              /*length in total number of frames*/
+  extended80          AIFFSampleRate;         /*IEEE sample rate*/
+  Ptr                 markerChunk;            /*sync track*/
+  Ptr                 instrumentChunks;       /*AIFF instrument chunks*/
+  Ptr                 AESRecording;
+  unsigned short      sampleSize;             /*number of bits in sample*/
+  unsigned short      futureUse1;             /*reserved by Apple*/
+  unsigned long       futureUse2;             /*reserved by Apple*/
+  unsigned long       futureUse3;             /*reserved by Apple*/
+  unsigned long       futureUse4;             /*reserved by Apple*/
+  UInt8               sampleArea[1];          /*space for when samples follow directly*/
+};
+typedef struct ExtSoundHeader           ExtSoundHeader;
+typedef ExtSoundHeader *                ExtSoundHeaderPtr;
+union SoundHeaderUnion {
+  SoundHeader         stdHeader;
+  CmpSoundHeader      cmpHeader;
+  ExtSoundHeader      extHeader;
+};
+typedef union SoundHeaderUnion          SoundHeaderUnion;
+struct ConversionBlock {
+  short               destination;
+  short               unused;
+  CmpSoundHeaderPtr   inputPtr;
+  CmpSoundHeaderPtr   outputPtr;
+};
+typedef struct ConversionBlock          ConversionBlock;
+typedef ConversionBlock *               ConversionBlockPtr;
+/* ScheduledSoundHeader flags*/
+enum {
+  kScheduledSoundDoScheduled    = 1 << 0,
+  kScheduledSoundDoCallBack     = 1 << 1,
+  kScheduledSoundExtendedHdr    = 1 << 2
+};
+
+struct ScheduledSoundHeader {
+  SoundHeaderUnion    u;
+  long                flags;
+  short               reserved;
+  short               callBackParam1;
+  long                callBackParam2;
+  TimeRecord          startTime;
+};
+typedef struct ScheduledSoundHeader     ScheduledSoundHeader;
+typedef ScheduledSoundHeader *          ScheduledSoundHeaderPtr;
+struct ExtendedScheduledSoundHeader {
+  SoundHeaderUnion    u;
+  long                flags;
+  short               reserved;
+  short               callBackParam1;
+  long                callBackParam2;
+  TimeRecord          startTime;
+  long                recordSize;
+  long                extendedFlags;
+  long                bufferSize;
+  long                frameCount;             /* number of audio frames*/
+  long *              frameSizesArray;        /* pointer to array of longs with frame sizes in bytes*/
+  long                commonFrameSize;        /* size of each frame if common*/
+  void *              extensionsPtr;          /*pointer to set of classic atoms (size,type,data,...)*/
+  long                extensionsSize;         /*size of extensions data (extensionsPtr)*/
+  unsigned long       bufferFlags;            /*set or cleared flags*/
+  unsigned long       bufferFlagsMask;        /*which flags are valid*/
+};
+typedef struct ExtendedScheduledSoundHeader ExtendedScheduledSoundHeader;
+typedef ExtendedScheduledSoundHeader *  ExtendedScheduledSoundHeaderPtr;
+struct SMStatus {
+  short               smMaxCPULoad;
+  short               smNumChannels;
+  short               smCurCPULoad;
+};
+typedef struct SMStatus                 SMStatus;
+typedef SMStatus *                      SMStatusPtr;
+struct SCStatus {
+  UnsignedFixed       scStartTime;
+  UnsignedFixed       scEndTime;
+  UnsignedFixed       scCurrentTime;
+  Boolean             scChannelBusy;
+  Boolean             scChannelDisposed;
+  Boolean             scChannelPaused;
+  Boolean             scUnused;
+  unsigned long       scChannelAttributes;
+  long                scCPULoad;
+};
+typedef struct SCStatus                 SCStatus;
+typedef SCStatus *                      SCStatusPtr;
+struct AudioSelection {
+  long                unitType;
+  UnsignedFixed       selStart;
+  UnsignedFixed       selEnd;
+};
+typedef struct AudioSelection           AudioSelection;
+typedef AudioSelection *                AudioSelectionPtr;
+#if CALL_NOT_IN_CARBON
+struct SndDoubleBuffer {
+  long                dbNumFrames;
+  long                dbFlags;
+  long                dbUserInfo[2];
+  SInt8               dbSoundData[1];
+};
+typedef struct SndDoubleBuffer          SndDoubleBuffer;
+typedef SndDoubleBuffer *               SndDoubleBufferPtr;
+
+
+typedef CALLBACK_API( void , SndDoubleBackProcPtr )(SndChannelPtr channel, SndDoubleBufferPtr doubleBufferPtr);
+typedef STACK_UPP_TYPE(SndDoubleBackProcPtr)                    SndDoubleBackUPP;
+#if CALL_NOT_IN_CARBON
+/*
+ *  NewSndDoubleBackUPP()
+ *  
+ *  Availability:
+ *    Non-Carbon CFM:   available as macro/inline
+ *    CarbonLib:        not available
+ *    Mac OS X:         not available
+ */
+EXTERN_API_C( SndDoubleBackUPP )
+NewSndDoubleBackUPP(SndDoubleBackProcPtr userRoutine);
+#if !OPAQUE_UPP_TYPES
+  enum { uppSndDoubleBackProcInfo = 0x000003C0 };  /* pascal no_return_value Func(4_bytes, 4_bytes) */
+  #ifdef __cplusplus
+    inline DEFINE_API_C(SndDoubleBackUPP) NewSndDoubleBackUPP(SndDoubleBackProcPtr userRoutine) { return (SndDoubleBackUPP)NewRoutineDescriptor((ProcPtr)(userRoutine), uppSndDoubleBackProcInfo, GetCurrentArchitecture()); }
+  #else
+    #define NewSndDoubleBackUPP(userRoutine) (SndDoubleBackUPP)NewRoutineDescriptor((ProcPtr)(userRoutine), uppSndDoubleBackProcInfo, GetCurrentArchitecture())
+  #endif
+#endif
+
+/*
+ *  DisposeSndDoubleBackUPP()
+ *  
+ *  Availability:
+ *    Non-Carbon CFM:   available as macro/inline
+ *    CarbonLib:        not available
+ *    Mac OS X:         not available
+ */
+EXTERN_API_C( void )
+DisposeSndDoubleBackUPP(SndDoubleBackUPP userUPP);
+#if !OPAQUE_UPP_TYPES
+  #ifdef __cplusplus
+      inline DEFINE_API_C(void) DisposeSndDoubleBackUPP(SndDoubleBackUPP userUPP) { DisposeRoutineDescriptor((UniversalProcPtr)userUPP); }
+  #else
+      #define DisposeSndDoubleBackUPP(userUPP) DisposeRoutineDescriptor(userUPP)
+  #endif
+#endif
+
+/*
+ *  InvokeSndDoubleBackUPP()
+ *  
+ *  Availability:
+ *    Non-Carbon CFM:   available as macro/inline
+ *    CarbonLib:        not available
+ *    Mac OS X:         not available
+ */
+EXTERN_API_C( void )
+InvokeSndDoubleBackUPP(
+  SndChannelPtr       channel,
+  SndDoubleBufferPtr  doubleBufferPtr,
+  SndDoubleBackUPP    userUPP);
+#if !OPAQUE_UPP_TYPES
+  #ifdef __cplusplus
+      inline DEFINE_API_C(void) InvokeSndDoubleBackUPP(SndChannelPtr channel, SndDoubleBufferPtr doubleBufferPtr, SndDoubleBackUPP userUPP) { CALL_TWO_PARAMETER_UPP(userUPP, uppSndDoubleBackProcInfo, channel, doubleBufferPtr); }
+  #else
+    #define InvokeSndDoubleBackUPP(channel, doubleBufferPtr, userUPP) CALL_TWO_PARAMETER_UPP((userUPP), uppSndDoubleBackProcInfo, (channel), (doubleBufferPtr))
+  #endif
+#endif
+
+#endif  /* CALL_NOT_IN_CARBON */
+
+#if CALL_NOT_IN_CARBON || OLDROUTINENAMES
+    /* support for pre-Carbon UPP routines: New...Proc and Call...Proc */
+    #define NewSndDoubleBackProc(userRoutine)                   NewSndDoubleBackUPP(userRoutine)
+    #define CallSndDoubleBackProc(userRoutine, channel, doubleBufferPtr) InvokeSndDoubleBackUPP(channel, doubleBufferPtr, userRoutine)
+#endif /* CALL_NOT_IN_CARBON */
+
+struct SndDoubleBufferHeader {
+  short               dbhNumChannels;
+  short               dbhSampleSize;
+  short               dbhCompressionID;
+  short               dbhPacketSize;
+  UnsignedFixed       dbhSampleRate;
+  SndDoubleBufferPtr  dbhBufferPtr[2];
+  SndDoubleBackUPP    dbhDoubleBack;
+};
+typedef struct SndDoubleBufferHeader    SndDoubleBufferHeader;
+typedef SndDoubleBufferHeader *         SndDoubleBufferHeaderPtr;
+struct SndDoubleBufferHeader2 {
+  short               dbhNumChannels;
+  short               dbhSampleSize;
+  short               dbhCompressionID;
+  short               dbhPacketSize;
+  UnsignedFixed       dbhSampleRate;
+  SndDoubleBufferPtr  dbhBufferPtr[2];
+  SndDoubleBackUPP    dbhDoubleBack;
+  OSType              dbhFormat;
+};
+typedef struct SndDoubleBufferHeader2   SndDoubleBufferHeader2;
+typedef SndDoubleBufferHeader2 *        SndDoubleBufferHeader2Ptr;
+#endif  /* CALL_NOT_IN_CARBON */
+
+struct SoundInfoList {
+  short               count;
+  Handle              infoHandle;
+};
+typedef struct SoundInfoList            SoundInfoList;
+typedef SoundInfoList *                 SoundInfoListPtr;
+struct SoundComponentData {
+  long                flags;
+  OSType              format;
+  short               numChannels;
+  short               sampleSize;
+  UnsignedFixed       sampleRate;
+  long                sampleCount;
+  Byte *              buffer;
+  long                reserved;
+};
+typedef struct SoundComponentData       SoundComponentData;
+typedef SoundComponentData *            SoundComponentDataPtr;
+struct ExtendedSoundComponentData {
+  SoundComponentData  desc;                   /*description of sound buffer*/
+  long                recordSize;             /*size of this record in bytes*/
+  long                extendedFlags;          /*flags for extended record*/
+  long                bufferSize;             /*size of buffer in bytes*/
+  long                frameCount;             /*number of audio frames*/
+  long *              frameSizesArray;        /*pointer to array of longs with frame sizes in bytes*/
+  long                commonFrameSize;        /*size of each frame if common*/
+  void *              extensionsPtr;          /*pointer to set of classic atoms (size,type,data,...)*/
+  long                extensionsSize;         /*size of extensions data (extensionsPtr)*/
+  unsigned long       bufferFlags;            /*set or cleared flags*/
+  unsigned long       bufferFlagsMask;        /*which flags are valid*/
+};
+typedef struct ExtendedSoundComponentData ExtendedSoundComponentData;
+typedef ExtendedSoundComponentData *    ExtendedSoundComponentDataPtr;
+typedef struct SoundParamBlock          SoundParamBlock;
+typedef SoundParamBlock *               SoundParamBlockPtr;
+typedef CALLBACK_API( Boolean , SoundParamProcPtr )(SoundParamBlockPtr * pb);
+typedef STACK_UPP_TYPE(SoundParamProcPtr)                       SoundParamUPP;
+struct SoundParamBlock {
+  long                recordSize;             /*size of this record in bytes*/
+  SoundComponentData  desc;                   /*description of sound buffer*/
+  UnsignedFixed       rateMultiplier;         /*rate multiplier to apply to sound*/
+  short               leftVolume;             /*volumes to apply to sound*/
+  short               rightVolume;
+  long                quality;                /*quality to apply to sound*/
+  ComponentInstance   filter;                 /*filter to apply to sound*/
+  SoundParamUPP       moreRtn;                /*routine to call to get more data*/
+  SoundParamUPP       completionRtn;          /*routine to call when buffer is complete*/
+  long                refCon;                 /*user refcon*/
+  short               result;                 /*result*/
+};
+
+struct ExtendedSoundParamBlock {
+  SoundParamBlock     pb;                     /*classic SoundParamBlock except recordSize == sizeof(ExtendedSoundParamBlock)*/
+  short               reserved;
+  long                extendedFlags;          /*flags*/
+  long                bufferSize;             /*size of buffer in bytes*/
+  long                frameCount;             /*number of audio frames*/
+  long *              frameSizesArray;        /*pointer to array of longs with frame sizes in bytes*/
+  long                commonFrameSize;        /*size of each frame if common*/
+  void *              extensionsPtr;          /*pointer to set of classic atoms (size,type,data,...)*/
+  long                extensionsSize;         /*size of extensions data (extensionsPtr)*/
+  unsigned long       bufferFlags;            /*set or cleared flags*/
+  unsigned long       bufferFlagsMask;        /*which flags are valid*/
+};
+typedef struct ExtendedSoundParamBlock  ExtendedSoundParamBlock;
+typedef ExtendedSoundParamBlock *       ExtendedSoundParamBlockPtr;
+struct CompressionInfo {
+  long                recordSize;
+  OSType              format;
+  short               compressionID;
+  unsigned short      samplesPerPacket;
+  unsigned short      bytesPerPacket;
+  unsigned short      bytesPerFrame;
+  unsigned short      bytesPerSample;
+  unsigned short      futureUse1;
+};
+typedef struct CompressionInfo          CompressionInfo;
+typedef CompressionInfo *               CompressionInfoPtr;
+typedef CompressionInfoPtr *            CompressionInfoHandle;
+/*variables for floating point conversion*/
+struct SoundSlopeAndInterceptRecord {
+  Float64             slope;
+  Float64             intercept;
+  Float64             minClip;
+  Float64             maxClip;
+};
+typedef struct SoundSlopeAndInterceptRecord SoundSlopeAndInterceptRecord;
+typedef SoundSlopeAndInterceptRecord *  SoundSlopeAndInterceptPtr;
+/*private thing to use as a reference to a Sound Converter*/
+typedef struct OpaqueSoundConverter*    SoundConverter;
+/*callback routine to provide data to the Sound Converter*/
+typedef CALLBACK_API( Boolean , SoundConverterFillBufferDataProcPtr )(SoundComponentDataPtr *data, void *refCon);
+typedef STACK_UPP_TYPE(SoundConverterFillBufferDataProcPtr)     SoundConverterFillBufferDataUPP;
+/*private thing to use as a reference to a Sound Source*/
+typedef struct OpaqueSoundSource*       SoundSource;
+typedef SoundSource *                   SoundSourcePtr;
+
+
+struct SoundComponentLink {
+  ComponentDescription  description;          /*Describes the sound component*/
+  SoundSource         mixerID;                /*Reserved by Apple*/
+  SoundSource *       linkID;                 /*Reserved by Apple*/
+};
+typedef struct SoundComponentLink       SoundComponentLink;
+typedef SoundComponentLink *            SoundComponentLinkPtr;
+struct AudioInfo {
+  long                capabilitiesFlags;      /*Describes device capabilities*/
+  long                reserved;               /*Reserved by Apple*/
+  unsigned short      numVolumeSteps;         /*Number of significant increments between min and max volume*/
+};
+typedef struct AudioInfo                AudioInfo;
+typedef AudioInfo *                     AudioInfoPtr;
+struct AudioFormatAtom {
+  long                size;                   /* = sizeof(AudioFormatAtom)*/
+  OSType              atomType;               /* = kAudioFormatAtomType*/
+  OSType              format;
+};
+typedef struct AudioFormatAtom          AudioFormatAtom;
+typedef AudioFormatAtom *               AudioFormatAtomPtr;
+struct AudioEndianAtom {
+  long                size;                   /* = sizeof(AudioEndianAtom)*/
+  OSType              atomType;               /* = kAudioEndianAtomType*/
+  short               littleEndian;
+};
+typedef struct AudioEndianAtom          AudioEndianAtom;
+typedef AudioEndianAtom *               AudioEndianAtomPtr;
+struct AudioTerminatorAtom {
+  long                size;                   /* = sizeof(AudioTerminatorAtom)*/
+  OSType              atomType;               /* = kAudioTerminatorAtomType*/
+};
+typedef struct AudioTerminatorAtom      AudioTerminatorAtom;
+typedef AudioTerminatorAtom *           AudioTerminatorAtomPtr;
+struct LevelMeterInfo {
+  short               numChannels;            /* mono or stereo source*/
+  UInt8               leftMeter;              /* 0-255 range*/
+  UInt8               rightMeter;             /* 0-255 range*/
+};
+typedef struct LevelMeterInfo           LevelMeterInfo;
+typedef LevelMeterInfo *                LevelMeterInfoPtr;
+struct EQSpectrumBandsRecord {
+  short               count;
+  UnsignedFixedPtr    frequency;              /* pointer to array of frequencies*/
+};
+typedef struct EQSpectrumBandsRecord    EQSpectrumBandsRecord;
+typedef EQSpectrumBandsRecord *         EQSpectrumBandsRecordPtr;
+enum {
+  kSoundAudioCodecPropertyWritableFlag = 1L << 0
+};
+
+struct SoundAudioCodecPropertyRequestParams {
+  UInt32              propertyClass;
+  UInt32              propertyID;
+  UInt32              propertyDataSize;       /* out -- GetPropertyInfo, in/out -- GetProperty, in -- SetProperty*/
+  void *              propertyData;           /* in -- GetPropertyInfo, GetProperty, SetProperty*/
+  UInt32              propertyRequestFlags;   /* out -- GetPropertyInfo*/
+  UInt32              propertyDataType;       /* out -- GetPropertyInfo, often 0*/
+  ComponentResult     propertyRequestResult;  /* out -- GetPropertyInfo, GetProperty, SetProperty*/
+};
+typedef struct SoundAudioCodecPropertyRequestParams SoundAudioCodecPropertyRequestParams;
+
+
+/* Sound Input Structures*/
+typedef struct SPB                      SPB;
+
+typedef SPB *                           SPBPtr;
+
+
+/*user procedures called by sound input routines*/
+typedef CALLBACK_API_REGISTER68K( void , SIInterruptProcPtr, (SPBPtr inParamPtr, Ptr dataBuffer, short peakAmplitude, long sampleSize) );
+typedef CALLBACK_API( void , SICompletionProcPtr )(SPBPtr inParamPtr);
+typedef REGISTER_UPP_TYPE(SIInterruptProcPtr)                   SIInterruptUPP;
+typedef STACK_UPP_TYPE(SICompletionProcPtr)                     SICompletionUPP;
+
+
+/*Sound Input Parameter Block*/
+struct SPB {
+  long                inRefNum;               /*reference number of sound input device*/
+  unsigned long       count;                  /*number of bytes to record*/
+  unsigned long       milliseconds;           /*number of milliseconds to record*/
+  unsigned long       bufferLength;           /*length of buffer in bytes*/
+  Ptr                 bufferPtr;              /*buffer to store sound data in*/
+  SICompletionUPP     completionRoutine;      /*completion routine*/
+  SIInterruptUPP      interruptRoutine;       /*interrupt routine*/
+  long                userLong;               /*user-defined field*/
+  OSErr               error;                  /*error*/
+  long                unused1;                /*reserved - must be zero*/
+};
+
+/*
+ *  NewSoundParamUPP()
+ *  
+ *  Availability:
+ *    Non-Carbon CFM:   available as macro/inline
+ *    CarbonLib:        in CarbonLib 1.0 and later
+ *    Mac OS X:         in version 10.0 and later
+ */
+EXTERN_API_C( SoundParamUPP )
+NewSoundParamUPP(SoundParamProcPtr userRoutine);
+#if !OPAQUE_UPP_TYPES
+  enum { uppSoundParamProcInfo = 0x000000D0 };  /* pascal 1_byte Func(4_bytes) */
+  #ifdef __cplusplus
+    inline DEFINE_API_C(SoundParamUPP) NewSoundParamUPP(SoundParamProcPtr userRoutine) { return (SoundParamUPP)NewRoutineDescriptor((ProcPtr)(userRoutine), uppSoundParamProcInfo, GetCurrentArchitecture()); }
+  #else
+    #define NewSoundParamUPP(userRoutine) (SoundParamUPP)NewRoutineDescriptor((ProcPtr)(userRoutine), uppSoundParamProcInfo, GetCurrentArchitecture())
+  #endif
+#endif
+
+/*
+ *  NewSoundConverterFillBufferDataUPP()
+ *  
+ *  Availability:
+ *    Non-Carbon CFM:   available as macro/inline
+ *    CarbonLib:        in CarbonLib 1.1 and later
+ *    Mac OS X:         in version 10.0 and later
+ */
+EXTERN_API_C( SoundConverterFillBufferDataUPP )
+NewSoundConverterFillBufferDataUPP(SoundConverterFillBufferDataProcPtr userRoutine);
+#if !OPAQUE_UPP_TYPES
+  enum { uppSoundConverterFillBufferDataProcInfo = 0x000003D0 };  /* pascal 1_byte Func(4_bytes, 4_bytes) */
+  #ifdef __cplusplus
+    inline DEFINE_API_C(SoundConverterFillBufferDataUPP) NewSoundConverterFillBufferDataUPP(SoundConverterFillBufferDataProcPtr userRoutine) { return (SoundConverterFillBufferDataUPP)NewRoutineDescriptor((ProcPtr)(userRoutine), uppSoundConverterFillBufferDataProcInfo, GetCurrentArchitecture()); }
+  #else
+    #define NewSoundConverterFillBufferDataUPP(userRoutine) (SoundConverterFillBufferDataUPP)NewRoutineDescriptor((ProcPtr)(userRoutine), uppSoundConverterFillBufferDataProcInfo, GetCurrentArchitecture())
+  #endif
+#endif
+
+/*
+ *  NewSIInterruptUPP()
+ *  
+ *  Availability:
+ *    Non-Carbon CFM:   available as macro/inline
+ *    CarbonLib:        in CarbonLib 1.0 and later
+ *    Mac OS X:         in version 10.0 and later
+ */
+EXTERN_API_C( SIInterruptUPP )
+NewSIInterruptUPP(SIInterruptProcPtr userRoutine);
+#if !OPAQUE_UPP_TYPES
+  enum { uppSIInterruptProcInfo = 0x1C579802 };  /* register no_return_value Func(4_bytes:A0, 4_bytes:A1, 2_bytes:D0, 4_bytes:D1) */
+  #ifdef __cplusplus
+    inline DEFINE_API_C(SIInterruptUPP) NewSIInterruptUPP(SIInterruptProcPtr userRoutine) { return (SIInterruptUPP)NewRoutineDescriptor((ProcPtr)(userRoutine), uppSIInterruptProcInfo, GetCurrentArchitecture()); }
+  #else
+    #define NewSIInterruptUPP(userRoutine) (SIInterruptUPP)NewRoutineDescriptor((ProcPtr)(userRoutine), uppSIInterruptProcInfo, GetCurrentArchitecture())
+  #endif
+#endif
+
+/*
+ *  NewSICompletionUPP()
+ *  
+ *  Availability:
+ *    Non-Carbon CFM:   available as macro/inline
+ *    CarbonLib:        in CarbonLib 1.0 and later
+ *    Mac OS X:         in version 10.0 and later
+ */
+EXTERN_API_C( SICompletionUPP )
+NewSICompletionUPP(SICompletionProcPtr userRoutine);
+#if !OPAQUE_UPP_TYPES
+  enum { uppSICompletionProcInfo = 0x000000C0 };  /* pascal no_return_value Func(4_bytes) */
+  #ifdef __cplusplus
+    inline DEFINE_API_C(SICompletionUPP) NewSICompletionUPP(SICompletionProcPtr userRoutine) { return (SICompletionUPP)NewRoutineDescriptor((ProcPtr)(userRoutine), uppSICompletionProcInfo, GetCurrentArchitecture()); }
+  #else
+    #define NewSICompletionUPP(userRoutine) (SICompletionUPP)NewRoutineDescriptor((ProcPtr)(userRoutine), uppSICompletionProcInfo, GetCurrentArchitecture())
+  #endif
+#endif
+
+/*
+ *  DisposeSoundParamUPP()
+ *  
+ *  Availability:
+ *    Non-Carbon CFM:   available as macro/inline
+ *    CarbonLib:        in CarbonLib 1.0 and later
+ *    Mac OS X:         in version 10.0 and later
+ */
+EXTERN_API_C( void )
+DisposeSoundParamUPP(SoundParamUPP userUPP);
+#if !OPAQUE_UPP_TYPES
+  #ifdef __cplusplus
+      inline DEFINE_API_C(void) DisposeSoundParamUPP(SoundParamUPP userUPP) { DisposeRoutineDescriptor((UniversalProcPtr)userUPP); }
+  #else
+      #define DisposeSoundParamUPP(userUPP) DisposeRoutineDescriptor(userUPP)
+  #endif
+#endif
+
+/*
+ *  DisposeSoundConverterFillBufferDataUPP()
+ *  
+ *  Availability:
+ *    Non-Carbon CFM:   available as macro/inline
+ *    CarbonLib:        in CarbonLib 1.1 and later
+ *    Mac OS X:         in version 10.0 and later
+ */
+EXTERN_API_C( void )
+DisposeSoundConverterFillBufferDataUPP(SoundConverterFillBufferDataUPP userUPP);
+#if !OPAQUE_UPP_TYPES
+  #ifdef __cplusplus
+      inline DEFINE_API_C(void) DisposeSoundConverterFillBufferDataUPP(SoundConverterFillBufferDataUPP userUPP) { DisposeRoutineDescriptor((UniversalProcPtr)userUPP); }
+  #else
+      #define DisposeSoundConverterFillBufferDataUPP(userUPP) DisposeRoutineDescriptor(userUPP)
+  #endif
+#endif
+
+/*
+ *  DisposeSIInterruptUPP()
+ *  
+ *  Availability:
+ *    Non-Carbon CFM:   available as macro/inline
+ *    CarbonLib:        in CarbonLib 1.0 and later
+ *    Mac OS X:         in version 10.0 and later
+ */
+EXTERN_API_C( void )
+DisposeSIInterruptUPP(SIInterruptUPP userUPP);
+#if !OPAQUE_UPP_TYPES
+  #ifdef __cplusplus
+      inline DEFINE_API_C(void) DisposeSIInterruptUPP(SIInterruptUPP userUPP) { DisposeRoutineDescriptor((UniversalProcPtr)userUPP); }
+  #else
+      #define DisposeSIInterruptUPP(userUPP) DisposeRoutineDescriptor(userUPP)
+  #endif
+#endif
+
+/*
+ *  DisposeSICompletionUPP()
+ *  
+ *  Availability:
+ *    Non-Carbon CFM:   available as macro/inline
+ *    CarbonLib:        in CarbonLib 1.0 and later
+ *    Mac OS X:         in version 10.0 and later
+ */
+EXTERN_API_C( void )
+DisposeSICompletionUPP(SICompletionUPP userUPP);
+#if !OPAQUE_UPP_TYPES
+  #ifdef __cplusplus
+      inline DEFINE_API_C(void) DisposeSICompletionUPP(SICompletionUPP userUPP) { DisposeRoutineDescriptor((UniversalProcPtr)userUPP); }
+  #else
+      #define DisposeSICompletionUPP(userUPP) DisposeRoutineDescriptor(userUPP)
+  #endif
+#endif
+
+/*
+ *  InvokeSoundParamUPP()
+ *  
+ *  Availability:
+ *    Non-Carbon CFM:   available as macro/inline
+ *    CarbonLib:        in CarbonLib 1.0 and later
+ *    Mac OS X:         in version 10.0 and later
+ */
+EXTERN_API_C( Boolean )
+InvokeSoundParamUPP(
+  SoundParamBlockPtr *  pb,
+  SoundParamUPP         userUPP);
+#if !OPAQUE_UPP_TYPES
+  #ifdef __cplusplus
+      inline DEFINE_API_C(Boolean) InvokeSoundParamUPP(SoundParamBlockPtr * pb, SoundParamUPP userUPP) { return (Boolean)CALL_ONE_PARAMETER_UPP(userUPP, uppSoundParamProcInfo, pb); }
+  #else
+    #define InvokeSoundParamUPP(pb, userUPP) (Boolean)CALL_ONE_PARAMETER_UPP((userUPP), uppSoundParamProcInfo, (pb))
+  #endif
+#endif
+
+/*
+ *  InvokeSoundConverterFillBufferDataUPP()
+ *  
+ *  Availability:
+ *    Non-Carbon CFM:   available as macro/inline
+ *    CarbonLib:        in CarbonLib 1.1 and later
+ *    Mac OS X:         in version 10.0 and later
+ */
+EXTERN_API_C( Boolean )
+InvokeSoundConverterFillBufferDataUPP(
+  SoundComponentDataPtr *          data,
+  void *                           refCon,
+  SoundConverterFillBufferDataUPP  userUPP);
+#if !OPAQUE_UPP_TYPES
+  #ifdef __cplusplus
+      inline DEFINE_API_C(Boolean) InvokeSoundConverterFillBufferDataUPP(SoundComponentDataPtr * data, void * refCon, SoundConverterFillBufferDataUPP userUPP) { return (Boolean)CALL_TWO_PARAMETER_UPP(userUPP, uppSoundConverterFillBufferDataProcInfo, data, refCon); }
+  #else
+    #define InvokeSoundConverterFillBufferDataUPP(data, refCon, userUPP) (Boolean)CALL_TWO_PARAMETER_UPP((userUPP), uppSoundConverterFillBufferDataProcInfo, (data), (refCon))
+  #endif
+#endif
+
+/*
+ *  InvokeSIInterruptUPP()
+ *  
+ *  Availability:
+ *    Non-Carbon CFM:   available as macro/inline
+ *    CarbonLib:        in CarbonLib 1.0 and later
+ *    Mac OS X:         in version 10.0 and later
+ */
+EXTERN_API_C( void )
+InvokeSIInterruptUPP(
+  SPBPtr          inParamPtr,
+  Ptr             dataBuffer,
+  short           peakAmplitude,
+  long            sampleSize,
+  SIInterruptUPP  userUPP);
+#if !OPAQUE_UPP_TYPES && (!TARGET_OS_MAC || !TARGET_CPU_68K || TARGET_RT_MAC_CFM)
+  #ifdef __cplusplus
+      inline DEFINE_API_C(void) InvokeSIInterruptUPP(SPBPtr inParamPtr, Ptr dataBuffer, short peakAmplitude, long sampleSize, SIInterruptUPP userUPP) { CALL_FOUR_PARAMETER_UPP(userUPP, uppSIInterruptProcInfo, inParamPtr, dataBuffer, peakAmplitude, sampleSize); }
+  #else
+    #define InvokeSIInterruptUPP(inParamPtr, dataBuffer, peakAmplitude, sampleSize, userUPP) CALL_FOUR_PARAMETER_UPP((userUPP), uppSIInterruptProcInfo, (inParamPtr), (dataBuffer), (peakAmplitude), (sampleSize))
+  #endif
+#endif
+
+/*
+ *  InvokeSICompletionUPP()
+ *  
+ *  Availability:
+ *    Non-Carbon CFM:   available as macro/inline
+ *    CarbonLib:        in CarbonLib 1.0 and later
+ *    Mac OS X:         in version 10.0 and later
+ */
+EXTERN_API_C( void )
+InvokeSICompletionUPP(
+  SPBPtr           inParamPtr,
+  SICompletionUPP  userUPP);
+#if !OPAQUE_UPP_TYPES
+  #ifdef __cplusplus
+      inline DEFINE_API_C(void) InvokeSICompletionUPP(SPBPtr inParamPtr, SICompletionUPP userUPP) { CALL_ONE_PARAMETER_UPP(userUPP, uppSICompletionProcInfo, inParamPtr); }
+  #else
+    #define InvokeSICompletionUPP(inParamPtr, userUPP) CALL_ONE_PARAMETER_UPP((userUPP), uppSICompletionProcInfo, (inParamPtr))
+  #endif
+#endif
+
+#if CALL_NOT_IN_CARBON || OLDROUTINENAMES
+    /* support for pre-Carbon UPP routines: New...Proc and Call...Proc */
+    #define NewSoundParamProc(userRoutine)                      NewSoundParamUPP(userRoutine)
+    #define NewSoundConverterFillBufferDataProc(userRoutine)    NewSoundConverterFillBufferDataUPP(userRoutine)
+    #define NewSIInterruptProc(userRoutine)                     NewSIInterruptUPP(userRoutine)
+    #define NewSICompletionProc(userRoutine)                    NewSICompletionUPP(userRoutine)
+    #define CallSoundParamProc(userRoutine, pb)                 InvokeSoundParamUPP(pb, userRoutine)
+    #define CallSoundConverterFillBufferDataProc(userRoutine, data, refCon) InvokeSoundConverterFillBufferDataUPP(data, refCon, userRoutine)
+    #define CallSIInterruptProc(userRoutine, inParamPtr, dataBuffer, peakAmplitude, sampleSize) InvokeSIInterruptUPP(inParamPtr, dataBuffer, peakAmplitude, sampleSize, userRoutine)
+    #define CallSICompletionProc(userRoutine, inParamPtr)       InvokeSICompletionUPP(inParamPtr, userRoutine)
+#endif /* CALL_NOT_IN_CARBON */
+
+typedef CALLBACK_API( void , FilePlayCompletionProcPtr )(SndChannelPtr chan);
+typedef STACK_UPP_TYPE(FilePlayCompletionProcPtr)               FilePlayCompletionUPP;
+#if CALL_NOT_IN_CARBON
+/*
+ *  NewFilePlayCompletionUPP()
+ *  
+ *  Availability:
+ *    Non-Carbon CFM:   available as macro/inline
+ *    CarbonLib:        not available
+ *    Mac OS X:         not available
+ */
+EXTERN_API_C( FilePlayCompletionUPP )
+NewFilePlayCompletionUPP(FilePlayCompletionProcPtr userRoutine);
+#if !OPAQUE_UPP_TYPES
+  enum { uppFilePlayCompletionProcInfo = 0x000000C0 };  /* pascal no_return_value Func(4_bytes) */
+  #ifdef __cplusplus
+    inline DEFINE_API_C(FilePlayCompletionUPP) NewFilePlayCompletionUPP(FilePlayCompletionProcPtr userRoutine) { return (FilePlayCompletionUPP)NewRoutineDescriptor((ProcPtr)(userRoutine), uppFilePlayCompletionProcInfo, GetCurrentArchitecture()); }
+  #else
+    #define NewFilePlayCompletionUPP(userRoutine) (FilePlayCompletionUPP)NewRoutineDescriptor((ProcPtr)(userRoutine), uppFilePlayCompletionProcInfo, GetCurrentArchitecture())
+  #endif
+#endif
+
+/*
+ *  DisposeFilePlayCompletionUPP()
+ *  
+ *  Availability:
+ *    Non-Carbon CFM:   available as macro/inline
+ *    CarbonLib:        not available
+ *    Mac OS X:         not available
+ */
+EXTERN_API_C( void )
+DisposeFilePlayCompletionUPP(FilePlayCompletionUPP userUPP);
+#if !OPAQUE_UPP_TYPES
+  #ifdef __cplusplus
+      inline DEFINE_API_C(void) DisposeFilePlayCompletionUPP(FilePlayCompletionUPP userUPP) { DisposeRoutineDescriptor((UniversalProcPtr)userUPP); }
+  #else
+      #define DisposeFilePlayCompletionUPP(userUPP) DisposeRoutineDescriptor(userUPP)
+  #endif
+#endif
+
+/*
+ *  InvokeFilePlayCompletionUPP()
+ *  
+ *  Availability:
+ *    Non-Carbon CFM:   available as macro/inline
+ *    CarbonLib:        not available
+ *    Mac OS X:         not available
+ */
+EXTERN_API_C( void )
+InvokeFilePlayCompletionUPP(
+  SndChannelPtr          chan,
+  FilePlayCompletionUPP  userUPP);
+#if !OPAQUE_UPP_TYPES
+  #ifdef __cplusplus
+      inline DEFINE_API_C(void) InvokeFilePlayCompletionUPP(SndChannelPtr chan, FilePlayCompletionUPP userUPP) { CALL_ONE_PARAMETER_UPP(userUPP, uppFilePlayCompletionProcInfo, chan); }
+  #else
+    #define InvokeFilePlayCompletionUPP(chan, userUPP) CALL_ONE_PARAMETER_UPP((userUPP), uppFilePlayCompletionProcInfo, (chan))
+  #endif
+#endif
+
+#endif  /* CALL_NOT_IN_CARBON */
+
+#if CALL_NOT_IN_CARBON || OLDROUTINENAMES
+    /* support for pre-Carbon UPP routines: New...Proc and Call...Proc */
+    #define NewFilePlayCompletionProc(userRoutine)              NewFilePlayCompletionUPP(userRoutine)
+    #define CallFilePlayCompletionProc(userRoutine, chan)       InvokeFilePlayCompletionUPP(chan, userRoutine)
+#endif /* CALL_NOT_IN_CARBON */
+
+/*
+  ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+   prototypes
+  ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+*/
+
+
+/* Sound Manager routines */
+/*
+ *  SysBeep()
+ *  
+ *  Availability:
+ *    Non-Carbon CFM:   in InterfaceLib 7.1 and later
+ *    CarbonLib:        in CarbonLib 1.0 and later
+ *    Mac OS X:         in version 10.0 and later
+ */
+EXTERN_API( void )
+SysBeep(short duration)                                       ONEWORDINLINE(0xA9C8);
+
+
+/*
+ *  SndDoCommand()
+ *  
+ *  Availability:
+ *    Non-Carbon CFM:   in InterfaceLib 7.1 and later
+ *    CarbonLib:        in CarbonLib 1.0 and later
+ *    Mac OS X:         in version 10.0 and later
+ */
+EXTERN_API( OSErr )
+SndDoCommand(
+  SndChannelPtr       chan,
+  const SndCommand *  cmd,
+  Boolean             noWait)                                 ONEWORDINLINE(0xA803);
+
+
+/*
+ *  SndDoImmediate()
+ *  
+ *  Availability:
+ *    Non-Carbon CFM:   in InterfaceLib 7.1 and later
+ *    CarbonLib:        in CarbonLib 1.0 and later
+ *    Mac OS X:         in version 10.0 and later
+ */
+EXTERN_API( OSErr )
+SndDoImmediate(
+  SndChannelPtr       chan,
+  const SndCommand *  cmd)                                    ONEWORDINLINE(0xA804);
+
+
+/*
+ *  SndNewChannel()
+ *  
+ *  Availability:
+ *    Non-Carbon CFM:   in InterfaceLib 7.1 and later
+ *    CarbonLib:        in CarbonLib 1.0 and later
+ *    Mac OS X:         in version 10.0 and later
+ */
+EXTERN_API( OSErr )
+SndNewChannel(
+  SndChannelPtr *  chan,
+  short            synth,
+  long             init,
+  SndCallBackUPP   userRoutine)                               ONEWORDINLINE(0xA807);
+
+
+/*
+ *  SndDisposeChannel()
+ *  
+ *  Availability:
+ *    Non-Carbon CFM:   in InterfaceLib 7.1 and later
+ *    CarbonLib:        in CarbonLib 1.0 and later
+ *    Mac OS X:         in version 10.0 and later
+ */
+EXTERN_API( OSErr )
+SndDisposeChannel(
+  SndChannelPtr   chan,
+  Boolean         quietNow)                                   ONEWORDINLINE(0xA801);
+
+
+/*
+ *  SndPlay()
+ *  
+ *  Availability:
+ *    Non-Carbon CFM:   in InterfaceLib 7.1 and later
+ *    CarbonLib:        in CarbonLib 1.0 and later
+ *    Mac OS X:         in version 10.0 and later
+ */
+EXTERN_API( OSErr )
+SndPlay(
+  SndChannelPtr   chan,
+  SndListHandle   sndHandle,
+  Boolean         async)                                      ONEWORDINLINE(0xA805);
+
+
+#if OLDROUTINENAMES
+#if CALL_NOT_IN_CARBON
+/*
+ *  SndAddModifier()
+ *  
+ *  Availability:
+ *    Non-Carbon CFM:   in InterfaceLib 7.1 and later
+ *    CarbonLib:        not available
+ *    Mac OS X:         not available
+ */
+EXTERN_API( OSErr )
+SndAddModifier(
+  SndChannelPtr   chan,
+  Ptr             modifier,
+  short           id,
+  long            init)                                       ONEWORDINLINE(0xA802);
+
+
+#endif  /* CALL_NOT_IN_CARBON */
+
+#endif  /* OLDROUTINENAMES */
+
+#if CALL_NOT_IN_CARBON
+/*
+ *  SndControl()
+ *  
+ *  Availability:
+ *    Non-Carbon CFM:   in InterfaceLib 7.1 and later
+ *    CarbonLib:        not available
+ *    Mac OS X:         not available
+ */
+EXTERN_API( OSErr )
+SndControl(
+  short         id,
+  SndCommand *  cmd)                                          ONEWORDINLINE(0xA806);
+
+
+/* Sound Manager 2.0 and later, uses _SoundDispatch */
+#endif  /* CALL_NOT_IN_CARBON */
+
+/*
+ *  SndSoundManagerVersion()
+ *  
+ *  Availability:
+ *    Non-Carbon CFM:   in InterfaceLib 7.1 and later
+ *    CarbonLib:        in CarbonLib 1.0 and later
+ *    Mac OS X:         in version 10.0 and later
+ */
+EXTERN_API( NumVersion )
+SndSoundManagerVersion(void)                                  FOURWORDINLINE(0x203C, 0x000C, 0x0008, 0xA800);
+
+
+#if CALL_NOT_IN_CARBON
+/*
+ *  SndStartFilePlay()
+ *  
+ *  Availability:
+ *    Non-Carbon CFM:   in InterfaceLib 7.1 and later
+ *    CarbonLib:        not available
+ *    Mac OS X:         not available
+ */
+EXTERN_API( OSErr )
+SndStartFilePlay(
+  SndChannelPtr           chan,
+  short                   fRefNum,
+  short                   resNum,
+  long                    bufferSize,
+  void *                  theBuffer,
+  AudioSelectionPtr       theSelection,
+  FilePlayCompletionUPP   theCompletion,
+  Boolean                 async)                              FOURWORDINLINE(0x203C, 0x0D00, 0x0008, 0xA800);
+
+
+/*
+ *  SndPauseFilePlay()
+ *  
+ *  Availability:
+ *    Non-Carbon CFM:   in InterfaceLib 7.1 and later
+ *    CarbonLib:        not available
+ *    Mac OS X:         not available
+ */
+EXTERN_API( OSErr )
+SndPauseFilePlay(SndChannelPtr chan)                          FOURWORDINLINE(0x203C, 0x0204, 0x0008, 0xA800);
+
+
+/*
+ *  SndStopFilePlay()
+ *  
+ *  Availability:
+ *    Non-Carbon CFM:   in InterfaceLib 7.1 and later
+ *    CarbonLib:        not available
+ *    Mac OS X:         not available
+ */
+EXTERN_API( OSErr )
+SndStopFilePlay(
+  SndChannelPtr   chan,
+  Boolean         quietNow)                                   FOURWORDINLINE(0x203C, 0x0308, 0x0008, 0xA800);
+
+
+#endif  /* CALL_NOT_IN_CARBON */
+
+/*
+ *  SndChannelStatus()
+ *  
+ *  Availability:
+ *    Non-Carbon CFM:   in InterfaceLib 7.1 and later
+ *    CarbonLib:        in CarbonLib 1.0 and later
+ *    Mac OS X:         in version 10.0 and later
+ */
+EXTERN_API( OSErr )
+SndChannelStatus(
+  SndChannelPtr   chan,
+  short           theLength,
+  SCStatusPtr     theStatus)                                  FOURWORDINLINE(0x203C, 0x0510, 0x0008, 0xA800);
+
+
+/*
+ *  SndManagerStatus()
+ *  
+ *  Availability:
+ *    Non-Carbon CFM:   in InterfaceLib 7.1 and later
+ *    CarbonLib:        in CarbonLib 1.0 and later
+ *    Mac OS X:         in version 10.0 and later
+ */
+EXTERN_API( OSErr )
+SndManagerStatus(
+  short         theLength,
+  SMStatusPtr   theStatus)                                    FOURWORDINLINE(0x203C, 0x0314, 0x0008, 0xA800);
+
+
+/*
+ *  SndGetSysBeepState()
+ *  
+ *  Availability:
+ *    Non-Carbon CFM:   in InterfaceLib 7.1 and later
+ *    CarbonLib:        in CarbonLib 1.0 and later
+ *    Mac OS X:         in version 10.0 and later
+ */
+EXTERN_API( void )
+SndGetSysBeepState(short * sysBeepState)                      FOURWORDINLINE(0x203C, 0x0218, 0x0008, 0xA800);
+
+
+/*
+ *  SndSetSysBeepState()
+ *  
+ *  Availability:
+ *    Non-Carbon CFM:   in InterfaceLib 7.1 and later
+ *    CarbonLib:        in CarbonLib 1.0 and later
+ *    Mac OS X:         in version 10.0 and later
+ */
+EXTERN_API( OSErr )
+SndSetSysBeepState(short sysBeepState)                        FOURWORDINLINE(0x203C, 0x011C, 0x0008, 0xA800);
+
+
+#if CALL_NOT_IN_CARBON
+/*
+ *  SndPlayDoubleBuffer()
+ *  
+ *  Availability:
+ *    Non-Carbon CFM:   in InterfaceLib 7.1 and later
+ *    CarbonLib:        not available
+ *    Mac OS X:         not available
+ */
+EXTERN_API( OSErr )
+SndPlayDoubleBuffer(
+  SndChannelPtr              chan,
+  SndDoubleBufferHeaderPtr   theParams)                       FOURWORDINLINE(0x203C, 0x0420, 0x0008, 0xA800);
+
+
+/* MACE compression routines, uses _SoundDispatch */
+/*
+ *  MACEVersion()
+ *  
+ *  Availability:
+ *    Non-Carbon CFM:   in InterfaceLib 7.1 and later
+ *    CarbonLib:        not available
+ *    Mac OS X:         not available
+ */
+EXTERN_API( NumVersion )
+MACEVersion(void)                                             FOURWORDINLINE(0x203C, 0x0000, 0x0010, 0xA800);
+
+
+/*
+ *  Comp3to1()
+ *  
+ *  Availability:
+ *    Non-Carbon CFM:   in InterfaceLib 7.1 and later
+ *    CarbonLib:        not available
+ *    Mac OS X:         not available
+ */
+EXTERN_API( void )
+Comp3to1(
+  const void *    inBuffer,
+  void *          outBuffer,
+  unsigned long   cnt,
+  StateBlockPtr   inState,
+  StateBlockPtr   outState,
+  unsigned long   numChannels,
+  unsigned long   whichChannel)                               FOURWORDINLINE(0x203C, 0x0004, 0x0010, 0xA800);
+
+
+/*
+ *  Exp1to3()
+ *  
+ *  Availability:
+ *    Non-Carbon CFM:   in InterfaceLib 7.1 and later
+ *    CarbonLib:        not available
+ *    Mac OS X:         not available
+ */
+EXTERN_API( void )
+Exp1to3(
+  const void *    inBuffer,
+  void *          outBuffer,
+  unsigned long   cnt,
+  StateBlockPtr   inState,
+  StateBlockPtr   outState,
+  unsigned long   numChannels,
+  unsigned long   whichChannel)                               FOURWORDINLINE(0x203C, 0x0008, 0x0010, 0xA800);
+
+
+/*
+ *  Comp6to1()
+ *  
+ *  Availability:
+ *    Non-Carbon CFM:   in InterfaceLib 7.1 and later
+ *    CarbonLib:        not available
+ *    Mac OS X:         not available
+ */
+EXTERN_API( void )
+Comp6to1(
+  const void *    inBuffer,
+  void *          outBuffer,
+  unsigned long   cnt,
+  StateBlockPtr   inState,
+  StateBlockPtr   outState,
+  unsigned long   numChannels,
+  unsigned long   whichChannel)                               FOURWORDINLINE(0x203C, 0x000C, 0x0010, 0xA800);
+
+
+/*
+ *  Exp1to6()
+ *  
+ *  Availability:
+ *    Non-Carbon CFM:   in InterfaceLib 7.1 and later
+ *    CarbonLib:        not available
+ *    Mac OS X:         not available
+ */
+EXTERN_API( void )
+Exp1to6(
+  const void *    inBuffer,
+  void *          outBuffer,
+  unsigned long   cnt,
+  StateBlockPtr   inState,
+  StateBlockPtr   outState,
+  unsigned long   numChannels,
+  unsigned long   whichChannel)                               FOURWORDINLINE(0x203C, 0x0010, 0x0010, 0xA800);
+
+
+/* Sound Manager 3.0 and later calls, uses _SoundDispatch */
+#endif  /* CALL_NOT_IN_CARBON */
+
+/*
+ *  GetSysBeepVolume()
+ *  
+ *  Availability:
+ *    Non-Carbon CFM:   in InterfaceLib 7.1 and later
+ *    CarbonLib:        in CarbonLib 1.0 and later
+ *    Mac OS X:         in version 10.0 and later
+ */
+EXTERN_API( OSErr )
+GetSysBeepVolume(long * level)                                FOURWORDINLINE(0x203C, 0x0224, 0x0018, 0xA800);
+
+
+/*
+ *  SetSysBeepVolume()
+ *  
+ *  Availability:
+ *    Non-Carbon CFM:   in InterfaceLib 7.1 and later
+ *    CarbonLib:        in CarbonLib 1.0 and later
+ *    Mac OS X:         in version 10.0 and later
+ */
+EXTERN_API( OSErr )
+SetSysBeepVolume(long level)                                  FOURWORDINLINE(0x203C, 0x0228, 0x0018, 0xA800);
+
+
+/*
+ *  GetDefaultOutputVolume()
+ *  
+ *  Availability:
+ *    Non-Carbon CFM:   in InterfaceLib 7.1 and later
+ *    CarbonLib:        in CarbonLib 1.0 and later
+ *    Mac OS X:         in version 10.0 and later
+ */
+EXTERN_API( OSErr )
+GetDefaultOutputVolume(long * level)                          FOURWORDINLINE(0x203C, 0x022C, 0x0018, 0xA800);
+
+
+/*
+ *  SetDefaultOutputVolume()
+ *  
+ *  Availability:
+ *    Non-Carbon CFM:   in InterfaceLib 7.1 and later
+ *    CarbonLib:        in CarbonLib 1.0 and later
+ *    Mac OS X:         in version 10.0 and later
+ */
+EXTERN_API( OSErr )
+SetDefaultOutputVolume(long level)                            FOURWORDINLINE(0x203C, 0x0230, 0x0018, 0xA800);
+
+
+/*
+ *  GetSoundHeaderOffset()
+ *  
+ *  Availability:
+ *    Non-Carbon CFM:   in InterfaceLib 7.1 and later
+ *    CarbonLib:        in CarbonLib 1.0 and later
+ *    Mac OS X:         in version 10.0 and later
+ */
+EXTERN_API( OSErr )
+GetSoundHeaderOffset(
+  SndListHandle   sndHandle,
+  long *          offset)                                     FOURWORDINLINE(0x203C, 0x0404, 0x0018, 0xA800);
+
+
+/*
+ *  UnsignedFixedMulDiv()
+ *  
+ *  Availability:
+ *    Non-Carbon CFM:   in SoundLib 3.0 and later
+ *    CarbonLib:        in CarbonLib 1.0 and later
+ *    Mac OS X:         not available
+ */
+EXTERN_API( UnsignedFixed )
+UnsignedFixedMulDiv(
+  UnsignedFixed   value,
+  UnsignedFixed   multiplier,
+  UnsignedFixed   divisor)                                    FOURWORDINLINE(0x203C, 0x060C, 0x0018, 0xA800);
+
+
+/*
+ *  GetCompressionInfo()
+ *  
+ *  Availability:
+ *    Non-Carbon CFM:   in SoundLib 3.0 and later
+ *    CarbonLib:        in CarbonLib 1.0 and later
+ *    Mac OS X:         in version 10.0 and later
+ */
+EXTERN_API( OSErr )
+GetCompressionInfo(
+  short                compressionID,
+  OSType               format,
+  short                numChannels,
+  short                sampleSize,
+  CompressionInfoPtr   cp)                                    FOURWORDINLINE(0x203C, 0x0710, 0x0018, 0xA800);
+
+
+/*
+ *  SetSoundPreference()
+ *  
+ *  Availability:
+ *    Non-Carbon CFM:   in SoundLib 3.0 and later
+ *    CarbonLib:        in CarbonLib 1.0 and later
+ *    Mac OS X:         in version 10.0 and later
+ */
+EXTERN_API( OSErr )
+SetSoundPreference(
+  OSType   theType,
+  Str255   name,
+  Handle   settings)                                          FOURWORDINLINE(0x203C, 0x0634, 0x0018, 0xA800);
+
+
+/*
+ *  GetSoundPreference()
+ *  
+ *  Availability:
+ *    Non-Carbon CFM:   in SoundLib 3.0 and later
+ *    CarbonLib:        in CarbonLib 1.0 and later
+ *    Mac OS X:         in version 10.0 and later
+ */
+EXTERN_API( OSErr )
+GetSoundPreference(
+  OSType   theType,
+  Str255   name,
+  Handle   settings)                                          FOURWORDINLINE(0x203C, 0x0638, 0x0018, 0xA800);
+
+
+/*
+ *  OpenMixerSoundComponent()
+ *  
+ *  Availability:
+ *    Non-Carbon CFM:   in SoundLib 3.0 and later
+ *    CarbonLib:        in CarbonLib 1.0 and later
+ *    Mac OS X:         in version 10.0 and later
+ */
+EXTERN_API( OSErr )
+OpenMixerSoundComponent(
+  SoundComponentDataPtr   outputDescription,
+  long                    outputFlags,
+  ComponentInstance *     mixerComponent)                     FOURWORDINLINE(0x203C, 0x0614, 0x0018, 0xA800);
+
+
+/*
+ *  CloseMixerSoundComponent()
+ *  
+ *  Availability:
+ *    Non-Carbon CFM:   in SoundLib 3.0 and later
+ *    CarbonLib:        in CarbonLib 1.0 and later
+ *    Mac OS X:         in version 10.0 and later
+ */
+EXTERN_API( OSErr )
+CloseMixerSoundComponent(ComponentInstance ci)                FOURWORDINLINE(0x203C, 0x0218, 0x0018, 0xA800);
+
+
+/* Sound Manager 3.1 and later calls, uses _SoundDispatch */
+/*
+ *  SndGetInfo()
+ *  
+ *  Availability:
+ *    Non-Carbon CFM:   in SoundLib 3.1 and later
+ *    CarbonLib:        in CarbonLib 1.0 and later
+ *    Mac OS X:         in version 10.0 and later
+ */
+EXTERN_API( OSErr )
+SndGetInfo(
+  SndChannelPtr   chan,
+  OSType          selector,
+  void *          infoPtr)                                    FOURWORDINLINE(0x203C, 0x063C, 0x0018, 0xA800);
+
+
+/*
+ *  SndSetInfo()
+ *  
+ *  Availability:
+ *    Non-Carbon CFM:   in SoundLib 3.1 and later
+ *    CarbonLib:        in CarbonLib 1.0 and later
+ *    Mac OS X:         in version 10.0 and later
+ */
+EXTERN_API( OSErr )
+SndSetInfo(
+  SndChannelPtr   chan,
+  OSType          selector,
+  const void *    infoPtr)                                    FOURWORDINLINE(0x203C, 0x0640, 0x0018, 0xA800);
+
+
+/*
+ *  GetSoundOutputInfo()
+ *  
+ *  Availability:
+ *    Non-Carbon CFM:   in SoundLib 3.1 and later
+ *    CarbonLib:        in CarbonLib 1.0 and later
+ *    Mac OS X:         in version 10.0 and later
+ */
+EXTERN_API( OSErr )
+GetSoundOutputInfo(
+  Component   outputDevice,
+  OSType      selector,
+  void *      infoPtr)                                        FOURWORDINLINE(0x203C, 0x0644, 0x0018, 0xA800);
+
+
+/*
+ *  SetSoundOutputInfo()
+ *  
+ *  Availability:
+ *    Non-Carbon CFM:   in SoundLib 3.1 and later
+ *    CarbonLib:        in CarbonLib 1.0 and later
+ *    Mac OS X:         in version 10.0 and later
+ */
+EXTERN_API( OSErr )
+SetSoundOutputInfo(
+  Component     outputDevice,
+  OSType        selector,
+  const void *  infoPtr)                                      FOURWORDINLINE(0x203C, 0x0648, 0x0018, 0xA800);
+
+
+/* Sound Manager 3.2 and later calls, uses _SoundDispatch */
+/*
+ *  GetCompressionName()
+ *  
+ *  Availability:
+ *    Non-Carbon CFM:   in SoundLib 3.2 and later
+ *    CarbonLib:        in CarbonLib 1.0 and later
+ *    Mac OS X:         in version 10.0 and later
+ */
+EXTERN_API( OSErr )
+GetCompressionName(
+  OSType   compressionType,
+  Str255   compressionName)                                   FOURWORDINLINE(0x203C, 0x044C, 0x0018, 0xA800);
+
+
+/*
+ *  SoundConverterOpen()
+ *  
+ *  Availability:
+ *    Non-Carbon CFM:   in SoundLib 3.2 and later
+ *    CarbonLib:        in CarbonLib 1.0 and later
+ *    Mac OS X:         in version 10.0 and later
+ */
+EXTERN_API( OSErr )
+SoundConverterOpen(
+  const SoundComponentData *  inputFormat,
+  const SoundComponentData *  outputFormat,
+  SoundConverter *            sc)                             FOURWORDINLINE(0x203C, 0x0650, 0x0018, 0xA800);
+
+
+/*
+ *  SoundConverterClose()
+ *  
+ *  Availability:
+ *    Non-Carbon CFM:   in SoundLib 3.2 and later
+ *    CarbonLib:        in CarbonLib 1.0 and later
+ *    Mac OS X:         in version 10.0 and later
+ */
+EXTERN_API( OSErr )
+SoundConverterClose(SoundConverter sc)                        FOURWORDINLINE(0x203C, 0x0254, 0x0018, 0xA800);
+
+
+/*
+ *  SoundConverterGetBufferSizes()
+ *  
+ *  Availability:
+ *    Non-Carbon CFM:   in SoundLib 3.2 and later
+ *    CarbonLib:        in CarbonLib 1.0 and later
+ *    Mac OS X:         in version 10.0 and later
+ */
+EXTERN_API( OSErr )
+SoundConverterGetBufferSizes(
+  SoundConverter   sc,
+  unsigned long    inputBytesTarget,
+  unsigned long *  inputFrames,
+  unsigned long *  inputBytes,
+  unsigned long *  outputBytes)                               FOURWORDINLINE(0x203C, 0x0A58, 0x0018, 0xA800);
+
+
+/*
+ *  SoundConverterBeginConversion()
+ *  
+ *  Availability:
+ *    Non-Carbon CFM:   in SoundLib 3.2 and later
+ *    CarbonLib:        in CarbonLib 1.0 and later
+ *    Mac OS X:         in version 10.0 and later
+ */
+EXTERN_API( OSErr )
+SoundConverterBeginConversion(SoundConverter sc)              FOURWORDINLINE(0x203C, 0x025C, 0x0018, 0xA800);
+
+
+/*
+ *  SoundConverterConvertBuffer()
+ *  
+ *  Availability:
+ *    Non-Carbon CFM:   in SoundLib 3.2 and later
+ *    CarbonLib:        in CarbonLib 1.0 and later
+ *    Mac OS X:         in version 10.0 and later
+ */
+EXTERN_API( OSErr )
+SoundConverterConvertBuffer(
+  SoundConverter   sc,
+  const void *     inputPtr,
+  unsigned long    inputFrames,
+  void *           outputPtr,
+  unsigned long *  outputFrames,
+  unsigned long *  outputBytes)                               FOURWORDINLINE(0x203C, 0x0C60, 0x0018, 0xA800);
+
+
+/*
+ *  SoundConverterEndConversion()
+ *  
+ *  Availability:
+ *    Non-Carbon CFM:   in SoundLib 3.2 and later
+ *    CarbonLib:        in CarbonLib 1.0 and later
+ *    Mac OS X:         in version 10.0 and later
+ */
+EXTERN_API( OSErr )
+SoundConverterEndConversion(
+  SoundConverter   sc,
+  void *           outputPtr,
+  unsigned long *  outputFrames,
+  unsigned long *  outputBytes)                               FOURWORDINLINE(0x203C, 0x0864, 0x0018, 0xA800);
+
+
+/* Sound Manager 3.3 and later calls, uses _SoundDispatch */
+/*
+ *  SoundConverterGetInfo()
+ *  
+ *  Availability:
+ *    Non-Carbon CFM:   in SoundLib 3.3 and later
+ *    CarbonLib:        in CarbonLib 1.0 and later
+ *    Mac OS X:         in version 10.0 and later
+ */
+EXTERN_API( OSErr )
+SoundConverterGetInfo(
+  SoundConverter   sc,
+  OSType           selector,
+  void *           infoPtr)                                   FOURWORDINLINE(0x203C, 0x0668, 0x0018, 0xA800);
+
+
+/*
+ *  SoundConverterSetInfo()
+ *  
+ *  Availability:
+ *    Non-Carbon CFM:   in SoundLib 3.3 and later
+ *    CarbonLib:        in CarbonLib 1.0 and later
+ *    Mac OS X:         in version 10.0 and later
+ */
+EXTERN_API( OSErr )
+SoundConverterSetInfo(
+  SoundConverter   sc,
+  OSType           selector,
+  void *           infoPtr)                                   FOURWORDINLINE(0x203C, 0x066C, 0x0018, 0xA800);
+
+
+/* Sound Manager 3.6 and later calls, uses _SoundDispatch */
+/*
+ *  SoundConverterFillBuffer()
+ *  
+ *  Availability:
+ *    Non-Carbon CFM:   in SoundLib 3.6 and later
+ *    CarbonLib:        in CarbonLib 1.1 and later
+ *    Mac OS X:         in version 10.0 and later
+ */
+EXTERN_API( OSErr )
+SoundConverterFillBuffer(
+  SoundConverter                    sc,
+  SoundConverterFillBufferDataUPP   fillBufferDataUPP,
+  void *                            fillBufferDataRefCon,
+  void *                            outputBuffer,
+  unsigned long                     outputBufferByteSize,
+  unsigned long *                   bytesWritten,
+  unsigned long *                   framesWritten,
+  unsigned long *                   outputFlags)              FOURWORDINLINE(0x203C, 0x1078, 0x0018, 0xA800);
+
+
+/*
+ *  SoundManagerGetInfo()
+ *  
+ *  Availability:
+ *    Non-Carbon CFM:   in SoundLib 3.6 and later
+ *    CarbonLib:        in CarbonLib 1.1 and later
+ *    Mac OS X:         in version 10.0 and later
+ */
+EXTERN_API( OSErr )
+SoundManagerGetInfo(
+  OSType   selector,
+  void *   infoPtr)                                           FOURWORDINLINE(0x203C, 0x047C, 0x0018, 0xA800);
+
+
+/*
+ *  SoundManagerSetInfo()
+ *  
+ *  Availability:
+ *    Non-Carbon CFM:   in SoundLib 3.6 and later
+ *    CarbonLib:        in CarbonLib 1.1 and later
+ *    Mac OS X:         in version 10.0 and later
+ */
+EXTERN_API( OSErr )
+SoundManagerSetInfo(
+  OSType        selector,
+  const void *  infoPtr)                                      FOURWORDINLINE(0x203C, 0x0480, 0x0018, 0xA800);
+
+
+/*
+  Sound Component Functions
+   basic sound component functions
+*/
+
+/*
+ *  SoundComponentInitOutputDevice()
+ *  
+ *  Availability:
+ *    Non-Carbon CFM:   in SoundLib 3.0 and later
+ *    CarbonLib:        in CarbonLib 1.0 and later
+ *    Mac OS X:         in version 10.0 and later
+ */
+EXTERN_API( ComponentResult )
+SoundComponentInitOutputDevice(
+  ComponentInstance   ti,
+  long                actions)                                FIVEWORDINLINE(0x2F3C, 0x0004, 0x0001, 0x7000, 0xA82A);
+
+
+/*
+ *  SoundComponentSetSource()
+ *  
+ *  Availability:
+ *    Non-Carbon CFM:   in SoundLib 3.0 and later
+ *    CarbonLib:        in CarbonLib 1.0 and later
+ *    Mac OS X:         in version 10.0 and later
+ */
+EXTERN_API( ComponentResult )
+SoundComponentSetSource(
+  ComponentInstance   ti,
+  SoundSource         sourceID,
+  ComponentInstance   source)                                 FIVEWORDINLINE(0x2F3C, 0x0008, 0x0002, 0x7000, 0xA82A);
+
+
+/*
+ *  SoundComponentGetSource()
+ *  
+ *  Availability:
+ *    Non-Carbon CFM:   in SoundLib 3.0 and later
+ *    CarbonLib:        in CarbonLib 1.0 and later
+ *    Mac OS X:         in version 10.0 and later
+ */
+EXTERN_API( ComponentResult )
+SoundComponentGetSource(
+  ComponentInstance    ti,
+  SoundSource          sourceID,
+  ComponentInstance *  source)                                FIVEWORDINLINE(0x2F3C, 0x0008, 0x0003, 0x7000, 0xA82A);
+
+
+/*
+ *  SoundComponentGetSourceData()
+ *  
+ *  Availability:
+ *    Non-Carbon CFM:   in SoundLib 3.0 and later
+ *    CarbonLib:        in CarbonLib 1.0 and later
+ *    Mac OS X:         in version 10.0 and later
+ */
+EXTERN_API( ComponentResult )
+SoundComponentGetSourceData(
+  ComponentInstance        ti,
+  SoundComponentDataPtr *  sourceData)                        FIVEWORDINLINE(0x2F3C, 0x0004, 0x0004, 0x7000, 0xA82A);
+
+
+/*
+ *  SoundComponentSetOutput()
+ *  
+ *  Availability:
+ *    Non-Carbon CFM:   in SoundLib 3.0 and later
+ *    CarbonLib:        in CarbonLib 1.0 and later
+ *    Mac OS X:         in version 10.0 and later
+ */
+EXTERN_API( ComponentResult )
+SoundComponentSetOutput(
+  ComponentInstance        ti,
+  SoundComponentDataPtr    requested,
+  SoundComponentDataPtr *  actual)                            FIVEWORDINLINE(0x2F3C, 0x0008, 0x0005, 0x7000, 0xA82A);
+
+
+/* junction methods for the mixer, must be called at non-interrupt level*/
+/*
+ *  SoundComponentAddSource()
+ *  
+ *  Availability:
+ *    Non-Carbon CFM:   in SoundLib 3.0 and later
+ *    CarbonLib:        in CarbonLib 1.0 and later
+ *    Mac OS X:         in version 10.0 and later
+ */
+EXTERN_API( ComponentResult )
+SoundComponentAddSource(
+  ComponentInstance   ti,
+  SoundSource *       sourceID)                               FIVEWORDINLINE(0x2F3C, 0x0004, 0x0101, 0x7000, 0xA82A);
+
+
+/*
+ *  SoundComponentRemoveSource()
+ *  
+ *  Availability:
+ *    Non-Carbon CFM:   in SoundLib 3.0 and later
+ *    CarbonLib:        in CarbonLib 1.0 and later
+ *    Mac OS X:         in version 10.0 and later
+ */
+EXTERN_API( ComponentResult )
+SoundComponentRemoveSource(
+  ComponentInstance   ti,
+  SoundSource         sourceID)                               FIVEWORDINLINE(0x2F3C, 0x0004, 0x0102, 0x7000, 0xA82A);
+
+
+/* info methods*/
+/*
+ *  SoundComponentGetInfo()
+ *  
+ *  Availability:
+ *    Non-Carbon CFM:   in SoundLib 3.0 and later
+ *    CarbonLib:        in CarbonLib 1.0 and later
+ *    Mac OS X:         in version 10.0 and later
+ */
+EXTERN_API( ComponentResult )
+SoundComponentGetInfo(
+  ComponentInstance   ti,
+  SoundSource         sourceID,
+  OSType              selector,
+  void *              infoPtr)                                FIVEWORDINLINE(0x2F3C, 0x000C, 0x0103, 0x7000, 0xA82A);
+
+
+/*
+ *  SoundComponentSetInfo()
+ *  
+ *  Availability:
+ *    Non-Carbon CFM:   in SoundLib 3.0 and later
+ *    CarbonLib:        in CarbonLib 1.0 and later
+ *    Mac OS X:         in version 10.0 and later
+ */
+EXTERN_API( ComponentResult )
+SoundComponentSetInfo(
+  ComponentInstance   ti,
+  SoundSource         sourceID,
+  OSType              selector,
+  void *              infoPtr)                                FIVEWORDINLINE(0x2F3C, 0x000C, 0x0104, 0x7000, 0xA82A);
+
+
+/* control methods*/
+/*
+ *  SoundComponentStartSource()
+ *  
+ *  Availability:
+ *    Non-Carbon CFM:   in SoundLib 3.0 and later
+ *    CarbonLib:        in CarbonLib 1.0 and later
+ *    Mac OS X:         in version 10.0 and later
+ */
+EXTERN_API( ComponentResult )
+SoundComponentStartSource(
+  ComponentInstance   ti,
+  short               count,
+  SoundSource *       sources)                                FIVEWORDINLINE(0x2F3C, 0x0006, 0x0105, 0x7000, 0xA82A);
+
+
+/*
+ *  SoundComponentStopSource()
+ *  
+ *  Availability:
+ *    Non-Carbon CFM:   in SoundLib 3.0 and later
+ *    CarbonLib:        in CarbonLib 1.0 and later
+ *    Mac OS X:         in version 10.0 and later
+ */
+EXTERN_API( ComponentResult )
+SoundComponentStopSource(
+  ComponentInstance   ti,
+  short               count,
+  SoundSource *       sources)                                FIVEWORDINLINE(0x2F3C, 0x0006, 0x0106, 0x7000, 0xA82A);
+
+
+/*
+ *  SoundComponentPauseSource()
+ *  
+ *  Availability:
+ *    Non-Carbon CFM:   in SoundLib 3.0 and later
+ *    CarbonLib:        in CarbonLib 1.0 and later
+ *    Mac OS X:         in version 10.0 and later
+ */
+EXTERN_API( ComponentResult )
+SoundComponentPauseSource(
+  ComponentInstance   ti,
+  short               count,
+  SoundSource *       sources)                                FIVEWORDINLINE(0x2F3C, 0x0006, 0x0107, 0x7000, 0xA82A);
+
+
+/*
+ *  SoundComponentPlaySourceBuffer()
+ *  
+ *  Availability:
+ *    Non-Carbon CFM:   in SoundLib 3.0 and later
+ *    CarbonLib:        in CarbonLib 1.0 and later
+ *    Mac OS X:         in version 10.0 and later
+ */
+EXTERN_API( ComponentResult )
+SoundComponentPlaySourceBuffer(
+  ComponentInstance    ti,
+  SoundSource          sourceID,
+  SoundParamBlockPtr   pb,
+  long                 actions)                               FIVEWORDINLINE(0x2F3C, 0x000C, 0x0108, 0x7000, 0xA82A);
+
+
+
+/* selectors for component calls */
+enum {
+    kSoundComponentInitOutputDeviceSelect      = 0x0001,
+    kSoundComponentSetSourceSelect             = 0x0002,
+    kSoundComponentGetSourceSelect             = 0x0003,
+    kSoundComponentGetSourceDataSelect         = 0x0004,
+    kSoundComponentSetOutputSelect             = 0x0005,
+    kSoundComponentAddSourceSelect             = 0x0101,
+    kSoundComponentRemoveSourceSelect          = 0x0102,
+    kSoundComponentGetInfoSelect               = 0x0103,
+    kSoundComponentSetInfoSelect               = 0x0104,
+    kSoundComponentStartSourceSelect           = 0x0105,
+    kSoundComponentStopSourceSelect            = 0x0106,
+    kSoundComponentPauseSourceSelect           = 0x0107,
+    kSoundComponentPlaySourceBufferSelect      = 0x0108
+};
+/*Audio Components*/
+/*Volume is described as a value between 0 and 1, with 0 indicating minimum
+  volume and 1 indicating maximum volume; if the device doesn't support
+  software control of volume, then a value of unimpErr is returned, indicating
+  that these functions are not supported by the device
+*/
+#if CALL_NOT_IN_CARBON
+/*
+ *  AudioGetVolume()
+ *  
+ *  Availability:
+ *    Non-Carbon CFM:   in SoundLib 3.0 and later
+ *    CarbonLib:        not available
+ *    Mac OS X:         not available
+ */
+EXTERN_API( ComponentResult )
+AudioGetVolume(
+  ComponentInstance   ac,
+  short               whichChannel,
+  ShortFixed *        volume)                                 FIVEWORDINLINE(0x2F3C, 0x0006, 0x0000, 0x7000, 0xA82A);
+
+
+/*
+ *  AudioSetVolume()
+ *  
+ *  Availability:
+ *    Non-Carbon CFM:   in SoundLib 3.0 and later
+ *    CarbonLib:        not available
+ *    Mac OS X:         not available
+ */
+EXTERN_API( ComponentResult )
+AudioSetVolume(
+  ComponentInstance   ac,
+  short               whichChannel,
+  ShortFixed          volume)                                 FIVEWORDINLINE(0x2F3C, 0x0004, 0x0001, 0x7000, 0xA82A);
+
+
+/*If the device doesn't support software control of mute, then a value of unimpErr is
+returned, indicating that these functions are not supported by the device.*/
+/*
+ *  AudioGetMute()
+ *  
+ *  Availability:
+ *    Non-Carbon CFM:   in SoundLib 3.0 and later
+ *    CarbonLib:        not available
+ *    Mac OS X:         not available
+ */
+EXTERN_API( ComponentResult )
+AudioGetMute(
+  ComponentInstance   ac,
+  short               whichChannel,
+  short *             mute)                                   FIVEWORDINLINE(0x2F3C, 0x0006, 0x0002, 0x7000, 0xA82A);
+
+
+/*
+ *  AudioSetMute()
+ *  
+ *  Availability:
+ *    Non-Carbon CFM:   in SoundLib 3.0 and later
+ *    CarbonLib:        not available
+ *    Mac OS X:         not available
+ */
+EXTERN_API( ComponentResult )
+AudioSetMute(
+  ComponentInstance   ac,
+  short               whichChannel,
+  short               mute)                                   FIVEWORDINLINE(0x2F3C, 0x0004, 0x0003, 0x7000, 0xA82A);
+
+
+/*AudioSetToDefaults causes the associated device to reset its volume and mute values
+(and perhaps other characteristics, e.g. attenuation) to "factory default" settings*/
+/*
+ *  AudioSetToDefaults()
+ *  
+ *  Availability:
+ *    Non-Carbon CFM:   in SoundLib 3.0 and later
+ *    CarbonLib:        not available
+ *    Mac OS X:         not available
+ */
+EXTERN_API( ComponentResult )
+AudioSetToDefaults(ComponentInstance ac)                      FIVEWORDINLINE(0x2F3C, 0x0000, 0x0004, 0x7000, 0xA82A);
+
+
+/*This routine is required; it must be implemented by all audio components*/
+
+/*
+ *  AudioGetInfo()
+ *  
+ *  Availability:
+ *    Non-Carbon CFM:   in SoundLib 3.0 and later
+ *    CarbonLib:        not available
+ *    Mac OS X:         not available
+ */
+EXTERN_API( ComponentResult )
+AudioGetInfo(
+  ComponentInstance   ac,
+  AudioInfoPtr        info)                                   FIVEWORDINLINE(0x2F3C, 0x0004, 0x0005, 0x7000, 0xA82A);
+
+
+/*
+ *  AudioGetBass()
+ *  
+ *  Availability:
+ *    Non-Carbon CFM:   in SoundLib 3.0 and later
+ *    CarbonLib:        not available
+ *    Mac OS X:         not available
+ */
+EXTERN_API( ComponentResult )
+AudioGetBass(
+  ComponentInstance   ac,
+  short               whichChannel,
+  short *             bass)                                   FIVEWORDINLINE(0x2F3C, 0x0006, 0x0006, 0x7000, 0xA82A);
+
+
+/*
+ *  AudioSetBass()
+ *  
+ *  Availability:
+ *    Non-Carbon CFM:   in SoundLib 3.0 and later
+ *    CarbonLib:        not available
+ *    Mac OS X:         not available
+ */
+EXTERN_API( ComponentResult )
+AudioSetBass(
+  ComponentInstance   ac,
+  short               whichChannel,
+  short               bass)                                   FIVEWORDINLINE(0x2F3C, 0x0004, 0x0007, 0x7000, 0xA82A);
+
+
+/*
+ *  AudioGetTreble()
+ *  
+ *  Availability:
+ *    Non-Carbon CFM:   in SoundLib 3.0 and later
+ *    CarbonLib:        not available
+ *    Mac OS X:         not available
+ */
+EXTERN_API( ComponentResult )
+AudioGetTreble(
+  ComponentInstance   ac,
+  short               whichChannel,
+  short *             Treble)                                 FIVEWORDINLINE(0x2F3C, 0x0006, 0x0008, 0x7000, 0xA82A);
+
+
+/*
+ *  AudioSetTreble()
+ *  
+ *  Availability:
+ *    Non-Carbon CFM:   in SoundLib 3.0 and later
+ *    CarbonLib:        not available
+ *    Mac OS X:         not available
+ */
+EXTERN_API( ComponentResult )
+AudioSetTreble(
+  ComponentInstance   ac,
+  short               whichChannel,
+  short               Treble)                                 FIVEWORDINLINE(0x2F3C, 0x0004, 0x0009, 0x7000, 0xA82A);
+
+
+/*
+ *  AudioGetOutputDevice()
+ *  
+ *  Availability:
+ *    Non-Carbon CFM:   in SoundLib 3.0 and later
+ *    CarbonLib:        not available
+ *    Mac OS X:         not available
+ */
+EXTERN_API( ComponentResult )
+AudioGetOutputDevice(
+  ComponentInstance   ac,
+  Component *         outputDevice)                           FIVEWORDINLINE(0x2F3C, 0x0004, 0x000A, 0x7000, 0xA82A);
+
+
+/*This is routine is private to the AudioVision component.  It enables the watching of the mute key.*/
+/*
+ *  AudioMuteOnEvent()
+ *  
+ *  Availability:
+ *    Non-Carbon CFM:   in SoundLib 3.0 and later
+ *    CarbonLib:        not available
+ *    Mac OS X:         not available
+ */
+EXTERN_API( ComponentResult )
+AudioMuteOnEvent(
+  ComponentInstance   ac,
+  short               muteOnEvent)                            FIVEWORDINLINE(0x2F3C, 0x0002, 0x0081, 0x7000, 0xA82A);
+
+
+
+/* selectors for component calls */
+enum {
+    kAudioGetVolumeSelect                      = 0x0000,
+    kAudioSetVolumeSelect                      = 0x0001,
+    kAudioGetMuteSelect                        = 0x0002,
+    kAudioSetMuteSelect                        = 0x0003,
+    kAudioSetToDefaultsSelect                  = 0x0004,
+    kAudioGetInfoSelect                        = 0x0005,
+    kAudioGetBassSelect                        = 0x0006,
+    kAudioSetBassSelect                        = 0x0007,
+    kAudioGetTrebleSelect                      = 0x0008,
+    kAudioSetTrebleSelect                      = 0x0009,
+    kAudioGetOutputDeviceSelect                = 0x000A,
+    kAudioMuteOnEventSelect                    = 0x0081
+};
+#endif  /* CALL_NOT_IN_CARBON */
+
+
+enum {
+  kDelegatedSoundComponentSelectors = 0x0100
+};
+
+
+
+/* Sound Input Manager routines, uses _SoundDispatch */
+/*
+ *  SPBVersion()
+ *  
+ *  Availability:
+ *    Non-Carbon CFM:   in InterfaceLib 7.1 and later
+ *    CarbonLib:        in CarbonLib 1.0 and later
+ *    Mac OS X:         in version 10.0 and later
+ */
+EXTERN_API( NumVersion )
+SPBVersion(void)                                              FOURWORDINLINE(0x203C, 0x0000, 0x0014, 0xA800);
+
+
+/*
+ *  SndRecord()
+ *  
+ *  Availability:
+ *    Non-Carbon CFM:   in InterfaceLib 7.1 and later
+ *    CarbonLib:        in CarbonLib 1.0 and later
+ *    Mac OS X:         in version 10.0 and later
+ */
+EXTERN_API( OSErr )
+SndRecord(
+  ModalFilterUPP   filterProc,
+  Point            corner,
+  OSType           quality,
+  SndListHandle *  sndHandle)                                 FOURWORDINLINE(0x203C, 0x0804, 0x0014, 0xA800);
+
+
+#if CALL_NOT_IN_CARBON
+/*
+ *  SndRecordToFile()
+ *  
+ *  Availability:
+ *    Non-Carbon CFM:   in InterfaceLib 7.1 and later
+ *    CarbonLib:        not available
+ *    Mac OS X:         not available
+ */
+EXTERN_API( OSErr )
+SndRecordToFile(
+  ModalFilterUPP   filterProc,
+  Point            corner,
+  OSType           quality,
+  short            fRefNum)                                   FOURWORDINLINE(0x203C, 0x0708, 0x0014, 0xA800);
+
+
+#endif  /* CALL_NOT_IN_CARBON */
+
+/*
+ *  SPBSignInDevice()
+ *  
+ *  Availability:
+ *    Non-Carbon CFM:   in InterfaceLib 7.1 and later
+ *    CarbonLib:        in CarbonLib 1.0 and later
+ *    Mac OS X:         in version 10.0 and later
+ */
+EXTERN_API( OSErr )
+SPBSignInDevice(
+  short              deviceRefNum,
+  ConstStr255Param   deviceName)                              FOURWORDINLINE(0x203C, 0x030C, 0x0014, 0xA800);
+
+
+/*
+ *  SPBSignOutDevice()
+ *  
+ *  Availability:
+ *    Non-Carbon CFM:   in InterfaceLib 7.1 and later
+ *    CarbonLib:        in CarbonLib 1.0 and later
+ *    Mac OS X:         in version 10.0 and later
+ */
+EXTERN_API( OSErr )
+SPBSignOutDevice(short deviceRefNum)                          FOURWORDINLINE(0x203C, 0x0110, 0x0014, 0xA800);
+
+
+/*
+ *  SPBGetIndexedDevice()
+ *  
+ *  Availability:
+ *    Non-Carbon CFM:   in InterfaceLib 7.1 and later
+ *    CarbonLib:        in CarbonLib 1.0 and later
+ *    Mac OS X:         in version 10.0 and later
+ */
+EXTERN_API( OSErr )
+SPBGetIndexedDevice(
+  short     count,
+  Str255    deviceName,
+  Handle *  deviceIconHandle)                                 FOURWORDINLINE(0x203C, 0x0514, 0x0014, 0xA800);
+
+
+/*
+ *  SPBOpenDevice()
+ *  
+ *  Availability:
+ *    Non-Carbon CFM:   in InterfaceLib 7.1 and later
+ *    CarbonLib:        in CarbonLib 1.0 and later
+ *    Mac OS X:         in version 10.0 and later
+ */
+EXTERN_API( OSErr )
+SPBOpenDevice(
+  ConstStr255Param   deviceName,
+  short              permission,
+  long *             inRefNum)                                FOURWORDINLINE(0x203C, 0x0518, 0x0014, 0xA800);
+
+
+/*
+ *  SPBCloseDevice()
+ *  
+ *  Availability:
+ *    Non-Carbon CFM:   in InterfaceLib 7.1 and later
+ *    CarbonLib:        in CarbonLib 1.0 and later
+ *    Mac OS X:         in version 10.0 and later
+ */
+EXTERN_API( OSErr )
+SPBCloseDevice(long inRefNum)                                 FOURWORDINLINE(0x203C, 0x021C, 0x0014, 0xA800);
+
+
+/*
+ *  SPBRecord()
+ *  
+ *  Availability:
+ *    Non-Carbon CFM:   in InterfaceLib 7.1 and later
+ *    CarbonLib:        in CarbonLib 1.0 and later
+ *    Mac OS X:         in version 10.0 and later
+ */
+EXTERN_API( OSErr )
+SPBRecord(
+  SPBPtr    inParamPtr,
+  Boolean   asynchFlag)                                       FOURWORDINLINE(0x203C, 0x0320, 0x0014, 0xA800);
+
+
+#if CALL_NOT_IN_CARBON
+/*
+ *  SPBRecordToFile()
+ *  
+ *  Availability:
+ *    Non-Carbon CFM:   in InterfaceLib 7.1 and later
+ *    CarbonLib:        not available
+ *    Mac OS X:         not available
+ */
+EXTERN_API( OSErr )
+SPBRecordToFile(
+  short     fRefNum,
+  SPBPtr    inParamPtr,
+  Boolean   asynchFlag)                                       FOURWORDINLINE(0x203C, 0x0424, 0x0014, 0xA800);
+
+
+#endif  /* CALL_NOT_IN_CARBON */
+
+/*
+ *  SPBPauseRecording()
+ *  
+ *  Availability:
+ *    Non-Carbon CFM:   in InterfaceLib 7.1 and later
+ *    CarbonLib:        in CarbonLib 1.0 and later
+ *    Mac OS X:         in version 10.0 and later
+ */
+EXTERN_API( OSErr )
+SPBPauseRecording(long inRefNum)                              FOURWORDINLINE(0x203C, 0x0228, 0x0014, 0xA800);
+
+
+/*
+ *  SPBResumeRecording()
+ *  
+ *  Availability:
+ *    Non-Carbon CFM:   in InterfaceLib 7.1 and later
+ *    CarbonLib:        in CarbonLib 1.0 and later
+ *    Mac OS X:         in version 10.0 and later
+ */
+EXTERN_API( OSErr )
+SPBResumeRecording(long inRefNum)                             FOURWORDINLINE(0x203C, 0x022C, 0x0014, 0xA800);
+
+
+/*
+ *  SPBStopRecording()
+ *  
+ *  Availability:
+ *    Non-Carbon CFM:   in InterfaceLib 7.1 and later
+ *    CarbonLib:        in CarbonLib 1.0 and later
+ *    Mac OS X:         in version 10.0 and later
+ */
+EXTERN_API( OSErr )
+SPBStopRecording(long inRefNum)                               FOURWORDINLINE(0x203C, 0x0230, 0x0014, 0xA800);
+
+
+/*
+ *  SPBGetRecordingStatus()
+ *  
+ *  Availability:
+ *    Non-Carbon CFM:   in InterfaceLib 7.1 and later
+ *    CarbonLib:        in CarbonLib 1.0 and later
+ *    Mac OS X:         in version 10.0 and later
+ */
+EXTERN_API( OSErr )
+SPBGetRecordingStatus(
+  long             inRefNum,
+  short *          recordingStatus,
+  short *          meterLevel,
+  unsigned long *  totalSamplesToRecord,
+  unsigned long *  numberOfSamplesRecorded,
+  unsigned long *  totalMsecsToRecord,
+  unsigned long *  numberOfMsecsRecorded)                     FOURWORDINLINE(0x203C, 0x0E34, 0x0014, 0xA800);
+
+
+/*
+ *  SPBGetDeviceInfo()
+ *  
+ *  Availability:
+ *    Non-Carbon CFM:   in InterfaceLib 7.1 and later
+ *    CarbonLib:        in CarbonLib 1.0 and later
+ *    Mac OS X:         in version 10.0 and later
+ */
+EXTERN_API( OSErr )
+SPBGetDeviceInfo(
+  long     inRefNum,
+  OSType   infoType,
+  void *   infoData)                                          FOURWORDINLINE(0x203C, 0x0638, 0x0014, 0xA800);
+
+
+/*
+ *  SPBSetDeviceInfo()
+ *  
+ *  Availability:
+ *    Non-Carbon CFM:   in InterfaceLib 7.1 and later
+ *    CarbonLib:        in CarbonLib 1.0 and later
+ *    Mac OS X:         in version 10.0 and later
+ */
+EXTERN_API( OSErr )
+SPBSetDeviceInfo(
+  long     inRefNum,
+  OSType   infoType,
+  void *   infoData)                                          FOURWORDINLINE(0x203C, 0x063C, 0x0014, 0xA800);
+
+
+/*
+ *  SPBMillisecondsToBytes()
+ *  
+ *  Availability:
+ *    Non-Carbon CFM:   in InterfaceLib 7.1 and later
+ *    CarbonLib:        in CarbonLib 1.0 and later
+ *    Mac OS X:         in version 10.0 and later
+ */
+EXTERN_API( OSErr )
+SPBMillisecondsToBytes(
+  long    inRefNum,
+  long *  milliseconds)                                       FOURWORDINLINE(0x203C, 0x0440, 0x0014, 0xA800);
+
+
+/*
+ *  SPBBytesToMilliseconds()
+ *  
+ *  Availability:
+ *    Non-Carbon CFM:   in InterfaceLib 7.1 and later
+ *    CarbonLib:        in CarbonLib 1.0 and later
+ *    Mac OS X:         in version 10.0 and later
+ */
+EXTERN_API( OSErr )
+SPBBytesToMilliseconds(
+  long    inRefNum,
+  long *  byteCount)                                          FOURWORDINLINE(0x203C, 0x0444, 0x0014, 0xA800);
+
+
+/*
+ *  SetupSndHeader()
+ *  
+ *  Availability:
+ *    Non-Carbon CFM:   in InterfaceLib 7.1 and later
+ *    CarbonLib:        in CarbonLib 1.0 and later
+ *    Mac OS X:         in version 10.0 and later
+ */
+EXTERN_API( OSErr )
+SetupSndHeader(
+  SndListHandle   sndHandle,
+  short           numChannels,
+  UnsignedFixed   sampleRate,
+  short           sampleSize,
+  OSType          compressionType,
+  short           baseNote,
+  unsigned long   numBytes,
+  short *         headerLen)                                  FOURWORDINLINE(0x203C, 0x0D48, 0x0014, 0xA800);
+
+
+/*
+ *  SetupAIFFHeader()
+ *  
+ *  Availability:
+ *    Non-Carbon CFM:   in InterfaceLib 7.1 and later
+ *    CarbonLib:        in CarbonLib 1.0 and later
+ *    Mac OS X:         in version 10.0 and later
+ */
+EXTERN_API( OSErr )
+SetupAIFFHeader(
+  short           fRefNum,
+  short           numChannels,
+  UnsignedFixed   sampleRate,
+  short           sampleSize,
+  OSType          compressionType,
+  unsigned long   numBytes,
+  unsigned long   numFrames)                                  FOURWORDINLINE(0x203C, 0x0B4C, 0x0014, 0xA800);
+
+
+/* Sound Input Manager 1.1 and later calls, uses _SoundDispatch */
+/*
+ *  ParseAIFFHeader()
+ *  
+ *  Availability:
+ *    Non-Carbon CFM:   in SoundLib 3.0 and later
+ *    CarbonLib:        in CarbonLib 1.0 and later
+ *    Mac OS X:         in version 10.0 and later
+ */
+EXTERN_API( OSErr )
+ParseAIFFHeader(
+  short                 fRefNum,
+  SoundComponentData *  sndInfo,
+  unsigned long *       numFrames,
+  unsigned long *       dataOffset)                           FOURWORDINLINE(0x203C, 0x0758, 0x0014, 0xA800);
+
+
+/*
+ *  ParseSndHeader()
+ *  
+ *  Availability:
+ *    Non-Carbon CFM:   in SoundLib 3.0 and later
+ *    CarbonLib:        in CarbonLib 1.0 and later
+ *    Mac OS X:         in version 10.0 and later
+ */
+EXTERN_API( OSErr )
+ParseSndHeader(
+  SndListHandle         sndHandle,
+  SoundComponentData *  sndInfo,
+  unsigned long *       numFrames,
+  unsigned long *       dataOffset)                           FOURWORDINLINE(0x203C, 0x085C, 0x0014, 0xA800);
+
+
+
+
+
+
+#if !TARGET_OS_MAC || TARGET_API_MAC_CARBON
+/*  Only to be used if you are writing a sound input component; this */
+/*  is the param block for a read request from the SoundMgr to the   */
+/*  sound input component.  Not to be confused with the SPB struct   */
+/*  above, which is the param block for a read request from an app   */
+/*  to the SoundMgr.                                                 */
+typedef struct SndInputCmpParam         SndInputCmpParam;
+typedef SndInputCmpParam *              SndInputCmpParamPtr;
+typedef CALLBACK_API( void , SICCompletionProcPtr )(SndInputCmpParamPtr SICParmPtr);
+struct SndInputCmpParam {
+  SICCompletionProcPtr  ioCompletion;         /* completion routine [pointer]*/
+  SIInterruptProcPtr  ioInterrupt;            /* interrupt routine [pointer]*/
+  OSErr               ioResult;               /* I/O result code [word]*/
+  short               pad;
+  unsigned long       ioReqCount;
+  unsigned long       ioActCount;
+  Ptr                 ioBuffer;
+  Ptr                 ioMisc;
+};
+
+/*
+ *  SndInputReadAsync()
+ *  
+ *  Availability:
+ *    Non-Carbon CFM:   not available
+ *    CarbonLib:        not available
+ *    Mac OS X:         in version 10.0 and later
+ */
+EXTERN_API( ComponentResult )
+SndInputReadAsync(
+  ComponentInstance     self,
+  SndInputCmpParamPtr   SICParmPtr)                           FIVEWORDINLINE(0x2F3C, 0x0004, 0x0001, 0x7000, 0xA82A);
+
+
+/*
+ *  SndInputReadSync()
+ *  
+ *  Availability:
+ *    Non-Carbon CFM:   not available
+ *    CarbonLib:        not available
+ *    Mac OS X:         in version 10.0 and later
+ */
+EXTERN_API( ComponentResult )
+SndInputReadSync(
+  ComponentInstance     self,
+  SndInputCmpParamPtr   SICParmPtr)                           FIVEWORDINLINE(0x2F3C, 0x0004, 0x0002, 0x7000, 0xA82A);
+
+
+/*
+ *  SndInputPauseRecording()
+ *  
+ *  Availability:
+ *    Non-Carbon CFM:   not available
+ *    CarbonLib:        not available
+ *    Mac OS X:         in version 10.0 and later
+ */
+EXTERN_API( ComponentResult )
+SndInputPauseRecording(ComponentInstance self)                FIVEWORDINLINE(0x2F3C, 0x0000, 0x0003, 0x7000, 0xA82A);
+
+
+/*
+ *  SndInputResumeRecording()
+ *  
+ *  Availability:
+ *    Non-Carbon CFM:   not available
+ *    CarbonLib:        not available
+ *    Mac OS X:         in version 10.0 and later
+ */
+EXTERN_API( ComponentResult )
+SndInputResumeRecording(ComponentInstance self)               FIVEWORDINLINE(0x2F3C, 0x0000, 0x0004, 0x7000, 0xA82A);
+
+
+/*
+ *  SndInputStopRecording()
+ *  
+ *  Availability:
+ *    Non-Carbon CFM:   not available
+ *    CarbonLib:        not available
+ *    Mac OS X:         in version 10.0 and later
+ */
+EXTERN_API( ComponentResult )
+SndInputStopRecording(ComponentInstance self)                 FIVEWORDINLINE(0x2F3C, 0x0000, 0x0005, 0x7000, 0xA82A);
+
+
+/*
+ *  SndInputGetStatus()
+ *  
+ *  Availability:
+ *    Non-Carbon CFM:   not available
+ *    CarbonLib:        not available
+ *    Mac OS X:         in version 10.0 and later
+ */
+EXTERN_API( ComponentResult )
+SndInputGetStatus(
+  ComponentInstance   self,
+  short *             recordingStatus,
+  unsigned long *     totalSamplesToRecord,
+  unsigned long *     numberOfSamplesRecorded)                FIVEWORDINLINE(0x2F3C, 0x000C, 0x0006, 0x7000, 0xA82A);
+
+
+/*
+ *  SndInputGetDeviceInfo()
+ *  
+ *  Availability:
+ *    Non-Carbon CFM:   not available
+ *    CarbonLib:        not available
+ *    Mac OS X:         in version 10.0 and later
+ */
+EXTERN_API( ComponentResult )
+SndInputGetDeviceInfo(
+  ComponentInstance   self,
+  OSType              infoType,
+  void *              infoData)                               FIVEWORDINLINE(0x2F3C, 0x0008, 0x0007, 0x7000, 0xA82A);
+
+
+/*
+ *  SndInputSetDeviceInfo()
+ *  
+ *  Availability:
+ *    Non-Carbon CFM:   not available
+ *    CarbonLib:        not available
+ *    Mac OS X:         in version 10.0 and later
+ */
+EXTERN_API( ComponentResult )
+SndInputSetDeviceInfo(
+  ComponentInstance   self,
+  OSType              infoType,
+  void *              infoData)                               FIVEWORDINLINE(0x2F3C, 0x0008, 0x0008, 0x7000, 0xA82A);
+
+
+/*
+ *  SndInputInitHardware()
+ *  
+ *  Availability:
+ *    Non-Carbon CFM:   not available
+ *    CarbonLib:        not available
+ *    Mac OS X:         in version 10.0 and later
+ */
+EXTERN_API( ComponentResult )
+SndInputInitHardware(ComponentInstance self)                  FIVEWORDINLINE(0x2F3C, 0x0000, 0x0009, 0x7000, 0xA82A);
+
+
+
+/* selectors for component calls */
+enum {
+    kSndInputReadAsyncSelect                   = 0x0001,
+    kSndInputReadSyncSelect                    = 0x0002,
+    kSndInputPauseRecordingSelect              = 0x0003,
+    kSndInputResumeRecordingSelect             = 0x0004,
+    kSndInputStopRecordingSelect               = 0x0005,
+    kSndInputGetStatusSelect                   = 0x0006,
+    kSndInputGetDeviceInfoSelect               = 0x0007,
+    kSndInputSetDeviceInfoSelect               = 0x0008,
+    kSndInputInitHardwareSelect                = 0x0009
+};
+#endif  /* !TARGET_OS_MAC || TARGET_API_MAC_CARBON */
+
+
+
+#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 /* __SOUND__ */
+