QuickTimeComponents.h

Go to the documentation of this file.

 
#ifndef __QUICKTIMECOMPONENTS__
#define __QUICKTIMECOMPONENTS__
 
#ifndef __MACTYPES__
#include <MacTypes.h>
#endif
 
#ifndef __MIXEDMODE__
#include <MixedMode.h>
#endif
 
#ifndef __COMPONENTS__
#include <Components.h>
#endif
 
#ifndef __QUICKDRAW__
#include <Quickdraw.h>
#endif
 
#ifndef __VIDEO__
#include <Video.h>
#endif
 
#ifndef __SOUND__
#include <Sound.h>
#endif
 
#ifndef __IMAGECOMPRESSION__
#include <ImageCompression.h>
#endif
 
#ifndef __MOVIES__
#include <Movies.h>
#endif
 
#ifndef __QUICKTIMEMUSIC__
#include <QuickTimeMusic.h>
#endif
 
#if PRAGMA_ONCE
#pragma once
#endif
 
#ifdef __cplusplus
extern "C"
{
#endif
 
#if PRAGMA_IMPORT
#pragma import on
#endif
 
#if PRAGMA_STRUCT_ALIGN
#pragma options align = mac68k
#elif PRAGMA_STRUCT_PACKPUSH
#pragma pack(push, 2)
#elif PRAGMA_STRUCT_PACK
#pragma pack(2)
#endif
 
    enum
    {
        clockComponentType = FOUR_CHAR_CODE('clok'),
        systemTickClock = FOUR_CHAR_CODE('tick'),   
        systemSecondClock = FOUR_CHAR_CODE('seco'), 
        systemMillisecondClock =
            FOUR_CHAR_CODE('mill'), 
        systemMicrosecondClock =
            FOUR_CHAR_CODE('micr') 
    };
 
    enum
    {
        kClockRateIsLinear = 1,
        kClockImplementsCallBacks = 2,
        kClockCanHandleIntermittentSound = 4 
    };
 
#if OLDROUTINENAMES
#define GetClockTime(aClock, out) ClockGetTime(aClock, out)
#endif
    /*** These are Clock procedures **/
    ComponentResult
    ClockGetTime(ComponentInstance aClock, TimeRecord *out);
 
    QTCallBack
    ClockNewCallBack(ComponentInstance aClock, TimeBase tb, short callBackType);
 
    ComponentResult
    ClockDisposeCallBack(ComponentInstance aClock, QTCallBack cb);
 
    ComponentResult
    ClockCallMeWhen(ComponentInstance aClock, QTCallBack cb, long param1,
                    long param2, long param3);
 
    ComponentResult
    ClockCancelCallBack(ComponentInstance aClock, QTCallBack cb);
 
    ComponentResult
    ClockRateChanged(ComponentInstance aClock, QTCallBack cb);
 
    ComponentResult
    ClockTimeChanged(ComponentInstance aClock, QTCallBack cb);
 
    ComponentResult
    ClockSetTimeBase(ComponentInstance aClock, TimeBase tb);
 
    ComponentResult
    ClockStartStopChanged(ComponentInstance aClock, QTCallBack cb,
                          Boolean startChanged, Boolean stopChanged);
 
    ComponentResult
    ClockGetRate(ComponentInstance aClock, Fixed *rate);
 
    enum
    {
        StandardCompressionType = FOUR_CHAR_CODE('scdi'),
        StandardCompressionSubType = FOUR_CHAR_CODE('imag'),
        StandardCompressionSubTypeSound = FOUR_CHAR_CODE('soun')
    };
 
    typedef CALLBACK_API(Boolean, SCModalFilterProcPtr)(DialogRef theDialog,
                                                        EventRecord *theEvent,
                                                        short *itemHit,
                                                        long refcon);
    typedef CALLBACK_API(short, SCModalHookProcPtr)(DialogRef theDialog,
                                                    short itemHit, void *params,
                                                    long refcon);
    typedef STACK_UPP_TYPE(SCModalFilterProcPtr) SCModalFilterUPP;
    typedef STACK_UPP_TYPE(SCModalHookProcPtr) SCModalHookUPP;
    enum
    {
        scListEveryCodec = 1L << 1,
        scAllowZeroFrameRate = 1L << 2,
        scAllowZeroKeyFrameRate = 1L << 3,
        scShowBestDepth = 1L << 4,
        scUseMovableModal = 1L << 5,
        scDisableFrameRateItem = 1L << 6,
        scShowDataRateAsKilobits = 1L << 7
    };
 
    enum
    {
        scPreferCropping = 1 << 0,
        scPreferScaling = 1 << 1,
        scPreferScalingAndCropping = scPreferScaling | scPreferCropping,
        scDontDetermineSettingsFromTestImage = 1 << 2
    };
 
    enum
    {
        scTestImageWidth = 80,
        scTestImageHeight = 80
    };
 
    enum
    {
        scOKItem = 1,
        scCancelItem = 2,
        scCustomItem = 3
    };
 
    enum
    {
        scUserCancelled = 1
    };
 
    enum
    {
        scPositionRect = 2,
        scPositionDialog = 3,
        scSetTestImagePictHandle = 4,
        scSetTestImagePictFile = 5,
        scSetTestImagePixMap = 6,
        scGetBestDeviceRect = 7,
        scRequestImageSettings = 10,
        scCompressImage = 11,
        scCompressPicture = 12,
        scCompressPictureFile = 13,
        scRequestSequenceSettings = 14,
        scCompressSequenceBegin = 15,
        scCompressSequenceFrame = 16,
        scCompressSequenceEnd = 17,
        scDefaultPictHandleSettings = 18,
        scDefaultPictFileSettings = 19,
        scDefaultPixMapSettings = 20,
        scGetInfo = 21,
        scSetInfo = 22,
        scNewGWorld = 23
    };
 
    struct SCSpatialSettings
    {
        CodecType codecType;
        CodecComponent codec;
        short depth;
        CodecQ spatialQuality;
    };
    typedef struct SCSpatialSettings SCSpatialSettings;
    struct SCTemporalSettings
    {
        CodecQ temporalQuality;
        Fixed frameRate;
        long keyFrameRate;
    };
    typedef struct SCTemporalSettings SCTemporalSettings;
    struct SCDataRateSettings
    {
        long dataRate;
        long frameDuration;
        CodecQ minSpatialQuality;
        CodecQ minTemporalQuality;
    };
    typedef struct SCDataRateSettings SCDataRateSettings;
    struct SCExtendedProcs
    {
        SCModalFilterUPP filterProc;
        SCModalHookUPP hookProc;
        long refcon;
        Str31 customName;
    };
    typedef struct SCExtendedProcs SCExtendedProcs;
    enum
    {
        scSpatialSettingsType =
            FOUR_CHAR_CODE('sptl'), 
        scTemporalSettingsType =
            FOUR_CHAR_CODE('tprl'), 
        scDataRateSettingsType =
            FOUR_CHAR_CODE('drat'),                
        scColorTableType = FOUR_CHAR_CODE('clut'), 
        scProgressProcType =
            FOUR_CHAR_CODE('prog'), 
        scExtendedProcsType =
            FOUR_CHAR_CODE('xprc'),                       
        scPreferenceFlagsType = FOUR_CHAR_CODE('pref'),   
        scSettingsStateType = FOUR_CHAR_CODE('ssta'),     
        scSequenceIDType = FOUR_CHAR_CODE('sequ'),        
        scWindowPositionType = FOUR_CHAR_CODE('wndw'),    
        scCodecFlagsType = FOUR_CHAR_CODE('cflg'),        
        scCodecSettingsType = FOUR_CHAR_CODE('cdec'),     
        scForceKeyValueType = FOUR_CHAR_CODE('ksim'),     
        scSoundSampleRateType = FOUR_CHAR_CODE('ssrt'),   
        scSoundSampleSizeType = FOUR_CHAR_CODE('ssss'),   
        scSoundChannelCountType = FOUR_CHAR_CODE('sscc'), 
        scSoundCompressionType = FOUR_CHAR_CODE('ssct'),  
        scCompressionListType = FOUR_CHAR_CODE('ctyl'),   
        scCodecManufacturerType = FOUR_CHAR_CODE('cmfr')  
    };
 
    struct SCParams
    {
        long flags;
        CodecType theCodecType;
        CodecComponent theCodec;
        CodecQ spatialQuality;
        CodecQ temporalQuality;
        short depth;
        Fixed frameRate;
        long keyFrameRate;
        long reserved1;
        long reserved2;
    };
    typedef struct SCParams SCParams;
    enum
    {
        scGetCompression = 1,
        scShowMotionSettings = 1L << 0,
        scSettingsChangedItem = -1
    };
 
    enum
    {
        scCompressFlagIgnoreIdenticalFrames = 1
    };
 
    enum
    {
        kQTSettingsVideo =
            FOUR_CHAR_CODE('vide'), 
        kQTSettingsSound =
            FOUR_CHAR_CODE('soun'), 
        kQTSettingsComponentVersion =
            FOUR_CHAR_CODE('vers') 
    };
 
    struct QTSettingsVersionAtomRecord
    {
        long componentVersion; 
        short flags;           
        short reserved;        
    };
    typedef struct QTSettingsVersionAtomRecord QTSettingsVersionAtomRecord;
#define SCGetCompression(ci, params, where) \
    SCGetCompressionExtended(ci, params, where, 0, 0, 0, 0)
    /*** These are Progress procedures **/
    ComponentResult
    SCGetCompressionExtended(ComponentInstance ci, SCParams *params, Point where,
                             SCModalFilterUPP filterProc, SCModalHookUPP hookProc,
                             long refcon, StringPtr customName);
 
    ComponentResult
    SCPositionRect(ComponentInstance ci, Rect *rp, Point *where);
 
    ComponentResult
    SCPositionDialog(ComponentInstance ci, short id, Point *where);
 
    ComponentResult
    SCSetTestImagePictHandle(ComponentInstance ci, PicHandle testPict,
                             Rect *testRect, short testFlags);
 
    ComponentResult
    SCSetTestImagePictFile(ComponentInstance ci, short testFileRef, Rect *testRect,
                           short testFlags);
 
    ComponentResult
    SCSetTestImagePixMap(ComponentInstance ci, PixMapHandle testPixMap,
                         Rect *testRect, short testFlags);
 
    ComponentResult
    SCGetBestDeviceRect(ComponentInstance ci, Rect *r);
 
    ComponentResult
    SCRequestImageSettings(ComponentInstance ci);
 
    ComponentResult
    SCCompressImage(ComponentInstance ci, PixMapHandle src, const Rect *srcRect,
                    ImageDescriptionHandle *desc, Handle *data);
 
    ComponentResult
    SCCompressPicture(ComponentInstance ci, PicHandle srcPicture,
                      PicHandle dstPicture);
 
    ComponentResult
    SCCompressPictureFile(ComponentInstance ci, short srcRefNum, short dstRefNum);
 
    ComponentResult
    SCRequestSequenceSettings(ComponentInstance ci);
 
    ComponentResult
    SCCompressSequenceBegin(ComponentInstance ci, PixMapHandle src,
                            const Rect *srcRect, ImageDescriptionHandle *desc);
 
    ComponentResult
    SCCompressSequenceFrame(ComponentInstance ci, PixMapHandle src,
                            const Rect *srcRect, Handle *data, long *dataSize,
                            short *notSyncFlag);
 
    ComponentResult
    SCCompressSequenceEnd(ComponentInstance ci);
 
    ComponentResult
    SCDefaultPictHandleSettings(ComponentInstance ci, PicHandle srcPicture,
                                short motion);
 
    ComponentResult
    SCDefaultPictFileSettings(ComponentInstance ci, short srcRef, short motion);
 
    ComponentResult
    SCDefaultPixMapSettings(ComponentInstance ci, PixMapHandle src, short motion);
 
    ComponentResult
    SCGetInfo(ComponentInstance ci, OSType infoType, void *info);
 
    ComponentResult
    SCSetInfo(ComponentInstance ci, OSType infoType, void *info);
 
    ComponentResult
    SCNewGWorld(ComponentInstance ci, GWorldPtr *gwp, Rect *rp, GWorldFlags flags);
 
    ComponentResult
    SCSetCompressFlags(ComponentInstance ci, long flags);
 
    ComponentResult
    SCGetCompressFlags(ComponentInstance ci, long *flags);
 
    ComponentResult
    SCGetSettingsAsText(ComponentInstance ci, Handle *text);
 
    ComponentResult
    SCGetSettingsAsAtomContainer(ComponentInstance ci, QTAtomContainer *settings);
 
    ComponentResult
    SCSetSettingsFromAtomContainer(ComponentInstance ci, QTAtomContainer settings);
 
    ComponentResult
    SCCompressSequenceFrameAsync(ComponentInstance ci, PixMapHandle src,
                                 const Rect *srcRect, Handle *data, long *dataSize,
                                 short *notSyncFlag,
                                 ICMCompletionProcRecordPtr asyncCompletionProc);
 
    ComponentResult
    SCAsyncIdle(ComponentInstance ci);
 
    enum
    {
        TweenComponentType = FOUR_CHAR_CODE('twen')
    };
 
    typedef ComponentInstance TweenerComponent;
    ComponentResult
    TweenerInitialize(TweenerComponent tc, QTAtomContainer container,
                      QTAtom tweenAtom, QTAtom dataAtom);
 
    ComponentResult
    TweenerDoTween(TweenerComponent tc, TweenRecord *tr);
 
    ComponentResult
    TweenerReset(TweenerComponent tc);
 
    enum
    {
        TCSourceRefNameType = FOUR_CHAR_CODE('name')
    };
 
    enum
    {
        tcDropFrame = 1 << 0,
        tc24HourMax = 1 << 1,
        tcNegTimesOK = 1 << 2,
        tcCounter = 1 << 3
    };
 
    struct TimeCodeDef
    {
        long flags;              
        TimeScale fTimeScale;    
        TimeValue frameDuration; 
        UInt8 numFrames;         
        UInt8 padding;           
    };
    typedef struct TimeCodeDef TimeCodeDef;
    enum
    {
        tctNegFlag = 0x80 
    };
 
    struct TimeCodeTime
    {
        UInt8 hours;
        UInt8 minutes;
        UInt8 seconds;
        UInt8 frames;
    };
    typedef struct TimeCodeTime TimeCodeTime;
    struct TimeCodeCounter
    {
        long counter;
    };
    typedef struct TimeCodeCounter TimeCodeCounter;
    union TimeCodeRecord
    {
        TimeCodeTime t;
        TimeCodeCounter c;
    };
    typedef union TimeCodeRecord TimeCodeRecord;
    struct TimeCodeDescription
    {
        long descSize; 
        long dataFormat;
        long resvd1;
        short resvd2;
        short dataRefIndex;
        long flags; 
        TimeCodeDef timeCodeDef;
        long srcRef[1];
    };
    typedef struct TimeCodeDescription TimeCodeDescription;
    typedef TimeCodeDescription *TimeCodeDescriptionPtr;
    typedef TimeCodeDescriptionPtr *TimeCodeDescriptionHandle;
    enum
    {
        tcdfShowTimeCode = 1 << 0
    };
 
    struct TCTextOptions
    {
        short txFont;
        short txFace;
        short txSize;
        short pad; 
        RGBColor foreColor;
        RGBColor backColor;
    };
    typedef struct TCTextOptions TCTextOptions;
    typedef TCTextOptions *TCTextOptionsPtr;
    HandlerError
    TCGetCurrentTimeCode(MediaHandler mh, long *frameNum, TimeCodeDef *tcdef,
                         TimeCodeRecord *tcrec, UserData *srcRefH);
 
    HandlerError
    TCGetTimeCodeAtTime(MediaHandler mh, TimeValue mediaTime, long *frameNum,
                        TimeCodeDef *tcdef, TimeCodeRecord *tcdata,
                        UserData *srcRefH);
 
    HandlerError
    TCTimeCodeToString(MediaHandler mh, TimeCodeDef *tcdef, TimeCodeRecord *tcrec,
                       StringPtr tcStr);
 
    HandlerError
    TCTimeCodeToFrameNumber(MediaHandler mh, TimeCodeDef *tcdef,
                            TimeCodeRecord *tcrec, long *frameNumber);
 
    HandlerError
    TCFrameNumberToTimeCode(MediaHandler mh, long frameNumber, TimeCodeDef *tcdef,
                            TimeCodeRecord *tcrec);
 
    HandlerError
    TCGetSourceRef(MediaHandler mh, TimeCodeDescriptionHandle tcdH, UserData *srefH);
 
    HandlerError
    TCSetSourceRef(MediaHandler mh, TimeCodeDescriptionHandle tcdH, UserData srefH);
 
    HandlerError
    TCSetTimeCodeFlags(MediaHandler mh, long flags, long flagsMask);
 
    HandlerError
    TCGetTimeCodeFlags(MediaHandler mh, long *flags);
 
    HandlerError
    TCSetDisplayOptions(MediaHandler mh, TCTextOptionsPtr textOptions);
 
    HandlerError
    TCGetDisplayOptions(MediaHandler mh, TCTextOptionsPtr textOptions);
 
    typedef ComponentInstance MovieImportComponent;
    typedef ComponentInstance MovieExportComponent;
    enum
    {
        MovieImportType = FOUR_CHAR_CODE('eat '),
        MovieExportType = FOUR_CHAR_CODE('spit')
    };
 
    enum
    {
        canMovieImportHandles = 1 << 0,
        canMovieImportFiles = 1 << 1,
        hasMovieImportUserInterface = 1 << 2,
        canMovieExportHandles = 1 << 3,
        canMovieExportFiles = 1 << 4,
        hasMovieExportUserInterface = 1 << 5,
        movieImporterIsXMLBased = 1 << 5,
        dontAutoFileMovieImport = 1 << 6,
        canMovieExportAuxDataHandle = 1 << 7,
        canMovieImportValidateHandles = 1 << 8,
        canMovieImportValidateFile = 1 << 9,
        dontRegisterWithEasyOpen = 1 << 10,
        canMovieImportInPlace = 1 << 11,
        movieImportSubTypeIsFileExtension = 1 << 12,
        canMovieImportPartial = 1 << 13,
        hasMovieImportMIMEList = 1 << 14,
        canMovieImportAvoidBlocking = 1 << 15,
        canMovieExportFromProcedures = 1 << 15,
        canMovieExportValidateMovie = 1L << 16,
        movieExportNeedsResourceFork = 1L << 17,
        canMovieImportDataReferences = 1L << 18,
        movieExportMustGetSourceMediaType = 1L << 19,
        canMovieImportWithIdle = 1L << 20,
        canMovieImportValidateDataReferences = 1L << 21,
        reservedForUseByGraphicsImporters = 1L << 23
    };
 
    enum
    {
        movieImportCreateTrack = 1,
        movieImportInParallel = 2,
        movieImportMustUseTrack = 4,
        movieImportWithIdle = 16
    };
 
    enum
    {
        movieImportResultUsedMultipleTracks = 8,
        movieImportResultNeedIdles = 32,
        movieImportResultComplete = 64
    };
 
    enum
    {
        kMovieExportTextOnly = 0,
        kMovieExportAbsoluteTime = 1,
        kMovieExportRelativeTime = 2
    };
 
    enum
    {
        kMIDIImportSilenceBefore = 1 << 0,
        kMIDIImportSilenceAfter = 1 << 1,
        kMIDIImport20Playable = 1 << 2,
        kMIDIImportWantLyrics = 1 << 3
    };
 
    enum
    {
        kQTMediaConfigResourceType = FOUR_CHAR_CODE('mcfg'),
        kQTMediaConfigResourceVersion = 2,
        kQTMediaGroupResourceType = FOUR_CHAR_CODE('mgrp'),
        kQTMediaGroupResourceVersion = 1
    };
 
    enum
    {
        kQTMediaMIMEInfoHasChanged = (1L << 1), 
        kQTMediaFileInfoHasChanged =
            (1L << 2), 
        kQTMediaConfigCanUseApp =
            (1L << 18), 
        kQTMediaConfigCanUsePlugin =
            (1L << 19),                    
        kQTMediaConfigUNUSED = (1L << 20), 
        kQTMediaConfigBinaryFile =
            (1L << 23),             
        kQTMediaConfigTextFile = 0, 
        kQTMediaConfigMacintoshFile =
            (1L << 24), 
        kQTMediaConfigAssociateByDefault =
            (1L << 27), 
        kQTMediaConfigUseAppByDefault =
            (1L << 28), 
        kQTMediaConfigUsePluginByDefault =
            (1L << 29), 
        kQTMediaConfigDefaultsMask =
            (kQTMediaConfigUseAppByDefault | kQTMediaConfigUsePluginByDefault),
        kQTMediaConfigDefaultsShift =
            12 
    };
 
    enum
    {
        kQTMediaConfigStreamGroupID = FOUR_CHAR_CODE('strm'),
        kQTMediaConfigInteractiveGroupID = FOUR_CHAR_CODE('intr'),
        kQTMediaConfigVideoGroupID = FOUR_CHAR_CODE('eyes'),
        kQTMediaConfigAudioGroupID = FOUR_CHAR_CODE('ears'),
        kQTMediaConfigMPEGGroupID = FOUR_CHAR_CODE('mpeg'),
        kQTMediaConfigMP3GroupID = FOUR_CHAR_CODE('mp3 '),
        kQTMediaConfigImageGroupID = FOUR_CHAR_CODE('ogle'),
        kQTMediaConfigMiscGroupID = FOUR_CHAR_CODE('misc')
    };
 
    enum
    {
        kQTMediaInfoNetGroup = FOUR_CHAR_CODE('net '),
        kQTMediaInfoWinGroup = FOUR_CHAR_CODE('win '),
        kQTMediaInfoMacGroup = FOUR_CHAR_CODE('mac '),
        kQTMediaInfoMiscGroup = 0x3F3F3F3F 
    };
 
    enum
    {
        kMimeInfoMimeTypeTag = FOUR_CHAR_CODE('mime'),
        kMimeInfoFileExtensionTag = FOUR_CHAR_CODE('ext '),
        kMimeInfoDescriptionTag = FOUR_CHAR_CODE('desc'),
        kMimeInfoGroupTag = FOUR_CHAR_CODE('grop'),
        kMimeInfoDoNotOverrideExistingFileTypeAssociation = FOUR_CHAR_CODE('nofa')
    };
 
    enum
    {
        kQTFileTypeAIFF = FOUR_CHAR_CODE('AIFF'),
        kQTFileTypeAIFC = FOUR_CHAR_CODE('AIFC'),
        kQTFileTypeDVC = FOUR_CHAR_CODE('dvc!'),
        kQTFileTypeMIDI = FOUR_CHAR_CODE('Midi'),
        kQTFileTypePicture = FOUR_CHAR_CODE('PICT'),
        kQTFileTypeMovie = FOUR_CHAR_CODE('MooV'),
        kQTFileTypeText = FOUR_CHAR_CODE('TEXT'),
        kQTFileTypeWave = FOUR_CHAR_CODE('WAVE'),
        kQTFileTypeSystemSevenSound = FOUR_CHAR_CODE('sfil'),
        kQTFileTypeMuLaw = FOUR_CHAR_CODE('ULAW'),
        kQTFileTypeAVI = FOUR_CHAR_CODE('VfW '),
        kQTFileTypeSoundDesignerII = FOUR_CHAR_CODE('Sd2f'),
        kQTFileTypeAudioCDTrack = FOUR_CHAR_CODE('trak'),
        kQTFileTypePICS = FOUR_CHAR_CODE('PICS'),
        kQTFileTypeGIF = FOUR_CHAR_CODE('GIFf'),
        kQTFileTypePNG = FOUR_CHAR_CODE('PNGf'),
        kQTFileTypeTIFF = FOUR_CHAR_CODE('TIFF'),
        kQTFileTypePhotoShop = FOUR_CHAR_CODE('8BPS'),
        kQTFileTypeSGIImage = FOUR_CHAR_CODE('.SGI'),
        kQTFileTypeBMP = FOUR_CHAR_CODE('BMPf'),
        kQTFileTypeJPEG = FOUR_CHAR_CODE('JPEG'),
        kQTFileTypeJFIF = FOUR_CHAR_CODE('JPEG'),
        kQTFileTypeMacPaint = FOUR_CHAR_CODE('PNTG'),
        kQTFileTypeTargaImage = FOUR_CHAR_CODE('TPIC'),
        kQTFileTypeQuickDrawGXPicture = FOUR_CHAR_CODE('qdgx'),
        kQTFileTypeQuickTimeImage = FOUR_CHAR_CODE('qtif'),
        kQTFileType3DMF = FOUR_CHAR_CODE('3DMF'),
        kQTFileTypeFLC = FOUR_CHAR_CODE('FLC '),
        kQTFileTypeFlash = FOUR_CHAR_CODE('SWFL'),
        kQTFileTypeFlashPix = FOUR_CHAR_CODE('FPix')
    };
 
    enum
    {
        kQTSettingsDVExportNTSC = FOUR_CHAR_CODE(
            'dvcv'), 
        kQTSettingsDVExportLockedAudio =
            FOUR_CHAR_CODE('lock'), 
        kQTSettingsEffect =
            FOUR_CHAR_CODE('effe'), 
        kQTSettingsGraphicsFileImportSequence = FOUR_CHAR_CODE(
            'sequ'), 
        kQTSettingsGraphicsFileImportSequenceEnabled = FOUR_CHAR_CODE(
            'enab'), 
        kQTSettingsMovieExportEnableVideo =
            FOUR_CHAR_CODE('envi'), 
        kQTSettingsMovieExportEnableSound =
            FOUR_CHAR_CODE('enso'), 
        kQTSettingsMovieExportSaveOptions =
            FOUR_CHAR_CODE('save'), 
        kQTSettingsMovieExportSaveForInternet =
            FOUR_CHAR_CODE('fast'), 
        kQTSettingsMovieExportSaveCompressedMovie =
            FOUR_CHAR_CODE('cmpm'),               
        kQTSettingsMIDI = FOUR_CHAR_CODE('MIDI'), 
        kQTSettingsMIDISettingFlags =
            FOUR_CHAR_CODE('sttg'),               
        kQTSettingsText = FOUR_CHAR_CODE('text'), 
        kQTSettingsTextDescription = FOUR_CHAR_CODE(
            'desc'), 
        kQTSettingsTextSize = FOUR_CHAR_CODE(
            'size'), 
        kQTSettingsTextSettingFlags =
            FOUR_CHAR_CODE('sttg'), 
        kQTSettingsTextTimeFraction =
            FOUR_CHAR_CODE('timf'),               
        kQTSettingsTime = FOUR_CHAR_CODE('time'), 
        kQTSettingsTimeDuration =
            FOUR_CHAR_CODE('dura'), 
        kQTSettingsAudioCDTrack =
            FOUR_CHAR_CODE('trak'), 
        kQTSettingsAudioCDTrackRateShift =
            FOUR_CHAR_CODE('rshf') 
    };
 
    struct MovieExportGetDataParams
    {
        long recordSize;
 
        long trackID;
 
        TimeScale sourceTimeScale;
        TimeValue requestedTime;
        TimeValue actualTime;
 
        Ptr dataPtr;
        long dataSize;
 
        SampleDescriptionHandle desc;
        OSType descType;
        long descSeed;
 
        long requestedSampleCount;
        long actualSampleCount;
        TimeValue durationPerSample;
        long sampleFlags;
    };
    typedef struct MovieExportGetDataParams MovieExportGetDataParams;
    typedef CALLBACK_API(OSErr, MovieExportGetDataProcPtr)(
        void *refCon, MovieExportGetDataParams *params);
    typedef CALLBACK_API(OSErr, MovieExportGetPropertyProcPtr)(void *refcon,
                                                               long trackID,
                                                               OSType propertyType,
                                                               void *propertyValue);
    enum
    {
        kQTPresetsListResourceType = FOUR_CHAR_CODE('stg#'),
        kQTPresetsPlatformListResourceType = FOUR_CHAR_CODE('stgp')
    };
 
    enum
    {
        kQTPresetInfoIsDivider = 1
    };
 
    struct QTPresetInfo
    {
        OSType presetKey;            
        UInt32 presetFlags;          
        OSType settingsResourceType; 
        SInt16 settingsResourceID;   
        SInt16 padding1;
        SInt16 nameStringListID; 
        SInt16 nameStringIndex;  
        SInt16 infoStringListID; 
        SInt16 infoStringIndex;  
    };
    typedef struct QTPresetInfo QTPresetInfo;
    struct QTPresetListRecord
    {
        UInt32 flags; 
        UInt32 count; 
        UInt32 reserved;
        QTPresetInfo presetsArray[1]; 
    };
    typedef struct QTPresetListRecord QTPresetListRecord;
    enum
    {
        kQTMovieExportSourceInfoResourceType = FOUR_CHAR_CODE('src#'),
        kQTMovieExportSourceInfoIsMediaType = 1L << 0,
        kQTMovieExportSourceInfoIsMediaCharacteristic = 1L << 1,
        kQTMovieExportSourceInfoIsSourceType = 1L << 2
    };
 
    struct QTMovieExportSourceInfo
    {
        OSType mediaType; 
        UInt16 minCount;  
        UInt16 maxCount;  
        long flags;       
    };
    typedef struct QTMovieExportSourceInfo QTMovieExportSourceInfo;
    struct QTMovieExportSourceRecord
    {
        long count;
        long reserved;
        QTMovieExportSourceInfo sourceArray[1];
    };
    typedef struct QTMovieExportSourceRecord QTMovieExportSourceRecord;
    typedef STACK_UPP_TYPE(MovieExportGetDataProcPtr) MovieExportGetDataUPP;
    typedef STACK_UPP_TYPE(MovieExportGetPropertyProcPtr) MovieExportGetPropertyUPP;
    SCModalFilterUPP
    NewSCModalFilterUPP(SCModalFilterProcPtr userRoutine);
#if !OPAQUE_UPP_TYPES
    enum
    {
        uppSCModalFilterProcInfo = 0x00003FD0
    }; 
#ifdef __cplusplus
    inline SCModalFilterUPP NewSCModalFilterUPP(SCModalFilterProcPtr userRoutine)
    {
        return (SCModalFilterUPP)NewRoutineDescriptor((ProcPtr)(userRoutine),
                                                      uppSCModalFilterProcInfo,
                                                      GetCurrentArchitecture());
    }
#else
#define NewSCModalFilterUPP(userRoutine)                                       \
    (SCModalFilterUPP)                                                         \
        NewRoutineDescriptor((ProcPtr)(userRoutine), uppSCModalFilterProcInfo, \
                             GetCurrentArchitecture())
#endif
#endif
 
    SCModalHookUPP
    NewSCModalHookUPP(SCModalHookProcPtr userRoutine);
#if !OPAQUE_UPP_TYPES
    enum
    {
        uppSCModalHookProcInfo = 0x00003EE0
    }; 
#ifdef __cplusplus
    inline SCModalHookUPP NewSCModalHookUPP(SCModalHookProcPtr userRoutine)
    {
        return (SCModalHookUPP)NewRoutineDescriptor(
            (ProcPtr)(userRoutine), uppSCModalHookProcInfo, GetCurrentArchitecture());
    }
#else
#define NewSCModalHookUPP(userRoutine)                                       \
    (SCModalHookUPP)                                                         \
        NewRoutineDescriptor((ProcPtr)(userRoutine), uppSCModalHookProcInfo, \
                             GetCurrentArchitecture())
#endif
#endif
 
    MovieExportGetDataUPP
    NewMovieExportGetDataUPP(MovieExportGetDataProcPtr userRoutine);
#if !OPAQUE_UPP_TYPES
    enum
    {
        uppMovieExportGetDataProcInfo = 0x000003E0
    }; 
#ifdef __cplusplus
    inline MovieExportGetDataUPP
    NewMovieExportGetDataUPP(MovieExportGetDataProcPtr userRoutine)
    {
        return (MovieExportGetDataUPP)NewRoutineDescriptor(
            (ProcPtr)(userRoutine), uppMovieExportGetDataProcInfo,
            GetCurrentArchitecture());
    }
#else
#define NewMovieExportGetDataUPP(userRoutine)                                   \
    (MovieExportGetDataUPP) NewRoutineDescriptor((ProcPtr)(userRoutine),        \
                                                 uppMovieExportGetDataProcInfo, \
                                                 GetCurrentArchitecture())
#endif
#endif
 
    MovieExportGetPropertyUPP
    NewMovieExportGetPropertyUPP(MovieExportGetPropertyProcPtr userRoutine);
#if !OPAQUE_UPP_TYPES
    enum
    {
        uppMovieExportGetPropertyProcInfo = 0x00003FE0
    }; 
#ifdef __cplusplus
    inline MovieExportGetPropertyUPP
    NewMovieExportGetPropertyUPP(MovieExportGetPropertyProcPtr userRoutine)
    {
        return (MovieExportGetPropertyUPP)NewRoutineDescriptor(
            (ProcPtr)(userRoutine), uppMovieExportGetPropertyProcInfo,
            GetCurrentArchitecture());
    }
#else
#define NewMovieExportGetPropertyUPP(userRoutine)                  \
    (MovieExportGetPropertyUPP) NewRoutineDescriptor(              \
        (ProcPtr)(userRoutine), uppMovieExportGetPropertyProcInfo, \
        GetCurrentArchitecture())
#endif
#endif
 
    void
    DisposeSCModalFilterUPP(SCModalFilterUPP userUPP);
#if !OPAQUE_UPP_TYPES
#ifdef __cplusplus
    inline void DisposeSCModalFilterUPP(SCModalFilterUPP userUPP)
    {
        DisposeRoutineDescriptor((UniversalProcPtr)userUPP);
    }
#else
#define DisposeSCModalFilterUPP(userUPP) DisposeRoutineDescriptor(userUPP)
#endif
#endif
 
    void
    DisposeSCModalHookUPP(SCModalHookUPP userUPP);
#if !OPAQUE_UPP_TYPES
#ifdef __cplusplus
    inline void DisposeSCModalHookUPP(SCModalHookUPP userUPP)
    {
        DisposeRoutineDescriptor((UniversalProcPtr)userUPP);
    }
#else
#define DisposeSCModalHookUPP(userUPP) DisposeRoutineDescriptor(userUPP)
#endif
#endif
 
    void
    DisposeMovieExportGetDataUPP(MovieExportGetDataUPP userUPP);
#if !OPAQUE_UPP_TYPES
#ifdef __cplusplus
    inline void DisposeMovieExportGetDataUPP(MovieExportGetDataUPP userUPP)
    {
        DisposeRoutineDescriptor((UniversalProcPtr)userUPP);
    }
#else
#define DisposeMovieExportGetDataUPP(userUPP) DisposeRoutineDescriptor(userUPP)
#endif
#endif
 
    void
    DisposeMovieExportGetPropertyUPP(MovieExportGetPropertyUPP userUPP);
#if !OPAQUE_UPP_TYPES
#ifdef __cplusplus
    inline void
    DisposeMovieExportGetPropertyUPP(MovieExportGetPropertyUPP userUPP)
    {
        DisposeRoutineDescriptor((UniversalProcPtr)userUPP);
    }
#else
#define DisposeMovieExportGetPropertyUPP(userUPP) \
    DisposeRoutineDescriptor(userUPP)
#endif
#endif
 
    Boolean
    InvokeSCModalFilterUPP(DialogRef theDialog, EventRecord *theEvent,
                           short *itemHit, long refcon, SCModalFilterUPP userUPP);
#if !OPAQUE_UPP_TYPES
#ifdef __cplusplus
    inline Boolean InvokeSCModalFilterUPP(DialogRef theDialog,
                                          EventRecord *theEvent, short *itemHit,
                                          long refcon, SCModalFilterUPP userUPP)
    {
        return (Boolean)CALL_FOUR_PARAMETER_UPP(userUPP, uppSCModalFilterProcInfo,
                                                theDialog, theEvent, itemHit, refcon);
    }
#else
#define InvokeSCModalFilterUPP(theDialog, theEvent, itemHit, refcon, userUPP) \
    (Boolean)                                                                 \
        CALL_FOUR_PARAMETER_UPP((userUPP), uppSCModalFilterProcInfo,          \
                                (theDialog), (theEvent), (itemHit), (refcon))
#endif
#endif
 
    short
    InvokeSCModalHookUPP(DialogRef theDialog, short itemHit, void *params,
                         long refcon, SCModalHookUPP userUPP);
#if !OPAQUE_UPP_TYPES
#ifdef __cplusplus
    inline short InvokeSCModalHookUPP(DialogRef theDialog, short itemHit,
                                      void *params, long refcon,
                                      SCModalHookUPP userUPP)
    {
        return (short)CALL_FOUR_PARAMETER_UPP(userUPP, uppSCModalHookProcInfo,
                                              theDialog, itemHit, params, refcon);
    }
#else
#define InvokeSCModalHookUPP(theDialog, itemHit, params, refcon, userUPP) \
    (short)CALL_FOUR_PARAMETER_UPP((userUPP), uppSCModalHookProcInfo,     \
                                   (theDialog), (itemHit), (params), (refcon))
#endif
#endif
 
    OSErr
    InvokeMovieExportGetDataUPP(void *refCon, MovieExportGetDataParams *params,
                                MovieExportGetDataUPP userUPP);
#if !OPAQUE_UPP_TYPES
#ifdef __cplusplus
    inline OSErr InvokeMovieExportGetDataUPP(void *refCon,
                                             MovieExportGetDataParams *params,
                                             MovieExportGetDataUPP userUPP)
    {
        return (OSErr)CALL_TWO_PARAMETER_UPP(userUPP, uppMovieExportGetDataProcInfo,
                                             refCon, params);
    }
#else
#define InvokeMovieExportGetDataUPP(refCon, params, userUPP)                 \
    (OSErr) CALL_TWO_PARAMETER_UPP((userUPP), uppMovieExportGetDataProcInfo, \
                                   (refCon), (params))
#endif
#endif
 
    OSErr
    InvokeMovieExportGetPropertyUPP(void *refcon, long trackID, OSType propertyType,
                                    void *propertyValue,
                                    MovieExportGetPropertyUPP userUPP);
#if !OPAQUE_UPP_TYPES
#ifdef __cplusplus
    inline OSErr
    InvokeMovieExportGetPropertyUPP(void *refcon, long trackID, OSType propertyType,
                                    void *propertyValue,
                                    MovieExportGetPropertyUPP userUPP)
    {
        return (OSErr)CALL_FOUR_PARAMETER_UPP(
            userUPP, uppMovieExportGetPropertyProcInfo, refcon, trackID, propertyType,
            propertyValue);
    }
#else
#define InvokeMovieExportGetPropertyUPP(refcon, trackID, propertyType,           \
                                        propertyValue, userUPP)                  \
    (OSErr) CALL_FOUR_PARAMETER_UPP((userUPP),                                   \
                                    uppMovieExportGetPropertyProcInfo, (refcon), \
                                    (trackID), (propertyType), (propertyValue))
