Sound.h

Go to the documentation of this file.

 
#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
 
#define twelfthRootTwo 1.05946309435
 
  enum
  {
    soundListRsrc =
        FOUR_CHAR_CODE('snd ') 
  };
 
  enum
  {
    kSimpleBeepID = 1 
  };
 
  enum
  {
    rate48khz = (long)0xBB800000, 
    rate44khz = (long)0xAC440000, 
    rate32khz = 0x7D000000,       
    rate22050hz = 0x56220000,     
    rate22khz = 0x56EE8BA3,       
    rate16khz = 0x3E800000,       
    rate11khz = 0x2B7745D1,       
    rate11025hz = 0x2B110000,     
    rate8khz = 0x1F400000         
  };
 
  enum
  {
    sampledSynth = 5 
  };
 
#if CALL_NOT_IN_CARBON
  enum
  {
    squareWaveSynth = 1, 
    waveTableSynth = 3,  
    MACE3snthID = 11,
    MACE6snthID = 13
  };
 
#endif 
  enum
  {
    kMiddleC = 60 
  };
 
  enum
  {
    kNoVolume = 0,       
    kFullVolume = 0x0100 
  };
 
  enum
  {
    stdQLength = 128
  };
 
  enum
  {
    dataOffsetFlag = 0x8000
  };
 
  enum
  {
    kUseOptionalOutputDevice = -1 
  };
 
  enum
  {
    notCompressed = 0,       
    fixedCompression = -1,   
    variableCompression = -2 
  };
 
  enum
  {
    twoToOne = 1,
    eightToThree = 2,
    threeToOne = 3,
    sixToOne = 4,
    sixToOnePacketSize = 8,
    threeToOnePacketSize = 16
  };
 
  enum
  {
    stateBlockSize = 64,
    leftOverBlockSize = 32
  };
 
  enum
  {
    firstSoundFormat = 0x0001, 
    secondSoundFormat = 0x0002 
  };
 
#if CALL_NOT_IN_CARBON
  enum
  {
    dbBufferReady = 0x00000001, 
    dbLastBuffer = 0x00000004   
  };
 
#endif 
  enum
  {
    sysBeepDisable = 0x0000, 
    sysBeepEnable = (1 << 0),
    sysBeepSynchronous = (1 << 1) 
  };
 
  enum
  {
    unitTypeNoSelection = 0xFFFF, 
    unitTypeSeconds = 0x0000
  };
 
  enum
  {
    stdSH = 0x00, 
    extSH = 0xFF, 
    cmpSH = 0xFE  
  };
 
  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,              
    getVolumeCmd = 47,           
    clockComponentCmd = 50,      
    getClockComponentCmd = 51,   
    scheduledSoundCmd = 52,      
    linkSoundComponentsCmd = 53, 
    soundCmd = 80,
    bufferCmd = 81,
    rateMultiplierCmd = 86,
    getRateMultiplierCmd = 87
  };
 
#if CALL_NOT_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,   
    convertCmd = 91 
  };
 
#endif 
#if OLDROUTINENAMES
  enum
  {
    waveInitChannelMask = 0x07,
    waveInitChannel0 = 0x04,      
    waveInitChannel1 = 0x05,      
    waveInitChannel2 = 0x06,      
    waveInitChannel3 = 0x07,      
    initChan0 = waveInitChannel0, 
    initChan1 = waveInitChannel1, 
    initChan2 = waveInitChannel2, 
    initChan3 = waveInitChannel3  
  };
 
  enum
  {
    outsideCmpSH = 0, 
    insideCmpSH = 1,  
    aceSuccess = 0,   
    aceMemFull = 1,   
    aceNilBlock = 2,  
    aceBadComp = 3,   
    aceBadEncode = 4, 
    aceBadDest = 5,   
    aceBadCmd = 6     
  };
 