#endif
#endif
 
#if CALL_NOT_IN_CARBON || OLDROUTINENAMES
#define NewSCModalFilterProc(userRoutine) NewSCModalFilterUPP(userRoutine)
#define NewSCModalHookProc(userRoutine) NewSCModalHookUPP(userRoutine)
#define NewMovieExportGetDataProc(userRoutine) \
    NewMovieExportGetDataUPP(userRoutine)
#define NewMovieExportGetPropertyProc(userRoutine) \
    NewMovieExportGetPropertyUPP(userRoutine)
#define CallSCModalFilterProc(userRoutine, theDialog, theEvent, itemHit, \
                              refcon)                                    \
    InvokeSCModalFilterUPP(theDialog, theEvent, itemHit, refcon, userRoutine)
#define CallSCModalHookProc(userRoutine, theDialog, itemHit, params, refcon) \
    InvokeSCModalHookUPP(theDialog, itemHit, params, refcon, userRoutine)
#define CallMovieExportGetDataProc(userRoutine, refCon, params) \
    InvokeMovieExportGetDataUPP(refCon, params, userRoutine)
#define CallMovieExportGetPropertyProc(userRoutine, refcon, trackID, \
                                       propertyType, propertyValue)  \
    InvokeMovieExportGetPropertyUPP(refcon, trackID, propertyType,   \
                                    propertyValue, userRoutine)
#endif 
    ComponentResult
    MovieImportHandle(MovieImportComponent ci, Handle dataH, Movie theMovie,
                      Track targetTrack, Track *usedTrack, TimeValue atTime,
                      TimeValue *addedDuration, long inFlags, long *outFlags);
 
    ComponentResult
    MovieImportFile(MovieImportComponent ci, const FSSpec *theFile, Movie theMovie,
                    Track targetTrack, Track *usedTrack, TimeValue atTime,
                    TimeValue *addedDuration, long inFlags, long *outFlags);
 
    ComponentResult
    MovieImportSetSampleDuration(MovieImportComponent ci, TimeValue duration,
                                 TimeScale scale);
 
    ComponentResult
    MovieImportSetSampleDescription(MovieImportComponent ci,
                                    SampleDescriptionHandle desc, OSType mediaType);
 
    ComponentResult
    MovieImportSetMediaFile(MovieImportComponent ci, AliasHandle alias);
 
    ComponentResult
    MovieImportSetDimensions(MovieImportComponent ci, Fixed width, Fixed height);
 
    ComponentResult
    MovieImportSetChunkSize(MovieImportComponent ci, long chunkSize);
 
    ComponentResult
    MovieImportSetProgressProc(MovieImportComponent ci, MovieProgressUPP proc,
                               long refcon);
 
    ComponentResult
    MovieImportSetAuxiliaryData(MovieImportComponent ci, Handle data,
                                OSType handleType);
 
    ComponentResult
    MovieImportSetFromScrap(MovieImportComponent ci, Boolean fromScrap);
 
    ComponentResult
    MovieImportDoUserDialog(MovieImportComponent ci, const FSSpec *theFile,
                            Handle theData, Boolean *canceled);
 
    ComponentResult
    MovieImportSetDuration(MovieImportComponent ci, TimeValue duration);
 
    ComponentResult
    MovieImportGetAuxiliaryDataType(MovieImportComponent ci, OSType *auxType);
 
    ComponentResult
    MovieImportValidate(MovieImportComponent ci, const FSSpec *theFile,
                        Handle theData, Boolean *valid);
 
    ComponentResult
    MovieImportGetFileType(MovieImportComponent ci, OSType *fileType);
 
    ComponentResult
    MovieImportDataRef(MovieImportComponent ci, Handle dataRef, OSType dataRefType,
                       Movie theMovie, Track targetTrack, Track *usedTrack,
                       TimeValue atTime, TimeValue *addedDuration, long inFlags,
                       long *outFlags);
 
    ComponentResult
    MovieImportGetSampleDescription(MovieImportComponent ci,
                                    SampleDescriptionHandle *desc,
                                    OSType *mediaType);
 
    ComponentResult
    MovieImportGetMIMETypeList(MovieImportComponent ci, QTAtomContainer *mimeInfo);
 
    ComponentResult
    MovieImportSetOffsetAndLimit(MovieImportComponent ci, unsigned long offset,
                                 unsigned long limit);
 
    ComponentResult
    MovieImportGetSettingsAsAtomContainer(MovieImportComponent ci,
                                          QTAtomContainer *settings);
 
    ComponentResult
    MovieImportSetSettingsFromAtomContainer(MovieImportComponent ci,
                                            QTAtomContainer settings);
 
    ComponentResult
    MovieImportSetOffsetAndLimit64(MovieImportComponent ci, const wide *offset,
                                   const wide *limit);
 
    ComponentResult
    MovieImportIdle(MovieImportComponent ci, long inFlags, long *outFlags);
 
    ComponentResult
    MovieImportValidateDataRef(MovieImportComponent ci, Handle dataRef,
                               OSType dataRefType, UInt8 *valid);
 
    ComponentResult
    MovieImportGetLoadState(MovieImportComponent ci, long *importerLoadState);
 
    ComponentResult
    MovieImportGetMaxLoadedTime(MovieImportComponent ci, TimeValue *time);
 
    ComponentResult
    MovieImportEstimateCompletionTime(MovieImportComponent ci, TimeRecord *time);
 
    ComponentResult
    MovieImportSetDontBlock(MovieImportComponent ci, Boolean dontBlock);
 
    ComponentResult
    MovieImportGetDontBlock(MovieImportComponent ci, Boolean *willBlock);
 
    ComponentResult
    MovieExportToHandle(MovieExportComponent ci, Handle dataH, Movie theMovie,
                        Track onlyThisTrack, TimeValue startTime,
                        TimeValue duration);
 
    ComponentResult
    MovieExportToFile(MovieExportComponent ci, const FSSpec *theFile,
                      Movie theMovie, Track onlyThisTrack, TimeValue startTime,
                      TimeValue duration);
 
    ComponentResult
    MovieExportGetAuxiliaryData(MovieExportComponent ci, Handle dataH,
                                OSType *handleType);
 
    ComponentResult
    MovieExportSetProgressProc(MovieExportComponent ci, MovieProgressUPP proc,
                               long refcon);
 
    ComponentResult
    MovieExportSetSampleDescription(MovieExportComponent ci,
                                    SampleDescriptionHandle desc, OSType mediaType);
 
    ComponentResult
    MovieExportDoUserDialog(MovieExportComponent ci, Movie theMovie,
                            Track onlyThisTrack, TimeValue startTime,
                            TimeValue duration, Boolean *canceled);
 
    ComponentResult
    MovieExportGetCreatorType(MovieExportComponent ci, OSType *creator);
 
    ComponentResult
    MovieExportToDataRef(MovieExportComponent ci, Handle dataRef,
                         OSType dataRefType, Movie theMovie, Track onlyThisTrack,
                         TimeValue startTime, TimeValue duration);
 
    ComponentResult
    MovieExportFromProceduresToDataRef(MovieExportComponent ci, Handle dataRef,
                                       OSType dataRefType);
 
    ComponentResult
    MovieExportAddDataSource(MovieExportComponent ci, OSType trackType,
                             TimeScale scale, long *trackID,
                             MovieExportGetPropertyUPP getPropertyProc,
                             MovieExportGetDataUPP getDataProc, void *refCon);
 
    ComponentResult
    MovieExportValidate(MovieExportComponent ci, Movie theMovie,
                        Track onlyThisTrack, Boolean *valid);
 
    ComponentResult
    MovieExportGetSettingsAsAtomContainer(MovieExportComponent ci,
                                          QTAtomContainer *settings);
 
    ComponentResult
    MovieExportSetSettingsFromAtomContainer(MovieExportComponent ci,
                                            QTAtomContainer settings);
 
    ComponentResult
    MovieExportGetFileNameExtension(MovieExportComponent ci, OSType *extension);
 
    ComponentResult
    MovieExportGetShortFileTypeString(MovieExportComponent ci, Str255 typeString);
 
    ComponentResult
    MovieExportGetSourceMediaType(MovieExportComponent ci, OSType *mediaType);
 
    ComponentResult
    MovieExportSetGetMoviePropertyProc(MovieExportComponent ci,
                                       MovieExportGetPropertyUPP getPropertyProc,
                                       void *refCon);
 
    struct TextDisplayData
    {
        long displayFlags;
        long textJustification;
        RGBColor bgColor;
        Rect textBox;
 
        short beginHilite;
        short endHilite;
        RGBColor hiliteColor;
        Boolean doHiliteColor;
        SInt8 filler;
        TimeValue scrollDelayDur;
        Point dropShadowOffset;
        short dropShadowTransparency;
    };
    typedef struct TextDisplayData TextDisplayData;
 
    typedef ComponentInstance TextExportComponent;
    typedef ComponentInstance GraphicImageMovieImportComponent;
    ComponentResult
    TextExportGetDisplayData(TextExportComponent ci, TextDisplayData *textDisplay);
 
    ComponentResult
    TextExportGetTimeFraction(TextExportComponent ci, long *movieTimeFraction);
 
    ComponentResult
    TextExportSetTimeFraction(TextExportComponent ci, long movieTimeFraction);
 
    ComponentResult
    TextExportGetSettings(TextExportComponent ci, long *setting);
 
    ComponentResult
    TextExportSetSettings(TextExportComponent ci, long setting);
 
    ComponentResult
    MIDIImportGetSettings(TextExportComponent ci, long *setting);
 
    ComponentResult
    MIDIImportSetSettings(TextExportComponent ci, long setting);
 
    ComponentResult
    MovieExportNewGetDataAndPropertiesProcs(
        MovieExportComponent ci, OSType trackType, TimeScale *scale, Movie theMovie,
        Track theTrack, TimeValue startTime, TimeValue duration,
        MovieExportGetPropertyUPP *getPropertyProc,
        MovieExportGetDataUPP *getDataProc, void **refCon);
 
    ComponentResult
    MovieExportDisposeGetDataAndPropertiesProcs(
        MovieExportComponent ci, MovieExportGetPropertyUPP getPropertyProc,
        MovieExportGetDataUPP getDataProc, void *refCon);
 
    enum
    {
        movieExportUseConfiguredSettings =
            FOUR_CHAR_CODE('ucfg'),                   
        movieExportWidth = FOUR_CHAR_CODE('wdth'),    
        movieExportHeight = FOUR_CHAR_CODE('hegt'),   
        movieExportDuration = FOUR_CHAR_CODE('dura'), 
        movieExportVideoFilter =
            FOUR_CHAR_CODE('iflt'),                   
        movieExportTimeScale = FOUR_CHAR_CODE('tmsc') 
    };
 
    ComponentResult
    GraphicsImageImportSetSequenceEnabled(GraphicImageMovieImportComponent ci,
                                          Boolean enable);
 
    ComponentResult
    GraphicsImageImportGetSequenceEnabled(GraphicImageMovieImportComponent ci,
                                          Boolean *enable);
 
    /****************
 
        File Preview Components
 
    ***************/
    typedef ComponentInstance pnotComponent;
    enum
    {
        pnotComponentWantsEvents = 1,
        pnotComponentNeedsNoCache = 2
    };
 
    enum
    {
        ShowFilePreviewComponentType = FOUR_CHAR_CODE('pnot'),
        CreateFilePreviewComponentType = FOUR_CHAR_CODE('pmak')
    };
 
    ComponentResult
    PreviewShowData(pnotComponent p, OSType dataType, Handle data,
                    const Rect *inHere);
 
    ComponentResult
    PreviewMakePreview(pnotComponent p, OSType *previewType, Handle *previewResult,
                       const FSSpec *sourceFile, ICMProgressProcRecordPtr progress);
 
    ComponentResult
    PreviewMakePreviewReference(pnotComponent p, OSType *previewType, short *resID,
                                const FSSpec *sourceFile);
 
    ComponentResult
    PreviewEvent(pnotComponent p, EventRecord *e, Boolean *handledEvent);
 
    typedef ComponentInstance DataCompressorComponent;
    typedef ComponentInstance DataDecompressorComponent;
    typedef ComponentInstance DataCodecComponent;
    enum
    {
        DataCompressorComponentType = FOUR_CHAR_CODE('dcom'),
        DataDecompressorComponentType = FOUR_CHAR_CODE('ddec'),
        AppleDataCompressorSubType = FOUR_CHAR_CODE('adec'),
        zlibDataCompressorSubType = FOUR_CHAR_CODE('zlib')
    };
 
    /*** These are DataCodec procedures **/
    ComponentResult
    DataCodecDecompress(DataCodecComponent dc, void *srcData, UInt32 srcSize,
                        void *dstData, UInt32 dstBufferSize);
 
    ComponentResult
    DataCodecGetCompressBufferSize(DataCodecComponent dc, UInt32 srcSize,
                                   UInt32 *dstSize);
 
    ComponentResult
    DataCodecCompress(DataCodecComponent dc, void *srcData, UInt32 srcSize,
                      void *dstData, UInt32 dstBufferSize, UInt32 *actualDstSize,
                      UInt32 *decompressSlop);
 
    ComponentResult
    DataCodecBeginInterruptSafe(DataCodecComponent dc, unsigned long maxSrcSize);
 
    ComponentResult
    DataCodecEndInterruptSafe(DataCodecComponent dc);
 
    ComponentResult
    DataCodecDecompressPartial(DataCodecComponent dc, void **next_in,
                               unsigned long *avail_in, unsigned long *total_in,
                               void **next_out, unsigned long *avail_out,
                               unsigned long *total_out, Boolean *didFinish);
 
    ComponentResult
    DataCodecCompressPartial(DataCodecComponent dc, void **next_in,
                             unsigned long *avail_in, unsigned long *total_in,
                             void **next_out, unsigned long *avail_out,
                             unsigned long *total_out, Boolean tryToFinish,
                             Boolean *didFinish);
 
    typedef CALLBACK_API(void, DataHCompletionProcPtr)(Ptr request, long refcon,
                                                       OSErr err);
    typedef STACK_UPP_TYPE(DataHCompletionProcPtr) DataHCompletionUPP;
 
    enum
    {
        kDataHCanRead = 1L << 0,
        kDataHSpecialRead = 1L << 1,
        kDataHSpecialReadFile = 1L << 2,
        kDataHCanWrite = 1L << 3,
        kDataHSpecialWrite = 1 << 4,
        kDataHSpecialWriteFile = 1 << 5,
        kDataHCanStreamingWrite = 1 << 6,
        kDataHMustCheckDataRef = 1 << 7
    };
 
    struct HandleDataRefRecord
    {
        Handle dataHndl;
    };
    typedef struct HandleDataRefRecord HandleDataRefRecord;
    typedef HandleDataRefRecord *HandleDataRefPtr;
    typedef HandleDataRefPtr *HandleDataRef;
    struct PointerDataRefRecord
    {
        void *data;
        Size dataLength;
    };
    typedef struct PointerDataRefRecord PointerDataRefRecord;
    typedef PointerDataRefRecord *PointerDataRefPtr;
    typedef PointerDataRefPtr *PointerDataRef;
    enum
    {
        kDataRefExtensionChokeSpeed = FOUR_CHAR_CODE('chok'),
        kDataRefExtensionFileName = FOUR_CHAR_CODE('fnam'),
        kDataRefExtensionMIMEType = FOUR_CHAR_CODE('mime'),
        kDataRefExtensionMacOSFileType = FOUR_CHAR_CODE('ftyp'),
        kDataRefExtensionInitializationData = FOUR_CHAR_CODE('data')
    };
 
    enum
    {
        kDataHChokeToMovieDataRate = 1 << 0, 
        kDataHChokeToParam = 1 << 1          
    };
 
    struct DataHChokeAtomRecord
    {
        long flags; 
        long param;
    };
    typedef struct DataHChokeAtomRecord DataHChokeAtomRecord;
 
    struct DataHVolumeListRecord
    {
        short vRefNum;
        long flags;
    };
    typedef struct DataHVolumeListRecord DataHVolumeListRecord;
    typedef DataHVolumeListRecord *DataHVolumeListPtr;
    typedef DataHVolumeListPtr *DataHVolumeList;
    enum
    {
        kDataHExtendedSchedule = FOUR_CHAR_CODE('xtnd')
    };
 
    struct DataHScheduleRecord
    {
        TimeRecord timeNeededBy;
        long extendedID;   
        long extendedVers; 
        Fixed priority;    
    };
    typedef struct DataHScheduleRecord DataHScheduleRecord;
    typedef DataHScheduleRecord *DataHSchedulePtr;
    enum
    {
        kDataHInfoFlagNeverStreams =
            1 << 0, 
        kDataHInfoFlagCanUpdateDataRefs =
            1 << 1, 
        kDataHInfoFlagNeedsNetworkBandwidth =
            1 << 2 
    };
 
    enum
    {
        kDataHFileTypeMacOSFileType = FOUR_CHAR_CODE('ftyp'),
        kDataHFileTypeExtension = FOUR_CHAR_CODE('fext'),
        kDataHFileTypeMIME = FOUR_CHAR_CODE('mime')
    };
 
    typedef OSType *DataHFileTypeOrderingPtr;
    typedef DataHFileTypeOrderingPtr *DataHFileTypeOrderingHandle;
 
    ComponentResult
    DataHGetData(DataHandler dh, Handle h, long hOffset, long offset, long size);
 
    ComponentResult
    DataHPutData(DataHandler dh, Handle h, long hOffset, long *offset, long size);
 
    ComponentResult
    DataHFlushData(DataHandler dh);
 
    ComponentResult
    DataHOpenForWrite(DataHandler dh);
 
    ComponentResult
    DataHCloseForWrite(DataHandler dh);
 
    ComponentResult
    DataHOpenForRead(DataHandler dh);
 
    ComponentResult
    DataHCloseForRead(DataHandler dh);
 
    ComponentResult
    DataHSetDataRef(DataHandler dh, Handle dataRef);
 
    ComponentResult
    DataHGetDataRef(DataHandler dh, Handle *dataRef);
 
    ComponentResult
    DataHCompareDataRef(DataHandler dh, Handle dataRef, Boolean *equal);
 
    ComponentResult
    DataHTask(DataHandler dh);
 
    ComponentResult
    DataHScheduleData(DataHandler dh, Ptr PlaceToPutDataPtr, long FileOffset,
                      long DataSize, long RefCon, DataHSchedulePtr scheduleRec,
                      DataHCompletionUPP CompletionRtn);
 
    ComponentResult
    DataHFinishData(DataHandler dh, Ptr PlaceToPutDataPtr, Boolean Cancel);
 
    ComponentResult
    DataHFlushCache(DataHandler dh);
 
    ComponentResult
    DataHResolveDataRef(DataHandler dh, Handle theDataRef, Boolean *wasChanged,
                        Boolean userInterfaceAllowed);
 
    ComponentResult
    DataHGetFileSize(DataHandler dh, long *fileSize);
 
    ComponentResult
    DataHCanUseDataRef(DataHandler dh, Handle dataRef, long *useFlags);
 
    ComponentResult
    DataHGetVolumeList(DataHandler dh, DataHVolumeList *volumeList);
 
    ComponentResult
    DataHWrite(DataHandler dh, Ptr data, long offset, long size,
               DataHCompletionUPP completion, long refCon);
 
    ComponentResult
    DataHPreextend(DataHandler dh, unsigned long maxToAdd,
                   unsigned long *spaceAdded);
 
    ComponentResult
    DataHSetFileSize(DataHandler dh, long fileSize);
 
    ComponentResult
    DataHGetFreeSpace(DataHandler dh, unsigned long *freeSize);
 
    ComponentResult
    DataHCreateFile(DataHandler dh, OSType creator, Boolean deleteExisting);
 
    ComponentResult
    DataHGetPreferredBlockSize(DataHandler dh, long *blockSize);
 
    ComponentResult
    DataHGetDeviceIndex(DataHandler dh, long *deviceIndex);
 
    ComponentResult
    DataHIsStreamingDataHandler(DataHandler dh, Boolean *yes);
 
    ComponentResult
    DataHGetDataInBuffer(DataHandler dh, long startOffset, long *size);
 
    ComponentResult
    DataHGetScheduleAheadTime(DataHandler dh, long *millisecs);
 
    ComponentResult
    DataHSetCacheSizeLimit(DataHandler dh, Size cacheSizeLimit);
 
    ComponentResult
    DataHGetCacheSizeLimit(DataHandler dh, Size *cacheSizeLimit);
 
    ComponentResult
    DataHGetMovie(DataHandler dh, Movie *theMovie, short *id);
 
    ComponentResult
    DataHAddMovie(DataHandler dh, Movie theMovie, short *id);
 
    ComponentResult
    DataHUpdateMovie(DataHandler dh, Movie theMovie, short id);
 
    ComponentResult
    DataHDoesBuffer(DataHandler dh, Boolean *buffersReads, Boolean *buffersWrites);
 
    ComponentResult
    DataHGetFileName(DataHandler dh, Str255 str);
 
    ComponentResult
    DataHGetAvailableFileSize(DataHandler dh, long *fileSize);
 
    ComponentResult
    DataHGetMacOSFileType(DataHandler dh, OSType *fileType);
 
    ComponentResult
    DataHGetMIMEType(DataHandler dh, Str255 mimeType);
 
    ComponentResult
    DataHSetDataRefWithAnchor(DataHandler dh, Handle anchorDataRef,
                              OSType dataRefType, Handle dataRef);
 
    ComponentResult
    DataHGetDataRefWithAnchor(DataHandler dh, Handle anchorDataRef,
                              OSType dataRefType, Handle *dataRef);
 
    ComponentResult
    DataHSetMacOSFileType(DataHandler dh, OSType fileType);
 
    ComponentResult
    DataHSetTimeBase(DataHandler dh, TimeBase tb);
 
    ComponentResult
    DataHGetInfoFlags(DataHandler dh, UInt32 *flags);
 
    ComponentResult
    DataHScheduleData64(DataHandler dh, Ptr PlaceToPutDataPtr,
                        const wide *FileOffset, long DataSize, long RefCon,
                        DataHSchedulePtr scheduleRec,
                        DataHCompletionUPP CompletionRtn);
 
    ComponentResult
    DataHWrite64(DataHandler dh, Ptr data, const wide *offset, long size,
                 DataHCompletionUPP completion, long refCon);
 
    ComponentResult
    DataHGetFileSize64(DataHandler dh, wide *fileSize);
 
    ComponentResult
    DataHPreextend64(DataHandler dh, const wide *maxToAdd, wide *spaceAdded);
 
    ComponentResult
    DataHSetFileSize64(DataHandler dh, const wide *fileSize);
 
    ComponentResult
    DataHGetFreeSpace64(DataHandler dh, wide *freeSize);
 
    ComponentResult
    DataHAppend64(DataHandler dh, void *data, wide *fileOffset, unsigned long size);
 
    ComponentResult
    DataHReadAsync(DataHandler dh, void *dataPtr, UInt32 dataSize,
                   const wide *dataOffset, DataHCompletionUPP completion,
                   long refCon);
 
    ComponentResult
    DataHPollRead(DataHandler dh, void *dataPtr, UInt32 *dataSizeSoFar);
 
    ComponentResult
    DataHGetDataAvailability(DataHandler dh, long offset, long len,
                             long *missing_offset, long *missing_len);
 
    ComponentResult
    DataHGetFileSizeAsync(DataHandler dh, wide *fileSize,
                          DataHCompletionUPP completionRtn, long refCon);
 
    ComponentResult
    DataHGetDataRefAsType(DataHandler dh, OSType requestedType, Handle *dataRef);
 
    ComponentResult
    DataHSetDataRefExtension(DataHandler dh, Handle extension, OSType idType);
 
    ComponentResult
    DataHGetDataRefExtension(DataHandler dh, Handle *extension, OSType idType);
 
    ComponentResult
    DataHGetMovieWithFlags(DataHandler dh, Movie *theMovie, short *id, short flags);
 
    ComponentResult
    DataHGetFileTypeOrdering(DataHandler dh,
                             DataHFileTypeOrderingHandle *orderingListHandle);
 
    enum
    {
        kDataHCreateFileButDontCreateResFile = (1L << 0)
    };
 
    ComponentResult
    DataHCreateFileWithFlags(DataHandler dh, OSType creator, Boolean deleteExisting,
                             UInt32 flags);
 
    ComponentResult
    DataHGetMIMETypeAsync(DataHandler dh, Str255 mimeType,
                          DataHCompletionUPP completionRtn, long refCon);
 
    ComponentResult
    DataHGetInfo(DataHandler dh, OSType what, void *info);
 
    ComponentResult
    DataHPlaybackHints(DataHandler dh, long flags, unsigned long minFileOffset,
                       unsigned long maxFileOffset, long bytesPerSecond);
 
    ComponentResult
    DataHPlaybackHints64(DataHandler dh, long flags, const wide *minFileOffset,
                         const wide *maxFileOffset, long bytesPerSecond);
 
    enum
    {
        kDataHGetDataRateInfiniteRate =
            0x7FFFFFFF 
    };
 
    ComponentResult
    DataHGetDataRate(DataHandler dh, long flags, long *bytesPerSecond);
 
    enum
    {
        kDataHSetTimeHintsSkipBandwidthRequest =
            1 << 0 
    };
 
    ComponentResult
    DataHSetTimeHints(DataHandler dh, long flags, long bandwidthPriority,
                      TimeScale scale, TimeValue minTime, TimeValue maxTime);
 
    enum
    {
        videoDigitizerComponentType = FOUR_CHAR_CODE('vdig'),
        vdigInterfaceRev = 2
    };
 
    enum
    {
        ntscIn = 0,      
        currentIn = 0,   
        palIn = 1,       
        secamIn = 2,     
        ntscReallyIn = 3 
    };
 
    enum
    {
        compositeIn = 0,        
        sVideoIn = 1,           
        rgbComponentIn = 2,     
        rgbComponentSyncIn = 3, 
        yuvComponentIn = 4,     
        yuvComponentSyncIn = 5, 
        tvTunerIn = 6,
        sdiIn = 7
    };
 
    enum
    {
        vdPlayThruOff = 0,
        vdPlayThruOn = 1
    };
 
    enum
    {
        vdDigitizerBW = 0, 
        vdDigitizerRGB = 1 
    };
 
    enum
    {
        vdBroadcastMode = 0, 
        vdVTRMode = 1        
    };
 
    enum
    {
        vdUseAnyField = 0, 
        vdUseOddField = 1, 
        vdUseEvenField = 2 
    };
 
    enum
    {
        vdTypeBasic = 0, 
        vdTypeAlpha = 1, 
        vdTypeMask = 2,  
        vdTypeKey = 3    
    };
 
    enum
    {
        digiInDoesNTSC = 1L << 0,      
        digiInDoesPAL = 1L << 1,       
        digiInDoesSECAM = 1L << 2,     
        digiInDoesGenLock = 1L << 7,   
        digiInDoesComposite = 1L << 8, 
        digiInDoesSVideo = 1L << 9,    
        digiInDoesComponent =
            1L << 10, 
        digiInVTR_Broadcast =
            1L << 11,               
        digiInDoesColor = 1L << 12, 
        digiInDoesBW = 1L << 13,    
        digiInSignalLock = 1L << 31 
    };
 
    enum
    {
        digiOutDoes1 = 1L << 0,       
        digiOutDoes2 = 1L << 1,       
        digiOutDoes4 = 1L << 2,       
        digiOutDoes8 = 1L << 3,       
        digiOutDoes16 = 1L << 4,      
        digiOutDoes32 = 1L << 5,      
        digiOutDoesDither = 1L << 6,  
        digiOutDoesStretch = 1L << 7, 
        digiOutDoesShrink = 1L << 8,  
        digiOutDoesMask = 1L << 9,    
        digiOutDoesDouble =
            1L << 11, 
        digiOutDoesQuad =
            1L << 12, 
        digiOutDoesQuarter =
            1L << 13, 
        digiOutDoesSixteenth =
            1L << 14,                 
        digiOutDoesRotate = 1L << 15, 
        digiOutDoesHorizFlip =
            1L << 16, 
        digiOutDoesVertFlip =
            1L << 17,               
        digiOutDoesSkew = 1L << 18, 
        digiOutDoesBlend = 1L << 19,
        digiOutDoesWarp = 1L << 20,
        digiOutDoesHW_DMA = 1L << 21, 
        digiOutDoesHWPlayThru = 1L
                                << 22,    
        digiOutDoesILUT = 1L << 23,       
        digiOutDoesKeyColor = 1L << 24,   
        digiOutDoesAsyncGrabs = 1L << 25, 
        digiOutDoesUnreadableScreenBits =
            1L << 26,                       
        digiOutDoesCompress = 1L << 27,     
        digiOutDoesCompressOnly = 1L << 28, 
        digiOutDoesPlayThruDuringCompress =
            1L << 29, 
        digiOutDoesCompressPartiallyVisible =
            1L << 30, 
        digiOutDoesNotNeedCopyOfCompressData =
            1L << 31 
    };
 
    typedef ComponentInstance VideoDigitizerComponent;
    typedef ComponentResult VideoDigitizerError;
    struct DigitizerInfo
    {
        short vdigType;
        long inputCapabilityFlags;
        long outputCapabilityFlags;
        long inputCurrentFlags;
        long outputCurrentFlags;
        short slot;          
        GDHandle gdh;        
        GDHandle maskgdh;    
        short minDestHeight; 
        short minDestWidth;  
        short maxDestHeight; 
        short maxDestWidth;  
        short blendLevels;   
        long reserved;       
    };
    typedef struct DigitizerInfo DigitizerInfo;
    struct VdigType
    {
        long digType;
        long reserved;
    };
    typedef struct VdigType VdigType;
    struct VdigTypeList
    {
        short count;
        VdigType list[1];
    };
    typedef struct VdigTypeList VdigTypeList;
    struct VdigBufferRec
    {
        PixMapHandle dest;
        Point location;
        long reserved;
    };
    typedef struct VdigBufferRec VdigBufferRec;
    struct VdigBufferRecList
    {
        short count;
        MatrixRecordPtr matrix;
        RgnHandle mask;
        VdigBufferRec list[1];
    };
    typedef struct VdigBufferRecList VdigBufferRecList;
    typedef VdigBufferRecList *VdigBufferRecListPtr;
    typedef VdigBufferRecListPtr *VdigBufferRecListHandle;
    typedef CALLBACK_API(void, VdigIntProcPtr)(long flags, long refcon);
    typedef STACK_UPP_TYPE(VdigIntProcPtr) VdigIntUPP;
    struct VDCompressionList
    {
        CodecComponent codec;
        CodecType cType;
        Str63 typeName;
        Str63 name;
        long formatFlags;
        long compressFlags;
        long reserved;
    };
    typedef struct VDCompressionList VDCompressionList;
    typedef VDCompressionList *VDCompressionListPtr;
    typedef VDCompressionListPtr *VDCompressionListHandle;
    enum
    {
        dmaDepth1 = 1,
        dmaDepth2 = 2,
        dmaDepth4 = 4,
        dmaDepth8 = 8,
        dmaDepth16 = 16,
        dmaDepth32 = 32,
        dmaDepth2Gray = 64,
        dmaDepth4Gray = 128,
        dmaDepth8Gray = 256
    };
 
    enum
    {
        kVDIGControlledFrameRate = -1
    };
 
    VideoDigitizerError
    VDGetMaxSrcRect(VideoDigitizerComponent ci, short inputStd, Rect *maxSrcRect);
 
    VideoDigitizerError
    VDGetActiveSrcRect(VideoDigitizerComponent ci, short inputStd,
                       Rect *activeSrcRect);
 
    VideoDigitizerError
    VDSetDigitizerRect(VideoDigitizerComponent ci, Rect *digitizerRect);
 
    VideoDigitizerError
    VDGetDigitizerRect(VideoDigitizerComponent ci, Rect *digitizerRect);
 
    VideoDigitizerError
    VDGetVBlankRect(VideoDigitizerComponent ci, short inputStd, Rect *vBlankRect);
 
    VideoDigitizerError
    VDGetMaskPixMap(VideoDigitizerComponent ci, PixMapHandle maskPixMap);
 
    VideoDigitizerError
    VDGetPlayThruDestination(VideoDigitizerComponent ci, PixMapHandle *dest,
                             Rect *destRect, MatrixRecord *m, RgnHandle *mask);
 
    VideoDigitizerError
    VDUseThisCLUT(VideoDigitizerComponent ci, CTabHandle colorTableHandle);
 
    VideoDigitizerError
    VDSetInputGammaValue(VideoDigitizerComponent ci, Fixed channel1, Fixed channel2,
                         Fixed channel3);
 
    VideoDigitizerError
    VDGetInputGammaValue(VideoDigitizerComponent ci, Fixed *channel1,
                         Fixed *channel2, Fixed *channel3);
 
    VideoDigitizerError
    VDSetBrightness(VideoDigitizerComponent ci, unsigned short *brightness);
 
    VideoDigitizerError
    VDGetBrightness(VideoDigitizerComponent ci, unsigned short *brightness);
 
    VideoDigitizerError
    VDSetContrast(VideoDigitizerComponent ci, unsigned short *contrast);
 
    VideoDigitizerError
    VDSetHue(VideoDigitizerComponent ci, unsigned short *hue);
 
    VideoDigitizerError
    VDSetSharpness(VideoDigitizerComponent ci, unsigned short *sharpness);
 
    VideoDigitizerError
    VDSetSaturation(VideoDigitizerComponent ci, unsigned short *saturation);
 
    VideoDigitizerError
    VDGetContrast(VideoDigitizerComponent ci, unsigned short *contrast);
 
    VideoDigitizerError
    VDGetHue(VideoDigitizerComponent ci, unsigned short *hue);
 
    VideoDigitizerError
    VDGetSharpness(VideoDigitizerComponent ci, unsigned short *sharpness);
 
    VideoDigitizerError
    VDGetSaturation(VideoDigitizerComponent ci, unsigned short *saturation);
 
    VideoDigitizerError
    VDGrabOneFrame(VideoDigitizerComponent ci);
 
    VideoDigitizerError
    VDGetMaxAuxBuffer(VideoDigitizerComponent ci, PixMapHandle *pm, Rect *r);
 
    VideoDigitizerError
    VDGetDigitizerInfo(VideoDigitizerComponent ci, DigitizerInfo *info);
 
    VideoDigitizerError
    VDGetCurrentFlags(VideoDigitizerComponent ci, long *inputCurrentFlag,
                      long *outputCurrentFlag);
 
    VideoDigitizerError
    VDSetKeyColor(VideoDigitizerComponent ci, long index);
 
    VideoDigitizerError
    VDGetKeyColor(VideoDigitizerComponent ci, long *index);
 
    VideoDigitizerError
    VDAddKeyColor(VideoDigitizerComponent ci, long *index);
 
    VideoDigitizerError
    VDGetNextKeyColor(VideoDigitizerComponent ci, long index);
 
    VideoDigitizerError
    VDSetKeyColorRange(VideoDigitizerComponent ci, RGBColor *minRGB,
                       RGBColor *maxRGB);
 
    VideoDigitizerError
    VDGetKeyColorRange(VideoDigitizerComponent ci, RGBColor *minRGB,
                       RGBColor *maxRGB);
 
    VideoDigitizerError
    VDSetDigitizerUserInterrupt(VideoDigitizerComponent ci, long flags,
                                VdigIntUPP userInterruptProc, long refcon);
 
    VideoDigitizerError
    VDSetInputColorSpaceMode(VideoDigitizerComponent ci, short colorSpaceMode);
 
    VideoDigitizerError
    VDGetInputColorSpaceMode(VideoDigitizerComponent ci, short *colorSpaceMode);
 
    VideoDigitizerError
    VDSetClipState(VideoDigitizerComponent ci, short clipEnable);
 
    VideoDigitizerError
    VDGetClipState(VideoDigitizerComponent ci, short *clipEnable);
 
    VideoDigitizerError
    VDSetClipRgn(VideoDigitizerComponent ci, RgnHandle clipRegion);
 
    VideoDigitizerError
    VDClearClipRgn(VideoDigitizerComponent ci, RgnHandle clipRegion);
 
    VideoDigitizerError
    VDGetCLUTInUse(VideoDigitizerComponent ci, CTabHandle *colorTableHandle);
 
    VideoDigitizerError
    VDSetPLLFilterType(VideoDigitizerComponent ci, short pllType);
 
    VideoDigitizerError
    VDGetPLLFilterType(VideoDigitizerComponent ci, short *pllType);
 
    VideoDigitizerError
    VDGetMaskandValue(VideoDigitizerComponent ci, unsigned short blendLevel,
                      long *mask, long *value);
 
    VideoDigitizerError
    VDSetMasterBlendLevel(VideoDigitizerComponent ci, unsigned short *blendLevel);
 
    VideoDigitizerError
    VDSetPlayThruDestination(VideoDigitizerComponent ci, PixMapHandle dest,
                             RectPtr destRect, MatrixRecordPtr m, RgnHandle mask);
 
    VideoDigitizerError
    VDSetPlayThruOnOff(VideoDigitizerComponent ci, short state);
 
    VideoDigitizerError
    VDSetFieldPreference(VideoDigitizerComponent ci, short fieldFlag);
 
    VideoDigitizerError
    VDGetFieldPreference(VideoDigitizerComponent ci, short *fieldFlag);
 
    VideoDigitizerError
    VDPreflightDestination(VideoDigitizerComponent ci, Rect *digitizerRect,
                           PixMap **dest, RectPtr destRect, MatrixRecordPtr m);
 
    VideoDigitizerError
    VDPreflightGlobalRect(VideoDigitizerComponent ci, GrafPtr theWindow,
                          Rect *globalRect);
 
    VideoDigitizerError
    VDSetPlayThruGlobalRect(VideoDigitizerComponent ci, GrafPtr theWindow,
                            Rect *globalRect);
 
    VideoDigitizerError
    VDSetInputGammaRecord(VideoDigitizerComponent ci, VDGamRecPtr inputGammaPtr);
 
    VideoDigitizerError
    VDGetInputGammaRecord(VideoDigitizerComponent ci, VDGamRecPtr *inputGammaPtr);
 
    VideoDigitizerError
    VDSetBlackLevelValue(VideoDigitizerComponent ci, unsigned short *blackLevel);
 
    VideoDigitizerError
    VDGetBlackLevelValue(VideoDigitizerComponent ci, unsigned short *blackLevel);
 
    VideoDigitizerError
    VDSetWhiteLevelValue(VideoDigitizerComponent ci, unsigned short *whiteLevel);
 
    VideoDigitizerError
    VDGetWhiteLevelValue(VideoDigitizerComponent ci, unsigned short *whiteLevel);
 
    VideoDigitizerError
    VDGetVideoDefaults(VideoDigitizerComponent ci, unsigned short *blackLevel,
                       unsigned short *whiteLevel, unsigned short *brightness,
                       unsigned short *hue, unsigned short *saturation,
                       unsigned short *contrast, unsigned short *sharpness);
 
    VideoDigitizerError
    VDGetNumberOfInputs(VideoDigitizerComponent ci, short *inputs);
 
    VideoDigitizerError
    VDGetInputFormat(VideoDigitizerComponent ci, short input, short *format);
 
    VideoDigitizerError
    VDSetInput(VideoDigitizerComponent ci, short input);
 
    VideoDigitizerError
    VDGetInput(VideoDigitizerComponent ci, short *input);
 
    VideoDigitizerError
    VDSetInputStandard(VideoDigitizerComponent ci, short inputStandard);
 
    VideoDigitizerError
    VDSetupBuffers(VideoDigitizerComponent ci, VdigBufferRecListHandle bufferList);
 
    VideoDigitizerError
    VDGrabOneFrameAsync(VideoDigitizerComponent ci, short buffer);
 
    VideoDigitizerError
    VDDone(VideoDigitizerComponent ci, short buffer);
 
    VideoDigitizerError
    VDSetCompression(VideoDigitizerComponent ci, OSType compressType, short depth,
                     Rect *bounds, CodecQ spatialQuality, CodecQ temporalQuality,
                     long keyFrameRate);
 
    VideoDigitizerError
    VDCompressOneFrameAsync(VideoDigitizerComponent ci);
 
    VideoDigitizerError
    VDCompressDone(VideoDigitizerComponent ci, Boolean *done, Ptr *theData,
                   long *dataSize, UInt8 *similarity, TimeRecord *t);
 
    VideoDigitizerError
    VDReleaseCompressBuffer(VideoDigitizerComponent ci, Ptr bufferAddr);
 
    VideoDigitizerError
    VDGetImageDescription(VideoDigitizerComponent ci, ImageDescriptionHandle desc);
 
    VideoDigitizerError
    VDResetCompressSequence(VideoDigitizerComponent ci);
 
    VideoDigitizerError
    VDSetCompressionOnOff(VideoDigitizerComponent ci, Boolean state);
 
    VideoDigitizerError
    VDGetCompressionTypes(VideoDigitizerComponent ci, VDCompressionListHandle h);
 
    VideoDigitizerError
    VDSetTimeBase(VideoDigitizerComponent ci, TimeBase t);
 
    VideoDigitizerError
    VDSetFrameRate(VideoDigitizerComponent ci, Fixed framesPerSecond);
 
    VideoDigitizerError
    VDGetDataRate(VideoDigitizerComponent ci, long *milliSecPerFrame,
                  Fixed *framesPerSecond, long *bytesPerSecond);
 
    VideoDigitizerError
    VDGetSoundInputDriver(VideoDigitizerComponent ci, Str255 soundDriverName);
 
    VideoDigitizerError
    VDGetDMADepths(VideoDigitizerComponent ci, long *depthArray,
                   long *preferredDepth);
 
    VideoDigitizerError
    VDGetPreferredTimeScale(VideoDigitizerComponent ci, TimeScale *preferred);
 
    VideoDigitizerError
    VDReleaseAsyncBuffers(VideoDigitizerComponent ci);
 
    VideoDigitizerError
    VDSetDataRate(VideoDigitizerComponent ci, long bytesPerSecond);
 
    VideoDigitizerError
    VDGetTimeCode(VideoDigitizerComponent ci, TimeRecord *atTime,
                  void *timeCodeFormat, void *timeCodeTime);
 
    VideoDigitizerError
    VDUseSafeBuffers(VideoDigitizerComponent ci, Boolean useSafeBuffers);
 
    VideoDigitizerError
    VDGetSoundInputSource(VideoDigitizerComponent ci, long videoInput,
                          long *soundInput);
 
    VideoDigitizerError
    VDGetCompressionTime(VideoDigitizerComponent ci, OSType compressionType,
                         short depth, Rect *srcRect, CodecQ *spatialQuality,
                         CodecQ *temporalQuality, unsigned long *compressTime);
 
    VideoDigitizerError
    VDSetPreferredPacketSize(VideoDigitizerComponent ci,
                             long preferredPacketSizeInBytes);
 
    VideoDigitizerError
    VDSetPreferredImageDimensions(VideoDigitizerComponent ci, long width,
                                  long height);
 
    VideoDigitizerError
    VDGetPreferredImageDimensions(VideoDigitizerComponent ci, long *width,
                                  long *height);
 
    VideoDigitizerError
    VDGetInputName(VideoDigitizerComponent ci, long videoInput, Str255 name);
 
    VideoDigitizerError
    VDSetDestinationPort(VideoDigitizerComponent ci, CGrafPtr destPort);
 
    enum
    {
        xmlParseComponentType = FOUR_CHAR_CODE('pars'),
        xmlParseComponentSubType = FOUR_CHAR_CODE('xml ')
    };
 
    enum
    {
        xmlIdentifierInvalid = 0,
        xmlIdentifierUnrecognized = (long)0xFFFFFFFF,
        xmlContentTypeInvalid = 0,
        xmlContentTypeElement = 1,
        xmlContentTypeCharData = 2
    };
 
    enum
    {
        elementFlagAlwaysSelfContained =
            1L << 0, 
        elementFlagPreserveWhiteSpace =
            1L << 1, 
        xmlParseFlagAllowUppercase =
            1L << 0, 
        xmlParseFlagAllowUnquotedAttributeValues =
            1L << 1,                         
        xmlParseFlagEventParseOnly = 1L << 2 
    };
 
    enum
    {
        attributeValueKindCharString = 0,
        attributeValueKindInteger = 1L << 0, 
        attributeValueKindPercent = 1L << 1, 
        attributeValueKindBoolean = 1L << 2, 
        attributeValueKindOnOff = 1L << 3,   
        attributeValueKindColor = 1L << 4,   
        attributeValueKindEnum =
            1L << 5, 
        attributeValueKindCaseSensEnum =
            1L
            << 6, 
        MAX_ATTRIBUTE_VALUE_KIND = attributeValueKindCaseSensEnum
    };
 
    enum
    {
        nameSpaceIDNone = 0
    };
 
    union XMLAttributeValue
    {
        SInt32 number;   
        Boolean boolean; 
        RGBColor color;  
        UInt32 enumType; 
    };
    typedef union XMLAttributeValue XMLAttributeValue;
    struct XMLAttribute
    {
        UInt32 identifier;       
        char *name;              
        long valueKind;          
        XMLAttributeValue value; 
        char *valueStr;          
    };
    typedef struct XMLAttribute XMLAttribute;
    typedef XMLAttribute *XMLAttributePtr;
    typedef struct XMLContent XMLContent;
    typedef XMLContent *XMLContentPtr;
    struct XMLElement
    {
        UInt32 identifier; 
        char *name;        
        XMLAttributePtr
            attributes;         
        XMLContentPtr contents; 
    };
    typedef struct XMLElement XMLElement;
    typedef XMLElement *XMLElementPtr;
    union XMLElementContent
    {
        XMLElement element; 
        char *charData;     
    };
    typedef union XMLElementContent XMLElementContent;
    struct XMLContent
    {
        UInt32 kind;
        XMLElementContent actualContent;
    };
 
    struct XMLDocRecord
    {
        void *xmlDataStorage; 
        XMLElement rootElement;
    };
    typedef struct XMLDocRecord XMLDocRecord;
    typedef XMLDocRecord *XMLDoc;
    typedef CALLBACK_API(ComponentResult, StartDocumentHandler)(long refcon);
    typedef CALLBACK_API(ComponentResult, EndDocumentHandler)(long refcon);
    typedef CALLBACK_API(ComponentResult, StartElementHandler)(const char *name,
                                                               const char **atts,
                                                               long refcon);
    typedef CALLBACK_API(ComponentResult, EndElementHandler)(const char *name,
                                                             long refcon);
    typedef CALLBACK_API(ComponentResult, CharDataHandler)(const char *charData,
                                                           long refcon);
    typedef CALLBACK_API(ComponentResult,
                         PreprocessInstructionHandler)(const char *name,
                                                       const char **atts,
                                                       long refcon);
    typedef CALLBACK_API(ComponentResult, CommentHandler)(const char *comment,
                                                          long refcon);
    typedef STACK_UPP_TYPE(StartDocumentHandler) StartDocumentHandlerUPP;
    typedef STACK_UPP_TYPE(EndDocumentHandler) EndDocumentHandlerUPP;
    typedef STACK_UPP_TYPE(StartElementHandler) StartElementHandlerUPP;
    typedef STACK_UPP_TYPE(EndElementHandler) EndElementHandlerUPP;
    typedef STACK_UPP_TYPE(CharDataHandler) CharDataHandlerUPP;
    typedef STACK_UPP_TYPE(PreprocessInstructionHandler)
        PreprocessInstructionHandlerUPP;
    typedef STACK_UPP_TYPE(CommentHandler) CommentHandlerUPP;
    ComponentResult
    XMLParseDataRef(ComponentInstance aParser, Handle dataRef, OSType dataRefType,
                    long parseFlags, XMLDoc *document);
 
    ComponentResult
    XMLParseFile(ComponentInstance aParser, ConstFSSpecPtr fileSpec,
                 long parseFlags, XMLDoc *document);
 
    ComponentResult
    XMLParseDisposeXMLDoc(ComponentInstance aParser, XMLDoc document);
 
    ComponentResult
    XMLParseGetDetailedParseError(ComponentInstance aParser, long *errorLine,
                                  StringPtr errDesc);
 
    ComponentResult
    XMLParseAddElement(ComponentInstance aParser, char *elementName,
                       UInt32 nameSpaceID, UInt32 *elementID, long elementFlags);
 
    ComponentResult
    XMLParseAddAttribute(ComponentInstance aParser, UInt32 elementID,
                         UInt32 nameSpaceID, char *attributeName,
                         UInt32 *attributeID);
 
    ComponentResult
    XMLParseAddMultipleAttributes(ComponentInstance aParser, UInt32 elementID,
                                  UInt32 *nameSpaceIDs, char *attributeNames,
                                  UInt32 *attributeIDs);
 
    ComponentResult
    XMLParseAddAttributeAndValue(ComponentInstance aParser, UInt32 elementID,
                                 UInt32 nameSpaceID, char *attributeName,
                                 UInt32 *attributeID, UInt32 attributeValueKind,
                                 void *attributeValueKindInfo);
 
    ComponentResult
    XMLParseAddMultipleAttributesAndValues(ComponentInstance aParser,
                                           UInt32 elementID, UInt32 *nameSpaceIDs,
                                           char *attributeNames,
                                           UInt32 *attributeIDs,
                                           UInt32 *attributeValueKinds,
                                           void **attributeValueKindInfos);
 
    ComponentResult
    XMLParseAddAttributeValueKind(ComponentInstance aParser, UInt32 elementID,
                                  UInt32 attributeID, UInt32 attributeValueKind,
                                  void *attributeValueKindInfo);
 
    ComponentResult
    XMLParseAddNameSpace(ComponentInstance aParser, char *nameSpaceURL,
                         UInt32 *nameSpaceID);
 
    ComponentResult
    XMLParseSetOffsetAndLimit(ComponentInstance aParser, UInt32 offset,
                              UInt32 limit);
 
    ComponentResult
    XMLParseSetEventParseRefCon(ComponentInstance aParser, long refcon);
 
    ComponentResult
    XMLParseSetStartDocumentHandler(ComponentInstance aParser,
                                    StartDocumentHandlerUPP startDocument);
 
    ComponentResult
    XMLParseSetEndDocumentHandler(ComponentInstance aParser,
                                  EndDocumentHandlerUPP endDocument);
 
    ComponentResult
    XMLParseSetStartElementHandler(ComponentInstance aParser,
                                   StartElementHandlerUPP startElement);
 
    ComponentResult
    XMLParseSetEndElementHandler(ComponentInstance aParser,
                                 EndElementHandlerUPP endElement);
 
    ComponentResult
    XMLParseSetCharDataHandler(ComponentInstance aParser,
                               CharDataHandlerUPP charData);
 
    ComponentResult
    XMLParseSetPreprocessInstructionHandler(
        ComponentInstance aParser,
        PreprocessInstructionHandlerUPP preprocessInstruction);
 
    ComponentResult
    XMLParseSetCommentHandler(ComponentInstance aParser, CommentHandlerUPP comment);
 