#endif 
  enum
  {
    initChanLeft = 0x0002,   
    initChanRight = 0x0003,  
    initNoInterp = 0x0004,   
    initNoDrop = 0x0008,     
    initMono = 0x0080,       
    initStereo = 0x00C0,     
    initMACE3 = 0x0300,      
    initMACE6 = 0x0400,      
    initPanMask = 0x0003,    
    initSRateMask = 0x0030,  
    initStereoMask = 0x00C0, 
    initCompMask = 0xFF00    
  };
 
  enum
  {
    siActiveChannels = FOUR_CHAR_CODE('chac'), 
    siActiveLevels = FOUR_CHAR_CODE('lmac'),   
    siAGCOnOff = FOUR_CHAR_CODE('agc '),       
    siAsync = FOUR_CHAR_CODE('asyn'),          
    siAVDisplayBehavior = FOUR_CHAR_CODE('avdb'),
    siChannelAvailable = FOUR_CHAR_CODE('chav'), 
    siCompressionAvailable =
        FOUR_CHAR_CODE('cmav'), 
    siCompressionChannels =
        FOUR_CHAR_CODE('cpct'),                   
    siCompressionFactor = FOUR_CHAR_CODE('cmfa'), 
    siCompressionHeader = FOUR_CHAR_CODE('cmhd'), 
    siCompressionNames =
        FOUR_CHAR_CODE('cnam'),                   
    siCompressionParams = FOUR_CHAR_CODE('evaw'), 
    siCompressionSampleRate =
        FOUR_CHAR_CODE('cprt'),                     
    siCompressionType = FOUR_CHAR_CODE('comp'),     
    siContinuous = FOUR_CHAR_CODE('cont'),          
    siDecompressionParams = FOUR_CHAR_CODE('wave'), 
    siDeviceBufferInfo = FOUR_CHAR_CODE('dbin'),    
    siDeviceConnected =
        FOUR_CHAR_CODE('dcon'),                  
    siDeviceIcon = FOUR_CHAR_CODE('icon'),       
    siDeviceName = FOUR_CHAR_CODE('name'),       
    siEQSpectrumBands = FOUR_CHAR_CODE('eqsb'),  
    siEQSpectrumLevels = FOUR_CHAR_CODE('eqlv'), 
    siEQSpectrumOnOff =
        FOUR_CHAR_CODE('eqlo'), 
    siEQSpectrumResolution =
        FOUR_CHAR_CODE('eqrs'), 
    siEQToneControlGain =
        FOUR_CHAR_CODE('eqtg'), 
    siEQToneControlOnOff =
        FOUR_CHAR_CODE('eqtc'), 
    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'),   
    siHardwareFormat = FOUR_CHAR_CODE('hwfm'), 
    siHardwareMute = FOUR_CHAR_CODE('hmut'),   
    siHardwareMuteNoPrefs = FOUR_CHAR_CODE(
        'hmnp'), 
    siHardwareTreble = FOUR_CHAR_CODE('htrb'),
    siHardwareTrebleSteps = FOUR_CHAR_CODE('hwts'),
    siHardwareVolume = FOUR_CHAR_CODE('hvol'), 
    siHardwareVolumeSteps =
        FOUR_CHAR_CODE('hstp'),                 
    siHeadphoneMute = FOUR_CHAR_CODE('pmut'),   
    siHeadphoneVolume = FOUR_CHAR_CODE('pvol'), 
    siHeadphoneVolumeSteps =
        FOUR_CHAR_CODE('hdst'),                  
    siInputAvailable = FOUR_CHAR_CODE('inav'),   
    siInputGain = FOUR_CHAR_CODE('gain'),        
    siInputSource = FOUR_CHAR_CODE('sour'),      
    siInputSourceNames = FOUR_CHAR_CODE('snam'), 
    siLevelMeterOnOff = FOUR_CHAR_CODE('lmet'),  
    siModemGain = FOUR_CHAR_CODE('mgai'),        
    siMonitorAvailable = FOUR_CHAR_CODE('mnav'),
    siMonitorSource = FOUR_CHAR_CODE('mons'),
    siNumberChannels = FOUR_CHAR_CODE('chan'),    
    siOptionsDialog = FOUR_CHAR_CODE('optd'),     
    siOSTypeInputSource = FOUR_CHAR_CODE('inpt'), 
    siOSTypeInputAvailable =
        FOUR_CHAR_CODE('inav'),                  
    siOutputDeviceName = FOUR_CHAR_CODE('onam'), 
    siPlayThruOnOff = FOUR_CHAR_CODE('plth'),    
    siPostMixerSoundComponent =
        FOUR_CHAR_CODE('psmx'), 
    siPreMixerSoundComponent =
        FOUR_CHAR_CODE('prmx'),                     
    siQuality = FOUR_CHAR_CODE('qual'),             
    siRateMultiplier = FOUR_CHAR_CODE('rmul'),      
    siRecordingQuality = FOUR_CHAR_CODE('qual'),    
    siSampleRate = FOUR_CHAR_CODE('srat'),          
    siSampleRateAvailable = FOUR_CHAR_CODE('srav'), 
    siSampleSize = FOUR_CHAR_CODE('ssiz'),          
    siSampleSizeAvailable = FOUR_CHAR_CODE('ssav'), 
    siSetupCDAudio =
        FOUR_CHAR_CODE('sucd'), 
    siSetupModemAudio =
        FOUR_CHAR_CODE('sumd'), 
    siSlopeAndIntercept =
        FOUR_CHAR_CODE('flap'), 
    siSoundClock = FOUR_CHAR_CODE('sclk'),
    siUseThisSoundClock = FOUR_CHAR_CODE(
        'sclc'), 
    siSpeakerMute =
        FOUR_CHAR_CODE('smut'), 
    siSpeakerVolume =
        FOUR_CHAR_CODE('svol'), 
    siSSpCPULoadLimit = FOUR_CHAR_CODE('3dll'),
    siSSpLocalization = FOUR_CHAR_CODE('3dif'),
    siSSpSpeakerSetup = FOUR_CHAR_CODE('3dst'),
    siStereoInputGain = FOUR_CHAR_CODE('sgai'),     
    siSubwooferMute = FOUR_CHAR_CODE('bmut'),       
    siTerminalType = FOUR_CHAR_CODE('ttyp'),        
    siTwosComplementOnOff = FOUR_CHAR_CODE('twos'), 
    siVendorProduct = FOUR_CHAR_CODE('vpro'),       
    siVolume = FOUR_CHAR_CODE('volu'),              
    siVoxRecordInfo = FOUR_CHAR_CODE('voxr'),       
    siVoxStopInfo = FOUR_CHAR_CODE('voxs'),         
    siWideStereo = FOUR_CHAR_CODE('wide'),          
    siSupportedExtendedFlags = FOUR_CHAR_CODE(
        'exfl'), 
    siRateConverterRollOffSlope = FOUR_CHAR_CODE(
        'rcdb'), 
    siOutputLatency =
        FOUR_CHAR_CODE('olte') 
  };
 
  enum
  {
    siCloseDriver = FOUR_CHAR_CODE('clos'), 
    siInitializeDriver =
        FOUR_CHAR_CODE('init'),                
    siPauseRecording = FOUR_CHAR_CODE('paus'), 
    siUserInterruptProc =
        FOUR_CHAR_CODE('user') 
  };
 
  enum
  {
    kInvalidSource =
        (long)0xFFFFFFFF,                    
    kNoSource = FOUR_CHAR_CODE('none'),      
    kCDSource = FOUR_CHAR_CODE('cd  '),      
    kExtMicSource = FOUR_CHAR_CODE('emic'),  
    kSoundInSource = FOUR_CHAR_CODE('sinj'), 
    kRCAInSource = FOUR_CHAR_CODE('irca'),   
    kTVFMTunerSource = FOUR_CHAR_CODE('tvfm'),
    kDAVInSource = FOUR_CHAR_CODE('idav'),     
    kIntMicSource = FOUR_CHAR_CODE('imic'),    
    kMediaBaySource = FOUR_CHAR_CODE('mbay'),  
    kModemSource = FOUR_CHAR_CODE('modm'),     
    kPCCardSource = FOUR_CHAR_CODE('pcm '),    
    kZoomVideoSource = FOUR_CHAR_CODE('zvpc'), 
    kDVDSource = FOUR_CHAR_CODE('dvda'),       
    kMicrophoneArray = FOUR_CHAR_CODE('mica')  
  };
 
  enum
  {
    kNoSoundComponentType = FOUR_CHAR_CODE('****'),
    kSoundComponentType = FOUR_CHAR_CODE('sift'), 
    kSoundComponentPPCType =
        FOUR_CHAR_CODE('nift'),                 
    kRate8SubType = FOUR_CHAR_CODE('ratb'),     
    kRate16SubType = FOUR_CHAR_CODE('ratw'),    
    kConverterSubType = FOUR_CHAR_CODE('conv'), 
    kSndSourceSubType = FOUR_CHAR_CODE('sour'), 
    kMixerType = FOUR_CHAR_CODE('mixr'),
    kMixer8SubType = FOUR_CHAR_CODE('mixb'),         
    kMixer16SubType = FOUR_CHAR_CODE('mixw'),        
    kSoundInputDeviceType = FOUR_CHAR_CODE('sinp'),  
    kWaveInSubType = FOUR_CHAR_CODE('wavi'),         
    kWaveInSnifferSubType = FOUR_CHAR_CODE('wisn'),  
    kSoundOutputDeviceType = FOUR_CHAR_CODE('sdev'), 
    kClassicSubType = FOUR_CHAR_CODE('clas'),        
    kASCSubType = FOUR_CHAR_CODE('asc '),            
    kDSPSubType = FOUR_CHAR_CODE('dsp '),            
    kAwacsSubType =
        FOUR_CHAR_CODE('awac'), 
    kGCAwacsSubType =
        FOUR_CHAR_CODE('awgc'),               
    kSingerSubType = FOUR_CHAR_CODE('sing'),  
    kSinger2SubType = FOUR_CHAR_CODE('sng2'), 
    kWhitSubType =
        FOUR_CHAR_CODE('whit'),                      
    kSoundBlasterSubType = FOUR_CHAR_CODE('sbls'),   
    kWaveOutSubType = FOUR_CHAR_CODE('wavo'),        
    kWaveOutSnifferSubType = FOUR_CHAR_CODE('wosn'), 
    kDirectSoundSubType = FOUR_CHAR_CODE('dsnd'),    
    kDirectSoundSnifferSubType =
        FOUR_CHAR_CODE('dssn'),                
    kUNIXsdevSubType = FOUR_CHAR_CODE('un1x'), 
    kUSBSubType = FOUR_CHAR_CODE('usb '),      
    kBlueBoxSubType = FOUR_CHAR_CODE('bsnd'),  
    kSoundCompressor = FOUR_CHAR_CODE('scom'),
    kSoundDecompressor = FOUR_CHAR_CODE('sdec'),
    kAudioComponentType =
        FOUR_CHAR_CODE('adio'), 
    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'), 
    kEqualizerSubType = FOUR_CHAR_CODE('eqal'), 
    kSSpLocalizationSubType = FOUR_CHAR_CODE('snd3')
  };
 
  enum
  {
    kSoundNotCompressed = FOUR_CHAR_CODE('NONE'),      
    k8BitOffsetBinaryFormat = FOUR_CHAR_CODE('raw '),  
    k16BitBigEndianFormat = FOUR_CHAR_CODE('twos'),    
    k16BitLittleEndianFormat = FOUR_CHAR_CODE('sowt'), 
    kFloat32Format = FOUR_CHAR_CODE('fl32'),           
    kFloat64Format = FOUR_CHAR_CODE('fl64'),           
    k24BitFormat = FOUR_CHAR_CODE('in24'),             
    k32BitFormat = FOUR_CHAR_CODE('in32'),             
    k32BitLittleEndianFormat =
        FOUR_CHAR_CODE('23ni'),                     
    kMACE3Compression = FOUR_CHAR_CODE('MAC3'),     
    kMACE6Compression = FOUR_CHAR_CODE('MAC6'),     
    kCDXA4Compression = FOUR_CHAR_CODE('cdx4'),     
    kCDXA2Compression = FOUR_CHAR_CODE('cdx2'),     
    kIMACompression = FOUR_CHAR_CODE('ima4'),       
    kULawCompression = FOUR_CHAR_CODE('ulaw'),      
    kALawCompression = FOUR_CHAR_CODE('alaw'),      
    kMicrosoftADPCMFormat = 0x6D730002,             
    kDVIIntelIMAFormat = 0x6D730011,                
    kDVAudioFormat = FOUR_CHAR_CODE('dvca'),        
    kQDesignCompression = FOUR_CHAR_CODE('QDMC'),   
    kQDesign2Compression = FOUR_CHAR_CODE('QDM2'),  
    kQUALCOMMCompression = FOUR_CHAR_CODE('Qclp'),  
    kOffsetBinary = k8BitOffsetBinaryFormat,        
    kTwosComplement = k16BitBigEndianFormat,        
    kLittleEndianFormat = k16BitLittleEndianFormat, 
    kMPEGLayer3Format = 0x6D730055,                 
    kFullMPEGLay3Format =
        FOUR_CHAR_CODE('.mp3') 
  };
 