#define xmlpc_GLUE(a, b) a##b
#define xmlpc_GLUE2(a, b) xmlpc_GLUE(a, b)
#define XML_ADD_ELEMENT_NS(elementName, nameSpaceID) \
    elementID = xmlpc_GLUE2(element_, elementName);  \
    XMLParseAddElement(xmlParser, #elementName, nameSpaceID, &elementID, 0)
#define XML_ADD_ELEMENT(elementName) \
    XML_ADD_ELEMENT_NS(elementName, nameSpaceIDNone)
 
#define XML_ADD_COMPLEX_ELEMENT_NS(elementName, elemID, nameSpaceID) \
    elementID = xmlpc_GLUE2(element_, elemID);                       \
    XMLParseAddElement(xmlParser, #elementName, nameSpaceID, &elementID, 0)
#define XML_ADD_COMPLEX_ELEMENT(elementName, elemID) \
    XML_ADD_COMPLEX_ELEMENT_NS(elementName, elemID, nameSpaceIDNone)
 
#define XML_ADD_ATTRIBUTE_NS(attrName, nameSpaceID)                    \
    attributeID = xmlpc_GLUE2(attr_, attrName);                        \
    XMLParseAddAttribute(xmlParser, elementID, nameSpaceID, #attrName, \
                         &attributeID);
#define XML_ADD_ATTRIBUTE(attrName) \
    XML_ADD_ATTRIBUTE_NS(attrName, nameSpaceIDNone)
 
#define XML_ADD_COMPLEX_ATTRIBUTE_NS(attrName, attrID, nameSpaceID)    \
    attributeID = xmlpc_GLUE2(attr_, attrID);                          \
    XMLParseAddAttribute(xmlParser, elementID, nameSpaceID, #attrName, \
                         &attributeID);
#define XML_ADD_COMPLEX_ATTRIBUTE(attrName, attrID) \
    XML_ADD_COMPLEX_ATTRIBUTE_NS(attrName, attrID, nameSpaceIDNone)
 
#define XML_ADD_ATTRIBUTE_AND_VALUE_NS(attrName, valueKind, valueKindInfo,     \
                                       nameSpaceID)                            \
    attributeID = xmlpc_GLUE2(attr_, attrName);                                \
    XMLParseAddAttributeAndValue(xmlParser, elementID, nameSpaceID, #attrName, \
                                 &attributeID, valueKind, valueKindInfo);
#define XML_ADD_ATTRIBUTE_AND_VALUE(attrName, valueKind, valueKindInfo) \
    XML_ADD_ATTRIBUTE_AND_VALUE_NS(attrName, valueKind, valueKindInfo,  \
                                   nameSpaceIDNone)
 
#define XML_ADD_COMPLEX_ATTRIBUTE_AND_VALUE_NS(attrName, attrID, valueKind,    \
                                               valueKindInfo, nameSpaceID)     \
    attributeID = xmlpc_GLUE2(attr_, attrID);                                  \
    XMLParseAddAttributeAndValue(xmlParser, elementID, nameSpaceID, #attrName, \
                                 &attributeID, valueKind, valueKindInfo);