#if TARGET_RT_LITTLE_ENDIAN
  enum
  {
    k16BitNativeEndianFormat = k16BitLittleEndianFormat,
    k16BitNonNativeEndianFormat = k16BitBigEndianFormat
  };
 
#else
enum
{
  k16BitNativeEndianFormat = k16BitBigEndianFormat,
  k16BitNonNativeEndianFormat = k16BitLittleEndianFormat
};
 
#endif 
  enum
  {
    k8BitRawIn = (1 << 0), 
    k8BitTwosIn = (1 << 1),
    k16BitIn = (1 << 2),
    kStereoIn = (1 << 3),
    k8BitRawOut = (1 << 8),
    k8BitTwosOut = (1 << 9),
    k16BitOut = (1 << 10),
    kStereoOut = (1 << 11),
    kReverse = (1L << 16), 
    kRateConvert = (1L << 17),
    kCreateSoundSource = (1L << 18),
    kVMAwareness = (1L << 21), 
    kHighQuality = (1L << 22), 
    kNonRealTime = (1L << 23)
  };
 
  enum
  {
    kSourcePaused = (1 << 0),
    kPassThrough = (1L << 16),
    kNoSoundComponentChain = (1L << 17)
  };
 
  enum
  {
    kNoMixing = (1 << 0), 
    kNoSampleRateConversion =
        (1 << 1), 
    kNoSampleSizeConversion =
        (1 << 2), 
    kNoSampleFormatConversion =
        (1 << 3),                     
    kNoChannelConversion = (1 << 4),  
    kNoDecompression = (1 << 5),      
    kNoVolumeConversion = (1 << 6),   
    kNoRealtimeProcessing = (1 << 7), 
    kScheduledSource = (1 << 8),      
    kNonInterleavedBuffer = (1 << 9), 
    kNonPagingMixer = (1 << 10),      
    kSoundConverterMixer =
        (1 << 11), 
    kPagingMixer =
        (1 << 12),                 
    kVMAwareMixer = (1 << 13),     
    kExtendedSoundData = (1 << 14) 
  };
 
  enum
  {
    kBestQuality = (1 << 0) 
  };
 
  enum
  {
    kInputMask = 0x000000FF,  
    kOutputMask = 0x0000FF00, 
    kOutputShift = 8,         
    kActionMask = 0x00FF0000, 
    kSoundComponentBits = 0x00FFFFFF
  };
 
  enum
  {
    kAudioFormatAtomType = FOUR_CHAR_CODE('frma'),
    kAudioEndianAtomType = FOUR_CHAR_CODE('enda'),
    kAudioVBRAtomType = FOUR_CHAR_CODE('vbra'),
    kAudioTerminatorAtomType = 0
  };
 
  enum
  {
    kAVDisplayHeadphoneRemove =
        0,                         
    kAVDisplayHeadphoneInsert = 1, 
    kAVDisplayPlainTalkRemove =
        2,                        
    kAVDisplayPlainTalkInsert = 3 
  };
 
  enum
  {
    audioAllChannels =
        0,                       
    audioLeftChannel = 1,        
    audioRightChannel = 2,       
    audioUnmuted = 0,            
    audioMuted = 1,              
    audioDoesMono = (1L << 0),   
    audioDoesStereo = (1L << 1), 
    audioDoesIndependentChannels =
        (1L
         << 2) 
  };
 
  enum
  {
    siCDQuality = FOUR_CHAR_CODE('cd  '),     
    siBestQuality = FOUR_CHAR_CODE('best'),   
    siBetterQuality = FOUR_CHAR_CODE('betr'), 
    siGoodQuality = FOUR_CHAR_CODE('good'),   
    siNoneQuality = FOUR_CHAR_CODE(
        'none') 
  };
 
  enum
  {
    siDeviceIsConnected = 1,    
    siDeviceNotConnected = 0,   
    siDontKnowIfConnected = -1, 
    siReadPermission = 0,       
    siWritePermission = 1       
  };
 
  enum
  {
    kSoundConverterDidntFillBuffer =
        (1 << 0), 
    kSoundConverterHasLeftOverData =
        (1 << 1) 
  };
 
  enum
  {
    kExtendedSoundSampleCountNotValid =
        1L << 0,                            
    kExtendedSoundBufferSizeValid = 1L << 1 
  };
 
  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; 
    SndCallBackUPP callBack;
    long userInfo;
    long wait; 
    SndCommand cmdInProgress;
    short flags;
    short qLength;
    short qHead;
    short qTail;
    SndCommand queue[128];
  };
 
  SndCallBackUPP
  NewSndCallBackUPP(SndCallBackProcPtr userRoutine);
#if !OPAQUE_UPP_TYPES
  enum
  {
    uppSndCallBackProcInfo = 0x000003C0
  }; 
#ifdef __cplusplus
  inline SndCallBackUPP NewSndCallBackUPP(SndCallBackProcPtr userRoutine)
  {
    return (SndCallBackUPP)NewRoutineDescriptor(
        (ProcPtr)(userRoutine), uppSndCallBackProcInfo, GetCurrentArchitecture());
  }
#else
#define NewSndCallBackUPP(userRoutine)                                     \
  (SndCallBackUPP)                                                         \
      NewRoutineDescriptor((ProcPtr)(userRoutine), uppSndCallBackProcInfo, \
                           GetCurrentArchitecture())
#endif
#endif
 
  void
  DisposeSndCallBackUPP(SndCallBackUPP userUPP);
#if !OPAQUE_UPP_TYPES
#ifdef __cplusplus
  inline void DisposeSndCallBackUPP(SndCallBackUPP userUPP)
  {
    DisposeRoutineDescriptor((UniversalProcPtr)userUPP);
  }
#else
#define DisposeSndCallBackUPP(userUPP) DisposeRoutineDescriptor(userUPP)
#endif
#endif
 
  void
  InvokeSndCallBackUPP(SndChannelPtr chan, SndCommand *cmd,
                       SndCallBackUPP userUPP);
#if !OPAQUE_UPP_TYPES
#ifdef __cplusplus
  inline 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
#define NewSndCallBackProc(userRoutine) NewSndCallBackUPP(userRoutine)
#define CallSndCallBackProc(userRoutine, chan, cmd) \
  InvokeSndCallBackUPP(chan, cmd, userRoutine)
#endif 
  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;
  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;            
    unsigned long length;     
    UnsignedFixed sampleRate; 
    unsigned long loopStart;  
    unsigned long loopEnd;    
    UInt8 encode;             
    UInt8 baseFrequency;      
    UInt8 sampleArea[1];      
  };
  typedef struct SoundHeader SoundHeader;
  typedef SoundHeader *SoundHeaderPtr;
  struct CmpSoundHeader
  {
    Ptr samplePtr;             
    unsigned long numChannels; 
    UnsignedFixed
        sampleRate;          
    unsigned long loopStart; 
    unsigned long loopEnd;   
    UInt8 encode;            
    UInt8 baseFrequency;     
    unsigned long
        numFrames;                    
    extended80 AIFFSampleRate;        
    Ptr markerChunk;                  
    OSType format;                    
    unsigned long futureUse2;         
    StateBlockPtr stateVars;          
    LeftOverBlockPtr leftOverSamples; 
    short compressionID;              
    unsigned short packetSize;        
    unsigned short
        snthID;                
    unsigned short sampleSize; 
    UInt8 sampleArea[1];       
  };
  typedef struct CmpSoundHeader CmpSoundHeader;
  typedef CmpSoundHeader *CmpSoundHeaderPtr;
  struct ExtSoundHeader
  {
    Ptr samplePtr;             
    unsigned long numChannels; 
    UnsignedFixed
        sampleRate;            
    unsigned long loopStart;   
    unsigned long loopEnd;     
    UInt8 encode;              
    UInt8 baseFrequency;       
    unsigned long numFrames;   
    extended80 AIFFSampleRate; 
    Ptr markerChunk;           
    Ptr instrumentChunks;      
    Ptr AESRecording;
    unsigned short sampleSize; 
    unsigned short futureUse1; 
    unsigned long futureUse2;  
    unsigned long futureUse3;  
    unsigned long futureUse4;  
    UInt8 sampleArea[1];       
  };
  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;
  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;
  };
  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
  SndDoubleBackUPP
  NewSndDoubleBackUPP(SndDoubleBackProcPtr userRoutine);
#if !OPAQUE_UPP_TYPES
  enum
  {
    uppSndDoubleBackProcInfo = 0x000003C0
  }; 
#ifdef __cplusplus
  inline SndDoubleBackUPP NewSndDoubleBackUPP(SndDoubleBackProcPtr userRoutine)
  {
    return (SndDoubleBackUPP)NewRoutineDescriptor((ProcPtr)(userRoutine),
                                                  uppSndDoubleBackProcInfo,
                                                  GetCurrentArchitecture());
  }
#else
#define NewSndDoubleBackUPP(userRoutine)                                     \
  (SndDoubleBackUPP)                                                         \
      NewRoutineDescriptor((ProcPtr)(userRoutine), uppSndDoubleBackProcInfo, \
                           GetCurrentArchitecture())
#endif
#endif
 
  void
  DisposeSndDoubleBackUPP(SndDoubleBackUPP userUPP);
#if !OPAQUE_UPP_TYPES
#ifdef __cplusplus
  inline void DisposeSndDoubleBackUPP(SndDoubleBackUPP userUPP)
  {
    DisposeRoutineDescriptor((UniversalProcPtr)userUPP);
  }
#else
#define DisposeSndDoubleBackUPP(userUPP) DisposeRoutineDescriptor(userUPP)
#endif
#endif
 
  void
  InvokeSndDoubleBackUPP(SndChannelPtr channel,
                         SndDoubleBufferPtr doubleBufferPtr,
                         SndDoubleBackUPP userUPP);
#if !OPAQUE_UPP_TYPES
#ifdef __cplusplus
  inline 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 
#if CALL_NOT_IN_CARBON || OLDROUTINENAMES
#define NewSndDoubleBackProc(userRoutine) NewSndDoubleBackUPP(userRoutine)
#define CallSndDoubleBackProc(userRoutine, channel, doubleBufferPtr) \
  InvokeSndDoubleBackUPP(channel, doubleBufferPtr, userRoutine)