#define XML_ADD_COMPLEX_ATTRIBUTE_AND_VALUE(attrName, attrID, valueKind, \
                                            valueKindInfo)               \
    XML_ADD_COMPLEX_ATTRIBUTE_AND_VALUE_NS(attrName, attrID, valueKind,  \
                                           valueKindInfo, nameSpaceIDNone)
 
    typedef ComponentInstance SeqGrabComponent;
    typedef ComponentInstance SGChannel;
    enum
    {
        SeqGrabComponentType = FOUR_CHAR_CODE('barg'),
        SeqGrabChannelType = FOUR_CHAR_CODE('sgch'),
        SeqGrabPanelType = FOUR_CHAR_CODE('sgpn'),
        SeqGrabCompressionPanelType = FOUR_CHAR_CODE('cmpr'),
        SeqGrabSourcePanelType = FOUR_CHAR_CODE('sour')
    };
 
    enum
    {
        seqGrabToDisk = 1,
        seqGrabToMemory = 2,
        seqGrabDontUseTempMemory = 4,
        seqGrabAppendToFile = 8,
        seqGrabDontAddMovieResource = 16,
        seqGrabDontMakeMovie = 32,
        seqGrabPreExtendFile = 64,
        seqGrabDataProcIsInterruptSafe = 128,
        seqGrabDataProcDoesOverlappingReads = 256
    };
 
    typedef unsigned long SeqGrabDataOutputEnum;
    enum
    {
        seqGrabRecord = 1,
        seqGrabPreview = 2,
        seqGrabPlayDuringRecord = 4
    };
 
    typedef unsigned long SeqGrabUsageEnum;
    enum
    {
        seqGrabHasBounds = 1,
        seqGrabHasVolume = 2,
        seqGrabHasDiscreteSamples = 4,
        seqGrabDoNotBufferizeData = 8,
        seqGrabCanMoveWindowWhileRecording = 16
    };
 
    typedef unsigned long SeqGrabChannelInfoEnum;
    struct SGOutputRecord
    {
        long data[1];
    };
    typedef struct SGOutputRecord SGOutputRecord;
    typedef SGOutputRecord *SGOutput;
    struct SeqGrabFrameInfo
    {
        long frameOffset;
        long frameTime;
        long frameSize;
        SGChannel frameChannel;
        long frameRefCon;
    };
    typedef struct SeqGrabFrameInfo SeqGrabFrameInfo;
    typedef SeqGrabFrameInfo *SeqGrabFrameInfoPtr;
    struct SeqGrabExtendedFrameInfo
    {
        wide frameOffset;
        long frameTime;
        long frameSize;
        SGChannel frameChannel;
        long frameRefCon;
        SGOutput frameOutput;
    };
    typedef struct SeqGrabExtendedFrameInfo SeqGrabExtendedFrameInfo;
    typedef SeqGrabExtendedFrameInfo *SeqGrabExtendedFrameInfoPtr;
    enum
    {
        grabPictOffScreen = 1,
        grabPictIgnoreClip = 2,
        grabPictCurrentImage = 4
    };
 
    enum
    {
        sgFlagControlledGrab = (1 << 0),
        sgFlagAllowNonRGBPixMaps = (1 << 1)
    };
 
    typedef CALLBACK_API(OSErr, SGDataProcPtr)(SGChannel c, Ptr p, long len,
                                               long *offset, long chRefCon,
                                               TimeValue time, short writeType,
                                               long refCon);
    typedef STACK_UPP_TYPE(SGDataProcPtr) SGDataUPP;
    struct SGDeviceName
    {
        Str63 name;
        Handle icon;
        long flags;
        long refCon;
        long reserved; 
    };
    typedef struct SGDeviceName SGDeviceName;
    enum
    {
        sgDeviceNameFlagDeviceUnavailable = (1 << 0)
    };
 
    struct SGDeviceListRecord
    {
        short count;
        short selectedIndex;
        long reserved; 
        SGDeviceName entry[1];
    };
    typedef struct SGDeviceListRecord SGDeviceListRecord;
    typedef SGDeviceListRecord *SGDeviceListPtr;
    typedef SGDeviceListPtr *SGDeviceList;
    enum
    {
        sgDeviceListWithIcons = (1 << 0),
        sgDeviceListDontCheckAvailability = (1 << 1)
    };
 
    enum
    {
        seqGrabWriteAppend = 0,
        seqGrabWriteReserve = 1,
        seqGrabWriteFill = 2
    };
 
    enum
    {
        seqGrabUnpause = 0,
        seqGrabPause = 1,
        seqGrabPauseForMenu = 3
    };
 
    enum
    {
        channelFlagDontOpenResFile = 2,
        channelFlagHasDependency = 4
    };
 
    typedef CALLBACK_API(Boolean, SGModalFilterProcPtr)(DialogRef theDialog,
                                                        const EventRecord *theEvent,
                                                        short *itemHit,
                                                        long refCon);
    typedef STACK_UPP_TYPE(SGModalFilterProcPtr) SGModalFilterUPP;
    enum
    {
        sgPanelFlagForPanel = 1
    };
 
    enum
    {
        seqGrabSettingsPreviewOnly = 1
    };
 
    enum
    {
        channelPlayNormal = 0,
        channelPlayFast = 1,
        channelPlayHighQuality = 2,
        channelPlayAllData = 4
    };
 
    ComponentResult
    SGInitialize(SeqGrabComponent s);
 
    ComponentResult
    SGSetDataOutput(SeqGrabComponent s, const FSSpec *movieFile, long whereFlags);
 
    ComponentResult
    SGGetDataOutput(SeqGrabComponent s, FSSpec *movieFile, long *whereFlags);
 
    ComponentResult
    SGSetGWorld(SeqGrabComponent s, CGrafPtr gp, GDHandle gd);
 
    ComponentResult
    SGGetGWorld(SeqGrabComponent s, CGrafPtr *gp, GDHandle *gd);
 
    ComponentResult
    SGNewChannel(SeqGrabComponent s, OSType channelType, SGChannel *ref);
 
    ComponentResult
    SGDisposeChannel(SeqGrabComponent s, SGChannel c);
 
    ComponentResult
    SGStartPreview(SeqGrabComponent s);
 
    ComponentResult
    SGStartRecord(SeqGrabComponent s);
 
    ComponentResult
    SGIdle(SeqGrabComponent s);
 
    ComponentResult
    SGStop(SeqGrabComponent s);
 
    ComponentResult
    SGPause(SeqGrabComponent s, Byte pause);
 
    ComponentResult
    SGPrepare(SeqGrabComponent s, Boolean prepareForPreview,
              Boolean prepareForRecord);
 
    ComponentResult
    SGRelease(SeqGrabComponent s);
 
    Movie
    SGGetMovie(SeqGrabComponent s);
 
    ComponentResult
    SGSetMaximumRecordTime(SeqGrabComponent s, unsigned long ticks);
 
    ComponentResult
    SGGetMaximumRecordTime(SeqGrabComponent s, unsigned long *ticks);
 
    ComponentResult
    SGGetStorageSpaceRemaining(SeqGrabComponent s, unsigned long *bytes);
 
    ComponentResult
    SGGetTimeRemaining(SeqGrabComponent s, long *ticksLeft);
 
    ComponentResult
    SGGrabPict(SeqGrabComponent s, PicHandle *p, const Rect *bounds,
               short offscreenDepth, long grabPictFlags);
 
    ComponentResult
    SGGetLastMovieResID(SeqGrabComponent s, short *resID);
 
    ComponentResult
    SGSetFlags(SeqGrabComponent s, long sgFlags);
 
    ComponentResult
    SGGetFlags(SeqGrabComponent s, long *sgFlags);
 
    ComponentResult
    SGSetDataProc(SeqGrabComponent s, SGDataUPP proc, long refCon);
 
    ComponentResult
    SGNewChannelFromComponent(SeqGrabComponent s, SGChannel *newChannel,
                              Component sgChannelComponent);
 
    ComponentResult
    SGDisposeDeviceList(SeqGrabComponent s, SGDeviceList list);
 
    ComponentResult
    SGAppendDeviceListToMenu(SeqGrabComponent s, SGDeviceList list, MenuRef mh);
 
    ComponentResult
    SGSetSettings(SeqGrabComponent s, UserData ud, long flags);
 
    ComponentResult
    SGGetSettings(SeqGrabComponent s, UserData *ud, long flags);
 
    ComponentResult
    SGGetIndChannel(SeqGrabComponent s, short index, SGChannel *ref,
                    OSType *chanType);
 
    ComponentResult
    SGUpdate(SeqGrabComponent s, RgnHandle updateRgn);
 
    ComponentResult
    SGGetPause(SeqGrabComponent s, Byte *paused);
 
    typedef const Component *ConstComponentListPtr;
    ComponentResult
    SGSettingsDialog(SeqGrabComponent s, SGChannel c, short numPanels,
                     ConstComponentListPtr panelList, long flags,
                     SGModalFilterUPP proc, long procRefNum);
 
    ComponentResult
    SGGetAlignmentProc(SeqGrabComponent s, ICMAlignmentProcRecordPtr alignmentProc);
 
    ComponentResult
    SGSetChannelSettings(SeqGrabComponent s, SGChannel c, UserData ud, long flags);
 
    ComponentResult
    SGGetChannelSettings(SeqGrabComponent s, SGChannel c, UserData *ud, long flags);
 
    ComponentResult
    SGGetMode(SeqGrabComponent s, Boolean *previewMode, Boolean *recordMode);
 
    ComponentResult
    SGSetDataRef(SeqGrabComponent s, Handle dataRef, OSType dataRefType,
                 long whereFlags);
 
    ComponentResult
    SGGetDataRef(SeqGrabComponent s, Handle *dataRef, OSType *dataRefType,
                 long *whereFlags);
 
    ComponentResult
    SGNewOutput(SeqGrabComponent s, Handle dataRef, OSType dataRefType,
                long whereFlags, SGOutput *sgOut);
 
    ComponentResult
    SGDisposeOutput(SeqGrabComponent s, SGOutput sgOut);
 
    ComponentResult
    SGSetOutputFlags(SeqGrabComponent s, SGOutput sgOut, long whereFlags);
 
    ComponentResult
    SGSetChannelOutput(SeqGrabComponent s, SGChannel c, SGOutput sgOut);
 
    ComponentResult
    SGGetDataOutputStorageSpaceRemaining(SeqGrabComponent s, SGOutput sgOut,
                                         unsigned long *space);
 
    ComponentResult
    SGHandleUpdateEvent(SeqGrabComponent s, const EventRecord *event,
                        Boolean *handled);
 
    ComponentResult
    SGSetOutputNextOutput(SeqGrabComponent s, SGOutput sgOut, SGOutput nextOut);
 
    ComponentResult
    SGGetOutputNextOutput(SeqGrabComponent s, SGOutput sgOut, SGOutput *nextOut);
 
    ComponentResult
    SGSetOutputMaximumOffset(SeqGrabComponent s, SGOutput sgOut,
                             const wide *maxOffset);
 
    ComponentResult
    SGGetOutputMaximumOffset(SeqGrabComponent s, SGOutput sgOut, wide *maxOffset);
 
    ComponentResult
    SGGetOutputDataReference(SeqGrabComponent s, SGOutput sgOut, Handle *dataRef,
                             OSType *dataRefType);
 
    ComponentResult
    SGWriteExtendedMovieData(SeqGrabComponent s, SGChannel c, Ptr p, long len,
                             wide *offset, SGOutput *sgOut);
 
    ComponentResult
    SGGetStorageSpaceRemaining64(SeqGrabComponent s, wide *bytes);
 
    ComponentResult
    SGGetDataOutputStorageSpaceRemaining64(SeqGrabComponent s, SGOutput sgOut,
                                           wide *space);
 
    ComponentResult
    SGWriteMovieData(SeqGrabComponent s, SGChannel c, Ptr p, long len, long *offset);
 
    ComponentResult
    SGAddFrameReference(SeqGrabComponent s, SeqGrabFrameInfoPtr frameInfo);
 
    ComponentResult
    SGGetNextFrameReference(SeqGrabComponent s, SeqGrabFrameInfoPtr frameInfo,
                            TimeValue *frameDuration, long *frameNumber);
 
    ComponentResult
    SGGetTimeBase(SeqGrabComponent s, TimeBase *tb);
 
    ComponentResult
    SGSortDeviceList(SeqGrabComponent s, SGDeviceList list);
 
    ComponentResult
    SGAddMovieData(SeqGrabComponent s, SGChannel c, Ptr p, long len, long *offset,
                   long chRefCon, TimeValue time, short writeType);
 
    ComponentResult
    SGChangedSource(SeqGrabComponent s, SGChannel c);
 
    ComponentResult
    SGAddExtendedFrameReference(SeqGrabComponent s,
                                SeqGrabExtendedFrameInfoPtr frameInfo);
 
    ComponentResult
    SGGetNextExtendedFrameReference(SeqGrabComponent s,
                                    SeqGrabExtendedFrameInfoPtr frameInfo,
                                    TimeValue *frameDuration, long *frameNumber);
 
    ComponentResult
    SGAddExtendedMovieData(SeqGrabComponent s, SGChannel c, Ptr p, long len,
                           wide *offset, long chRefCon, TimeValue time,
                           short writeType, SGOutput *whichOutput);
 
    ComponentResult
    SGAddOutputDataRefToMedia(SeqGrabComponent s, SGOutput sgOut, Media theMedia,
                              SampleDescriptionHandle desc);
 
    /**** Sequence Grab CHANNEL Component Stuff ***/
 
    ComponentResult
    SGSetChannelUsage(SGChannel c, long usage);
 
    ComponentResult
    SGGetChannelUsage(SGChannel c, long *usage);
 
    ComponentResult
    SGSetChannelBounds(SGChannel c, const Rect *bounds);
 
    ComponentResult
    SGGetChannelBounds(SGChannel c, Rect *bounds);
 
    ComponentResult
    SGSetChannelVolume(SGChannel c, short volume);
 
    ComponentResult
    SGGetChannelVolume(SGChannel c, short *volume);
 
    ComponentResult
    SGGetChannelInfo(SGChannel c, long *channelInfo);
 
    ComponentResult
    SGSetChannelPlayFlags(SGChannel c, long playFlags);
 
    ComponentResult
    SGGetChannelPlayFlags(SGChannel c, long *playFlags);
 
    ComponentResult
    SGSetChannelMaxFrames(SGChannel c, long frameCount);
 
    ComponentResult
    SGGetChannelMaxFrames(SGChannel c, long *frameCount);
 
    ComponentResult
    SGSetChannelRefCon(SGChannel c, long refCon);
 
    ComponentResult
    SGSetChannelClip(SGChannel c, RgnHandle theClip);
 
    ComponentResult
    SGGetChannelClip(SGChannel c, RgnHandle *theClip);
 
    ComponentResult
    SGGetChannelSampleDescription(SGChannel c, Handle sampleDesc);
 
    ComponentResult
    SGGetChannelDeviceList(SGChannel c, long selectionFlags, SGDeviceList *list);
 
    ComponentResult
    SGSetChannelDevice(SGChannel c, StringPtr name);
 
    ComponentResult
    SGSetChannelMatrix(SGChannel c, const MatrixRecord *m);
 
    ComponentResult
    SGGetChannelMatrix(SGChannel c, MatrixRecord *m);
 
    ComponentResult
    SGGetChannelTimeScale(SGChannel c, TimeScale *scale);
 
    ComponentResult
    SGChannelPutPicture(SGChannel c);
 
    ComponentResult
    SGChannelSetRequestedDataRate(SGChannel c, long bytesPerSecond);
 
    ComponentResult
    SGChannelGetRequestedDataRate(SGChannel c, long *bytesPerSecond);
 
    ComponentResult
    SGChannelSetDataSourceName(SGChannel c, ConstStr255Param name,
                               ScriptCode scriptTag);
 
    ComponentResult
    SGChannelGetDataSourceName(SGChannel c, Str255 name, ScriptCode *scriptTag);
 
    ComponentResult
    SGChannelSetCodecSettings(SGChannel c, Handle settings);
 
    ComponentResult
    SGChannelGetCodecSettings(SGChannel c, Handle *settings);
 
    ComponentResult
    SGGetChannelTimeBase(SGChannel c, TimeBase *tb);
 
    ComponentResult
    SGInitChannel(SGChannel c, SeqGrabComponent owner);
 
    ComponentResult
    SGWriteSamples(SGChannel c, Movie m, AliasHandle theFile);
 
    ComponentResult
    SGGetDataRate(SGChannel c, long *bytesPerSecond);
 
    ComponentResult
    SGAlignChannelRect(SGChannel c, Rect *r);
 
    ComponentResult
    SGPanelGetDitl(SeqGrabComponent s, Handle *ditl);
 
    ComponentResult
    SGPanelGetTitle(SeqGrabComponent s, Str255 title);
 
    ComponentResult
    SGPanelCanRun(SeqGrabComponent s, SGChannel c);
 
    ComponentResult
    SGPanelInstall(SeqGrabComponent s, SGChannel c, DialogRef d, short itemOffset);
 
    ComponentResult
    SGPanelEvent(SeqGrabComponent s, SGChannel c, DialogRef d, short itemOffset,
                 const EventRecord *theEvent, short *itemHit, Boolean *handled);
 
    ComponentResult
    SGPanelItem(SeqGrabComponent s, SGChannel c, DialogRef d, short itemOffset,
                short itemNum);
 
    ComponentResult
    SGPanelRemove(SeqGrabComponent s, SGChannel c, DialogRef d, short itemOffset);
 
    ComponentResult
    SGPanelSetGrabber(SeqGrabComponent s, SeqGrabComponent sg);
 
    ComponentResult
    SGPanelSetResFile(SeqGrabComponent s, short resRef);
 
    ComponentResult
    SGPanelGetSettings(SeqGrabComponent s, SGChannel c, UserData *ud, long flags);
 
    ComponentResult
    SGPanelSetSettings(SeqGrabComponent s, SGChannel c, UserData ud, long flags);
 
    ComponentResult
    SGPanelValidateInput(SeqGrabComponent s, Boolean *ok);
 
    ComponentResult
    SGPanelSetEventFilter(SeqGrabComponent s, SGModalFilterUPP proc, long refCon);
 
    /**** Sequence Grab VIDEO CHANNEL Component Stuff ***/
    struct SGCompressInfo
    {
        Ptr buffer;
        unsigned long bufferSize;
        UInt8 similarity;
        UInt8 reserved;
    };
    typedef struct SGCompressInfo SGCompressInfo;
    typedef CALLBACK_API(ComponentResult, SGGrabBottleProcPtr)(SGChannel c,
                                                               short bufferNum,
                                                               long refCon);
    typedef CALLBACK_API(ComponentResult,
                         SGGrabCompleteBottleProcPtr)(SGChannel c, short bufferNum,
                                                      Boolean *done, long refCon);
    typedef CALLBACK_API(ComponentResult,
                         SGDisplayBottleProcPtr)(SGChannel c, short bufferNum,
                                                 MatrixRecord *mp,
                                                 RgnHandle clipRgn, long refCon);
    typedef CALLBACK_API(ComponentResult, SGCompressBottleProcPtr)(SGChannel c,
                                                                   short bufferNum,
                                                                   long refCon);
    typedef CALLBACK_API(ComponentResult, SGCompressCompleteBottleProcPtr)(
        SGChannel c, short bufferNum, Boolean *done, SGCompressInfo *ci,
        long refCon);
    typedef CALLBACK_API(ComponentResult,
                         SGAddFrameBottleProcPtr)(SGChannel c, short bufferNum,
                                                  TimeValue atTime, TimeScale scale,
                                                  const SGCompressInfo *ci,
                                                  long refCon);
    typedef CALLBACK_API(ComponentResult,
                         SGTransferFrameBottleProcPtr)(SGChannel c, short bufferNum,
                                                       MatrixRecord *mp,
                                                       RgnHandle clipRgn,
                                                       long refCon);
    typedef CALLBACK_API(ComponentResult, SGGrabCompressCompleteBottleProcPtr)(
        SGChannel c, Boolean *done, SGCompressInfo *ci, TimeRecord *t, long refCon);
    typedef CALLBACK_API(ComponentResult, SGDisplayCompressBottleProcPtr)(
        SGChannel c, Ptr dataPtr, ImageDescriptionHandle desc, MatrixRecord *mp,
        RgnHandle clipRgn, long refCon);
    typedef STACK_UPP_TYPE(SGGrabBottleProcPtr) SGGrabBottleUPP;
    typedef STACK_UPP_TYPE(SGGrabCompleteBottleProcPtr) SGGrabCompleteBottleUPP;
    typedef STACK_UPP_TYPE(SGDisplayBottleProcPtr) SGDisplayBottleUPP;
    typedef STACK_UPP_TYPE(SGCompressBottleProcPtr) SGCompressBottleUPP;
    typedef STACK_UPP_TYPE(SGCompressCompleteBottleProcPtr)
        SGCompressCompleteBottleUPP;
    typedef STACK_UPP_TYPE(SGAddFrameBottleProcPtr) SGAddFrameBottleUPP;
    typedef STACK_UPP_TYPE(SGTransferFrameBottleProcPtr) SGTransferFrameBottleUPP;
    typedef STACK_UPP_TYPE(SGGrabCompressCompleteBottleProcPtr)
        SGGrabCompressCompleteBottleUPP;
    typedef STACK_UPP_TYPE(SGDisplayCompressBottleProcPtr)
        SGDisplayCompressBottleUPP;
    struct VideoBottles
    {
        short procCount;
        SGGrabBottleUPP grabProc;
        SGGrabCompleteBottleUPP grabCompleteProc;
        SGDisplayBottleUPP displayProc;
        SGCompressBottleUPP compressProc;
        SGCompressCompleteBottleUPP compressCompleteProc;
        SGAddFrameBottleUPP addFrameProc;
        SGTransferFrameBottleUPP transferFrameProc;
        SGGrabCompressCompleteBottleUPP grabCompressCompleteProc;
        SGDisplayCompressBottleUPP displayCompressProc;
    };
    typedef struct VideoBottles VideoBottles;
    ComponentResult
    SGGetSrcVideoBounds(SGChannel c, Rect *r);
 
    ComponentResult
    SGSetVideoRect(SGChannel c, const Rect *r);
 
    ComponentResult
    SGGetVideoRect(SGChannel c, Rect *r);
 
    ComponentResult
    SGGetVideoCompressorType(SGChannel c, OSType *compressorType);
 
    ComponentResult
    SGSetVideoCompressorType(SGChannel c, OSType compressorType);
 
    ComponentResult
    SGSetVideoCompressor(SGChannel c, short depth, CompressorComponent compressor,
                         CodecQ spatialQuality, CodecQ temporalQuality,
                         long keyFrameRate);
 
    ComponentResult
    SGGetVideoCompressor(SGChannel c, short *depth, CompressorComponent *compressor,
                         CodecQ *spatialQuality, CodecQ *temporalQuality,
                         long *keyFrameRate);
 
    ComponentInstance
    SGGetVideoDigitizerComponent(SGChannel c);
 
    ComponentResult
    SGSetVideoDigitizerComponent(SGChannel c, ComponentInstance vdig);
 
    ComponentResult
    SGVideoDigitizerChanged(SGChannel c);
 
    ComponentResult
    SGSetVideoBottlenecks(SGChannel c, VideoBottles *vb);
 
    ComponentResult
    SGGetVideoBottlenecks(SGChannel c, VideoBottles *vb);
 
    ComponentResult
    SGGrabFrame(SGChannel c, short bufferNum);
 
    ComponentResult
    SGGrabFrameComplete(SGChannel c, short bufferNum, Boolean *done);
 
    ComponentResult
    SGDisplayFrame(SGChannel c, short bufferNum, const MatrixRecord *mp,
                   RgnHandle clipRgn);
 
    ComponentResult
    SGCompressFrame(SGChannel c, short bufferNum);
 
    ComponentResult
    SGCompressFrameComplete(SGChannel c, short bufferNum, Boolean *done,
                            SGCompressInfo *ci);
 
    ComponentResult
    SGAddFrame(SGChannel c, short bufferNum, TimeValue atTime, TimeScale scale,
               const SGCompressInfo *ci);
 
    ComponentResult
    SGTransferFrameForCompress(SGChannel c, short bufferNum, const MatrixRecord *mp,
                               RgnHandle clipRgn);
 
    ComponentResult
    SGSetCompressBuffer(SGChannel c, short depth, const Rect *compressSize);
 
    ComponentResult
    SGGetCompressBuffer(SGChannel c, short *depth, Rect *compressSize);
 
    ComponentResult
    SGGetBufferInfo(SGChannel c, short bufferNum, PixMapHandle *bufferPM,
                    Rect *bufferRect, GWorldPtr *compressBuffer,
                    Rect *compressBufferRect);
 
    ComponentResult
    SGSetUseScreenBuffer(SGChannel c, Boolean useScreenBuffer);
 
    ComponentResult
    SGGetUseScreenBuffer(SGChannel c, Boolean *useScreenBuffer);
 
    ComponentResult
    SGGrabCompressComplete(SGChannel c, Boolean *done, SGCompressInfo *ci,
                           TimeRecord *tr);
 
    ComponentResult
    SGDisplayCompress(SGChannel c, Ptr dataPtr, ImageDescriptionHandle desc,
                      MatrixRecord *mp, RgnHandle clipRgn);
 
    ComponentResult
    SGSetFrameRate(SGChannel c, Fixed frameRate);
 
    ComponentResult
    SGGetFrameRate(SGChannel c, Fixed *frameRate);
 
    ComponentResult
    SGSetPreferredPacketSize(SGChannel c, long preferredPacketSizeInBytes);
 
    ComponentResult
    SGGetPreferredPacketSize(SGChannel c, long *preferredPacketSizeInBytes);
 
    ComponentResult
    SGSetUserVideoCompressorList(SGChannel c, Handle compressorTypes);
 
    ComponentResult
    SGGetUserVideoCompressorList(SGChannel c, Handle *compressorTypes);
 
    /**** Sequence Grab SOUND CHANNEL Component Stuff ***/
 
    ComponentResult
    SGSetSoundInputDriver(SGChannel c, ConstStr255Param driverName);
 
    long
    SGGetSoundInputDriver(SGChannel c);
 
    ComponentResult
    SGSoundInputDriverChanged(SGChannel c);
 
    ComponentResult
    SGSetSoundRecordChunkSize(SGChannel c, long seconds);
 
    long
    SGGetSoundRecordChunkSize(SGChannel c);
 
    ComponentResult
    SGSetSoundInputRate(SGChannel c, Fixed rate);
 
    Fixed
    SGGetSoundInputRate(SGChannel c);
 
    ComponentResult
    SGSetSoundInputParameters(SGChannel c, short sampleSize, short numChannels,
                              OSType compressionType);
 
    ComponentResult
    SGGetSoundInputParameters(SGChannel c, short *sampleSize, short *numChannels,
                              OSType *compressionType);
 
    ComponentResult
    SGSetAdditionalSoundRates(SGChannel c, Handle rates);
 
    ComponentResult
    SGGetAdditionalSoundRates(SGChannel c, Handle *rates);
 
    ComponentResult
    SGSetFontName(SGChannel c, StringPtr pstr);
 
    ComponentResult
    SGSetFontSize(SGChannel c, short fontSize);
 
    ComponentResult
    SGSetTextForeColor(SGChannel c, RGBColor *theColor);
 
    ComponentResult
    SGSetTextBackColor(SGChannel c, RGBColor *theColor);
 
    ComponentResult
    SGSetJustification(SGChannel c, short just);
 
    ComponentResult
    SGGetTextReturnToSpaceValue(SGChannel c, short *rettospace);
 
    ComponentResult
    SGSetTextReturnToSpaceValue(SGChannel c, short rettospace);
 
    ComponentResult
    SGGetInstrument(SGChannel c, ToneDescription *td);
 
    ComponentResult
    SGSetInstrument(SGChannel c, ToneDescription *td);
 
    enum
    {
        sgChannelAtom = FOUR_CHAR_CODE('chan'),
        sgChannelSettingsAtom = FOUR_CHAR_CODE('ctom'),
        sgChannelDescription = FOUR_CHAR_CODE('cdsc'),
        sgChannelSettings = FOUR_CHAR_CODE('cset')
    };
 
    enum
    {
        sgDeviceNameType = FOUR_CHAR_CODE('name'),
        sgUsageType = FOUR_CHAR_CODE('use '),
        sgPlayFlagsType = FOUR_CHAR_CODE('plyf'),
        sgClipType = FOUR_CHAR_CODE('clip'),
        sgMatrixType = FOUR_CHAR_CODE('mtrx'),
        sgVolumeType = FOUR_CHAR_CODE('volu')
    };
 
    enum
    {
        sgPanelSettingsAtom = FOUR_CHAR_CODE('ptom'),
        sgPanelDescription = FOUR_CHAR_CODE('pdsc'),
        sgPanelSettings = FOUR_CHAR_CODE('pset')
    };
 
    enum
    {
        sgcSoundCompressionType = FOUR_CHAR_CODE('scmp'),
        sgcSoundSampleRateType = FOUR_CHAR_CODE('srat'),
        sgcSoundChannelCountType = FOUR_CHAR_CODE('schn'),
        sgcSoundSampleSizeType = FOUR_CHAR_CODE('ssiz'),
        sgcSoundInputType = FOUR_CHAR_CODE('sinp'),
        sgcSoundGainType = FOUR_CHAR_CODE('gain')
    };
 
    enum
    {
        sgcVideoHueType = FOUR_CHAR_CODE('hue '),
        sgcVideoSaturationType = FOUR_CHAR_CODE('satr'),
        sgcVideoContrastType = FOUR_CHAR_CODE('trst'),
        sgcVideoSharpnessType = FOUR_CHAR_CODE('shrp'),
        sgcVideoBrigtnessType = FOUR_CHAR_CODE('brit'),
        sgcVideoBlackLevelType = FOUR_CHAR_CODE('blkl'),
        sgcVideoWhiteLevelType = FOUR_CHAR_CODE('whtl'),
        sgcVideoInputType = FOUR_CHAR_CODE('vinp'),
        sgcVideoFormatType = FOUR_CHAR_CODE('vstd'),
        sgcVideoFilterType = FOUR_CHAR_CODE('vflt'),
        sgcVideoRectType = FOUR_CHAR_CODE('vrct'),
        sgcVideoDigitizerType = FOUR_CHAR_CODE('vdig')
    };
 
    typedef ComponentInstance QTVideoOutputComponent;
    enum
    {
        QTVideoOutputComponentType = FOUR_CHAR_CODE('vout'),
        QTVideoOutputComponentBaseSubType = FOUR_CHAR_CODE('base')
    };
 
    enum
    {
        kQTVideoOutputDontDisplayToUser = 1L << 0
    };
 
    enum
    {
        kQTVODisplayModeItem = FOUR_CHAR_CODE('qdmi'),
        kQTVODimensions = FOUR_CHAR_CODE(
            'dimn'), 
        kQTVOResolution =
            FOUR_CHAR_CODE('resl'), 
        kQTVORefreshRate =
            FOUR_CHAR_CODE('refr'), 
        kQTVOPixelType = FOUR_CHAR_CODE(
            'pixl'),                        
        kQTVOName = FOUR_CHAR_CODE('name'), 
        kQTVODecompressors =
            FOUR_CHAR_CODE('deco'), 
        kQTVODecompressorType = FOUR_CHAR_CODE(
            'dety'), 
        kQTVODecompressorContinuous =
            FOUR_CHAR_CODE('cont'), 
        kQTVODecompressorComponent = FOUR_CHAR_CODE(
            'cmpt') 
    };
 
    /*** These are QTVideoOutput procedures **/
    ComponentResult
    QTVideoOutputGetDisplayModeList(QTVideoOutputComponent vo,
                                    QTAtomContainer *outputs);
 
    ComponentResult
    QTVideoOutputGetCurrentClientName(QTVideoOutputComponent vo, Str255 str);
 
    ComponentResult
    QTVideoOutputSetClientName(QTVideoOutputComponent vo, ConstStr255Param str);
 
    ComponentResult
    QTVideoOutputGetClientName(QTVideoOutputComponent vo, Str255 str);
 
    ComponentResult
    QTVideoOutputBegin(QTVideoOutputComponent vo);
 
    ComponentResult
    QTVideoOutputEnd(QTVideoOutputComponent vo);
 
    ComponentResult
    QTVideoOutputSetDisplayMode(QTVideoOutputComponent vo, long displayModeID);
 
    ComponentResult
    QTVideoOutputGetDisplayMode(QTVideoOutputComponent vo, long *displayModeID);
 
    ComponentResult
    QTVideoOutputCustomConfigureDisplay(QTVideoOutputComponent vo,
                                        ModalFilterUPP filter);
 
    ComponentResult
    QTVideoOutputSaveState(QTVideoOutputComponent vo, QTAtomContainer *state);
 
    ComponentResult
    QTVideoOutputRestoreState(QTVideoOutputComponent vo, QTAtomContainer state);
 
    ComponentResult
    QTVideoOutputGetGWorld(QTVideoOutputComponent vo, GWorldPtr *gw);
 
    ComponentResult
    QTVideoOutputGetGWorldParameters(QTVideoOutputComponent vo, Ptr *baseAddr,
                                     long *rowBytes, CTabHandle *colorTable);
 
    ComponentResult
    QTVideoOutputGetIndSoundOutput(QTVideoOutputComponent vo, long index,
                                   Component *outputComponent);
 
    ComponentResult
    QTVideoOutputGetClock(QTVideoOutputComponent vo, ComponentInstance *clock);
 
    ComponentResult
    QTVideoOutputSetEchoPort(QTVideoOutputComponent vo, CGrafPtr echoPort);
 
    ComponentResult
    QTVideoOutputGetIndImageDecompressor(QTVideoOutputComponent vo, long index,
                                         Component *codec);
 
    DataHCompletionUPP
    NewDataHCompletionUPP(DataHCompletionProcPtr userRoutine);
#if !OPAQUE_UPP_TYPES
    enum
    {
        uppDataHCompletionProcInfo = 0x00000BC0
    }; 
#ifdef __cplusplus
    inline DataHCompletionUPP
    NewDataHCompletionUPP(DataHCompletionProcPtr userRoutine)
    {
        return (DataHCompletionUPP)NewRoutineDescriptor((ProcPtr)(userRoutine),
                                                        uppDataHCompletionProcInfo,
                                                        GetCurrentArchitecture());
    }
#else
#define NewDataHCompletionUPP(userRoutine)                                       \
    (DataHCompletionUPP)                                                         \
        NewRoutineDescriptor((ProcPtr)(userRoutine), uppDataHCompletionProcInfo, \
                             GetCurrentArchitecture())
#endif
#endif
 
    VdigIntUPP
    NewVdigIntUPP(VdigIntProcPtr userRoutine);
#if !OPAQUE_UPP_TYPES
    enum
    {
        uppVdigIntProcInfo = 0x000003C0
    }; 
#ifdef __cplusplus
    inline VdigIntUPP NewVdigIntUPP(VdigIntProcPtr userRoutine)
    {
        return (VdigIntUPP)NewRoutineDescriptor(
            (ProcPtr)(userRoutine), uppVdigIntProcInfo, GetCurrentArchitecture());
    }
#else
#define NewVdigIntUPP(userRoutine)     \
    (VdigIntUPP) NewRoutineDescriptor( \
        (ProcPtr)(userRoutine), uppVdigIntProcInfo, GetCurrentArchitecture())
#endif
#endif
 
    StartDocumentHandlerUPP
    NewStartDocumentHandlerUPP(StartDocumentHandler userRoutine);
#if !OPAQUE_UPP_TYPES
    enum
    {
        uppStartDocumentHandlerProcInfo = 0x000000F0
    }; 
#ifdef __cplusplus
    inline StartDocumentHandlerUPP
    NewStartDocumentHandlerUPP(StartDocumentHandler userRoutine)
    {
        return (StartDocumentHandlerUPP)NewRoutineDescriptor(
            (ProcPtr)(userRoutine), uppStartDocumentHandlerProcInfo,
            GetCurrentArchitecture());
    }
#else
#define NewStartDocumentHandlerUPP(userRoutine)                  \
    (StartDocumentHandlerUPP) NewRoutineDescriptor(              \
        (ProcPtr)(userRoutine), uppStartDocumentHandlerProcInfo, \
        GetCurrentArchitecture())
#endif
#endif
 
    EndDocumentHandlerUPP
    NewEndDocumentHandlerUPP(EndDocumentHandler userRoutine);
#if !OPAQUE_UPP_TYPES
    enum
    {
        uppEndDocumentHandlerProcInfo = 0x000000F0
    }; 
#ifdef __cplusplus
    inline EndDocumentHandlerUPP
    NewEndDocumentHandlerUPP(EndDocumentHandler userRoutine)
    {
        return (EndDocumentHandlerUPP)NewRoutineDescriptor(
            (ProcPtr)(userRoutine), uppEndDocumentHandlerProcInfo,
            GetCurrentArchitecture());
    }