#endif 
  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 
  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; 
    long recordSize;         
    long extendedFlags;      
    long bufferSize;         
  };
  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;              
    SoundComponentData desc;      
    UnsignedFixed rateMultiplier; 
    short leftVolume;             
    short rightVolume;
    long quality;                
    ComponentInstance filter;    
    SoundParamUPP moreRtn;       
    SoundParamUPP completionRtn; 
    long refCon;                 
    short result;                
  };
 
  struct ExtendedSoundParamBlock
  {
    SoundParamBlock pb; 
    short reserved;
    long extendedFlags; 
    long bufferSize;    
  };
  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;
  struct SoundSlopeAndInterceptRecord
  {
    Float64 slope;
    Float64 intercept;
    Float64 minClip;
    Float64 maxClip;
  };
  typedef struct SoundSlopeAndInterceptRecord SoundSlopeAndInterceptRecord;
  typedef SoundSlopeAndInterceptRecord *SoundSlopeAndInterceptPtr;
  typedef struct OpaqueSoundConverter *SoundConverter;
  typedef CALLBACK_API(Boolean, SoundConverterFillBufferDataProcPtr)(
      SoundComponentDataPtr *data, void *refCon);
  typedef STACK_UPP_TYPE(SoundConverterFillBufferDataProcPtr)
      SoundConverterFillBufferDataUPP;
  typedef struct OpaqueSoundSource *SoundSource;
  typedef SoundSource *SoundSourcePtr;
 
  struct SoundComponentLink
  {
    ComponentDescription description; 
    SoundSource mixerID;              
    SoundSource *linkID;              
  };
  typedef struct SoundComponentLink SoundComponentLink;
  typedef SoundComponentLink *SoundComponentLinkPtr;
  struct AudioInfo
  {
    long capabilitiesFlags;        
    long reserved;                 
    unsigned short numVolumeSteps; 
  };
  typedef struct AudioInfo AudioInfo;
  typedef AudioInfo *AudioInfoPtr;
  struct AudioFormatAtom
  {
    long size;       
    OSType atomType; 
    OSType format;
  };
  typedef struct AudioFormatAtom AudioFormatAtom;
  typedef AudioFormatAtom *AudioFormatAtomPtr;
  struct AudioEndianAtom
  {
    long size;       
    OSType atomType; 
    short littleEndian;
  };
  typedef struct AudioEndianAtom AudioEndianAtom;
  typedef AudioEndianAtom *AudioEndianAtomPtr;
  struct AudioTerminatorAtom
  {
    long size;       
    OSType atomType; 
  };
  typedef struct AudioTerminatorAtom AudioTerminatorAtom;
  typedef AudioTerminatorAtom *AudioTerminatorAtomPtr;
  struct LevelMeterInfo
  {
    short numChannels; 
    UInt8 leftMeter;   
    UInt8 rightMeter;  
  };
  typedef struct LevelMeterInfo LevelMeterInfo;
  typedef LevelMeterInfo *LevelMeterInfoPtr;
  struct EQSpectrumBandsRecord
  {
    short count;
    UnsignedFixedPtr frequency; 
  };
  typedef struct EQSpectrumBandsRecord EQSpectrumBandsRecord;
  typedef EQSpectrumBandsRecord *EQSpectrumBandsRecordPtr;
 
  typedef struct SPB SPB;
  typedef SPB *SPBPtr;
 
  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;
 
  struct SPB
  {
    long inRefNum;                     
    unsigned long count;               
    unsigned long milliseconds;        
    unsigned long bufferLength;        
    Ptr bufferPtr;                     
    SICompletionUPP completionRoutine; 
    SIInterruptUPP interruptRoutine;   
    long userLong;                     
    OSErr error;                       
    long unused1;                      
  };
 
  SoundParamUPP
  NewSoundParamUPP(SoundParamProcPtr userRoutine);
#if !OPAQUE_UPP_TYPES
  enum
  {
    uppSoundParamProcInfo = 0x000000D0
  }; 
#ifdef __cplusplus
  inline SoundParamUPP NewSoundParamUPP(SoundParamProcPtr userRoutine)
  {
    return (SoundParamUPP)NewRoutineDescriptor(
        (ProcPtr)(userRoutine), uppSoundParamProcInfo, GetCurrentArchitecture());
  }
#else
#define NewSoundParamUPP(userRoutine)   \
  (SoundParamUPP) NewRoutineDescriptor( \
      (ProcPtr)(userRoutine), uppSoundParamProcInfo, GetCurrentArchitecture())
#endif
#endif
 
  SoundConverterFillBufferDataUPP
  NewSoundConverterFillBufferDataUPP(
      SoundConverterFillBufferDataProcPtr userRoutine);
#if !OPAQUE_UPP_TYPES
  enum
  {
    uppSoundConverterFillBufferDataProcInfo = 0x000003D0
  }; 
#ifdef __cplusplus
  inline SoundConverterFillBufferDataUPP NewSoundConverterFillBufferDataUPP(
      SoundConverterFillBufferDataProcPtr userRoutine)
  {
    return (SoundConverterFillBufferDataUPP)NewRoutineDescriptor(
        (ProcPtr)(userRoutine), uppSoundConverterFillBufferDataProcInfo,
        GetCurrentArchitecture());
  }
#else
#define NewSoundConverterFillBufferDataUPP(userRoutine)                \
  (SoundConverterFillBufferDataUPP) NewRoutineDescriptor(              \
      (ProcPtr)(userRoutine), uppSoundConverterFillBufferDataProcInfo, \
      GetCurrentArchitecture())
#endif
#endif
 
  SIInterruptUPP
  NewSIInterruptUPP(SIInterruptProcPtr userRoutine);
#if !OPAQUE_UPP_TYPES
  enum
  {
    uppSIInterruptProcInfo = 0x1C579802
  }; 
#ifdef __cplusplus
  inline SIInterruptUPP NewSIInterruptUPP(SIInterruptProcPtr userRoutine)
  {
    return (SIInterruptUPP)NewRoutineDescriptor(
        (ProcPtr)(userRoutine), uppSIInterruptProcInfo, GetCurrentArchitecture());
  }
#else
#define NewSIInterruptUPP(userRoutine)                                     \
  (SIInterruptUPP)                                                         \
      NewRoutineDescriptor((ProcPtr)(userRoutine), uppSIInterruptProcInfo, \
                           GetCurrentArchitecture())
#endif
#endif
 
  SICompletionUPP
  NewSICompletionUPP(SICompletionProcPtr userRoutine);
#if !OPAQUE_UPP_TYPES
  enum
  {
    uppSICompletionProcInfo = 0x000000C0
  }; 
#ifdef __cplusplus
  inline SICompletionUPP NewSICompletionUPP(SICompletionProcPtr userRoutine)
  {
    return (SICompletionUPP)NewRoutineDescriptor((ProcPtr)(userRoutine),
                                                 uppSICompletionProcInfo,
                                                 GetCurrentArchitecture());
  }
#else
#define NewSICompletionUPP(userRoutine)                                     \
  (SICompletionUPP)                                                         \
      NewRoutineDescriptor((ProcPtr)(userRoutine), uppSICompletionProcInfo, \
                           GetCurrentArchitecture())
#endif
#endif
 
  void
  DisposeSoundParamUPP(SoundParamUPP userUPP);
#if !OPAQUE_UPP_TYPES
#ifdef __cplusplus
  inline void DisposeSoundParamUPP(SoundParamUPP userUPP)
  {
    DisposeRoutineDescriptor((UniversalProcPtr)userUPP);
  }