#else
#define NewEndDocumentHandlerUPP(userRoutine)                                   \
    (EndDocumentHandlerUPP) NewRoutineDescriptor((ProcPtr)(userRoutine),        \
                                                 uppEndDocumentHandlerProcInfo, \
                                                 GetCurrentArchitecture())
#endif
#endif
 
    StartElementHandlerUPP
    NewStartElementHandlerUPP(StartElementHandler userRoutine);
#if !OPAQUE_UPP_TYPES
    enum
    {
        uppStartElementHandlerProcInfo = 0x00000FF0
    }; 
#ifdef __cplusplus
    inline StartElementHandlerUPP
    NewStartElementHandlerUPP(StartElementHandler userRoutine)
    {
        return (StartElementHandlerUPP)NewRoutineDescriptor(
            (ProcPtr)(userRoutine), uppStartElementHandlerProcInfo,
            GetCurrentArchitecture());
    }
#else
#define NewStartElementHandlerUPP(userRoutine)                  \
    (StartElementHandlerUPP) NewRoutineDescriptor(              \
        (ProcPtr)(userRoutine), uppStartElementHandlerProcInfo, \
        GetCurrentArchitecture())
#endif
#endif
 
    EndElementHandlerUPP
    NewEndElementHandlerUPP(EndElementHandler userRoutine);
#if !OPAQUE_UPP_TYPES
    enum
    {
        uppEndElementHandlerProcInfo = 0x000003F0
    }; 
#ifdef __cplusplus
    inline EndElementHandlerUPP
    NewEndElementHandlerUPP(EndElementHandler userRoutine)
    {
        return (EndElementHandlerUPP)NewRoutineDescriptor(
            (ProcPtr)(userRoutine), uppEndElementHandlerProcInfo,
            GetCurrentArchitecture());
    }
#else
#define NewEndElementHandlerUPP(userRoutine)                                  \
    (EndElementHandlerUPP) NewRoutineDescriptor((ProcPtr)(userRoutine),       \
                                                uppEndElementHandlerProcInfo, \
                                                GetCurrentArchitecture())
#endif
#endif
 
    CharDataHandlerUPP
    NewCharDataHandlerUPP(CharDataHandler userRoutine);
#if !OPAQUE_UPP_TYPES
    enum
    {
        uppCharDataHandlerProcInfo = 0x000003F0
    }; 
#ifdef __cplusplus
    inline CharDataHandlerUPP NewCharDataHandlerUPP(CharDataHandler userRoutine)
    {
        return (CharDataHandlerUPP)NewRoutineDescriptor((ProcPtr)(userRoutine),
                                                        uppCharDataHandlerProcInfo,
                                                        GetCurrentArchitecture());
    }
#else
#define NewCharDataHandlerUPP(userRoutine)                                       \
    (CharDataHandlerUPP)                                                         \
        NewRoutineDescriptor((ProcPtr)(userRoutine), uppCharDataHandlerProcInfo, \
                             GetCurrentArchitecture())
#endif
#endif
 
    PreprocessInstructionHandlerUPP
    NewPreprocessInstructionHandlerUPP(PreprocessInstructionHandler userRoutine);
#if !OPAQUE_UPP_TYPES
    enum
    {
        uppPreprocessInstructionHandlerProcInfo = 0x00000FF0
    }; 
#ifdef __cplusplus
    inline PreprocessInstructionHandlerUPP
    NewPreprocessInstructionHandlerUPP(PreprocessInstructionHandler userRoutine)
    {
        return (PreprocessInstructionHandlerUPP)NewRoutineDescriptor(
            (ProcPtr)(userRoutine), uppPreprocessInstructionHandlerProcInfo,
            GetCurrentArchitecture());
    }
#else
#define NewPreprocessInstructionHandlerUPP(userRoutine)                  \
    (PreprocessInstructionHandlerUPP) NewRoutineDescriptor(              \
        (ProcPtr)(userRoutine), uppPreprocessInstructionHandlerProcInfo, \
        GetCurrentArchitecture())
#endif
#endif
 
    CommentHandlerUPP
    NewCommentHandlerUPP(CommentHandler userRoutine);
#if !OPAQUE_UPP_TYPES
    enum
    {
        uppCommentHandlerProcInfo = 0x000003F0
    }; 
#ifdef __cplusplus
    inline CommentHandlerUPP NewCommentHandlerUPP(CommentHandler userRoutine)
    {
        return (CommentHandlerUPP)NewRoutineDescriptor((ProcPtr)(userRoutine),
                                                       uppCommentHandlerProcInfo,
                                                       GetCurrentArchitecture());
    }
#else
#define NewCommentHandlerUPP(userRoutine)                                       \
    (CommentHandlerUPP)                                                         \
        NewRoutineDescriptor((ProcPtr)(userRoutine), uppCommentHandlerProcInfo, \
                             GetCurrentArchitecture())
#endif
#endif
 
    SGDataUPP
    NewSGDataUPP(SGDataProcPtr userRoutine);
#if !OPAQUE_UPP_TYPES
    enum
    {
        uppSGDataProcInfo = 0x003BFFE0
    }; 
#ifdef __cplusplus
    inline SGDataUPP NewSGDataUPP(SGDataProcPtr userRoutine)
    {
        return (SGDataUPP)NewRoutineDescriptor(
            (ProcPtr)(userRoutine), uppSGDataProcInfo, GetCurrentArchitecture());
    }
#else
#define NewSGDataUPP(userRoutine)                                               \
    (SGDataUPP) NewRoutineDescriptor((ProcPtr)(userRoutine), uppSGDataProcInfo, \
                                     GetCurrentArchitecture())
#endif
#endif
 
    SGModalFilterUPP
    NewSGModalFilterUPP(SGModalFilterProcPtr userRoutine);
#if !OPAQUE_UPP_TYPES
    enum
    {
        uppSGModalFilterProcInfo = 0x00003FD0
    }; 
#ifdef __cplusplus
    inline SGModalFilterUPP NewSGModalFilterUPP(SGModalFilterProcPtr userRoutine)
    {
        return (SGModalFilterUPP)NewRoutineDescriptor((ProcPtr)(userRoutine),
                                                      uppSGModalFilterProcInfo,
                                                      GetCurrentArchitecture());
    }
#else
#define NewSGModalFilterUPP(userRoutine)                                       \
    (SGModalFilterUPP)                                                         \
        NewRoutineDescriptor((ProcPtr)(userRoutine), uppSGModalFilterProcInfo, \
                             GetCurrentArchitecture())
#endif
#endif
 
    SGGrabBottleUPP
    NewSGGrabBottleUPP(SGGrabBottleProcPtr userRoutine);
#if !OPAQUE_UPP_TYPES
    enum
    {
        uppSGGrabBottleProcInfo = 0x00000EF0
    }; 
#ifdef __cplusplus
    inline SGGrabBottleUPP NewSGGrabBottleUPP(SGGrabBottleProcPtr userRoutine)
    {
        return (SGGrabBottleUPP)NewRoutineDescriptor((ProcPtr)(userRoutine),
                                                     uppSGGrabBottleProcInfo,
                                                     GetCurrentArchitecture());
    }
#else
#define NewSGGrabBottleUPP(userRoutine)                                       \
    (SGGrabBottleUPP)                                                         \
        NewRoutineDescriptor((ProcPtr)(userRoutine), uppSGGrabBottleProcInfo, \
                             GetCurrentArchitecture())
#endif
#endif
 
    SGGrabCompleteBottleUPP
    NewSGGrabCompleteBottleUPP(SGGrabCompleteBottleProcPtr userRoutine);
#if !OPAQUE_UPP_TYPES
    enum
    {
        uppSGGrabCompleteBottleProcInfo = 0x00003EF0
    }; 
#ifdef __cplusplus
    inline SGGrabCompleteBottleUPP
    NewSGGrabCompleteBottleUPP(SGGrabCompleteBottleProcPtr userRoutine)
    {
        return (SGGrabCompleteBottleUPP)NewRoutineDescriptor(
            (ProcPtr)(userRoutine), uppSGGrabCompleteBottleProcInfo,
            GetCurrentArchitecture());
    }
#else
#define NewSGGrabCompleteBottleUPP(userRoutine)                  \
    (SGGrabCompleteBottleUPP) NewRoutineDescriptor(              \
        (ProcPtr)(userRoutine), uppSGGrabCompleteBottleProcInfo, \
        GetCurrentArchitecture())
#endif
#endif
 
    SGDisplayBottleUPP
    NewSGDisplayBottleUPP(SGDisplayBottleProcPtr userRoutine);
#if !OPAQUE_UPP_TYPES
    enum
    {
        uppSGDisplayBottleProcInfo = 0x0000FEF0
    }; 
#ifdef __cplusplus
    inline SGDisplayBottleUPP
    NewSGDisplayBottleUPP(SGDisplayBottleProcPtr userRoutine)
    {
        return (SGDisplayBottleUPP)NewRoutineDescriptor((ProcPtr)(userRoutine),
                                                        uppSGDisplayBottleProcInfo,
                                                        GetCurrentArchitecture());
    }
#else
#define NewSGDisplayBottleUPP(userRoutine)                                       \
    (SGDisplayBottleUPP)                                                         \
        NewRoutineDescriptor((ProcPtr)(userRoutine), uppSGDisplayBottleProcInfo, \
                             GetCurrentArchitecture())
#endif
#endif
 
    SGCompressBottleUPP
    NewSGCompressBottleUPP(SGCompressBottleProcPtr userRoutine);
#if !OPAQUE_UPP_TYPES
    enum
    {
        uppSGCompressBottleProcInfo = 0x00000EF0
    }; 
#ifdef __cplusplus
    inline SGCompressBottleUPP
    NewSGCompressBottleUPP(SGCompressBottleProcPtr userRoutine)
    {
        return (SGCompressBottleUPP)NewRoutineDescriptor((ProcPtr)(userRoutine),
                                                         uppSGCompressBottleProcInfo,
                                                         GetCurrentArchitecture());
    }
#else
#define NewSGCompressBottleUPP(userRoutine)                                 \
    (SGCompressBottleUPP) NewRoutineDescriptor((ProcPtr)(userRoutine),      \
                                               uppSGCompressBottleProcInfo, \
                                               GetCurrentArchitecture())
#endif
#endif
 
    SGCompressCompleteBottleUPP
    NewSGCompressCompleteBottleUPP(SGCompressCompleteBottleProcPtr userRoutine);
#if !OPAQUE_UPP_TYPES
    enum
    {
        uppSGCompressCompleteBottleProcInfo = 0x0000FEF0
    }; 
#ifdef __cplusplus
    inline SGCompressCompleteBottleUPP
    NewSGCompressCompleteBottleUPP(SGCompressCompleteBottleProcPtr userRoutine)
    {
        return (SGCompressCompleteBottleUPP)NewRoutineDescriptor(
            (ProcPtr)(userRoutine), uppSGCompressCompleteBottleProcInfo,
            GetCurrentArchitecture());
    }
#else
#define NewSGCompressCompleteBottleUPP(userRoutine)                  \
    (SGCompressCompleteBottleUPP) NewRoutineDescriptor(              \
        (ProcPtr)(userRoutine), uppSGCompressCompleteBottleProcInfo, \
        GetCurrentArchitecture())
#endif
#endif
 
    SGAddFrameBottleUPP
    NewSGAddFrameBottleUPP(SGAddFrameBottleProcPtr userRoutine);
#if !OPAQUE_UPP_TYPES
    enum
    {
        uppSGAddFrameBottleProcInfo = 0x0003FEF0
    }; 
#ifdef __cplusplus
    inline SGAddFrameBottleUPP
    NewSGAddFrameBottleUPP(SGAddFrameBottleProcPtr userRoutine)
    {
        return (SGAddFrameBottleUPP)NewRoutineDescriptor((ProcPtr)(userRoutine),
                                                         uppSGAddFrameBottleProcInfo,
                                                         GetCurrentArchitecture());
    }
#else
#define NewSGAddFrameBottleUPP(userRoutine)                                 \
    (SGAddFrameBottleUPP) NewRoutineDescriptor((ProcPtr)(userRoutine),      \
                                               uppSGAddFrameBottleProcInfo, \
                                               GetCurrentArchitecture())
#endif
#endif
 
    SGTransferFrameBottleUPP
    NewSGTransferFrameBottleUPP(SGTransferFrameBottleProcPtr userRoutine);
#if !OPAQUE_UPP_TYPES
    enum
    {
        uppSGTransferFrameBottleProcInfo = 0x0000FEF0
    }; 
#ifdef __cplusplus
    inline SGTransferFrameBottleUPP
    NewSGTransferFrameBottleUPP(SGTransferFrameBottleProcPtr userRoutine)
    {
        return (SGTransferFrameBottleUPP)NewRoutineDescriptor(
            (ProcPtr)(userRoutine), uppSGTransferFrameBottleProcInfo,
            GetCurrentArchitecture());
    }
#else
#define NewSGTransferFrameBottleUPP(userRoutine)                  \
    (SGTransferFrameBottleUPP) NewRoutineDescriptor(              \
        (ProcPtr)(userRoutine), uppSGTransferFrameBottleProcInfo, \
        GetCurrentArchitecture())
#endif
#endif
 
    SGGrabCompressCompleteBottleUPP
    NewSGGrabCompressCompleteBottleUPP(
        SGGrabCompressCompleteBottleProcPtr userRoutine);
#if !OPAQUE_UPP_TYPES
    enum
    {
        uppSGGrabCompressCompleteBottleProcInfo = 0x0000FFF0
    }; 
#ifdef __cplusplus
    inline SGGrabCompressCompleteBottleUPP NewSGGrabCompressCompleteBottleUPP(
        SGGrabCompressCompleteBottleProcPtr userRoutine)
    {
        return (SGGrabCompressCompleteBottleUPP)NewRoutineDescriptor(
            (ProcPtr)(userRoutine), uppSGGrabCompressCompleteBottleProcInfo,
            GetCurrentArchitecture());
    }
#else
#define NewSGGrabCompressCompleteBottleUPP(userRoutine)                  \
    (SGGrabCompressCompleteBottleUPP) NewRoutineDescriptor(              \
        (ProcPtr)(userRoutine), uppSGGrabCompressCompleteBottleProcInfo, \
        GetCurrentArchitecture())
#endif
#endif
 
    SGDisplayCompressBottleUPP
    NewSGDisplayCompressBottleUPP(SGDisplayCompressBottleProcPtr userRoutine);
#if !OPAQUE_UPP_TYPES
    enum
    {
        uppSGDisplayCompressBottleProcInfo = 0x0003FFF0
    }; 
#ifdef __cplusplus
    inline SGDisplayCompressBottleUPP
    NewSGDisplayCompressBottleUPP(SGDisplayCompressBottleProcPtr userRoutine)
    {
        return (SGDisplayCompressBottleUPP)NewRoutineDescriptor(
            (ProcPtr)(userRoutine), uppSGDisplayCompressBottleProcInfo,
            GetCurrentArchitecture());
    }
#else
#define NewSGDisplayCompressBottleUPP(userRoutine)                  \
    (SGDisplayCompressBottleUPP) NewRoutineDescriptor(              \
        (ProcPtr)(userRoutine), uppSGDisplayCompressBottleProcInfo, \
        GetCurrentArchitecture())
#endif
#endif
 
    void
    DisposeDataHCompletionUPP(DataHCompletionUPP userUPP);
#if !OPAQUE_UPP_TYPES
#ifdef __cplusplus
    inline void DisposeDataHCompletionUPP(DataHCompletionUPP userUPP)
    {
        DisposeRoutineDescriptor((UniversalProcPtr)userUPP);
    }
#else
#define DisposeDataHCompletionUPP(userUPP) DisposeRoutineDescriptor(userUPP)
#endif
#endif
 
    void
    DisposeVdigIntUPP(VdigIntUPP userUPP);
#if !OPAQUE_UPP_TYPES
#ifdef __cplusplus
    inline void DisposeVdigIntUPP(VdigIntUPP userUPP)
    {
        DisposeRoutineDescriptor((UniversalProcPtr)userUPP);
    }
#else
#define DisposeVdigIntUPP(userUPP) DisposeRoutineDescriptor(userUPP)
#endif
#endif
 
    void
    DisposeStartDocumentHandlerUPP(StartDocumentHandlerUPP userUPP);
#if !OPAQUE_UPP_TYPES
#ifdef __cplusplus
    inline void DisposeStartDocumentHandlerUPP(StartDocumentHandlerUPP userUPP)
    {
        DisposeRoutineDescriptor((UniversalProcPtr)userUPP);
    }
#else
#define DisposeStartDocumentHandlerUPP(userUPP) \
    DisposeRoutineDescriptor(userUPP)
#endif
#endif
 
    void
    DisposeEndDocumentHandlerUPP(EndDocumentHandlerUPP userUPP);
#if !OPAQUE_UPP_TYPES
#ifdef __cplusplus
    inline void DisposeEndDocumentHandlerUPP(EndDocumentHandlerUPP userUPP)
    {
        DisposeRoutineDescriptor((UniversalProcPtr)userUPP);
    }
#else
#define DisposeEndDocumentHandlerUPP(userUPP) DisposeRoutineDescriptor(userUPP)
#endif
#endif
 
    void
    DisposeStartElementHandlerUPP(StartElementHandlerUPP userUPP);
#if !OPAQUE_UPP_TYPES
#ifdef __cplusplus
    inline void DisposeStartElementHandlerUPP(StartElementHandlerUPP userUPP)
    {
        DisposeRoutineDescriptor((UniversalProcPtr)userUPP);
    }
#else
#define DisposeStartElementHandlerUPP(userUPP) DisposeRoutineDescriptor(userUPP)
#endif
#endif
 
    void
    DisposeEndElementHandlerUPP(EndElementHandlerUPP userUPP);
#if !OPAQUE_UPP_TYPES
#ifdef __cplusplus
    inline void DisposeEndElementHandlerUPP(EndElementHandlerUPP userUPP)
    {
        DisposeRoutineDescriptor((UniversalProcPtr)userUPP);
    }
#else
#define DisposeEndElementHandlerUPP(userUPP) DisposeRoutineDescriptor(userUPP)
#endif
#endif
 
    void
    DisposeCharDataHandlerUPP(CharDataHandlerUPP userUPP);
#if !OPAQUE_UPP_TYPES
#ifdef __cplusplus
    inline void DisposeCharDataHandlerUPP(CharDataHandlerUPP userUPP)
    {
        DisposeRoutineDescriptor((UniversalProcPtr)userUPP);
    }
#else
#define DisposeCharDataHandlerUPP(userUPP) DisposeRoutineDescriptor(userUPP)
#endif
#endif
 
    void
    DisposePreprocessInstructionHandlerUPP(PreprocessInstructionHandlerUPP userUPP);
#if !OPAQUE_UPP_TYPES
#ifdef __cplusplus
    inline void DisposePreprocessInstructionHandlerUPP(
        PreprocessInstructionHandlerUPP userUPP)
    {
        DisposeRoutineDescriptor((UniversalProcPtr)userUPP);
    }
#else
#define DisposePreprocessInstructionHandlerUPP(userUPP) \
    DisposeRoutineDescriptor(userUPP)
#endif
#endif
 
    void
    DisposeCommentHandlerUPP(CommentHandlerUPP userUPP);
#if !OPAQUE_UPP_TYPES
#ifdef __cplusplus
    inline void DisposeCommentHandlerUPP(CommentHandlerUPP userUPP)
    {
        DisposeRoutineDescriptor((UniversalProcPtr)userUPP);
    }
#else
#define DisposeCommentHandlerUPP(userUPP) DisposeRoutineDescriptor(userUPP)
#endif
#endif
 
    void
    DisposeSGDataUPP(SGDataUPP userUPP);
#if !OPAQUE_UPP_TYPES
#ifdef __cplusplus
    inline void DisposeSGDataUPP(SGDataUPP userUPP)
    {
        DisposeRoutineDescriptor((UniversalProcPtr)userUPP);
    }
#else
#define DisposeSGDataUPP(userUPP) DisposeRoutineDescriptor(userUPP)
#endif
#endif
 
    void
    DisposeSGModalFilterUPP(SGModalFilterUPP userUPP);
#if !OPAQUE_UPP_TYPES
#ifdef __cplusplus
    inline void DisposeSGModalFilterUPP(SGModalFilterUPP userUPP)
    {
        DisposeRoutineDescriptor((UniversalProcPtr)userUPP);
    }
#else
#define DisposeSGModalFilterUPP(userUPP) DisposeRoutineDescriptor(userUPP)
#endif
#endif
 
    void
    DisposeSGGrabBottleUPP(SGGrabBottleUPP userUPP);
#if !OPAQUE_UPP_TYPES
#ifdef __cplusplus
    inline void DisposeSGGrabBottleUPP(SGGrabBottleUPP userUPP)
    {
        DisposeRoutineDescriptor((UniversalProcPtr)userUPP);
    }
#else
#define DisposeSGGrabBottleUPP(userUPP) DisposeRoutineDescriptor(userUPP)
#endif
#endif
 
    void
    DisposeSGGrabCompleteBottleUPP(SGGrabCompleteBottleUPP userUPP);
#if !OPAQUE_UPP_TYPES
#ifdef __cplusplus
    inline void DisposeSGGrabCompleteBottleUPP(SGGrabCompleteBottleUPP userUPP)
    {
        DisposeRoutineDescriptor((UniversalProcPtr)userUPP);
    }
#else
#define DisposeSGGrabCompleteBottleUPP(userUPP) \
    DisposeRoutineDescriptor(userUPP)
#endif
#endif
 
    void
    DisposeSGDisplayBottleUPP(SGDisplayBottleUPP userUPP);
#if !OPAQUE_UPP_TYPES
#ifdef __cplusplus
    inline void DisposeSGDisplayBottleUPP(SGDisplayBottleUPP userUPP)
    {
        DisposeRoutineDescriptor((UniversalProcPtr)userUPP);
    }
#else
#define DisposeSGDisplayBottleUPP(userUPP) DisposeRoutineDescriptor(userUPP)
#endif
#endif
 
    void
    DisposeSGCompressBottleUPP(SGCompressBottleUPP userUPP);
#if !OPAQUE_UPP_TYPES
#ifdef __cplusplus
    inline void DisposeSGCompressBottleUPP(SGCompressBottleUPP userUPP)
    {
        DisposeRoutineDescriptor((UniversalProcPtr)userUPP);
    }
#else
#define DisposeSGCompressBottleUPP(userUPP) DisposeRoutineDescriptor(userUPP)
#endif
#endif
 
    void
    DisposeSGCompressCompleteBottleUPP(SGCompressCompleteBottleUPP userUPP);
#if !OPAQUE_UPP_TYPES
#ifdef __cplusplus
    inline void
    DisposeSGCompressCompleteBottleUPP(SGCompressCompleteBottleUPP userUPP)
    {
        DisposeRoutineDescriptor((UniversalProcPtr)userUPP);
    }
#else
#define DisposeSGCompressCompleteBottleUPP(userUPP) \
    DisposeRoutineDescriptor(userUPP)
#endif
#endif
 
    void
    DisposeSGAddFrameBottleUPP(SGAddFrameBottleUPP userUPP);
#if !OPAQUE_UPP_TYPES
#ifdef __cplusplus
    inline void DisposeSGAddFrameBottleUPP(SGAddFrameBottleUPP userUPP)
    {
        DisposeRoutineDescriptor((UniversalProcPtr)userUPP);
    }
#else
#define DisposeSGAddFrameBottleUPP(userUPP) DisposeRoutineDescriptor(userUPP)
#endif
#endif
 
    void
    DisposeSGTransferFrameBottleUPP(SGTransferFrameBottleUPP userUPP);
#if !OPAQUE_UPP_TYPES
#ifdef __cplusplus
    inline void DisposeSGTransferFrameBottleUPP(SGTransferFrameBottleUPP userUPP)
    {
        DisposeRoutineDescriptor((UniversalProcPtr)userUPP);
    }
#else
#define DisposeSGTransferFrameBottleUPP(userUPP) \
    DisposeRoutineDescriptor(userUPP)
#endif
#endif
 
    void
    DisposeSGGrabCompressCompleteBottleUPP(SGGrabCompressCompleteBottleUPP userUPP);
#if !OPAQUE_UPP_TYPES
#ifdef __cplusplus
    inline void DisposeSGGrabCompressCompleteBottleUPP(
        SGGrabCompressCompleteBottleUPP userUPP)
    {
        DisposeRoutineDescriptor((UniversalProcPtr)userUPP);
    }
#else
#define DisposeSGGrabCompressCompleteBottleUPP(userUPP) \
    DisposeRoutineDescriptor(userUPP)
#endif
#endif
 
    void
    DisposeSGDisplayCompressBottleUPP(SGDisplayCompressBottleUPP userUPP);
#if !OPAQUE_UPP_TYPES
#ifdef __cplusplus
    inline void
    DisposeSGDisplayCompressBottleUPP(SGDisplayCompressBottleUPP userUPP)
    {
        DisposeRoutineDescriptor((UniversalProcPtr)userUPP);
    }
#else
#define DisposeSGDisplayCompressBottleUPP(userUPP) \
    DisposeRoutineDescriptor(userUPP)
#endif
#endif
 
    void
    InvokeDataHCompletionUPP(Ptr request, long refcon, OSErr err,
                             DataHCompletionUPP userUPP);
#if !OPAQUE_UPP_TYPES
#ifdef __cplusplus
    inline void InvokeDataHCompletionUPP(Ptr request, long refcon, OSErr err,
                                         DataHCompletionUPP userUPP)
    {
        CALL_THREE_PARAMETER_UPP(userUPP, uppDataHCompletionProcInfo, request, refcon,
                                 err);
    }
#else
#define InvokeDataHCompletionUPP(request, refcon, err, userUPP)                \
    CALL_THREE_PARAMETER_UPP((userUPP), uppDataHCompletionProcInfo, (request), \
                             (refcon), (err))
#endif
#endif
 
    void
    InvokeVdigIntUPP(long flags, long refcon, VdigIntUPP userUPP);