#else
#define DisposeSoundParamUPP(userUPP) DisposeRoutineDescriptor(userUPP)
#endif
#endif
 
  void
  DisposeSoundConverterFillBufferDataUPP(SoundConverterFillBufferDataUPP userUPP);
#if !OPAQUE_UPP_TYPES
#ifdef __cplusplus
  inline void DisposeSoundConverterFillBufferDataUPP(
      SoundConverterFillBufferDataUPP userUPP)
  {
    DisposeRoutineDescriptor((UniversalProcPtr)userUPP);
  }
#else
#define DisposeSoundConverterFillBufferDataUPP(userUPP) \
  DisposeRoutineDescriptor(userUPP)
#endif
#endif
 
  void
  DisposeSIInterruptUPP(SIInterruptUPP userUPP);
#if !OPAQUE_UPP_TYPES
#ifdef __cplusplus
  inline void DisposeSIInterruptUPP(SIInterruptUPP userUPP)
  {
    DisposeRoutineDescriptor((UniversalProcPtr)userUPP);
  }
#else
#define DisposeSIInterruptUPP(userUPP) DisposeRoutineDescriptor(userUPP)
#endif
#endif
 
  void
  DisposeSICompletionUPP(SICompletionUPP userUPP);
#if !OPAQUE_UPP_TYPES
#ifdef __cplusplus
  inline void DisposeSICompletionUPP(SICompletionUPP userUPP)
  {
    DisposeRoutineDescriptor((UniversalProcPtr)userUPP);
  }
#else
#define DisposeSICompletionUPP(userUPP) DisposeRoutineDescriptor(userUPP)
#endif
#endif
 
  Boolean
  InvokeSoundParamUPP(SoundParamBlockPtr *pb, SoundParamUPP userUPP);
#if !OPAQUE_UPP_TYPES
#ifdef __cplusplus
  inline 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
 
  Boolean
  InvokeSoundConverterFillBufferDataUPP(SoundComponentDataPtr *data, void *refCon,
                                        SoundConverterFillBufferDataUPP userUPP);
#if !OPAQUE_UPP_TYPES
#ifdef __cplusplus
  inline 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
 
  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 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
 
  void
  InvokeSICompletionUPP(SPBPtr inParamPtr, SICompletionUPP userUPP);
#if !OPAQUE_UPP_TYPES
#ifdef __cplusplus
  inline 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
#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 
  typedef CALLBACK_API(void, FilePlayCompletionProcPtr)(SndChannelPtr chan);
  typedef STACK_UPP_TYPE(FilePlayCompletionProcPtr) FilePlayCompletionUPP;
#if CALL_NOT_IN_CARBON
  FilePlayCompletionUPP
  NewFilePlayCompletionUPP(FilePlayCompletionProcPtr userRoutine);
#if !OPAQUE_UPP_TYPES
  enum
  {
    uppFilePlayCompletionProcInfo = 0x000000C0
  }; 
#ifdef __cplusplus
  inline FilePlayCompletionUPP
  NewFilePlayCompletionUPP(FilePlayCompletionProcPtr userRoutine)
  {
    return (FilePlayCompletionUPP)NewRoutineDescriptor(
        (ProcPtr)(userRoutine), uppFilePlayCompletionProcInfo,
        GetCurrentArchitecture());
  }
#else
#define NewFilePlayCompletionUPP(userRoutine)                                 \
  (FilePlayCompletionUPP) NewRoutineDescriptor((ProcPtr)(userRoutine),        \
                                               uppFilePlayCompletionProcInfo, \
                                               GetCurrentArchitecture())
#endif
#endif
 
  void
  DisposeFilePlayCompletionUPP(FilePlayCompletionUPP userUPP);
#if !OPAQUE_UPP_TYPES
#ifdef __cplusplus
  inline void DisposeFilePlayCompletionUPP(FilePlayCompletionUPP userUPP)
  {
    DisposeRoutineDescriptor((UniversalProcPtr)userUPP);
  }
#else
#define DisposeFilePlayCompletionUPP(userUPP) DisposeRoutineDescriptor(userUPP)
#endif
#endif
 
  void
  InvokeFilePlayCompletionUPP(SndChannelPtr chan, FilePlayCompletionUPP userUPP);
#if !OPAQUE_UPP_TYPES
#ifdef __cplusplus
  inline 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 
#if CALL_NOT_IN_CARBON || OLDROUTINENAMES
#define NewFilePlayCompletionProc(userRoutine) \
  NewFilePlayCompletionUPP(userRoutine)
#define CallFilePlayCompletionProc(userRoutine, chan) \
  InvokeFilePlayCompletionUPP(chan, userRoutine)
#endif 
  void
  SysBeep(short duration);
 
  OSErr
  SndDoCommand(SndChannelPtr chan, const SndCommand *cmd, Boolean noWait);
 
  OSErr
  SndDoImmediate(SndChannelPtr chan, const SndCommand *cmd);
 
  OSErr
  SndNewChannel(SndChannelPtr *chan, short synth, long init,
                SndCallBackUPP userRoutine);
 
  OSErr
  SndDisposeChannel(SndChannelPtr chan, Boolean quietNow);
 
  OSErr
  SndPlay(SndChannelPtr chan, SndListHandle sndHandle, Boolean async);
 
#if OLDROUTINENAMES
#if CALL_NOT_IN_CARBON
  OSErr
  SndAddModifier(SndChannelPtr chan, Ptr modifier, short id, long init);
 
#endif 
#endif 
#if CALL_NOT_IN_CARBON
  OSErr
  SndControl(short id, SndCommand *cmd);
 
#endif 
  NumVersion
  SndSoundManagerVersion(void);
 
#if CALL_NOT_IN_CARBON
  OSErr
  SndStartFilePlay(SndChannelPtr chan, short fRefNum, short resNum,
                   long bufferSize, void *theBuffer,
                   AudioSelectionPtr theSelection,
                   FilePlayCompletionUPP theCompletion, Boolean async);
 
  OSErr
  SndPauseFilePlay(SndChannelPtr chan);
 
  OSErr
  SndStopFilePlay(SndChannelPtr chan, Boolean quietNow);
 
#endif 
  OSErr
  SndChannelStatus(SndChannelPtr chan, short theLength, SCStatusPtr theStatus);
 
  OSErr
  SndManagerStatus(short theLength, SMStatusPtr theStatus);
 
  void
  SndGetSysBeepState(short *sysBeepState);
 
  OSErr
  SndSetSysBeepState(short sysBeepState);
 