#if !OPAQUE_UPP_TYPES
#ifdef __cplusplus
    inline void InvokeVdigIntUPP(long flags, long refcon, VdigIntUPP userUPP)
    {
        CALL_TWO_PARAMETER_UPP(userUPP, uppVdigIntProcInfo, flags, refcon);
    }
#else
#define InvokeVdigIntUPP(flags, refcon, userUPP) \
    CALL_TWO_PARAMETER_UPP((userUPP), uppVdigIntProcInfo, (flags), (refcon))
#endif
#endif
 
    ComponentResult
    InvokeStartDocumentHandlerUPP(long refcon, StartDocumentHandlerUPP userUPP);
#if !OPAQUE_UPP_TYPES
#ifdef __cplusplus
    inline ComponentResult
    InvokeStartDocumentHandlerUPP(long refcon, StartDocumentHandlerUPP userUPP)
    {
        return (ComponentResult)CALL_ONE_PARAMETER_UPP(
            userUPP, uppStartDocumentHandlerProcInfo, refcon);
    }
#else
#define InvokeStartDocumentHandlerUPP(refcon, userUPP) \
    (ComponentResult) CALL_ONE_PARAMETER_UPP(          \
        (userUPP), uppStartDocumentHandlerProcInfo, (refcon))
#endif
#endif
 
    ComponentResult
    InvokeEndDocumentHandlerUPP(long refcon, EndDocumentHandlerUPP userUPP);
#if !OPAQUE_UPP_TYPES
#ifdef __cplusplus
    inline ComponentResult
    InvokeEndDocumentHandlerUPP(long refcon, EndDocumentHandlerUPP userUPP)
    {
        return (ComponentResult)CALL_ONE_PARAMETER_UPP(
            userUPP, uppEndDocumentHandlerProcInfo, refcon);
    }
#else
#define InvokeEndDocumentHandlerUPP(refcon, userUPP) \
    (ComponentResult) CALL_ONE_PARAMETER_UPP(        \
        (userUPP), uppEndDocumentHandlerProcInfo, (refcon))
#endif
#endif
 
    ComponentResult
    InvokeStartElementHandlerUPP(const char *name, const char **atts, long refcon,
                                 StartElementHandlerUPP userUPP);
#if !OPAQUE_UPP_TYPES
#ifdef __cplusplus
    inline ComponentResult
    InvokeStartElementHandlerUPP(const char *name, const char **atts, long refcon,
                                 StartElementHandlerUPP userUPP)
    {
        return (ComponentResult)CALL_THREE_PARAMETER_UPP(
            userUPP, uppStartElementHandlerProcInfo, name, atts, refcon);
    }
#else
#define InvokeStartElementHandlerUPP(name, atts, refcon, userUPP) \
    (ComponentResult) CALL_THREE_PARAMETER_UPP(                   \
        (userUPP), uppStartElementHandlerProcInfo, (name), (atts), (refcon))
#endif
#endif
 
    ComponentResult
    InvokeEndElementHandlerUPP(const char *name, long refcon,
                               EndElementHandlerUPP userUPP);
#if !OPAQUE_UPP_TYPES
#ifdef __cplusplus
    inline ComponentResult
    InvokeEndElementHandlerUPP(const char *name, long refcon,
                               EndElementHandlerUPP userUPP)
    {
        return (ComponentResult)CALL_TWO_PARAMETER_UPP(
            userUPP, uppEndElementHandlerProcInfo, name, refcon);
    }
#else
#define InvokeEndElementHandlerUPP(name, refcon, userUPP) \
    (ComponentResult) CALL_TWO_PARAMETER_UPP(             \
        (userUPP), uppEndElementHandlerProcInfo, (name), (refcon))
#endif
#endif
 
    ComponentResult
    InvokeCharDataHandlerUPP(const char *charData, long refcon,
                             CharDataHandlerUPP userUPP);
#if !OPAQUE_UPP_TYPES
#ifdef __cplusplus
    inline ComponentResult InvokeCharDataHandlerUPP(const char *charData,
                                                    long refcon,
                                                    CharDataHandlerUPP userUPP)
    {
        return (ComponentResult)CALL_TWO_PARAMETER_UPP(
            userUPP, uppCharDataHandlerProcInfo, charData, refcon);
    }
#else
#define InvokeCharDataHandlerUPP(charData, refcon, userUPP) \
    (ComponentResult) CALL_TWO_PARAMETER_UPP(               \
        (userUPP), uppCharDataHandlerProcInfo, (charData), (refcon))
#endif
#endif
 
    ComponentResult
    InvokePreprocessInstructionHandlerUPP(const char *name, const char **atts,
                                          long refcon,
                                          PreprocessInstructionHandlerUPP userUPP);
#if !OPAQUE_UPP_TYPES
#ifdef __cplusplus
    inline ComponentResult
    InvokePreprocessInstructionHandlerUPP(const char *name, const char **atts,
                                          long refcon,
                                          PreprocessInstructionHandlerUPP userUPP)
    {
        return (ComponentResult)CALL_THREE_PARAMETER_UPP(
            userUPP, uppPreprocessInstructionHandlerProcInfo, name, atts, refcon);
    }
#else
#define InvokePreprocessInstructionHandlerUPP(name, atts, refcon, userUPP)  \
    (ComponentResult) CALL_THREE_PARAMETER_UPP(                             \
        (userUPP), uppPreprocessInstructionHandlerProcInfo, (name), (atts), \
        (refcon))
#endif
#endif
 
    ComponentResult
    InvokeCommentHandlerUPP(const char *comment, long refcon,
                            CommentHandlerUPP userUPP);
#if !OPAQUE_UPP_TYPES
#ifdef __cplusplus
    inline ComponentResult InvokeCommentHandlerUPP(const char *comment, long refcon,
                                                   CommentHandlerUPP userUPP)
    {
        return (ComponentResult)CALL_TWO_PARAMETER_UPP(
            userUPP, uppCommentHandlerProcInfo, comment, refcon);
    }
#else
#define InvokeCommentHandlerUPP(comment, refcon, userUPP) \
    (ComponentResult) CALL_TWO_PARAMETER_UPP(             \
        (userUPP), uppCommentHandlerProcInfo, (comment), (refcon))
#endif
#endif
 
    OSErr
    InvokeSGDataUPP(SGChannel c, Ptr p, long len, long *offset, long chRefCon,
                    TimeValue time, short writeType, long refCon,
                    SGDataUPP userUPP);
#if !OPAQUE_UPP_TYPES
#ifdef __cplusplus
    inline OSErr InvokeSGDataUPP(SGChannel c, Ptr p, long len, long *offset,
                                 long chRefCon, TimeValue time, short writeType,
                                 long refCon, SGDataUPP userUPP)
    {
        return (OSErr)CALL_EIGHT_PARAMETER_UPP(userUPP, uppSGDataProcInfo, c, p, len,
                                               offset, chRefCon, time, writeType,
                                               refCon);
    }
#else
#define InvokeSGDataUPP(c, p, len, offset, chRefCon, time, writeType, refCon, \
                        userUPP)                                              \
    (OSErr) CALL_EIGHT_PARAMETER_UPP((userUPP), uppSGDataProcInfo, (c), (p),  \
                                     (len), (offset), (chRefCon), (time),     \
                                     (writeType), (refCon))
#endif
#endif
 
    Boolean
    InvokeSGModalFilterUPP(DialogRef theDialog, const EventRecord *theEvent,
                           short *itemHit, long refCon, SGModalFilterUPP userUPP);
#if !OPAQUE_UPP_TYPES
#ifdef __cplusplus
    inline Boolean InvokeSGModalFilterUPP(DialogRef theDialog,
                                          const EventRecord *theEvent,
                                          short *itemHit, long refCon,
                                          SGModalFilterUPP userUPP)
    {
        return (Boolean)CALL_FOUR_PARAMETER_UPP(userUPP, uppSGModalFilterProcInfo,
                                                theDialog, theEvent, itemHit, refCon);
    }
#else
#define InvokeSGModalFilterUPP(theDialog, theEvent, itemHit, refCon, userUPP) \
    (Boolean)                                                                 \
        CALL_FOUR_PARAMETER_UPP((userUPP), uppSGModalFilterProcInfo,          \
                                (theDialog), (theEvent), (itemHit), (refCon))
#endif
#endif
 
    ComponentResult
    InvokeSGGrabBottleUPP(SGChannel c, short bufferNum, long refCon,
                          SGGrabBottleUPP userUPP);
#if !OPAQUE_UPP_TYPES
#ifdef __cplusplus
    inline ComponentResult InvokeSGGrabBottleUPP(SGChannel c, short bufferNum,
                                                 long refCon,
                                                 SGGrabBottleUPP userUPP)
    {
        return (ComponentResult)CALL_THREE_PARAMETER_UPP(
            userUPP, uppSGGrabBottleProcInfo, c, bufferNum, refCon);
    }
#else
#define InvokeSGGrabBottleUPP(c, bufferNum, refCon, userUPP) \
    (ComponentResult) CALL_THREE_PARAMETER_UPP(              \
        (userUPP), uppSGGrabBottleProcInfo, (c), (bufferNum), (refCon))
#endif
#endif
 
    ComponentResult
    InvokeSGGrabCompleteBottleUPP(SGChannel c, short bufferNum, Boolean *done,
                                  long refCon, SGGrabCompleteBottleUPP userUPP);
#if !OPAQUE_UPP_TYPES
#ifdef __cplusplus
    inline ComponentResult
    InvokeSGGrabCompleteBottleUPP(SGChannel c, short bufferNum, Boolean *done,
                                  long refCon, SGGrabCompleteBottleUPP userUPP)
    {
        return (ComponentResult)CALL_FOUR_PARAMETER_UPP(
            userUPP, uppSGGrabCompleteBottleProcInfo, c, bufferNum, done, refCon);
    }
#else
#define InvokeSGGrabCompleteBottleUPP(c, bufferNum, done, refCon, userUPP)       \
    (ComponentResult)                                                            \
        CALL_FOUR_PARAMETER_UPP((userUPP), uppSGGrabCompleteBottleProcInfo, (c), \
                                (bufferNum), (done), (refCon))
#endif
#endif
 
    ComponentResult
    InvokeSGDisplayBottleUPP(SGChannel c, short bufferNum, MatrixRecord *mp,
                             RgnHandle clipRgn, long refCon,
                             SGDisplayBottleUPP userUPP);
#if !OPAQUE_UPP_TYPES
#ifdef __cplusplus
    inline ComponentResult InvokeSGDisplayBottleUPP(SGChannel c, short bufferNum,
                                                    MatrixRecord *mp,
                                                    RgnHandle clipRgn, long refCon,
                                                    SGDisplayBottleUPP userUPP)
    {
        return (ComponentResult)CALL_FIVE_PARAMETER_UPP(
            userUPP, uppSGDisplayBottleProcInfo, c, bufferNum, mp, clipRgn, refCon);
    }
#else
#define InvokeSGDisplayBottleUPP(c, bufferNum, mp, clipRgn, refCon, userUPP) \
    (ComponentResult)                                                        \
        CALL_FIVE_PARAMETER_UPP((userUPP), uppSGDisplayBottleProcInfo, (c),  \
                                (bufferNum), (mp), (clipRgn), (refCon))
#endif
#endif
 
    ComponentResult
    InvokeSGCompressBottleUPP(SGChannel c, short bufferNum, long refCon,
                              SGCompressBottleUPP userUPP);
#if !OPAQUE_UPP_TYPES
#ifdef __cplusplus
    inline ComponentResult InvokeSGCompressBottleUPP(SGChannel c, short bufferNum,
                                                     long refCon,
                                                     SGCompressBottleUPP userUPP)
    {
        return (ComponentResult)CALL_THREE_PARAMETER_UPP(
            userUPP, uppSGCompressBottleProcInfo, c, bufferNum, refCon);
    }
#else
#define InvokeSGCompressBottleUPP(c, bufferNum, refCon, userUPP) \
    (ComponentResult) CALL_THREE_PARAMETER_UPP(                  \
        (userUPP), uppSGCompressBottleProcInfo, (c), (bufferNum), (refCon))
#endif
#endif
 
    ComponentResult
    InvokeSGCompressCompleteBottleUPP(SGChannel c, short bufferNum, Boolean *done,
                                      SGCompressInfo *ci, long refCon,
                                      SGCompressCompleteBottleUPP userUPP);
#if !OPAQUE_UPP_TYPES
#ifdef __cplusplus
    inline ComponentResult
    InvokeSGCompressCompleteBottleUPP(SGChannel c, short bufferNum, Boolean *done,
                                      SGCompressInfo *ci, long refCon,
                                      SGCompressCompleteBottleUPP userUPP)
    {
        return (ComponentResult)CALL_FIVE_PARAMETER_UPP(
            userUPP, uppSGCompressCompleteBottleProcInfo, c, bufferNum, done, ci,
            refCon);
    }
#else
#define InvokeSGCompressCompleteBottleUPP(c, bufferNum, done, ci, refCon,       \
                                          userUPP)                              \
    (ComponentResult)                                                           \
        CALL_FIVE_PARAMETER_UPP((userUPP), uppSGCompressCompleteBottleProcInfo, \
                                (c), (bufferNum), (done), (ci), (refCon))
#endif
#endif
 
    ComponentResult
    InvokeSGAddFrameBottleUPP(SGChannel c, short bufferNum, TimeValue atTime,
                              TimeScale scale, const SGCompressInfo *ci,
                              long refCon, SGAddFrameBottleUPP userUPP);
#if !OPAQUE_UPP_TYPES
#ifdef __cplusplus
    inline ComponentResult
    InvokeSGAddFrameBottleUPP(SGChannel c, short bufferNum, TimeValue atTime,
                              TimeScale scale, const SGCompressInfo *ci,
                              long refCon, SGAddFrameBottleUPP userUPP)
    {
        return (ComponentResult)CALL_SIX_PARAMETER_UPP(
            userUPP, uppSGAddFrameBottleProcInfo, c, bufferNum, atTime, scale, ci,
            refCon);
    }
#else
#define InvokeSGAddFrameBottleUPP(c, bufferNum, atTime, scale, ci, refCon,  \
                                  userUPP)                                  \
    (ComponentResult)                                                       \
        CALL_SIX_PARAMETER_UPP((userUPP), uppSGAddFrameBottleProcInfo, (c), \
                               (bufferNum), (atTime), (scale), (ci), (refCon))
#endif
#endif
 
    ComponentResult
    InvokeSGTransferFrameBottleUPP(SGChannel c, short bufferNum, MatrixRecord *mp,
                                   RgnHandle clipRgn, long refCon,
                                   SGTransferFrameBottleUPP userUPP);
#if !OPAQUE_UPP_TYPES
#ifdef __cplusplus
    inline ComponentResult
    InvokeSGTransferFrameBottleUPP(SGChannel c, short bufferNum, MatrixRecord *mp,
                                   RgnHandle clipRgn, long refCon,
                                   SGTransferFrameBottleUPP userUPP)
    {
        return (ComponentResult)CALL_FIVE_PARAMETER_UPP(
            userUPP, uppSGTransferFrameBottleProcInfo, c, bufferNum, mp, clipRgn,
            refCon);
    }
#else
#define InvokeSGTransferFrameBottleUPP(c, bufferNum, mp, clipRgn, refCon,    \
                                       userUPP)                              \
    (ComponentResult)                                                        \
        CALL_FIVE_PARAMETER_UPP((userUPP), uppSGTransferFrameBottleProcInfo, \
                                (c), (bufferNum), (mp), (clipRgn), (refCon))
#endif
#endif
 
    ComponentResult
    InvokeSGGrabCompressCompleteBottleUPP(SGChannel c, Boolean *done,
                                          SGCompressInfo *ci, TimeRecord *t,
                                          long refCon,
                                          SGGrabCompressCompleteBottleUPP userUPP);
#if !OPAQUE_UPP_TYPES
#ifdef __cplusplus
    inline ComponentResult InvokeSGGrabCompressCompleteBottleUPP(
        SGChannel c, Boolean *done, SGCompressInfo *ci, TimeRecord *t, long refCon,
        SGGrabCompressCompleteBottleUPP userUPP)
    {
        return (ComponentResult)CALL_FIVE_PARAMETER_UPP(
            userUPP, uppSGGrabCompressCompleteBottleProcInfo, c, done, ci, t, refCon);
    }
#else
#define InvokeSGGrabCompressCompleteBottleUPP(c, done, ci, t, refCon, userUPP) \
    (ComponentResult) CALL_FIVE_PARAMETER_UPP(                                 \
        (userUPP), uppSGGrabCompressCompleteBottleProcInfo, (c), (done), (ci), \
        (t), (refCon))
#endif
#endif
 
    ComponentResult
    InvokeSGDisplayCompressBottleUPP(SGChannel c, Ptr dataPtr,
                                     ImageDescriptionHandle desc, MatrixRecord *mp,
                                     RgnHandle clipRgn, long refCon,
                                     SGDisplayCompressBottleUPP userUPP);
#if !OPAQUE_UPP_TYPES
#ifdef __cplusplus
    inline ComponentResult InvokeSGDisplayCompressBottleUPP(
        SGChannel c, Ptr dataPtr, ImageDescriptionHandle desc, MatrixRecord *mp,
        RgnHandle clipRgn, long refCon, SGDisplayCompressBottleUPP userUPP)
    {
        return (ComponentResult)CALL_SIX_PARAMETER_UPP(
            userUPP, uppSGDisplayCompressBottleProcInfo, c, dataPtr, desc, mp,
            clipRgn, refCon);
    }
#else
#define InvokeSGDisplayCompressBottleUPP(c, dataPtr, desc, mp, clipRgn,        \
                                         refCon, userUPP)                      \
    (ComponentResult) CALL_SIX_PARAMETER_UPP(                                  \
        (userUPP), uppSGDisplayCompressBottleProcInfo, (c), (dataPtr), (desc), \
        (mp), (clipRgn), (refCon))
#endif
#endif
 
#if CALL_NOT_IN_CARBON || OLDROUTINENAMES
#define NewDataHCompletionProc(userRoutine) NewDataHCompletionUPP(userRoutine)
#define NewVdigIntProc(userRoutine) NewVdigIntUPP(userRoutine)
#define NewStartDocumentHandlerProc(userRoutine) \
    NewStartDocumentHandlerUPP(userRoutine)
#define NewEndDocumentHandlerProc(userRoutine) \
    NewEndDocumentHandlerUPP(userRoutine)
#define NewStartElementHandlerProc(userRoutine) \
    NewStartElementHandlerUPP(userRoutine)
#define NewEndElementHandlerProc(userRoutine) \
    NewEndElementHandlerUPP(userRoutine)
#define NewCharDataHandlerProc(userRoutine) NewCharDataHandlerUPP(userRoutine)
#define NewPreprocessInstructionHandlerProc(userRoutine) \
    NewPreprocessInstructionHandlerUPP(userRoutine)
#define NewCommentHandlerProc(userRoutine) NewCommentHandlerUPP(userRoutine)
#define NewSGDataProc(userRoutine) NewSGDataUPP(userRoutine)
#define NewSGModalFilterProc(userRoutine) NewSGModalFilterUPP(userRoutine)
#define NewSGGrabBottleProc(userRoutine) NewSGGrabBottleUPP(userRoutine)
#define NewSGGrabCompleteBottleProc(userRoutine) \
    NewSGGrabCompleteBottleUPP(userRoutine)
#define NewSGDisplayBottleProc(userRoutine) NewSGDisplayBottleUPP(userRoutine)
#define NewSGCompressBottleProc(userRoutine) NewSGCompressBottleUPP(userRoutine)
#define NewSGCompressCompleteBottleProc(userRoutine) \
    NewSGCompressCompleteBottleUPP(userRoutine)
#define NewSGAddFrameBottleProc(userRoutine) NewSGAddFrameBottleUPP(userRoutine)
#define NewSGTransferFrameBottleProc(userRoutine) \
    NewSGTransferFrameBottleUPP(userRoutine)
#define NewSGGrabCompressCompleteBottleProc(userRoutine) \
    NewSGGrabCompressCompleteBottleUPP(userRoutine)
#define NewSGDisplayCompressBottleProc(userRoutine) \
    NewSGDisplayCompressBottleUPP(userRoutine)
#define CallDataHCompletionProc(userRoutine, request, refcon, err) \
    InvokeDataHCompletionUPP(request, refcon, err, userRoutine)
#define CallVdigIntProc(userRoutine, flags, refcon) \
    InvokeVdigIntUPP(flags, refcon, userRoutine)
#define CallStartDocumentHandlerProc(userRoutine, refcon) \
    InvokeStartDocumentHandlerUPP(refcon, userRoutine)
#define CallEndDocumentHandlerProc(userRoutine, refcon) \
    InvokeEndDocumentHandlerUPP(refcon, userRoutine)
#define CallStartElementHandlerProc(userRoutine, name, atts, refcon) \
    InvokeStartElementHandlerUPP(name, atts, refcon, userRoutine)
#define CallEndElementHandlerProc(userRoutine, name, refcon) \
    InvokeEndElementHandlerUPP(name, refcon, userRoutine)
#define CallCharDataHandlerProc(userRoutine, charData, refcon) \
    InvokeCharDataHandlerUPP(charData, refcon, userRoutine)
#define CallPreprocessInstructionHandlerProc(userRoutine, name, atts, refcon) \
    InvokePreprocessInstructionHandlerUPP(name, atts, refcon, userRoutine)
#define CallCommentHandlerProc(userRoutine, comment, refcon) \
    InvokeCommentHandlerUPP(comment, refcon, userRoutine)
#define CallSGDataProc(userRoutine, c, p, len, offset, chRefCon, time,    \
                       writeType, refCon)                                 \
    InvokeSGDataUPP(c, p, len, offset, chRefCon, time, writeType, refCon, \
                    userRoutine)
#define CallSGModalFilterProc(userRoutine, theDialog, theEvent, itemHit, \
                              refCon)                                    \
    InvokeSGModalFilterUPP(theDialog, theEvent, itemHit, refCon, userRoutine)
#define CallSGGrabBottleProc(userRoutine, c, bufferNum, refCon) \
    InvokeSGGrabBottleUPP(c, bufferNum, refCon, userRoutine)
#define CallSGGrabCompleteBottleProc(userRoutine, c, bufferNum, done, refCon) \
    InvokeSGGrabCompleteBottleUPP(c, bufferNum, done, refCon, userRoutine)
#define CallSGDisplayBottleProc(userRoutine, c, bufferNum, mp, clipRgn, \
                                refCon)                                 \
    InvokeSGDisplayBottleUPP(c, bufferNum, mp, clipRgn, refCon, userRoutine)
#define CallSGCompressBottleProc(userRoutine, c, bufferNum, refCon) \
    InvokeSGCompressBottleUPP(c, bufferNum, refCon, userRoutine)
#define CallSGCompressCompleteBottleProc(userRoutine, c, bufferNum, done, ci, \
                                         refCon)                              \
    InvokeSGCompressCompleteBottleUPP(c, bufferNum, done, ci, refCon, userRoutine)
#define CallSGAddFrameBottleProc(userRoutine, c, bufferNum, atTime, scale, ci, \
                                 refCon)                                       \
    InvokeSGAddFrameBottleUPP(c, bufferNum, atTime, scale, ci, refCon,         \
                              userRoutine)
#define CallSGTransferFrameBottleProc(userRoutine, c, bufferNum, mp, clipRgn, \
                                      refCon)                                 \
    InvokeSGTransferFrameBottleUPP(c, bufferNum, mp, clipRgn, refCon, userRoutine)
#define CallSGGrabCompressCompleteBottleProc(userRoutine, c, done, ci, t, \
                                             refCon)                      \
    InvokeSGGrabCompressCompleteBottleUPP(c, done, ci, t, refCon, userRoutine)
#define CallSGDisplayCompressBottleProc(userRoutine, c, dataPtr, desc, mp,  \
                                        clipRgn, refCon)                    \
    InvokeSGDisplayCompressBottleUPP(c, dataPtr, desc, mp, clipRgn, refCon, \
                                     userRoutine)
#endif 
    enum
    {
        kClockGetTimeSelect = 0x0001,
        kClockNewCallBackSelect = 0x0002,
        kClockDisposeCallBackSelect = 0x0003,
        kClockCallMeWhenSelect = 0x0004,
        kClockCancelCallBackSelect = 0x0005,
        kClockRateChangedSelect = 0x0006,
        kClockTimeChangedSelect = 0x0007,
        kClockSetTimeBaseSelect = 0x0008,
        kClockStartStopChangedSelect = 0x0009,
        kClockGetRateSelect = 0x000A,
        kSCGetCompressionExtendedSelect = 0x0001,
        kSCPositionRectSelect = 0x0002,
        kSCPositionDialogSelect = 0x0003,
        kSCSetTestImagePictHandleSelect = 0x0004,
        kSCSetTestImagePictFileSelect = 0x0005,
        kSCSetTestImagePixMapSelect = 0x0006,
        kSCGetBestDeviceRectSelect = 0x0007,
        kSCRequestImageSettingsSelect = 0x000A,
        kSCCompressImageSelect = 0x000B,
        kSCCompressPictureSelect = 0x000C,
        kSCCompressPictureFileSelect = 0x000D,
        kSCRequestSequenceSettingsSelect = 0x000E,
        kSCCompressSequenceBeginSelect = 0x000F,
        kSCCompressSequenceFrameSelect = 0x0010,
        kSCCompressSequenceEndSelect = 0x0011,
        kSCDefaultPictHandleSettingsSelect = 0x0012,
        kSCDefaultPictFileSettingsSelect = 0x0013,
        kSCDefaultPixMapSettingsSelect = 0x0014,
        kSCGetInfoSelect = 0x0015,
        kSCSetInfoSelect = 0x0016,
        kSCNewGWorldSelect = 0x0017,
        kSCSetCompressFlagsSelect = 0x0018,
        kSCGetCompressFlagsSelect = 0x0019,
        kSCGetSettingsAsTextSelect = 0x001A,
        kSCGetSettingsAsAtomContainerSelect = 0x001B,
        kSCSetSettingsFromAtomContainerSelect = 0x001C,
        kSCCompressSequenceFrameAsyncSelect = 0x001D,
        kSCAsyncIdleSelect = 0x001E,
        kTweenerInitializeSelect = 0x0001,
        kTweenerDoTweenSelect = 0x0002,
        kTweenerResetSelect = 0x0003,
        kTCGetCurrentTimeCodeSelect = 0x0101,
        kTCGetTimeCodeAtTimeSelect = 0x0102,
        kTCTimeCodeToStringSelect = 0x0103,
        kTCTimeCodeToFrameNumberSelect = 0x0104,
        kTCFrameNumberToTimeCodeSelect = 0x0105,
        kTCGetSourceRefSelect = 0x0106,
        kTCSetSourceRefSelect = 0x0107,
        kTCSetTimeCodeFlagsSelect = 0x0108,
        kTCGetTimeCodeFlagsSelect = 0x0109,
        kTCSetDisplayOptionsSelect = 0x010A,
        kTCGetDisplayOptionsSelect = 0x010B,
        kMovieImportHandleSelect = 0x0001,
        kMovieImportFileSelect = 0x0002,
        kMovieImportSetSampleDurationSelect = 0x0003,
        kMovieImportSetSampleDescriptionSelect = 0x0004,
        kMovieImportSetMediaFileSelect = 0x0005,
        kMovieImportSetDimensionsSelect = 0x0006,
        kMovieImportSetChunkSizeSelect = 0x0007,
        kMovieImportSetProgressProcSelect = 0x0008,
        kMovieImportSetAuxiliaryDataSelect = 0x0009,
        kMovieImportSetFromScrapSelect = 0x000A,
        kMovieImportDoUserDialogSelect = 0x000B,
        kMovieImportSetDurationSelect = 0x000C,
        kMovieImportGetAuxiliaryDataTypeSelect = 0x000D,
        kMovieImportValidateSelect = 0x000E,
        kMovieImportGetFileTypeSelect = 0x000F,
        kMovieImportDataRefSelect = 0x0010,
        kMovieImportGetSampleDescriptionSelect = 0x0011,
        kMovieImportGetMIMETypeListSelect = 0x0012,
        kMovieImportSetOffsetAndLimitSelect = 0x0013,
        kMovieImportGetSettingsAsAtomContainerSelect = 0x0014,
        kMovieImportSetSettingsFromAtomContainerSelect = 0x0015,
        kMovieImportSetOffsetAndLimit64Select = 0x0016,
        kMovieImportIdleSelect = 0x0017,
        kMovieImportValidateDataRefSelect = 0x0018,
        kMovieImportGetLoadStateSelect = 0x0019,
        kMovieImportGetMaxLoadedTimeSelect = 0x001A,
        kMovieImportEstimateCompletionTimeSelect = 0x001B,
        kMovieImportSetDontBlockSelect = 0x001C,
        kMovieImportGetDontBlockSelect = 0x001D,
        kMovieExportToHandleSelect = 0x0080,
        kMovieExportToFileSelect = 0x0081,
        kMovieExportGetAuxiliaryDataSelect = 0x0083,
        kMovieExportSetProgressProcSelect = 0x0084,
        kMovieExportSetSampleDescriptionSelect = 0x0085,
        kMovieExportDoUserDialogSelect = 0x0086,
        kMovieExportGetCreatorTypeSelect = 0x0087,
        kMovieExportToDataRefSelect = 0x0088,
        kMovieExportFromProceduresToDataRefSelect = 0x0089,
        kMovieExportAddDataSourceSelect = 0x008A,
        kMovieExportValidateSelect = 0x008B,
        kMovieExportGetSettingsAsAtomContainerSelect = 0x008C,
        kMovieExportSetSettingsFromAtomContainerSelect = 0x008D,
        kMovieExportGetFileNameExtensionSelect = 0x008E,
        kMovieExportGetShortFileTypeStringSelect = 0x008F,
        kMovieExportGetSourceMediaTypeSelect = 0x0090,
        kMovieExportSetGetMoviePropertyProcSelect = 0x0091,
        kTextExportGetDisplayDataSelect = 0x0100,
        kTextExportGetTimeFractionSelect = 0x0101,
        kTextExportSetTimeFractionSelect = 0x0102,
        kTextExportGetSettingsSelect = 0x0103,
        kTextExportSetSettingsSelect = 0x0104,
        kMIDIImportGetSettingsSelect = 0x0100,
        kMIDIImportSetSettingsSelect = 0x0101,
        kMovieExportNewGetDataAndPropertiesProcsSelect = 0x0100,
        kMovieExportDisposeGetDataAndPropertiesProcsSelect = 0x0101,
        kGraphicsImageImportSetSequenceEnabledSelect = 0x0100,
        kGraphicsImageImportGetSequenceEnabledSelect = 0x0101,
        kPreviewShowDataSelect = 0x0001,
        kPreviewMakePreviewSelect = 0x0002,
        kPreviewMakePreviewReferenceSelect = 0x0003,
        kPreviewEventSelect = 0x0004,
        kDataCodecDecompressSelect = 0x0001,
        kDataCodecGetCompressBufferSizeSelect = 0x0002,
        kDataCodecCompressSelect = 0x0003,
        kDataCodecBeginInterruptSafeSelect = 0x0004,
        kDataCodecEndInterruptSafeSelect = 0x0005,
        kDataCodecDecompressPartialSelect = 0x0006,
        kDataCodecCompressPartialSelect = 0x0007,
        kDataHGetDataSelect = 0x0002,
        kDataHPutDataSelect = 0x0003,
        kDataHFlushDataSelect = 0x0004,
        kDataHOpenForWriteSelect = 0x0005,
        kDataHCloseForWriteSelect = 0x0006,
        kDataHOpenForReadSelect = 0x0008,
        kDataHCloseForReadSelect = 0x0009,
        kDataHSetDataRefSelect = 0x000A,
        kDataHGetDataRefSelect = 0x000B,
        kDataHCompareDataRefSelect = 0x000C,
        kDataHTaskSelect = 0x000D,
        kDataHScheduleDataSelect = 0x000E,
        kDataHFinishDataSelect = 0x000F,
        kDataHFlushCacheSelect = 0x0010,
        kDataHResolveDataRefSelect = 0x0011,
        kDataHGetFileSizeSelect = 0x0012,
        kDataHCanUseDataRefSelect = 0x0013,
        kDataHGetVolumeListSelect = 0x0014,
        kDataHWriteSelect = 0x0015,
        kDataHPreextendSelect = 0x0016,
        kDataHSetFileSizeSelect = 0x0017,
        kDataHGetFreeSpaceSelect = 0x0018,
        kDataHCreateFileSelect = 0x0019,
        kDataHGetPreferredBlockSizeSelect = 0x001A,
        kDataHGetDeviceIndexSelect = 0x001B,
        kDataHIsStreamingDataHandlerSelect = 0x001C,
        kDataHGetDataInBufferSelect = 0x001D,
        kDataHGetScheduleAheadTimeSelect = 0x001E,
        kDataHSetCacheSizeLimitSelect = 0x001F,
        kDataHGetCacheSizeLimitSelect = 0x0020,
        kDataHGetMovieSelect = 0x0021,
        kDataHAddMovieSelect = 0x0022,
        kDataHUpdateMovieSelect = 0x0023,
        kDataHDoesBufferSelect = 0x0024,
        kDataHGetFileNameSelect = 0x0025,
        kDataHGetAvailableFileSizeSelect = 0x0026,
        kDataHGetMacOSFileTypeSelect = 0x0027,
        kDataHGetMIMETypeSelect = 0x0028,
        kDataHSetDataRefWithAnchorSelect = 0x0029,
        kDataHGetDataRefWithAnchorSelect = 0x002A,
        kDataHSetMacOSFileTypeSelect = 0x002B,
        kDataHSetTimeBaseSelect = 0x002C,
        kDataHGetInfoFlagsSelect = 0x002D,
        kDataHScheduleData64Select = 0x002E,
        kDataHWrite64Select = 0x002F,
        kDataHGetFileSize64Select = 0x0030,
        kDataHPreextend64Select = 0x0031,
        kDataHSetFileSize64Select = 0x0032,
        kDataHGetFreeSpace64Select = 0x0033,
        kDataHAppend64Select = 0x0034,
        kDataHReadAsyncSelect = 0x0035,
        kDataHPollReadSelect = 0x0036,
        kDataHGetDataAvailabilitySelect = 0x0037,
        kDataHGetFileSizeAsyncSelect = 0x003A,
        kDataHGetDataRefAsTypeSelect = 0x003B,
        kDataHSetDataRefExtensionSelect = 0x003C,
        kDataHGetDataRefExtensionSelect = 0x003D,
        kDataHGetMovieWithFlagsSelect = 0x003E,
        kDataHGetFileTypeOrderingSelect = 0x0040,
        kDataHCreateFileWithFlagsSelect = 0x0041,
        kDataHGetMIMETypeAsyncSelect = 0x0042,
        kDataHGetInfoSelect = 0x0043,
        kDataHPlaybackHintsSelect = 0x0103,
        kDataHPlaybackHints64Select = 0x010E,
        kDataHGetDataRateSelect = 0x0110,
        kDataHSetTimeHintsSelect = 0x0111,
        kVDGetMaxSrcRectSelect = 0x0001,
        kVDGetActiveSrcRectSelect = 0x0002,
        kVDSetDigitizerRectSelect = 0x0003,
        kVDGetDigitizerRectSelect = 0x0004,
        kVDGetVBlankRectSelect = 0x0005,
        kVDGetMaskPixMapSelect = 0x0006,
        kVDGetPlayThruDestinationSelect = 0x0008,
        kVDUseThisCLUTSelect = 0x0009,
        kVDSetInputGammaValueSelect = 0x000A,
        kVDGetInputGammaValueSelect = 0x000B,
        kVDSetBrightnessSelect = 0x000C,
        kVDGetBrightnessSelect = 0x000D,
        kVDSetContrastSelect = 0x000E,
        kVDSetHueSelect = 0x000F,
        kVDSetSharpnessSelect = 0x0010,
        kVDSetSaturationSelect = 0x0011,
        kVDGetContrastSelect = 0x0012,
        kVDGetHueSelect = 0x0013,
        kVDGetSharpnessSelect = 0x0014,
        kVDGetSaturationSelect = 0x0015,
        kVDGrabOneFrameSelect = 0x0016,
        kVDGetMaxAuxBufferSelect = 0x0017,
        kVDGetDigitizerInfoSelect = 0x0019,
        kVDGetCurrentFlagsSelect = 0x001A,
        kVDSetKeyColorSelect = 0x001B,
        kVDGetKeyColorSelect = 0x001C,
        kVDAddKeyColorSelect = 0x001D,
        kVDGetNextKeyColorSelect = 0x001E,
        kVDSetKeyColorRangeSelect = 0x001F,
        kVDGetKeyColorRangeSelect = 0x0020,
        kVDSetDigitizerUserInterruptSelect = 0x0021,
        kVDSetInputColorSpaceModeSelect = 0x0022,
        kVDGetInputColorSpaceModeSelect = 0x0023,
        kVDSetClipStateSelect = 0x0024,
        kVDGetClipStateSelect = 0x0025,
        kVDSetClipRgnSelect = 0x0026,
        kVDClearClipRgnSelect = 0x0027,
        kVDGetCLUTInUseSelect = 0x0028,
        kVDSetPLLFilterTypeSelect = 0x0029,
        kVDGetPLLFilterTypeSelect = 0x002A,
        kVDGetMaskandValueSelect = 0x002B,
        kVDSetMasterBlendLevelSelect = 0x002C,
        kVDSetPlayThruDestinationSelect = 0x002D,
        kVDSetPlayThruOnOffSelect = 0x002E,
        kVDSetFieldPreferenceSelect = 0x002F,
        kVDGetFieldPreferenceSelect = 0x0030,
        kVDPreflightDestinationSelect = 0x0032,
        kVDPreflightGlobalRectSelect = 0x0033,
        kVDSetPlayThruGlobalRectSelect = 0x0034,
        kVDSetInputGammaRecordSelect = 0x0035,
        kVDGetInputGammaRecordSelect = 0x0036,
        kVDSetBlackLevelValueSelect = 0x0037,
        kVDGetBlackLevelValueSelect = 0x0038,
        kVDSetWhiteLevelValueSelect = 0x0039,
        kVDGetWhiteLevelValueSelect = 0x003A,
        kVDGetVideoDefaultsSelect = 0x003B,
        kVDGetNumberOfInputsSelect = 0x003C,
        kVDGetInputFormatSelect = 0x003D,
        kVDSetInputSelect = 0x003E,
        kVDGetInputSelect = 0x003F,
        kVDSetInputStandardSelect = 0x0040,
        kVDSetupBuffersSelect = 0x0041,
        kVDGrabOneFrameAsyncSelect = 0x0042,
        kVDDoneSelect = 0x0043,
        kVDSetCompressionSelect = 0x0044,
        kVDCompressOneFrameAsyncSelect = 0x0045,
        kVDCompressDoneSelect = 0x0046,
        kVDReleaseCompressBufferSelect = 0x0047,
        kVDGetImageDescriptionSelect = 0x0048,
        kVDResetCompressSequenceSelect = 0x0049,
        kVDSetCompressionOnOffSelect = 0x004A,
        kVDGetCompressionTypesSelect = 0x004B,
        kVDSetTimeBaseSelect = 0x004C,
        kVDSetFrameRateSelect = 0x004D,
        kVDGetDataRateSelect = 0x004E,
        kVDGetSoundInputDriverSelect = 0x004F,
        kVDGetDMADepthsSelect = 0x0050,
        kVDGetPreferredTimeScaleSelect = 0x0051,
        kVDReleaseAsyncBuffersSelect = 0x0052,
        kVDSetDataRateSelect = 0x0054,
        kVDGetTimeCodeSelect = 0x0055,
        kVDUseSafeBuffersSelect = 0x0056,
        kVDGetSoundInputSourceSelect = 0x0057,
        kVDGetCompressionTimeSelect = 0x0058,
        kVDSetPreferredPacketSizeSelect = 0x0059,
        kVDSetPreferredImageDimensionsSelect = 0x005A,
        kVDGetPreferredImageDimensionsSelect = 0x005B,
        kVDGetInputNameSelect = 0x005C,
        kVDSetDestinationPortSelect = 0x005D,
        kXMLParseDataRefSelect = 0x0001,
        kXMLParseFileSelect = 0x0002,
        kXMLParseDisposeXMLDocSelect = 0x0003,
        kXMLParseGetDetailedParseErrorSelect = 0x0004,
        kXMLParseAddElementSelect = 0x0005,
        kXMLParseAddAttributeSelect = 0x0006,
        kXMLParseAddMultipleAttributesSelect = 0x0007,
        kXMLParseAddAttributeAndValueSelect = 0x0008,
        kXMLParseAddMultipleAttributesAndValuesSelect = 0x0009,
        kXMLParseAddAttributeValueKindSelect = 0x000A,
        kXMLParseAddNameSpaceSelect = 0x000B,
        kXMLParseSetOffsetAndLimitSelect = 0x000C,
        kXMLParseSetEventParseRefConSelect = 0x000D,
        kXMLParseSetStartDocumentHandlerSelect = 0x000E,
        kXMLParseSetEndDocumentHandlerSelect = 0x000F,
        kXMLParseSetStartElementHandlerSelect = 0x0010,
        kXMLParseSetEndElementHandlerSelect = 0x0011,
        kXMLParseSetCharDataHandlerSelect = 0x0012,
        kXMLParseSetPreprocessInstructionHandlerSelect = 0x0013,
        kXMLParseSetCommentHandlerSelect = 0x0014,
        kSGInitializeSelect = 0x0001,
        kSGSetDataOutputSelect = 0x0002,
        kSGGetDataOutputSelect = 0x0003,
        kSGSetGWorldSelect = 0x0004,
        kSGGetGWorldSelect = 0x0005,
        kSGNewChannelSelect = 0x0006,
        kSGDisposeChannelSelect = 0x0007,
        kSGStartPreviewSelect = 0x0010,
        kSGStartRecordSelect = 0x0011,
        kSGIdleSelect = 0x0012,
        kSGStopSelect = 0x0013,
        kSGPauseSelect = 0x0014,
        kSGPrepareSelect = 0x0015,
        kSGReleaseSelect = 0x0016,
        kSGGetMovieSelect = 0x0017,
        kSGSetMaximumRecordTimeSelect = 0x0018,
        kSGGetMaximumRecordTimeSelect = 0x0019,
        kSGGetStorageSpaceRemainingSelect = 0x001A,
        kSGGetTimeRemainingSelect = 0x001B,
        kSGGrabPictSelect = 0x001C,
        kSGGetLastMovieResIDSelect = 0x001D,
        kSGSetFlagsSelect = 0x001E,
        kSGGetFlagsSelect = 0x001F,
        kSGSetDataProcSelect = 0x0020,
        kSGNewChannelFromComponentSelect = 0x0021,
        kSGDisposeDeviceListSelect = 0x0022,
        kSGAppendDeviceListToMenuSelect = 0x0023,
        kSGSetSettingsSelect = 0x0024,
        kSGGetSettingsSelect = 0x0025,
        kSGGetIndChannelSelect = 0x0026,
        kSGUpdateSelect = 0x0027,
        kSGGetPauseSelect = 0x0028,
        kSGSettingsDialogSelect = 0x0029,
        kSGGetAlignmentProcSelect = 0x002A,
        kSGSetChannelSettingsSelect = 0x002B,
        kSGGetChannelSettingsSelect = 0x002C,
        kSGGetModeSelect = 0x002D,
        kSGSetDataRefSelect = 0x002E,
        kSGGetDataRefSelect = 0x002F,
        kSGNewOutputSelect = 0x0030,
        kSGDisposeOutputSelect = 0x0031,
        kSGSetOutputFlagsSelect = 0x0032,
        kSGSetChannelOutputSelect = 0x0033,
        kSGGetDataOutputStorageSpaceRemainingSelect = 0x0034,
        kSGHandleUpdateEventSelect = 0x0035,
        kSGSetOutputNextOutputSelect = 0x0036,
        kSGGetOutputNextOutputSelect = 0x0037,
        kSGSetOutputMaximumOffsetSelect = 0x0038,
        kSGGetOutputMaximumOffsetSelect = 0x0039,
        kSGGetOutputDataReferenceSelect = 0x003A,
        kSGWriteExtendedMovieDataSelect = 0x003B,
        kSGGetStorageSpaceRemaining64Select = 0x003C,
        kSGGetDataOutputStorageSpaceRemaining64Select = 0x003D,
        kSGWriteMovieDataSelect = 0x0100,
        kSGAddFrameReferenceSelect = 0x0101,
        kSGGetNextFrameReferenceSelect = 0x0102,
        kSGGetTimeBaseSelect = 0x0103,
        kSGSortDeviceListSelect = 0x0104,
        kSGAddMovieDataSelect = 0x0105,
        kSGChangedSourceSelect = 0x0106,
        kSGAddExtendedFrameReferenceSelect = 0x0107,
        kSGGetNextExtendedFrameReferenceSelect = 0x0108,
        kSGAddExtendedMovieDataSelect = 0x0109,
        kSGAddOutputDataRefToMediaSelect = 0x010A,
        kSGSetChannelUsageSelect = 0x0080,
        kSGGetChannelUsageSelect = 0x0081,
        kSGSetChannelBoundsSelect = 0x0082,
        kSGGetChannelBoundsSelect = 0x0083,
        kSGSetChannelVolumeSelect = 0x0084,
        kSGGetChannelVolumeSelect = 0x0085,
        kSGGetChannelInfoSelect = 0x0086,
        kSGSetChannelPlayFlagsSelect = 0x0087,
        kSGGetChannelPlayFlagsSelect = 0x0088,
        kSGSetChannelMaxFramesSelect = 0x0089,
        kSGGetChannelMaxFramesSelect = 0x008A,
        kSGSetChannelRefConSelect = 0x008B,
        kSGSetChannelClipSelect = 0x008C,
        kSGGetChannelClipSelect = 0x008D,
        kSGGetChannelSampleDescriptionSelect = 0x008E,
        kSGGetChannelDeviceListSelect = 0x008F,
        kSGSetChannelDeviceSelect = 0x0090,
        kSGSetChannelMatrixSelect = 0x0091,
        kSGGetChannelMatrixSelect = 0x0092,
        kSGGetChannelTimeScaleSelect = 0x0093,
        kSGChannelPutPictureSelect = 0x0094,
        kSGChannelSetRequestedDataRateSelect = 0x0095,
        kSGChannelGetRequestedDataRateSelect = 0x0096,
        kSGChannelSetDataSourceNameSelect = 0x0097,
        kSGChannelGetDataSourceNameSelect = 0x0098,
        kSGChannelSetCodecSettingsSelect = 0x0099,
        kSGChannelGetCodecSettingsSelect = 0x009A,
        kSGGetChannelTimeBaseSelect = 0x009B,
        kSGInitChannelSelect = 0x0180,
        kSGWriteSamplesSelect = 0x0181,
        kSGGetDataRateSelect = 0x0182,
        kSGAlignChannelRectSelect = 0x0183,
        kSGPanelGetDitlSelect = 0x0200,
        kSGPanelGetTitleSelect = 0x0201,
        kSGPanelCanRunSelect = 0x0202,
        kSGPanelInstallSelect = 0x0203,
        kSGPanelEventSelect = 0x0204,
        kSGPanelItemSelect = 0x0205,
        kSGPanelRemoveSelect = 0x0206,
        kSGPanelSetGrabberSelect = 0x0207,
        kSGPanelSetResFileSelect = 0x0208,
        kSGPanelGetSettingsSelect = 0x0209,
        kSGPanelSetSettingsSelect = 0x020A,
        kSGPanelValidateInputSelect = 0x020B,
        kSGPanelSetEventFilterSelect = 0x020C,
        kSGGetSrcVideoBoundsSelect = 0x0100,
        kSGSetVideoRectSelect = 0x0101,
        kSGGetVideoRectSelect = 0x0102,
        kSGGetVideoCompressorTypeSelect = 0x0103,
        kSGSetVideoCompressorTypeSelect = 0x0104,
        kSGSetVideoCompressorSelect = 0x0105,
        kSGGetVideoCompressorSelect = 0x0106,
        kSGGetVideoDigitizerComponentSelect = 0x0107,
        kSGSetVideoDigitizerComponentSelect = 0x0108,
        kSGVideoDigitizerChangedSelect = 0x0109,
        kSGSetVideoBottlenecksSelect = 0x010A,
        kSGGetVideoBottlenecksSelect = 0x010B,
        kSGGrabFrameSelect = 0x010C,
        kSGGrabFrameCompleteSelect = 0x010D,
        kSGDisplayFrameSelect = 0x010E,
        kSGCompressFrameSelect = 0x010F,
        kSGCompressFrameCompleteSelect = 0x0110,
        kSGAddFrameSelect = 0x0111,
        kSGTransferFrameForCompressSelect = 0x0112,
        kSGSetCompressBufferSelect = 0x0113,
        kSGGetCompressBufferSelect = 0x0114,
        kSGGetBufferInfoSelect = 0x0115,
        kSGSetUseScreenBufferSelect = 0x0116,
        kSGGetUseScreenBufferSelect = 0x0117,
        kSGGrabCompressCompleteSelect = 0x0118,
        kSGDisplayCompressSelect = 0x0119,
        kSGSetFrameRateSelect = 0x011A,
        kSGGetFrameRateSelect = 0x011B,
        kSGSetPreferredPacketSizeSelect = 0x0121,
        kSGGetPreferredPacketSizeSelect = 0x0122,
        kSGSetUserVideoCompressorListSelect = 0x0123,
        kSGGetUserVideoCompressorListSelect = 0x0124,
        kSGSetSoundInputDriverSelect = 0x0100,
        kSGGetSoundInputDriverSelect = 0x0101,
        kSGSoundInputDriverChangedSelect = 0x0102,
        kSGSetSoundRecordChunkSizeSelect = 0x0103,
        kSGGetSoundRecordChunkSizeSelect = 0x0104,
        kSGSetSoundInputRateSelect = 0x0105,
        kSGGetSoundInputRateSelect = 0x0106,
        kSGSetSoundInputParametersSelect = 0x0107,
        kSGGetSoundInputParametersSelect = 0x0108,
        kSGSetAdditionalSoundRatesSelect = 0x0109,
        kSGGetAdditionalSoundRatesSelect = 0x010A,
        kSGSetFontNameSelect = 0x0100,
        kSGSetFontSizeSelect = 0x0101,
        kSGSetTextForeColorSelect = 0x0102,
        kSGSetTextBackColorSelect = 0x0103,
        kSGSetJustificationSelect = 0x0104,
        kSGGetTextReturnToSpaceValueSelect = 0x0105,
        kSGSetTextReturnToSpaceValueSelect = 0x0106,
        kSGGetInstrumentSelect = 0x0100,
        kSGSetInstrumentSelect = 0x0101,
        kQTVideoOutputGetDisplayModeListSelect = 0x0001,
        kQTVideoOutputGetCurrentClientNameSelect = 0x0002,
        kQTVideoOutputSetClientNameSelect = 0x0003,
        kQTVideoOutputGetClientNameSelect = 0x0004,
        kQTVideoOutputBeginSelect = 0x0005,
        kQTVideoOutputEndSelect = 0x0006,
        kQTVideoOutputSetDisplayModeSelect = 0x0007,
        kQTVideoOutputGetDisplayModeSelect = 0x0008,
        kQTVideoOutputCustomConfigureDisplaySelect = 0x0009,
        kQTVideoOutputSaveStateSelect = 0x000A,
        kQTVideoOutputRestoreStateSelect = 0x000B,
        kQTVideoOutputGetGWorldSelect = 0x000C,
        kQTVideoOutputGetGWorldParametersSelect = 0x000D,
        kQTVideoOutputGetIndSoundOutputSelect = 0x000E,
        kQTVideoOutputGetClockSelect = 0x000F,
        kQTVideoOutputSetEchoPortSelect = 0x0010,
        kQTVideoOutputGetIndImageDecompressorSelect = 0x0011
    };
 
#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