#if CALL_NOT_IN_CARBON
  OSErr
  SndPlayDoubleBuffer(SndChannelPtr chan, SndDoubleBufferHeaderPtr theParams);
 
  NumVersion
  MACEVersion(void);
 
  void
  Comp3to1(const void *inBuffer, void *outBuffer, unsigned long cnt,
           StateBlockPtr inState, StateBlockPtr outState,
           unsigned long numChannels, unsigned long whichChannel);
 
  void
  Exp1to3(const void *inBuffer, void *outBuffer, unsigned long cnt,
          StateBlockPtr inState, StateBlockPtr outState,
          unsigned long numChannels, unsigned long whichChannel);
 
  void
  Comp6to1(const void *inBuffer, void *outBuffer, unsigned long cnt,
           StateBlockPtr inState, StateBlockPtr outState,
           unsigned long numChannels, unsigned long whichChannel);
 
  void
  Exp1to6(const void *inBuffer, void *outBuffer, unsigned long cnt,
          StateBlockPtr inState, StateBlockPtr outState,
          unsigned long numChannels, unsigned long whichChannel);
 
#endif 
  OSErr
  GetSysBeepVolume(long *level);
 
  OSErr
  SetSysBeepVolume(long level);
 
  OSErr
  GetDefaultOutputVolume(long *level);
 
  OSErr
  SetDefaultOutputVolume(long level);
 
  OSErr
  GetSoundHeaderOffset(SndListHandle sndHandle, long *offset);
 
  UnsignedFixed
  UnsignedFixedMulDiv(UnsignedFixed value, UnsignedFixed multiplier,
                      UnsignedFixed divisor);
 
  OSErr
  GetCompressionInfo(short compressionID, OSType format, short numChannels,
                     short sampleSize, CompressionInfoPtr cp);
 
  OSErr
  SetSoundPreference(OSType theType, Str255 name, Handle settings);
 
  OSErr
  GetSoundPreference(OSType theType, Str255 name, Handle settings);
 
  OSErr
  OpenMixerSoundComponent(SoundComponentDataPtr outputDescription,
                          long outputFlags, ComponentInstance *mixerComponent);
 
  OSErr
  CloseMixerSoundComponent(ComponentInstance ci);
 
  OSErr
  SndGetInfo(SndChannelPtr chan, OSType selector, void *infoPtr);
 
  OSErr
  SndSetInfo(SndChannelPtr chan, OSType selector, const void *infoPtr);
 
  OSErr
  GetSoundOutputInfo(Component outputDevice, OSType selector, void *infoPtr);
 
  OSErr
  SetSoundOutputInfo(Component outputDevice, OSType selector, const void *infoPtr);
 
  OSErr
  GetCompressionName(OSType compressionType, Str255 compressionName);
 
  OSErr
  SoundConverterOpen(const SoundComponentData *inputFormat,
                     const SoundComponentData *outputFormat, SoundConverter *sc);
 
  OSErr
  SoundConverterClose(SoundConverter sc);
 
  OSErr
  SoundConverterGetBufferSizes(SoundConverter sc, unsigned long inputBytesTarget,
                               unsigned long *inputFrames,
                               unsigned long *inputBytes,
                               unsigned long *outputBytes);
 
  OSErr
  SoundConverterBeginConversion(SoundConverter sc);
 
  OSErr
  SoundConverterConvertBuffer(SoundConverter sc, const void *inputPtr,
                              unsigned long inputFrames, void *outputPtr,
                              unsigned long *outputFrames,
                              unsigned long *outputBytes);
 
  OSErr
  SoundConverterEndConversion(SoundConverter sc, void *outputPtr,
                              unsigned long *outputFrames,
                              unsigned long *outputBytes);
 
  OSErr
  SoundConverterGetInfo(SoundConverter sc, OSType selector, void *infoPtr);
 
  OSErr
  SoundConverterSetInfo(SoundConverter sc, OSType selector, void *infoPtr);
 
  OSErr
  SoundConverterFillBuffer(SoundConverter sc,
                           SoundConverterFillBufferDataUPP fillBufferDataUPP,
                           void *fillBufferDataRefCon, void *outputBuffer,
                           unsigned long outputBufferByteSize,
                           unsigned long *bytesWritten,
                           unsigned long *framesWritten,
                           unsigned long *outputFlags);
 
  OSErr
  SoundManagerGetInfo(OSType selector, void *infoPtr);
 
  OSErr
  SoundManagerSetInfo(OSType selector, const void *infoPtr);
 
  ComponentResult
  SoundComponentInitOutputDevice(ComponentInstance ti, long actions);
 
  ComponentResult
  SoundComponentSetSource(ComponentInstance ti, SoundSource sourceID,
                          ComponentInstance source);
 
  ComponentResult
  SoundComponentGetSource(ComponentInstance ti, SoundSource sourceID,
                          ComponentInstance *source);
 
  ComponentResult
  SoundComponentGetSourceData(ComponentInstance ti,
                              SoundComponentDataPtr *sourceData);
 
  ComponentResult
  SoundComponentSetOutput(ComponentInstance ti, SoundComponentDataPtr requested,
                          SoundComponentDataPtr *actual);
 
  ComponentResult
  SoundComponentAddSource(ComponentInstance ti, SoundSource *sourceID);
 
  ComponentResult
  SoundComponentRemoveSource(ComponentInstance ti, SoundSource sourceID);
 
  ComponentResult
  SoundComponentGetInfo(ComponentInstance ti, SoundSource sourceID,
                        OSType selector, void *infoPtr);
 
  ComponentResult
  SoundComponentSetInfo(ComponentInstance ti, SoundSource sourceID,
                        OSType selector, void *infoPtr);
 
  ComponentResult
  SoundComponentStartSource(ComponentInstance ti, short count,
                            SoundSource *sources);
 
  ComponentResult
  SoundComponentStopSource(ComponentInstance ti, short count,
                           SoundSource *sources);
 
  ComponentResult
  SoundComponentPauseSource(ComponentInstance ti, short count,
                            SoundSource *sources);
 
  ComponentResult
  SoundComponentPlaySourceBuffer(ComponentInstance ti, SoundSource sourceID,
                                 SoundParamBlockPtr pb, long actions);
 
  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
  };
#if CALL_NOT_IN_CARBON
  ComponentResult
  AudioGetVolume(ComponentInstance ac, short whichChannel, ShortFixed *volume);
 
  ComponentResult
  AudioSetVolume(ComponentInstance ac, short whichChannel, ShortFixed volume);
 
  ComponentResult
  AudioGetMute(ComponentInstance ac, short whichChannel, short *mute);
 
  ComponentResult
  AudioSetMute(ComponentInstance ac, short whichChannel, short mute);
 
  ComponentResult
  AudioSetToDefaults(ComponentInstance ac);
 
  ComponentResult
  AudioGetInfo(ComponentInstance ac, AudioInfoPtr info);
 
  ComponentResult
  AudioGetBass(ComponentInstance ac, short whichChannel, short *bass);
 
  ComponentResult
  AudioSetBass(ComponentInstance ac, short whichChannel, short bass);
 
  ComponentResult
  AudioGetTreble(ComponentInstance ac, short whichChannel, short *Treble);
 
  ComponentResult
  AudioSetTreble(ComponentInstance ac, short whichChannel, short Treble);
 
  ComponentResult
  AudioGetOutputDevice(ComponentInstance ac, Component *outputDevice);
 
  ComponentResult
  AudioMuteOnEvent(ComponentInstance ac, short muteOnEvent);
 
  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 
  enum
  {
    kDelegatedSoundComponentSelectors = 0x0100
  };
 
  NumVersion
  SPBVersion(void);
 
  OSErr
  SndRecord(ModalFilterUPP filterProc, Point corner, OSType quality,
            SndListHandle *sndHandle);
 
#if CALL_NOT_IN_CARBON
  OSErr
  SndRecordToFile(ModalFilterUPP filterProc, Point corner, OSType quality,
                  short fRefNum);
 
#endif 
  OSErr
  SPBSignInDevice(short deviceRefNum, ConstStr255Param deviceName);
 
  OSErr
  SPBSignOutDevice(short deviceRefNum);
 
  OSErr
  SPBGetIndexedDevice(short count, Str255 deviceName, Handle *deviceIconHandle);
 
  OSErr
  SPBOpenDevice(ConstStr255Param deviceName, short permission, long *inRefNum);
 
  OSErr
  SPBCloseDevice(long inRefNum);
 
  OSErr
  SPBRecord(SPBPtr inParamPtr, Boolean asynchFlag);
 
#if CALL_NOT_IN_CARBON
  OSErr
  SPBRecordToFile(short fRefNum, SPBPtr inParamPtr, Boolean asynchFlag);
 
#endif 
  OSErr
  SPBPauseRecording(long inRefNum);
 
  OSErr
  SPBResumeRecording(long inRefNum);
 
  OSErr
  SPBStopRecording(long inRefNum);
 
  OSErr
  SPBGetRecordingStatus(long inRefNum, short *recordingStatus, short *meterLevel,
                        unsigned long *totalSamplesToRecord,
                        unsigned long *numberOfSamplesRecorded,
                        unsigned long *totalMsecsToRecord,
                        unsigned long *numberOfMsecsRecorded);
 
  OSErr
  SPBGetDeviceInfo(long inRefNum, OSType infoType, void *infoData);
 
  OSErr
  SPBSetDeviceInfo(long inRefNum, OSType infoType, void *infoData);
 
  OSErr
  SPBMillisecondsToBytes(long inRefNum, long *milliseconds);
 
  OSErr
  SPBBytesToMilliseconds(long inRefNum, long *byteCount);
 
  OSErr
  SetupSndHeader(SndListHandle sndHandle, short numChannels,
                 UnsignedFixed sampleRate, short sampleSize,
                 OSType compressionType, short baseNote, unsigned long numBytes,
                 short *headerLen);
 
  OSErr
  SetupAIFFHeader(short fRefNum, short numChannels, UnsignedFixed sampleRate,
                  short sampleSize, OSType compressionType,
                  unsigned long numBytes, unsigned long numFrames);
 
  OSErr
  ParseAIFFHeader(short fRefNum, SoundComponentData *sndInfo,
                  unsigned long *numFrames, unsigned long *dataOffset);
 
  OSErr
  ParseSndHeader(SndListHandle sndHandle, SoundComponentData *sndInfo,
                 unsigned long *numFrames, unsigned long *dataOffset);
 
#if !TARGET_OS_MAC || TARGET_API_MAC_CARBON
  typedef struct SndInputCmpParam SndInputCmpParam;
  typedef SndInputCmpParam *SndInputCmpParamPtr;
  typedef CALLBACK_API(void,
                       SICCompletionProcPtr)(SndInputCmpParamPtr SICParmPtr);
  struct SndInputCmpParam
  {
    SICCompletionProcPtr ioCompletion; 
    SIInterruptProcPtr ioInterrupt;    
    OSErr ioResult;                    
    short pad;
    unsigned long ioReqCount;
    unsigned long ioActCount;
    Ptr ioBuffer;
    Ptr ioMisc;
  };
 
  ComponentResult
  SndInputReadAsync(ComponentInstance self, SndInputCmpParamPtr SICParmPtr);
 
  ComponentResult
  SndInputReadSync(ComponentInstance self, SndInputCmpParamPtr SICParmPtr);
 
  ComponentResult
  SndInputPauseRecording(ComponentInstance self);
 
  ComponentResult
  SndInputResumeRecording(ComponentInstance self);
 
  ComponentResult
  SndInputStopRecording(ComponentInstance self);
 
  ComponentResult
  SndInputGetStatus(ComponentInstance self, short *recordingStatus,
                    unsigned long *totalSamplesToRecord,
                    unsigned long *numberOfSamplesRecorded);
 
  ComponentResult
  SndInputGetDeviceInfo(ComponentInstance self, OSType infoType, void *infoData);
 
  ComponentResult
  SndInputSetDeviceInfo(ComponentInstance self, OSType infoType, void *infoData);
 
  ComponentResult
  SndInputInitHardware(ComponentInstance self);
 
  enum
  {
    kSndInputReadAsyncSelect = 0x0001,
    kSndInputReadSyncSelect = 0x0002,
    kSndInputPauseRecordingSelect = 0x0003,
    kSndInputResumeRecordingSelect = 0x0004,
    kSndInputStopRecordingSelect = 0x0005,
    kSndInputGetStatusSelect = 0x0006,
    kSndInputGetDeviceInfoSelect = 0x0007,
    kSndInputSetDeviceInfoSelect = 0x0008,
    kSndInputInitHardwareSelect = 0x0009
  };
#endif 
#if PRAGMA_STRUCT_ALIGN
#pragma options align = reset
#elif PRAGMA_STRUCT_PACKPUSH
#pragma pack(pop)
#elif PRAGMA_STRUCT_PACK
#pragma pack()
#endif
 
#ifdef PRAGMA_IMPORT_OFF
#pragma import off
#elif PRAGMA_IMPORT
#pragma import reset
#endif
 
#ifdef __cplusplus
}
#endif
 
#endif 
* / t available
            *    \mac_os_x in version 10.0 and
    later
            * /
        ComponentResult
        SndInputSetDeviceInfo(ComponentInstance self, OSType infoType, void *infoData);
 
ComponentResult
SndInputInitHardware(ComponentInstance self);
 
enum
{
  kSndInputReadAsyncSelect = 0x0001,
  kSndInputReadSyncSelect = 0x0002,
  kSndInputPauseRecordingSelect = 0x0003,
  kSndInputResumeRecordingSelect = 0x0004,
  kSndInputStopRecordingSelect = 0x0005,
  kSndInputGetStatusSelect = 0x0006,
  kSndInputGetDeviceInfoSelect = 0x0007,
  kSndInputSetDeviceInfoSelect = 0x0008,
  kSndInputInitHardwareSelect = 0x0009
};
#endif 
#if PRAGMA_STRUCT_ALIGN
#pragma options align = reset
#elif PRAGMA_STRUCT_PACKPUSH
#pragma pack(pop)
#elif PRAGMA_STRUCT_PACK
#pragma pack()
#endif
 
#ifdef PRAGMA_IMPORT_OFF
#pragma import off
#elif PRAGMA_IMPORT
#pragma import reset
#endif
 
#ifdef __cplusplus
}
#endif
 
#endif                    
* /*/*/ * /*/*/ * /*/*/ * /*/*/